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
,
66 static struct symtabs_and_lines
decode_compound (char **argptr
,
73 static struct symbol
*lookup_prefix_sym (char **argptr
, char *p
);
75 static struct symtabs_and_lines
find_method (int funfirstline
,
80 struct symbol
*sym_class
,
83 static void cplusplus_error (const char *name
, const char *fmt
, ...)
84 ATTRIBUTE_NORETURN
ATTRIBUTE_PRINTF (2, 3);
86 static int total_number_of_methods (struct type
*type
);
88 static int find_methods (struct type
*, char *,
89 enum language
, struct symbol
**);
91 static int add_matching_methods (int method_counter
, struct type
*t
,
92 enum language language
,
93 struct symbol
**sym_arr
);
95 static int add_constructors (int method_counter
, struct type
*t
,
96 enum language language
,
97 struct symbol
**sym_arr
);
99 static void build_canonical_line_spec (struct symtab_and_line
*,
102 static char *find_toplevel_char (char *s
, char c
);
104 static int is_objc_method_format (const char *s
);
106 static struct symtabs_and_lines
decode_line_2 (struct symbol
*[],
109 static struct symtab
*symtab_from_filename (char **argptr
,
110 char *p
, int is_quote_enclosed
,
114 symtabs_and_lines
decode_all_digits (char **argptr
,
115 struct symtab
*default_symtab
,
118 struct symtab
*file_symtab
,
121 static struct symtabs_and_lines
decode_dollar (char *copy
,
123 struct symtab
*default_symtab
,
125 struct symtab
*file_symtab
);
127 static int decode_label (char *copy
, char ***canonical
,
128 struct symtabs_and_lines
*result
);
130 static struct symtabs_and_lines
decode_variable (char *copy
,
133 struct symtab
*file_symtab
,
137 symtabs_and_lines
symbol_found (int funfirstline
,
141 struct symtab
*file_symtab
);
144 symtabs_and_lines
minsym_found (int funfirstline
,
145 struct minimal_symbol
*msymbol
);
147 /* Helper functions. */
149 /* Issue a helpful hint on using the command completion feature on
150 single quoted demangled C++ symbols as part of the completion
154 cplusplus_error (const char *name
, const char *fmt
, ...)
156 struct ui_file
*tmp_stream
;
159 tmp_stream
= mem_fileopen ();
160 make_cleanup_ui_file_delete (tmp_stream
);
165 va_start (args
, fmt
);
166 vfprintf_unfiltered (tmp_stream
, fmt
, args
);
170 while (*name
== '\'')
172 fprintf_unfiltered (tmp_stream
,
173 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
174 "(Note leading single quote.)"),
177 message
= ui_file_xstrdup (tmp_stream
, NULL
);
178 make_cleanup (xfree
, message
);
179 throw_error (NOT_FOUND_ERROR
, "%s", message
);
182 /* Return the number of methods described for TYPE, including the
183 methods from types it derives from. This can't be done in the symbol
184 reader because the type of the baseclass might still be stubbed
185 when the definition of the derived class is parsed. */
188 total_number_of_methods (struct type
*type
)
193 CHECK_TYPEDEF (type
);
194 if (! HAVE_CPLUS_STRUCT (type
))
196 count
= TYPE_NFN_FIELDS_TOTAL (type
);
198 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
199 count
+= total_number_of_methods (TYPE_BASECLASS (type
, n
));
204 /* Recursive helper function for decode_line_1.
205 Look for methods named NAME in type T.
206 Return number of matches.
207 Put matches in SYM_ARR, which should have been allocated with
208 a size of total_number_of_methods (T) * sizeof (struct symbol *).
209 Note that this function is g++ specific. */
212 find_methods (struct type
*t
, char *name
, enum language language
,
213 struct symbol
**sym_arr
)
217 char *class_name
= type_name_no_tag (t
);
218 struct cleanup
*cleanup
;
221 /* NAME is typed by the user: it needs to be canonicalized before
222 passing to lookup_symbol. */
223 canon
= cp_canonicalize_string (name
);
227 cleanup
= make_cleanup (xfree
, name
);
230 cleanup
= make_cleanup (null_cleanup
, NULL
);
232 /* Ignore this class if it doesn't have a name. This is ugly, but
233 unless we figure out how to get the physname without the name of
234 the class, then the loop can't do any good. */
236 && (lookup_symbol_in_language (class_name
, (struct block
*) NULL
,
237 STRUCT_DOMAIN
, language
, (int *) NULL
)))
240 int name_len
= strlen (name
);
244 /* Loop over each method name. At this level, all overloads of a name
245 are counted as a single name. There is an inner loop which loops over
248 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
252 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
255 if (strncmp (method_name
, "__", 2) == 0 ||
256 strncmp (method_name
, "op", 2) == 0 ||
257 strncmp (method_name
, "type", 4) == 0)
259 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
260 method_name
= dem_opname
;
261 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
262 method_name
= dem_opname
;
265 if (strcmp_iw (name
, method_name
) == 0)
266 /* Find all the overloaded methods with that name. */
267 i1
+= add_matching_methods (method_counter
, t
, language
,
269 else if (strncmp (class_name
, name
, name_len
) == 0
270 && (class_name
[name_len
] == '\0'
271 || class_name
[name_len
] == '<'))
272 i1
+= add_constructors (method_counter
, t
, language
,
277 /* Only search baseclasses if there is no match yet, since names in
278 derived classes override those in baseclasses.
280 FIXME: The above is not true; it is only true of member functions
281 if they have the same number of arguments (??? - section 13.1 of the
282 ARM says the function members are not in the same scope but doesn't
283 really spell out the rules in a way I understand. In any case, if
284 the number of arguments differ this is a case in which we can overload
285 rather than hiding without any problem, and gcc 2.4.5 does overload
286 rather than hiding in this case). */
289 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
290 i1
+= find_methods (TYPE_BASECLASS (t
, ibase
), name
,
291 language
, sym_arr
+ i1
);
293 do_cleanups (cleanup
);
297 /* Add the symbols associated to methods of the class whose type is T
298 and whose name matches the method indexed by METHOD_COUNTER in the
299 array SYM_ARR. Return the number of methods added. */
302 add_matching_methods (int method_counter
, struct type
*t
,
303 enum language language
, struct symbol
**sym_arr
)
308 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
315 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
317 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
321 tmp_name
= gdb_mangle_name (t
,
324 phys_name
= alloca (strlen (tmp_name
) + 1);
325 strcpy (phys_name
, tmp_name
);
329 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
331 sym_arr
[i1
] = lookup_symbol_in_language (phys_name
,
339 /* This error message gets printed, but the method
340 still seems to be found.
341 fputs_filtered("(Cannot find method ", gdb_stdout);
342 fprintf_symbol_filtered (gdb_stdout, phys_name,
344 DMGL_PARAMS | DMGL_ANSI);
345 fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
353 /* Add the symbols associated to constructors of the class whose type
354 is CLASS_TYPE and which are indexed by by METHOD_COUNTER to the
355 array SYM_ARR. Return the number of methods added. */
358 add_constructors (int method_counter
, struct type
*t
,
359 enum language language
, struct symbol
**sym_arr
)
364 /* For GCC 3.x and stabs, constructors and destructors
365 have names like __base_ctor and __complete_dtor.
366 Check the physname for now if we're looking for a
369 = TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
376 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
378 /* GCC 3.x will never produce stabs stub methods, so
379 we don't need to handle this case. */
380 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
382 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
383 if (! is_constructor_name (phys_name
))
386 /* If this method is actually defined, include it in the
388 sym_arr
[i1
] = lookup_symbol_in_language (phys_name
,
399 /* Helper function for decode_line_1.
400 Build a canonical line spec in CANONICAL if it is non-NULL and if
401 the SAL has a symtab.
402 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
403 If SYMNAME is NULL the line number from SAL is used and the canonical
404 line spec is `filename:linenum'. */
407 build_canonical_line_spec (struct symtab_and_line
*sal
, char *symname
,
410 char **canonical_arr
;
411 char *canonical_name
;
413 struct symtab
*s
= sal
->symtab
;
415 if (s
== (struct symtab
*) NULL
416 || s
->filename
== (char *) NULL
417 || canonical
== (char ***) NULL
)
420 canonical_arr
= (char **) xmalloc (sizeof (char *));
421 *canonical
= canonical_arr
;
423 filename
= s
->filename
;
426 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
427 sprintf (canonical_name
, "%s:%s", filename
, symname
);
431 canonical_name
= xmalloc (strlen (filename
) + 30);
432 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
434 canonical_arr
[0] = canonical_name
;
439 /* Find an instance of the character C in the string S that is outside
440 of all parenthesis pairs, single-quoted strings, and double-quoted
441 strings. Also, ignore the char within a template name, like a ','
442 within foo<int, int>. */
445 find_toplevel_char (char *s
, char c
)
447 int quoted
= 0; /* zero if we're not in quotes;
448 '"' if we're in a double-quoted string;
449 '\'' if we're in a single-quoted string. */
450 int depth
= 0; /* Number of unclosed parens we've seen. */
453 for (scan
= s
; *scan
; scan
++)
459 else if (*scan
== '\\' && *(scan
+ 1))
462 else if (*scan
== c
&& ! quoted
&& depth
== 0)
464 else if (*scan
== '"' || *scan
== '\'')
466 else if (*scan
== '(' || *scan
== '<')
468 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
475 /* Determines if the gives string corresponds to an Objective-C method
476 representation, such as -[Foo bar:] or +[Foo bar]. Objective-C symbols
477 are allowed to have spaces and parentheses in them. */
480 is_objc_method_format (const char *s
)
482 if (s
== NULL
|| *s
== '\0')
484 /* Handle arguments with the format FILENAME:SYMBOL. */
485 if ((s
[0] == ':') && (strchr ("+-", s
[1]) != NULL
)
486 && (s
[2] == '[') && strchr(s
, ']'))
488 /* Handle arguments that are just SYMBOL. */
489 else if ((strchr ("+-", s
[0]) != NULL
) && (s
[1] == '[') && strchr(s
, ']'))
494 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
495 operate on (ask user if necessary).
496 If CANONICAL is non-NULL return a corresponding array of mangled names
497 as canonical line specs there. */
499 static struct symtabs_and_lines
500 decode_line_2 (struct symbol
*sym_arr
[], int nelts
, int funfirstline
,
503 struct symtabs_and_lines values
, return_values
;
508 struct cleanup
*old_chain
;
509 char **canonical_arr
= (char **) NULL
;
510 const char *select_mode
= multiple_symbols_select_mode ();
512 if (select_mode
== multiple_symbols_cancel
)
513 error (_("canceled because the command is ambiguous\n"
514 "See set/show multiple-symbol."));
516 values
.sals
= (struct symtab_and_line
*)
517 alloca (nelts
* sizeof (struct symtab_and_line
));
518 return_values
.sals
= (struct symtab_and_line
*)
519 xmalloc (nelts
* sizeof (struct symtab_and_line
));
520 old_chain
= make_cleanup (xfree
, return_values
.sals
);
524 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
525 make_cleanup (xfree
, canonical_arr
);
526 memset (canonical_arr
, 0, nelts
* sizeof (char *));
527 *canonical
= canonical_arr
;
533 init_sal (&return_values
.sals
[i
]); /* Initialize to zeroes. */
534 init_sal (&values
.sals
[i
]);
535 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
536 values
.sals
[i
] = find_function_start_sal (sym_arr
[i
], funfirstline
);
540 /* If select_mode is "all", then do not print the multiple-choice
541 menu and act as if the user had chosen choice "1" (all). */
542 if (select_mode
== multiple_symbols_all
543 || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
548 printf_unfiltered (_("[0] cancel\n[1] all\n"));
551 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
553 if (values
.sals
[i
].symtab
)
554 printf_unfiltered ("[%d] %s at %s:%d\n",
556 SYMBOL_PRINT_NAME (sym_arr
[i
]),
557 values
.sals
[i
].symtab
->filename
,
558 values
.sals
[i
].line
);
560 printf_unfiltered (_("[%d] %s at ?FILE:%d [No symtab? "
561 "Probably broken debug info...]\n"),
563 SYMBOL_PRINT_NAME (sym_arr
[i
]),
564 values
.sals
[i
].line
);
568 printf_unfiltered (_("?HERE\n"));
572 prompt
= getenv ("PS2");
577 args
= command_line_input (prompt
, 0, "overload-choice");
580 if (args
== 0 || *args
== 0)
581 error_no_arg (_("one or more choice numbers"));
589 while (*arg1
>= '0' && *arg1
<= '9')
591 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
592 error (_("Arguments must be choice numbers."));
597 error (_("canceled"));
602 for (i
= 0; i
< nelts
; i
++)
604 if (canonical_arr
[i
] == NULL
)
606 symname
= SYMBOL_LINKAGE_NAME (sym_arr
[i
]);
607 canonical_arr
[i
] = xstrdup (symname
);
611 memcpy (return_values
.sals
, values
.sals
,
612 (nelts
* sizeof (struct symtab_and_line
)));
613 return_values
.nelts
= nelts
;
614 discard_cleanups (old_chain
);
615 return return_values
;
618 if (num
>= nelts
+ 2)
620 printf_unfiltered (_("No choice number %d.\n"), num
);
625 if (values
.sals
[num
].pc
)
629 symname
= SYMBOL_LINKAGE_NAME (sym_arr
[num
]);
630 make_cleanup (xfree
, symname
);
631 canonical_arr
[i
] = xstrdup (symname
);
633 return_values
.sals
[i
++] = values
.sals
[num
];
634 values
.sals
[num
].pc
= 0;
638 printf_unfiltered (_("duplicate request for %d ignored.\n"),
644 while (*args
== ' ' || *args
== '\t')
647 return_values
.nelts
= i
;
648 discard_cleanups (old_chain
);
649 return return_values
;
652 /* A helper function for decode_line_1 and friends which skips P
653 past any method overload information at the beginning of P, e.g.,
654 "(const struct foo *)".
656 This function assumes that P has already been validated to contain
657 overload information, and it will assert if *P != '('. */
659 find_method_overload_end (char *p
)
663 gdb_assert (*p
== '(');
683 /* Does P point to a sequence of characters which implies the end
684 of a name? Terminals include "if" and "thread" clauses. */
691 if (*p
== 'i' && p
[1] == 'f'
692 && (isspace (p
[2]) || p
[2] == '\0' || p
[2] == '('))
695 if (strncmp (p
, "thread", 6) == 0
696 && (isspace (p
[6]) || p
[6] == '\0'))
702 /* Keep important information used when looking up a name. This includes
703 template parameters, overload information, and important keywords. */
706 keep_name_info (char *ptr
)
711 /* Keep any template parameters. */
713 return remove_trailing_whitespace (start
, ptr
);
718 ptr
= p
= find_template_name_end (ptr
);
721 return remove_trailing_whitespace (start
, ptr
);
723 /* Keep method overload information. */
725 ptr
= p
= find_method_overload_end (p
);
728 return remove_trailing_whitespace (start
, ptr
);
730 /* Keep important keywords. */
733 if (strncmp (p
, "const", 5) == 0
734 && (isspace (p
[5]) || p
[5] == '\0'
735 || strchr (get_gdb_completer_quote_characters (), p
[5]) != NULL
))
738 return remove_trailing_whitespace (start
, ptr
);
742 /* The parser of linespec itself. */
744 /* Parse a string that specifies a line number.
745 Pass the address of a char * variable; that variable will be
746 advanced over the characters actually parsed.
750 LINENUM -- that line number in current file. PC returned is 0.
751 FILE:LINENUM -- that line in that file. PC returned is 0.
752 FUNCTION -- line number of openbrace of that function.
753 PC returned is the start of the function.
754 LABEL -- a label in the current scope
755 VARIABLE -- line number of definition of that variable.
757 FILE:FUNCTION -- likewise, but prefer functions in that file.
758 *EXPR -- line in which address EXPR appears.
760 This may all be followed by an "if EXPR", which we ignore.
762 FUNCTION may be an undebuggable function found in minimal symbol table.
764 If the argument FUNFIRSTLINE is nonzero, we want the first line
765 of real code inside a function when a function is specified, and it is
766 not OK to specify a variable or type to get its line number.
768 DEFAULT_SYMTAB specifies the file to use if none is specified.
769 It defaults to current_source_symtab.
770 DEFAULT_LINE specifies the line number to use for relative
771 line numbers (that start with signs). Defaults to current_source_line.
772 If CANONICAL is non-NULL, store an array of strings containing the canonical
773 line specs there if necessary. Currently overloaded member functions and
774 line numbers or static functions without a filename yield a canonical
775 line spec. The array and the line spec strings are allocated on the heap,
776 it is the callers responsibility to free them.
778 Note that it is possible to return zero for the symtab
779 if no file is validly specified. Callers must check that.
780 Also, the line number returned may be invalid.
782 If NOT_FOUND_PTR is not null, store a boolean true/false value at
783 the location, based on whether or not failure occurs due to an
784 unknown function or file. In the case where failure does occur due
785 to an unknown function or file, do not issue an error message. */
787 /* We allow single quotes in various places. This is a hideous
788 kludge, which exists because the completer can't yet deal with the
789 lack of single quotes. FIXME: write a linespec_completer which we
790 can use as appropriate instead of make_symbol_completion_list. */
792 struct symtabs_and_lines
793 decode_line_1 (char **argptr
, int funfirstline
, struct symtab
*default_symtab
,
794 int default_line
, char ***canonical
, int *not_found_ptr
)
798 /* If a file name is specified, this is its symtab. */
799 struct symtab
*file_symtab
= NULL
;
802 /* This says whether or not something in *ARGPTR is quoted with
803 completer_quotes (i.e. with single quotes). */
805 /* Is *ARGPTR is enclosed in double quotes? */
806 int is_quote_enclosed
;
807 int is_objc_method
= 0;
808 char *saved_arg
= *argptr
;
809 /* If IS_QUOTED, the end of the quoted bit. */
810 char *end_quote
= NULL
;
811 /* The "first half" of the linespec. */
817 /* Defaults have defaults. */
819 initialize_defaults (&default_symtab
, &default_line
);
821 /* See if arg is *PC. */
824 return decode_indirect (argptr
);
826 is_quoted
= (strchr (get_gdb_completer_quote_characters (),
830 end_quote
= skip_quoted (*argptr
);
832 /* Check to see if it's a multipart linespec (with colons or
835 /* Locate the end of the first half of the linespec.
836 After the call, for instance, if the argptr string is "foo.c:123"
837 p will point at "123". If there is only one part, like "foo", p
838 will point to "". If this is a C++ name, like "A::B::foo", p will
839 point to "::B::foo". Argptr is not changed by this call. */
841 first_half
= p
= locate_first_half (argptr
, &is_quote_enclosed
);
843 /* Check if this is an Objective-C method (anything that starts with
844 a '+' or '-' and a '['). */
845 if (is_objc_method_format (p
))
848 /* Check if the symbol could be an Objective-C selector. */
851 struct symtabs_and_lines values
;
853 values
= decode_objc (argptr
, funfirstline
, NULL
,
854 canonical
, saved_arg
);
855 if (values
.sals
!= NULL
)
859 /* Does it look like there actually were two parts? */
861 if (p
[0] == ':' || p
[0] == '.')
863 /* Is it a C++ or Java compound data structure?
864 The check on p[1] == ':' is capturing the case of "::",
865 since p[0]==':' was checked above.
866 Note that the call to decode_compound does everything
867 for us, including the lookup on the symbol table, so we
870 if (p
[0] == '.' || p
[1] == ':')
872 struct symtabs_and_lines values
;
874 if (is_quote_enclosed
)
876 values
= decode_compound (argptr
, funfirstline
, canonical
,
877 saved_arg
, p
, not_found_ptr
);
878 if (is_quoted
&& **argptr
== '\'')
879 *argptr
= *argptr
+ 1;
883 /* No, the first part is a filename; set file_symtab to be that file's
884 symtab. Also, move argptr past the filename. */
886 file_symtab
= symtab_from_filename (argptr
, p
, is_quote_enclosed
,
889 /* Check for single quotes on the non-filename part. */
892 is_quoted
= (**argptr
893 && strchr (get_gdb_completer_quote_characters (),
896 end_quote
= skip_quoted (*argptr
);
900 /* file_symtab is specified file's symtab, or 0 if no file specified.
901 arg no longer contains the file name. */
903 /* If the filename was quoted, we must re-check the quotation. */
905 if (end_quote
== first_half
&& *end_quote
!= '\0')
907 is_quoted
= (**argptr
908 && strchr (get_gdb_completer_quote_characters (),
911 end_quote
= skip_quoted (*argptr
);
914 /* Check whether arg is all digits (and sign). */
917 if (*q
== '-' || *q
== '+')
919 while (*q
>= '0' && *q
<= '9')
922 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ','))
923 /* We found a token consisting of all digits -- at least one digit. */
924 return decode_all_digits (argptr
, default_symtab
, default_line
,
925 canonical
, file_symtab
, q
);
927 /* Arg token is not digits => try it as a variable name
928 Find the next token (everything up to end or next whitespace). */
930 if (**argptr
== '$') /* May be a convenience variable. */
931 /* One or two $ chars possible. */
932 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1));
937 error (_("Unmatched single quote."));
939 else if (is_objc_method
)
941 /* allow word separators in method names for Obj-C. */
942 p
= skip_quoted_chars (*argptr
, NULL
, "");
946 p
= skip_quoted (*argptr
);
949 /* Keep any important naming information. */
950 p
= keep_name_info (p
);
952 copy
= (char *) alloca (p
- *argptr
+ 1);
953 memcpy (copy
, *argptr
, p
- *argptr
);
954 copy
[p
- *argptr
] = '\0';
957 && copy
[0] == copy
[p
- *argptr
- 1]
958 && strchr (get_gdb_completer_quote_characters (), copy
[0]) != NULL
)
960 copy
[p
- *argptr
- 1] = '\0';
964 copy
[p
- *argptr
- 1] = '\0';
965 while (*p
== ' ' || *p
== '\t')
969 /* If it starts with $: may be a legitimate variable or routine name
970 (e.g. HP-UX millicode routines such as $$dyncall), or it may
971 be history value, or it may be a convenience variable. */
974 return decode_dollar (copy
, funfirstline
, default_symtab
,
975 canonical
, file_symtab
);
977 /* Try the token as a label, but only if no file was specified,
978 because we can only really find labels in the current scope. */
982 struct symtabs_and_lines label_result
;
983 if (decode_label (copy
, canonical
, &label_result
))
987 /* Look up that token as a variable.
988 If file specified, use that file's per-file block to start with. */
990 return decode_variable (copy
, funfirstline
, canonical
,
991 file_symtab
, not_found_ptr
);
996 /* Now, more helper functions for decode_line_1. Some conventions
997 that these functions follow:
999 Decode_line_1 typically passes along some of its arguments or local
1000 variables to the subfunctions. It passes the variables by
1001 reference if they are modified by the subfunction, and by value
1004 Some of the functions have side effects that don't arise from
1005 variables that are passed by reference. In particular, if a
1006 function is passed ARGPTR as an argument, it modifies what ARGPTR
1007 points to; typically, it advances *ARGPTR past whatever substring
1008 it has just looked at. (If it doesn't modify *ARGPTR, then the
1009 function gets passed *ARGPTR instead, which is then called ARG.)
1010 Also, functions that return a struct symtabs_and_lines may modify
1011 CANONICAL, as in the description of decode_line_1.
1013 If a function returns a struct symtabs_and_lines, then that struct
1014 will immediately make its way up the call chain to be returned by
1015 decode_line_1. In particular, all of the functions decode_XXX
1016 calculate the appropriate struct symtabs_and_lines, under the
1017 assumption that their argument is of the form XXX. */
1019 /* First, some functions to initialize stuff at the beggining of the
1023 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
1025 if (*default_symtab
== 0)
1027 /* Use whatever we have for the default source line. We don't use
1028 get_current_or_default_symtab_and_line as it can recurse and call
1030 struct symtab_and_line cursal
=
1031 get_current_source_symtab_and_line ();
1033 *default_symtab
= cursal
.symtab
;
1034 *default_line
= cursal
.line
;
1040 /* Decode arg of the form *PC. */
1042 static struct symtabs_and_lines
1043 decode_indirect (char **argptr
)
1045 struct symtabs_and_lines values
;
1049 pc
= value_as_address (parse_to_comma_and_eval (argptr
));
1051 values
.sals
= (struct symtab_and_line
*)
1052 xmalloc (sizeof (struct symtab_and_line
));
1055 values
.sals
[0] = find_pc_line (pc
, 0);
1056 values
.sals
[0].pc
= pc
;
1057 values
.sals
[0].section
= find_pc_overlay (pc
);
1058 values
.sals
[0].explicit_pc
= 1;
1065 /* Locate the first half of the linespec, ending in a colon, period,
1066 or whitespace. (More or less.) Also, check to see if *ARGPTR is
1067 enclosed in double quotes; if so, set is_quote_enclosed, advance
1068 ARGPTR past that and zero out the trailing double quote.
1069 If ARGPTR is just a simple name like "main", p will point to ""
1073 locate_first_half (char **argptr
, int *is_quote_enclosed
)
1079 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1080 and we must isolate the first half. Outer layers will call again later
1081 for the second half.
1083 Don't count commas that appear in argument lists of overloaded
1084 functions, or in quoted strings. It's stupid to go to this much
1085 trouble when the rest of the function is such an obvious roach hotel. */
1086 ii
= find_toplevel_char (*argptr
, ',');
1087 has_comma
= (ii
!= 0);
1089 /* Temporarily zap out second half to not confuse the code below.
1090 This is undone below. Do not change ii!! */
1096 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION. May also be
1097 CLASS::MEMBER, or NAMESPACE::NAME. Look for ':', but ignore
1103 *is_quote_enclosed
= 1;
1109 *is_quote_enclosed
= 0;
1110 if (strchr (get_gdb_completer_quote_characters (), *p
))
1120 char *temp_end
= find_template_name_end (p
);
1123 error (_("malformed template specification in command"));
1128 p
= find_method_overload_end (p
);
1130 /* Check for a colon and a plus or minus and a [ (which
1131 indicates an Objective-C method). */
1132 if (is_objc_method_format (p
))
1136 /* Check for the end of the first half of the linespec. End of
1137 line, a tab, a double colon or the last single colon, or a
1138 space. But if enclosed in double quotes we do not break on
1143 && ((p
[1] == ':') || (strchr (p
+ 1, ':') == NULL
)))
1144 || ((p
[0] == ' ') && !*is_quote_enclosed
))
1146 if (p
[0] == '.' && strchr (p
, ':') == NULL
)
1148 /* Java qualified method. Find the *last* '.', since the
1149 others are package qualifiers. Stop at any open parenthesis
1150 which might provide overload information. */
1151 for (p1
= p
; *p1
&& *p1
!= '('; p1
++)
1159 while (p
[0] == ' ' || p
[0] == '\t')
1162 /* If the closing double quote was left at the end, remove it. */
1163 if (*is_quote_enclosed
)
1165 char *closing_quote
= strchr (p
- 1, '"');
1167 if (closing_quote
&& closing_quote
[1] == '\0')
1168 *closing_quote
= '\0';
1171 /* Now that we've safely parsed the first half, put back ',' so
1172 outer layers can see it. */
1181 /* Here's where we recognise an Objective-C Selector. An Objective C
1182 selector may be implemented by more than one class, therefore it
1183 may represent more than one method/function. This gives us a
1184 situation somewhat analogous to C++ overloading. If there's more
1185 than one method that could represent the selector, then use some of
1186 the existing C++ code to let the user choose one. */
1188 struct symtabs_and_lines
1189 decode_objc (char **argptr
, int funfirstline
, struct symtab
*file_symtab
,
1190 char ***canonical
, char *saved_arg
)
1192 struct symtabs_and_lines values
;
1193 struct symbol
**sym_arr
= NULL
;
1194 struct symbol
*sym
= NULL
;
1195 struct block
*block
= NULL
;
1202 if (file_symtab
!= NULL
)
1203 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab
), STATIC_BLOCK
);
1206 enum language save_language
;
1208 /* get_selected_block can change the current language when there is
1209 no selected frame yet. */
1210 save_language
= current_language
->la_language
;
1211 block
= get_selected_block (0);
1212 set_language (save_language
);
1215 find_imps (file_symtab
, block
, *argptr
, NULL
, &i1
, &i2
);
1219 sym_arr
= (struct symbol
**)
1220 alloca ((i1
+ 1) * sizeof (struct symbol
*));
1223 *argptr
= find_imps (file_symtab
, block
, *argptr
, sym_arr
, &i1
, &i2
);
1226 /* i1 now represents the TOTAL number of matches found.
1227 i2 represents how many HIGH-LEVEL (struct symbol) matches,
1228 which will come first in the sym_arr array. Any low-level
1229 (minimal_symbol) matches will follow those. */
1235 /* Already a struct symbol. */
1240 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr
[0]));
1241 if ((sym
!= NULL
) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr
[0]),
1242 SYMBOL_LINKAGE_NAME (sym
)) != 0)
1244 warning (_("debugging symbol \"%s\" does "
1245 "not match selector; ignoring"),
1246 SYMBOL_LINKAGE_NAME (sym
));
1251 values
.sals
= (struct symtab_and_line
*)
1252 xmalloc (sizeof (struct symtab_and_line
));
1255 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1257 /* Canonicalize this, so it remains resolved for dylib loads. */
1258 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
1259 build_canonical_line_spec (values
.sals
,
1260 SYMBOL_NATURAL_NAME (sym
), canonical
);
1264 /* The only match was a non-debuggable symbol, which might point
1265 to a function descriptor; resolve it to the actual code address
1267 struct minimal_symbol
*msymbol
= (struct minimal_symbol
*)sym_arr
[0];
1268 struct objfile
*objfile
= msymbol_objfile (msymbol
);
1269 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1270 CORE_ADDR pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
1272 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, pc
,
1275 init_sal (&values
.sals
[0]);
1276 values
.sals
[0].pc
= pc
;
1283 /* More than one match. The user must choose one or more. */
1284 return decode_line_2 (sym_arr
, i2
, funfirstline
, canonical
);
1290 /* This handles C++ and Java compound data structures. P should point
1291 at the first component separator, i.e. double-colon or period. As
1292 an example, on entrance to this function we could have ARGPTR
1293 pointing to "AAA::inA::fun" and P pointing to "::inA::fun". */
1295 static struct symtabs_and_lines
1296 decode_compound (char **argptr
, int funfirstline
, char ***canonical
,
1297 char *the_real_saved_arg
, char *p
, int *not_found_ptr
)
1299 struct symtabs_and_lines values
;
1301 char *saved_arg2
= *argptr
;
1305 struct symbol
*sym_class
;
1307 char *saved_java_argptr
= NULL
;
1310 /* If the user specified any completer quote characters in the input,
1311 strip them. They are superfluous. */
1312 saved_arg
= alloca (strlen (the_real_saved_arg
) + 1);
1314 char *dst
= saved_arg
;
1315 char *src
= the_real_saved_arg
;
1316 char *quotes
= get_gdb_completer_quote_characters ();
1317 while (*src
!= '\0')
1319 if (strchr (quotes
, *src
) == NULL
)
1326 /* First check for "global" namespace specification, of the form
1327 "::foo". If found, skip over the colons and jump to normal
1328 symbol processing. I.e. the whole line specification starts with
1329 "::" (note the condition that *argptr == p). */
1331 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
1334 /* Given our example "AAA::inA::fun", we have two cases to consider:
1336 1) AAA::inA is the name of a class. In that case, presumably it
1337 has a method called "fun"; we then look up that method using
1340 2) AAA::inA isn't the name of a class. In that case, either the
1341 user made a typo, AAA::inA is the name of a namespace, or it is
1342 the name of a minimal symbol.
1343 We just look up AAA::inA::fun with lookup_symbol. If that fails,
1344 try lookup_minimal_symbol.
1346 Thus, our first task is to find everything before the last set of
1347 double-colons and figure out if it's the name of a class. So we
1348 first loop through all of the double-colons. */
1350 p2
= p
; /* Save for restart. */
1352 /* This is very messy. Following the example above we have now the
1355 argptr -> "AAA::inA::fun
1356 saved_arg -> "AAA::inA::fun
1357 saved_arg2 -> "AAA::inA::fun
1358 p2 -> "::inA::fun". */
1360 /* In the loop below, with these strings, we'll make 2 passes, each
1361 is marked in comments. */
1365 static char *break_characters
= " \t(";
1367 /* Move pointer up to next possible class/namespace token. */
1369 p
= p2
+ 1; /* Restart with old value +1. */
1371 /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1372 i.e. if there is a double-colon, p will now point to the
1374 /* PASS2: p2->"::fun", p->":fun" */
1376 /* Move pointer ahead to next double-colon. */
1378 && strchr (break_characters
, *p
) == NULL
1379 && strchr (get_gdb_completer_quote_characters (), *p
) == NULL
)
1381 if (current_language
->la_language
== language_cplus
)
1382 p
+= cp_validate_operator (p
);
1386 temp_end
= find_template_name_end (p
);
1388 error (_("malformed template specification in command"));
1391 /* Note that, since, at the start of this loop, p would be
1392 pointing to the second colon in a double-colon, we only
1393 satisfy the condition below if there is another
1394 double-colon to the right (after). I.e. there is another
1395 component that can be a class or a namespace. I.e, if at
1396 the beginning of this loop (PASS1), we had
1397 p->":inA::fun", we'll trigger this when p has been
1398 advanced to point to "::fun". */
1399 /* PASS2: we will not trigger this. */
1400 else if ((p
[0] == ':') && (p
[1] == ':'))
1401 break; /* Found double-colon. */
1404 /* PASS2: We'll keep getting here, until P points to one of the
1405 break characters, at which point we exit this loop. */
1406 if (*p
&& strchr (break_characters
, *p
) == NULL
)
1412 break; /* Out of the while (1). This would happen
1413 for instance if we have looked up
1414 unsuccessfully all the components of the
1415 string, and p->""(PASS2). */
1417 /* We get here if p points to one of the break characters or "" (i.e.,
1419 /* Save restart for next time around. */
1421 /* Restore argptr as it was on entry to this function. */
1422 *argptr
= saved_arg2
;
1423 /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1426 /* All ready for next pass through the loop. */
1430 /* Start of lookup in the symbol tables. */
1432 /* Lookup in the symbol table the substring between argptr and
1433 p. Note, this call changes the value of argptr. */
1434 /* Before the call, argptr->"AAA::inA::fun",
1435 p->"", p2->"::fun". After the call: argptr->"fun", p, p2
1437 sym_class
= lookup_prefix_sym (argptr
, p2
);
1439 /* If sym_class has been found, and if "AAA::inA" is a class, then
1440 we're in case 1 above. So we look up "fun" as a method of that
1443 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
1444 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
1445 || TYPE_CODE (t
) == TYPE_CODE_UNION
)))
1447 /* Arg token is not digits => try it as a function name.
1448 Find the next token (everything up to end or next
1451 && strchr (get_gdb_completer_quote_characters (),
1454 p
= skip_quoted (*argptr
);
1455 *argptr
= *argptr
+ 1;
1459 /* At this point argptr->"fun". */
1463 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':'
1466 /* At this point p->"". String ended. */
1467 /* Nope, C++ operators could have spaces in them
1468 ("foo::operator <" or "foo::operator delete []").
1469 I apologize, this is a bit hacky... */
1470 if (current_language
->la_language
== language_cplus
1471 && *p
== ' ' && p
- 8 - *argptr
+ 1 > 0)
1473 /* The above loop has already swallowed "operator". */
1474 p
+= cp_validate_operator (p
- 8) - 8;
1477 /* Keep any important naming information. */
1478 p
= keep_name_info (p
);
1480 /* Java may append typenames, so assume that if there is
1481 anything else left in *argptr, it must be a typename. */
1482 if (*p
&& current_language
->la_language
== language_java
)
1489 copy
= (char *) alloca (p2
- p
+ 1);
1490 memcpy (copy
, p
, p2
- p
);
1491 copy
[p2
- p
] = '\0';
1492 type
= lookup_typename (current_language
, get_current_arch (),
1496 /* Save the location of this just in case this
1497 method/type combination isn't actually defined.
1498 It will be checked later. */
1499 saved_java_argptr
= p
;
1505 /* Allocate our own copy of the substring between argptr and
1507 copy
= (char *) alloca (p
- *argptr
+ 1);
1508 memcpy (copy
, *argptr
, p
- *argptr
);
1509 copy
[p
- *argptr
] = '\0';
1511 && copy
[p
- *argptr
- 1]
1512 && strchr (get_gdb_completer_quote_characters (),
1513 copy
[p
- *argptr
- 1]) != NULL
)
1514 copy
[p
- *argptr
- 1] = '\0';
1516 /* At this point copy->"fun", p->"". */
1518 /* No line number may be specified. */
1519 while (*p
== ' ' || *p
== '\t')
1522 /* At this point arptr->"". */
1524 /* Look for copy as a method of sym_class. */
1525 /* At this point copy->"fun", sym_class is "AAA:inA",
1526 saved_arg->"AAA::inA::fun". This concludes the scanning of
1527 the string for possible components matches. If we find it
1528 here, we return. If not, and we are at the and of the string,
1529 we'll lookup the whole string in the symbol tables. */
1531 values
= find_method (funfirstline
, canonical
, saved_arg
,
1532 copy
, t
, sym_class
, not_found_ptr
);
1533 if (saved_java_argptr
!= NULL
&& values
.nelts
== 1)
1535 /* The user specified a specific return type for a java method.
1536 Double-check that it really is the one the user specified.
1537 [This is a necessary evil because strcmp_iw_ordered stops
1538 comparisons too prematurely.] */
1539 sym
= find_pc_sect_function (values
.sals
[0].pc
,
1540 values
.sals
[0].section
);
1541 /* We just found a SAL, we had better be able to go backwards! */
1542 gdb_assert (sym
!= NULL
);
1543 if (strcmp_iw (SYMBOL_LINKAGE_NAME (sym
), saved_arg
) != 0)
1545 xfree (values
.sals
);
1546 error (_("the class `%s' does not have "
1547 "any method instance named %s"),
1548 SYMBOL_PRINT_NAME (sym_class
), copy
);
1552 } /* End if symbol found. */
1555 /* We couldn't find a class, so we're in case 2 above. We check the
1556 entire name as a symbol instead. */
1558 if (current_language
->la_language
== language_cplus
1559 || current_language
->la_language
== language_java
)
1560 p
= keep_name_info (p
);
1562 copy
= (char *) alloca (p
- saved_arg2
+ 1);
1563 memcpy (copy
, saved_arg2
, p
- saved_arg2
);
1564 /* Note: if is_quoted should be true, we snuff out quote here
1566 copy
[p
- saved_arg2
] = '\000';
1567 /* Set argptr to skip over the name. */
1568 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
1570 /* Look up entire name. */
1571 sym
= lookup_symbol (copy
, get_selected_block (0), VAR_DOMAIN
, 0);
1573 return symbol_found (funfirstline
, canonical
, copy
, sym
, NULL
);
1576 struct minimal_symbol
*msym
;
1578 /* Couldn't find any interpretation as classes/namespaces. As a last
1579 resort, try the minimal symbol tables. */
1580 msym
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1582 return minsym_found (funfirstline
, msym
);
1585 /* Couldn't find a minimal symbol, either, so give up. */
1588 cplusplus_error (the_real_saved_arg
,
1589 "Can't find member of namespace, "
1590 "class, struct, or union named \"%s\"\n",
1594 /* Next come some helper functions for decode_compound. */
1596 /* Return the symbol corresponding to the substring of *ARGPTR ending
1597 at P, allowing whitespace. Also, advance *ARGPTR past the symbol
1598 name in question, the compound object separator ("::" or "."), and
1599 whitespace. Note that *ARGPTR is changed whether or not the
1600 lookup_symbol call finds anything (i.e we return NULL). As an
1601 example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun". */
1603 static struct symbol
*
1604 lookup_prefix_sym (char **argptr
, char *p
)
1610 /* Extract the class name. */
1612 while (p
!= *argptr
&& p
[-1] == ' ')
1614 copy
= (char *) alloca (p
- *argptr
+ 1);
1615 memcpy (copy
, *argptr
, p
- *argptr
);
1616 copy
[p
- *argptr
] = 0;
1618 /* Discard the class name from the argptr. */
1619 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
1620 while (*p
== ' ' || *p
== '\t')
1624 /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1625 argptr->"inA::fun". */
1627 sym
= lookup_symbol (copy
, get_selected_block (0), STRUCT_DOMAIN
, 0);
1630 /* Typedefs are in VAR_DOMAIN so the above symbol lookup will
1631 fail when the user attempts to lookup a method of a class
1632 via a typedef'd name (NOT via the class's name, which is already
1633 handled in symbol_matches_domain). So try the lookup again
1634 using VAR_DOMAIN (where typedefs live) and double-check that we
1635 found a struct/class type. */
1636 struct symbol
*s
= lookup_symbol (copy
, 0, VAR_DOMAIN
, 0);
1640 struct type
*t
= SYMBOL_TYPE (s
);
1643 if (TYPE_CODE (t
) == TYPE_CODE_STRUCT
)
1651 /* This finds the method COPY in the class whose type is T and whose
1652 symbol is SYM_CLASS. */
1654 static struct symtabs_and_lines
1655 find_method (int funfirstline
, char ***canonical
, char *saved_arg
,
1656 char *copy
, struct type
*t
, struct symbol
*sym_class
,
1659 struct symtabs_and_lines values
;
1660 struct symbol
*sym
= NULL
;
1661 int i1
; /* Counter for the symbol array. */
1662 struct symbol
**sym_arr
= alloca (total_number_of_methods (t
)
1663 * sizeof (struct symbol
*));
1665 /* Find all methods with a matching name, and put them in
1668 i1
= find_methods (t
, copy
, SYMBOL_LANGUAGE (sym_class
), sym_arr
);
1672 /* There is exactly one field with that name. */
1675 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1677 values
.sals
= (struct symtab_and_line
*)
1678 xmalloc (sizeof (struct symtab_and_line
));
1680 values
.sals
[0] = find_function_start_sal (sym
,
1692 /* If we were given a specific overload instance, use that
1693 (or error if no matches were found). Otherwise ask the user
1694 which one to use. */
1695 if (strchr (copy
, '('))
1700 struct cleanup
*cleanup
;
1702 /* Construct the proper search name based on SYM_CLASS and COPY.
1703 SAVED_ARG may contain a valid name, but that name might not be
1704 what is actually stored in the symbol table. For example,
1705 if SAVED_ARG (and SYM_CLASS) were found via an import
1706 ("using namespace" in C++), then the physname of
1707 SYM_CLASS ("A::myclass") may not be the same as SAVED_ARG
1709 name
= xmalloc (strlen (SYMBOL_NATURAL_NAME (sym_class
))
1710 + 2 /* "::" */ + strlen (copy
) + 1);
1711 strcpy (name
, SYMBOL_NATURAL_NAME (sym_class
));
1712 strcat (name
, "::");
1713 strcat (name
, copy
);
1714 canon
= cp_canonicalize_string (name
);
1720 cleanup
= make_cleanup (xfree
, name
);
1722 for (i
= 0; i
< i1
; ++i
)
1724 if (strcmp_iw (name
, SYMBOL_LINKAGE_NAME (sym_arr
[i
])) == 0)
1726 values
.sals
= (struct symtab_and_line
*)
1727 xmalloc (sizeof (struct symtab_and_line
));
1729 values
.sals
[0] = find_function_start_sal (sym_arr
[i
],
1731 do_cleanups (cleanup
);
1736 error (_("the class `%s' does not have "
1737 "any method instance named %s"),
1738 SYMBOL_PRINT_NAME (sym_class
), copy
);
1741 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
1748 cplusplus_error (saved_arg
,
1749 "the class `%s' does not have destructor defined\n",
1750 SYMBOL_PRINT_NAME (sym_class
));
1752 cplusplus_error (saved_arg
,
1753 "the class %s does not have any method named %s\n",
1754 SYMBOL_PRINT_NAME (sym_class
), copy
);
1760 /* Return the symtab associated to the filename given by the substring
1761 of *ARGPTR ending at P, and advance ARGPTR past that filename. If
1762 NOT_FOUND_PTR is not null and the source file is not found, store
1763 boolean true at the location pointed to and do not issue an
1766 static struct symtab
*
1767 symtab_from_filename (char **argptr
, char *p
, int is_quote_enclosed
,
1772 struct symtab
*file_symtab
;
1775 while (p
!= *argptr
&& p
[-1] == ' ')
1777 if ((*p
== '"') && is_quote_enclosed
)
1779 copy
= (char *) alloca (p
- *argptr
+ 1);
1780 memcpy (copy
, *argptr
, p
- *argptr
);
1781 /* It may have the ending quote right after the file name. */
1782 if ((is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
1783 || copy
[p
- *argptr
- 1] == '\'')
1784 copy
[p
- *argptr
- 1] = 0;
1786 copy
[p
- *argptr
] = 0;
1788 /* Find that file's data. */
1789 file_symtab
= lookup_symtab (copy
);
1790 if (file_symtab
== 0)
1794 if (!have_full_symbols () && !have_partial_symbols ())
1795 throw_error (NOT_FOUND_ERROR
,
1796 _("No symbol table is loaded. "
1797 "Use the \"file\" command."));
1798 throw_error (NOT_FOUND_ERROR
, _("No source file named %s."), copy
);
1801 /* Discard the file name from the arg. */
1803 while (*p
== ' ' || *p
== '\t')
1812 /* This decodes a line where the argument is all digits (possibly
1813 preceded by a sign). Q should point to the end of those digits;
1814 the other arguments are as usual. */
1816 static struct symtabs_and_lines
1817 decode_all_digits (char **argptr
, struct symtab
*default_symtab
,
1818 int default_line
, char ***canonical
,
1819 struct symtab
*file_symtab
, char *q
)
1822 struct symtabs_and_lines values
;
1823 struct symtab_and_line val
;
1831 /* We might need a canonical line spec if no file was specified. */
1832 int need_canonical
= (file_symtab
== NULL
) ? 1 : 0;
1836 val
.pspace
= current_program_space
;
1838 /* This is where we need to make sure that we have good defaults.
1839 We must guarantee that this section of code is never executed
1840 when we are called with just a function name, since
1841 set_default_source_symtab_and_line uses
1842 select_source_symtab that calls us with such an argument. */
1844 if (file_symtab
== 0 && default_symtab
== 0)
1846 /* Make sure we have at least a default source file. */
1847 set_default_source_symtab_and_line ();
1848 initialize_defaults (&default_symtab
, &default_line
);
1851 if (**argptr
== '+')
1852 sign
= plus
, (*argptr
)++;
1853 else if (**argptr
== '-')
1854 sign
= minus
, (*argptr
)++;
1855 val
.line
= atoi (*argptr
);
1861 if (file_symtab
== 0)
1862 val
.line
= default_line
+ val
.line
;
1867 if (file_symtab
== 0)
1868 val
.line
= default_line
- val
.line
;
1873 break; /* No need to adjust val.line. */
1876 while (*q
== ' ' || *q
== '\t')
1879 if (file_symtab
== 0)
1880 file_symtab
= default_symtab
;
1882 /* It is possible that this source file has more than one symtab,
1883 and that the new line number specification has moved us from the
1884 default (in file_symtab) to a new one. */
1885 val
.symtab
= find_line_symtab (file_symtab
, val
.line
, NULL
, NULL
);
1886 if (val
.symtab
== 0)
1887 val
.symtab
= file_symtab
;
1889 val
.pspace
= SYMTAB_PSPACE (val
.symtab
);
1891 values
.sals
= (struct symtab_and_line
*)
1892 xmalloc (sizeof (struct symtab_and_line
));
1893 values
.sals
[0] = val
;
1896 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1897 values
.sals
[0].explicit_line
= 1;
1903 /* Decode a linespec starting with a dollar sign. */
1905 static struct symtabs_and_lines
1906 decode_dollar (char *copy
, int funfirstline
, struct symtab
*default_symtab
,
1907 char ***canonical
, struct symtab
*file_symtab
)
1911 int need_canonical
= 0;
1912 struct symtabs_and_lines values
;
1913 struct symtab_and_line val
;
1916 struct minimal_symbol
*msymbol
;
1918 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
1919 while (*p
>= '0' && *p
<= '9')
1921 if (!*p
) /* Reached end of token without hitting non-digit. */
1923 /* We have a value history reference. */
1924 struct value
*val_history
;
1926 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
1927 val_history
= access_value_history ((copy
[1] == '$') ? -index
: index
);
1928 if (TYPE_CODE (value_type (val_history
)) != TYPE_CODE_INT
)
1929 error (_("History values used in line "
1930 "specs must have integer values."));
1931 valx
= value_as_long (val_history
);
1935 /* Not all digits -- may be user variable/function or a
1936 convenience variable. */
1938 /* Look up entire name as a symbol first. */
1939 sym
= lookup_symbol (copy
, 0, VAR_DOMAIN
, 0);
1940 file_symtab
= (struct symtab
*) NULL
;
1942 /* Symbol was found --> jump to normal symbol processing. */
1944 return symbol_found (funfirstline
, canonical
, copy
, sym
, NULL
);
1946 /* If symbol was not found, look in minimal symbol tables. */
1947 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1948 /* Min symbol was found --> jump to minsym processing. */
1950 return minsym_found (funfirstline
, msymbol
);
1952 /* Not a user variable or function -- must be convenience variable. */
1953 if (!get_internalvar_integer (lookup_internalvar (copy
+ 1), &valx
))
1954 error (_("Convenience variables used in line "
1955 "specs must have integer values."));
1960 /* Either history value or convenience value from above, in valx. */
1961 val
.symtab
= file_symtab
? file_symtab
: default_symtab
;
1964 val
.pspace
= current_program_space
;
1966 values
.sals
= (struct symtab_and_line
*) xmalloc (sizeof val
);
1967 values
.sals
[0] = val
;
1971 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1978 /* A helper for decode_line_1 that tries to find a label. The label
1979 is searched for in the current block.
1980 COPY is the name of the label to find.
1981 CANONICAL is the same as the "canonical" argument to decode_line_1.
1982 RESULT is a pointer to a symtabs_and_lines structure which will be
1983 filled in on success.
1984 This function returns 1 if a label was found, 0 otherwise. */
1987 decode_label (char *copy
, char ***canonical
, struct symtabs_and_lines
*result
)
1991 sym
= lookup_symbol (copy
, get_selected_block (0), LABEL_DOMAIN
, 0);
1994 *result
= symbol_found (0, canonical
, copy
, sym
, NULL
);
1999 /* Decode a linespec that's a variable. If FILE_SYMTAB is non-NULL,
2000 look in that symtab's static variables first. If NOT_FOUND_PTR is
2001 not NULL and the function cannot be found, store boolean true in
2002 the location pointed to and do not issue an error message. */
2004 static struct symtabs_and_lines
2005 decode_variable (char *copy
, int funfirstline
, char ***canonical
,
2006 struct symtab
*file_symtab
, int *not_found_ptr
)
2009 struct minimal_symbol
*msymbol
;
2011 sym
= lookup_symbol (copy
,
2013 ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab
),
2015 : get_selected_block (0)),
2019 return symbol_found (funfirstline
, canonical
, copy
, sym
, file_symtab
);
2021 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
2023 if (msymbol
!= NULL
)
2024 return minsym_found (funfirstline
, msymbol
);
2029 if (!have_full_symbols ()
2030 && !have_partial_symbols ()
2031 && !have_minimal_symbols ())
2032 throw_error (NOT_FOUND_ERROR
,
2033 _("No symbol table is loaded. Use the \"file\" command."));
2034 throw_error (NOT_FOUND_ERROR
, _("Function \"%s\" not defined."), copy
);
2040 /* Now come some functions that are called from multiple places within
2043 /* We've found a symbol SYM to associate with our linespec; build a
2044 corresponding struct symtabs_and_lines. */
2046 static struct symtabs_and_lines
2047 symbol_found (int funfirstline
, char ***canonical
, char *copy
,
2048 struct symbol
*sym
, struct symtab
*file_symtab
)
2050 struct symtabs_and_lines values
;
2052 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2054 /* Arg is the name of a function. */
2055 values
.sals
= (struct symtab_and_line
*)
2056 xmalloc (sizeof (struct symtab_and_line
));
2057 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
2060 /* Don't use the SYMBOL_LINE; if used at all it points to
2061 the line containing the parameters or thereabouts, not
2062 the first line of code. */
2064 /* We might need a canonical line spec if it is a static
2066 if (file_symtab
== 0)
2068 struct blockvector
*bv
= BLOCKVECTOR (SYMBOL_SYMTAB (sym
));
2069 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
2071 if (lookup_block_symbol (b
, copy
, VAR_DOMAIN
) != NULL
)
2072 build_canonical_line_spec (values
.sals
, copy
, canonical
);
2078 if (funfirstline
&& SYMBOL_CLASS (sym
) != LOC_LABEL
)
2079 error (_("\"%s\" is not a function"), copy
);
2080 else if (SYMBOL_LINE (sym
) != 0)
2082 /* We know its line number. */
2083 values
.sals
= (struct symtab_and_line
*)
2084 xmalloc (sizeof (struct symtab_and_line
));
2086 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
2087 values
.sals
[0].symtab
= SYMBOL_SYMTAB (sym
);
2088 values
.sals
[0].line
= SYMBOL_LINE (sym
);
2089 values
.sals
[0].pspace
= SYMTAB_PSPACE (SYMBOL_SYMTAB (sym
));
2093 /* This can happen if it is compiled with a compiler which doesn't
2094 put out line numbers for variables. */
2095 /* FIXME: Shouldn't we just set .line and .symtab to zero
2096 and return? For example, "info line foo" could print
2098 error (_("Line number not known for symbol \"%s\""), copy
);
2102 /* We've found a minimal symbol MSYMBOL to associate with our
2103 linespec; build a corresponding struct symtabs_and_lines. */
2105 static struct symtabs_and_lines
2106 minsym_found (int funfirstline
, struct minimal_symbol
*msymbol
)
2108 struct objfile
*objfile
= msymbol_objfile (msymbol
);
2109 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2110 struct symtabs_and_lines values
;
2113 values
.sals
= (struct symtab_and_line
*)
2114 xmalloc (sizeof (struct symtab_and_line
));
2115 values
.sals
[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
2116 (struct obj_section
*) 0, 0);
2117 values
.sals
[0].section
= SYMBOL_OBJ_SECTION (msymbol
);
2119 /* The minimal symbol might point to a function descriptor;
2120 resolve it to the actual code address instead. */
2121 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
,
2124 if (pc
!= values
.sals
[0].pc
)
2125 values
.sals
[0] = find_pc_sect_line (pc
, NULL
, 0);
2128 skip_prologue_sal (&values
.sals
[0]);