1 /* Parser for linespec for the GNU debugger, GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
32 #include "completer.h"
34 #include "parser-defs.h"
36 /* We share this one with symtab.c, but it is not exported widely. */
38 extern char *operator_chars (char *, char **);
40 /* Prototypes for local functions */
42 static void initialize_defaults (struct symtab
**default_symtab
,
45 static void set_flags (char *arg
, int *is_quoted
, char **paren_pointer
);
47 static struct symtabs_and_lines
decode_indirect (char **argptr
);
49 static void cplusplus_error (const char *name
, const char *fmt
, ...) ATTR_FORMAT (printf
, 2, 3);
51 static int total_number_of_methods (struct type
*type
);
53 static int find_methods (struct type
*, char *, struct symbol
**);
55 static void build_canonical_line_spec (struct symtab_and_line
*,
58 static char *find_toplevel_char (char *s
, char c
);
60 static struct symtabs_and_lines
decode_line_2 (struct symbol
*[],
64 symtabs_and_lines
symbol_found (int funfirstline
,
69 struct symtab
*sym_symtab
);
72 symtabs_and_lines
minsym_found (int funfirstline
,
73 struct minimal_symbol
*msymbol
);
75 /* Helper functions. */
77 /* Issue a helpful hint on using the command completion feature on
78 single quoted demangled C++ symbols as part of the completion
82 cplusplus_error (const char *name
, const char *fmt
, ...)
84 struct ui_file
*tmp_stream
;
85 tmp_stream
= mem_fileopen ();
86 make_cleanup_ui_file_delete (tmp_stream
);
91 vfprintf_unfiltered (tmp_stream
, fmt
, args
);
97 fprintf_unfiltered (tmp_stream
,
98 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
99 "(Note leading single quote.)"),
101 error_stream (tmp_stream
);
104 /* Return the number of methods described for TYPE, including the
105 methods from types it derives from. This can't be done in the symbol
106 reader because the type of the baseclass might still be stubbed
107 when the definition of the derived class is parsed. */
110 total_number_of_methods (struct type
*type
)
115 CHECK_TYPEDEF (type
);
116 if (TYPE_CPLUS_SPECIFIC (type
) == NULL
)
118 count
= TYPE_NFN_FIELDS_TOTAL (type
);
120 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
121 count
+= total_number_of_methods (TYPE_BASECLASS (type
, n
));
126 /* Recursive helper function for decode_line_1.
127 Look for methods named NAME in type T.
128 Return number of matches.
129 Put matches in SYM_ARR, which should have been allocated with
130 a size of total_number_of_methods (T) * sizeof (struct symbol *).
131 Note that this function is g++ specific. */
134 find_methods (struct type
*t
, char *name
, struct symbol
**sym_arr
)
138 char *class_name
= type_name_no_tag (t
);
140 /* Ignore this class if it doesn't have a name. This is ugly, but
141 unless we figure out how to get the physname without the name of
142 the class, then the loop can't do any good. */
144 && (lookup_symbol (class_name
, (struct block
*) NULL
,
145 STRUCT_NAMESPACE
, (int *) NULL
,
146 (struct symtab
**) NULL
)))
149 int name_len
= strlen (name
);
153 /* Loop over each method name. At this level, all overloads of a name
154 are counted as a single name. There is an inner loop which loops over
157 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
162 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
165 if (strncmp (method_name
, "__", 2) == 0 ||
166 strncmp (method_name
, "op", 2) == 0 ||
167 strncmp (method_name
, "type", 4) == 0)
169 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
170 method_name
= dem_opname
;
171 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
172 method_name
= dem_opname
;
175 if (strcmp_iw (name
, method_name
) == 0)
176 /* Find all the overloaded methods with that name. */
177 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
184 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
186 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
190 tmp_name
= gdb_mangle_name (t
,
193 phys_name
= alloca (strlen (tmp_name
) + 1);
194 strcpy (phys_name
, tmp_name
);
198 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
200 /* Destructor is handled by caller, dont add it to the list */
201 if (is_destructor_name (phys_name
) != 0)
204 sym_arr
[i1
] = lookup_symbol (phys_name
,
207 (struct symtab
**) NULL
);
212 /* This error message gets printed, but the method
213 still seems to be found
214 fputs_filtered("(Cannot find method ", gdb_stdout);
215 fprintf_symbol_filtered (gdb_stdout, phys_name,
217 DMGL_PARAMS | DMGL_ANSI);
218 fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
222 else if (strncmp (class_name
, name
, name_len
) == 0
223 && (class_name
[name_len
] == '\0'
224 || class_name
[name_len
] == '<'))
226 /* For GCC 3.x and stabs, constructors and destructors have names
227 like __base_ctor and __complete_dtor. Check the physname for now
228 if we're looking for a constructor. */
230 = TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
237 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
239 /* GCC 3.x will never produce stabs stub methods, so we don't need
240 to handle this case. */
241 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
243 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
244 if (! is_constructor_name (phys_name
))
247 /* If this method is actually defined, include it in the
249 sym_arr
[i1
] = lookup_symbol (phys_name
,
252 (struct symtab
**) NULL
);
260 /* Only search baseclasses if there is no match yet, since names in
261 derived classes override those in baseclasses.
263 FIXME: The above is not true; it is only true of member functions
264 if they have the same number of arguments (??? - section 13.1 of the
265 ARM says the function members are not in the same scope but doesn't
266 really spell out the rules in a way I understand. In any case, if
267 the number of arguments differ this is a case in which we can overload
268 rather than hiding without any problem, and gcc 2.4.5 does overload
269 rather than hiding in this case). */
272 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
273 i1
+= find_methods (TYPE_BASECLASS (t
, ibase
), name
, sym_arr
+ i1
);
278 /* Helper function for decode_line_1.
279 Build a canonical line spec in CANONICAL if it is non-NULL and if
280 the SAL has a symtab.
281 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
282 If SYMNAME is NULL the line number from SAL is used and the canonical
283 line spec is `filename:linenum'. */
286 build_canonical_line_spec (struct symtab_and_line
*sal
, char *symname
,
289 char **canonical_arr
;
290 char *canonical_name
;
292 struct symtab
*s
= sal
->symtab
;
294 if (s
== (struct symtab
*) NULL
295 || s
->filename
== (char *) NULL
296 || canonical
== (char ***) NULL
)
299 canonical_arr
= (char **) xmalloc (sizeof (char *));
300 *canonical
= canonical_arr
;
302 filename
= s
->filename
;
305 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
306 sprintf (canonical_name
, "%s:%s", filename
, symname
);
310 canonical_name
= xmalloc (strlen (filename
) + 30);
311 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
313 canonical_arr
[0] = canonical_name
;
318 /* Find an instance of the character C in the string S that is outside
319 of all parenthesis pairs, single-quoted strings, and double-quoted
320 strings. Also, ignore the char within a template name, like a ','
321 within foo<int, int>. */
324 find_toplevel_char (char *s
, char c
)
326 int quoted
= 0; /* zero if we're not in quotes;
327 '"' if we're in a double-quoted string;
328 '\'' if we're in a single-quoted string. */
329 int depth
= 0; /* number of unclosed parens we've seen */
332 for (scan
= s
; *scan
; scan
++)
338 else if (*scan
== '\\' && *(scan
+ 1))
341 else if (*scan
== c
&& ! quoted
&& depth
== 0)
343 else if (*scan
== '"' || *scan
== '\'')
345 else if (*scan
== '(' || *scan
== '<')
347 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
354 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
355 operate on (ask user if necessary).
356 If CANONICAL is non-NULL return a corresponding array of mangled names
357 as canonical line specs there. */
359 static struct symtabs_and_lines
360 decode_line_2 (struct symbol
*sym_arr
[], int nelts
, int funfirstline
,
363 struct symtabs_and_lines values
, return_values
;
368 struct cleanup
*old_chain
;
369 char **canonical_arr
= (char **) NULL
;
371 values
.sals
= (struct symtab_and_line
*)
372 alloca (nelts
* sizeof (struct symtab_and_line
));
373 return_values
.sals
= (struct symtab_and_line
*)
374 xmalloc (nelts
* sizeof (struct symtab_and_line
));
375 old_chain
= make_cleanup (xfree
, return_values
.sals
);
379 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
380 make_cleanup (xfree
, canonical_arr
);
381 memset (canonical_arr
, 0, nelts
* sizeof (char *));
382 *canonical
= canonical_arr
;
386 printf_unfiltered ("[0] cancel\n[1] all\n");
389 init_sal (&return_values
.sals
[i
]); /* initialize to zeroes */
390 init_sal (&values
.sals
[i
]);
391 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
393 values
.sals
[i
] = find_function_start_sal (sym_arr
[i
], funfirstline
);
394 printf_unfiltered ("[%d] %s at %s:%d\n",
396 SYMBOL_SOURCE_NAME (sym_arr
[i
]),
397 values
.sals
[i
].symtab
->filename
,
398 values
.sals
[i
].line
);
401 printf_unfiltered ("?HERE\n");
405 if ((prompt
= getenv ("PS2")) == NULL
)
409 args
= command_line_input (prompt
, 0, "overload-choice");
411 if (args
== 0 || *args
== 0)
412 error_no_arg ("one or more choice numbers");
420 while (*arg1
>= '0' && *arg1
<= '9')
422 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
423 error ("Arguments must be choice numbers.");
433 for (i
= 0; i
< nelts
; i
++)
435 if (canonical_arr
[i
] == NULL
)
437 symname
= SYMBOL_NAME (sym_arr
[i
]);
438 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
442 memcpy (return_values
.sals
, values
.sals
,
443 (nelts
* sizeof (struct symtab_and_line
)));
444 return_values
.nelts
= nelts
;
445 discard_cleanups (old_chain
);
446 return return_values
;
449 if (num
>= nelts
+ 2)
451 printf_unfiltered ("No choice number %d.\n", num
);
456 if (values
.sals
[num
].pc
)
460 symname
= SYMBOL_NAME (sym_arr
[num
]);
461 make_cleanup (xfree
, symname
);
462 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
464 return_values
.sals
[i
++] = values
.sals
[num
];
465 values
.sals
[num
].pc
= 0;
469 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
474 while (*args
== ' ' || *args
== '\t')
477 return_values
.nelts
= i
;
478 discard_cleanups (old_chain
);
479 return return_values
;
482 /* The parser of linespec itself. */
484 /* Parse a string that specifies a line number.
485 Pass the address of a char * variable; that variable will be
486 advanced over the characters actually parsed.
490 LINENUM -- that line number in current file. PC returned is 0.
491 FILE:LINENUM -- that line in that file. PC returned is 0.
492 FUNCTION -- line number of openbrace of that function.
493 PC returned is the start of the function.
494 VARIABLE -- line number of definition of that variable.
496 FILE:FUNCTION -- likewise, but prefer functions in that file.
497 *EXPR -- line in which address EXPR appears.
499 This may all be followed by an "if EXPR", which we ignore.
501 FUNCTION may be an undebuggable function found in minimal symbol table.
503 If the argument FUNFIRSTLINE is nonzero, we want the first line
504 of real code inside a function when a function is specified, and it is
505 not OK to specify a variable or type to get its line number.
507 DEFAULT_SYMTAB specifies the file to use if none is specified.
508 It defaults to current_source_symtab.
509 DEFAULT_LINE specifies the line number to use for relative
510 line numbers (that start with signs). Defaults to current_source_line.
511 If CANONICAL is non-NULL, store an array of strings containing the canonical
512 line specs there if necessary. Currently overloaded member functions and
513 line numbers or static functions without a filename yield a canonical
514 line spec. The array and the line spec strings are allocated on the heap,
515 it is the callers responsibility to free them.
517 Note that it is possible to return zero for the symtab
518 if no file is validly specified. Callers must check that.
519 Also, the line number returned may be invalid. */
521 /* We allow single quotes in various places. This is a hideous
522 kludge, which exists because the completer can't yet deal with the
523 lack of single quotes. FIXME: write a linespec_completer which we
524 can use as appropriate instead of make_symbol_completion_list. */
526 struct symtabs_and_lines
527 decode_line_1 (char **argptr
, int funfirstline
, struct symtab
*default_symtab
,
528 int default_line
, char ***canonical
)
530 struct symtabs_and_lines values
;
531 struct symtab_and_line val
;
532 register char *p
, *p1
;
537 register struct symtab
*s
;
539 register struct symbol
*sym
;
540 /* The symtab that SYM was found in. */
541 struct symtab
*sym_symtab
;
543 register struct minimal_symbol
*msymbol
;
545 struct symbol
*sym_class
;
547 /* This is NULL if there are no parens in *ARGPTR, or a pointer to
548 the closing parenthesis if there are parens. */
550 /* This says whether or not something in *ARGPTR is quoted with
551 completer_quotes (i.e. with single quotes). */
553 int is_quote_enclosed
;
555 struct symbol
**sym_arr
;
557 char *saved_arg
= *argptr
;
558 extern char *gdb_completer_quote_characters
;
560 init_sal (&val
); /* initialize to zeroes */
562 /* Defaults have defaults. */
564 initialize_defaults (&default_symtab
, &default_line
);
566 /* See if arg is *PC */
569 return decode_indirect (argptr
);
571 /* Set various flags.
572 * 'paren_pointer' is important for overload checking, where
573 * we allow things like:
574 * (gdb) break c::f(int)
577 set_flags (*argptr
, &is_quoted
, &paren_pointer
);
579 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
580 and we must isolate the first half. Outer layers will call again later
583 Don't count commas that appear in argument lists of overloaded
584 functions, or in quoted strings. It's stupid to go to this much
585 trouble when the rest of the function is such an obvious roach hotel. */
586 ii
= find_toplevel_char (*argptr
, ',');
587 has_comma
= (ii
!= 0);
589 /* Temporarily zap out second half to not
590 * confuse the code below.
591 * This is undone below. Do not change ii!!
598 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
599 /* May also be CLASS::MEMBER, or NAMESPACE::NAME */
600 /* Look for ':', but ignore inside of <> */
606 is_quote_enclosed
= 1;
611 is_quote_enclosed
= 0;
616 char *temp_end
= find_template_name_end (p
);
618 error ("malformed template specification in command");
621 /* Check for the end of the first half of the linespec. End of line,
622 a tab, a double colon or the last single colon, or a space. But
623 if enclosed in double quotes we do not break on enclosed spaces */
627 && ((p
[1] == ':') || (strchr (p
+ 1, ':') == NULL
)))
628 || ((p
[0] == ' ') && !is_quote_enclosed
))
630 if (p
[0] == '.' && strchr (p
, ':') == NULL
) /* Java qualified method. */
632 /* Find the *last* '.', since the others are package qualifiers. */
633 for (p1
= p
; *p1
; p1
++)
641 while (p
[0] == ' ' || p
[0] == '\t')
644 /* if the closing double quote was left at the end, remove it */
645 if (is_quote_enclosed
)
647 char *closing_quote
= strchr (p
- 1, '"');
648 if (closing_quote
&& closing_quote
[1] == '\0')
649 *closing_quote
= '\0';
652 /* Now that we've safely parsed the first half,
653 * put back ',' so outer layers can see it
658 if ((p
[0] == ':' || p
[0] == '.') && paren_pointer
== NULL
)
663 *argptr
= *argptr
+ 1;
664 if (p
[0] == '.' || p
[1] == ':')
666 char *saved_arg2
= *argptr
;
668 /* First check for "global" namespace specification,
669 of the form "::foo". If found, skip over the colons
670 and jump to normal symbol processing */
672 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
675 /* We have what looks like a class or namespace
676 scope specification (A::B), possibly with many
677 levels of namespaces or classes (A::B::C::D).
679 Some versions of the HP ANSI C++ compiler (as also possibly
680 other compilers) generate class/function/member names with
681 embedded double-colons if they are inside namespaces. To
682 handle this, we loop a few times, considering larger and
683 larger prefixes of the string as though they were single
684 symbols. So, if the initially supplied string is
685 A::B::C::D::foo, we have to look up "A", then "A::B",
686 then "A::B::C", then "A::B::C::D", and finally
687 "A::B::C::D::foo" as single, monolithic symbols, because
688 A, B, C or D may be namespaces.
690 Note that namespaces can nest only inside other
691 namespaces, and not inside classes. So we need only
692 consider *prefixes* of the string; there is no need to look up
693 "B::C" separately as a symbol in the previous example. */
695 p2
= p
; /* save for restart */
698 /* Extract the class name. */
700 while (p
!= *argptr
&& p
[-1] == ' ')
702 copy
= (char *) alloca (p
- *argptr
+ 1);
703 memcpy (copy
, *argptr
, p
- *argptr
);
704 copy
[p
- *argptr
] = 0;
706 /* Discard the class name from the arg. */
707 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
708 while (*p
== ' ' || *p
== '\t')
712 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
713 (struct symtab
**) NULL
);
716 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
717 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
718 || TYPE_CODE (t
) == TYPE_CODE_UNION
)))
720 /* Arg token is not digits => try it as a function name
721 Find the next token(everything up to end or next blank). */
723 && strchr (get_gdb_completer_quote_characters (),
726 p
= skip_quoted (*argptr
);
727 *argptr
= *argptr
+ 1;
732 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':')
736 q = operator_chars (*argptr, &q1);
740 char *tmp = alloca (q1 - q + 1);
741 memcpy (tmp, q, q1 - q);
743 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
746 cplusplus_error (saved_arg, "no mangling for \"%s\"\n", tmp);
748 copy = (char*) alloca (3 + strlen(opname));
749 sprintf (copy, "__%s", opname);
755 copy
= (char *) alloca (p
- *argptr
+ 1);
756 memcpy (copy
, *argptr
, p
- *argptr
);
757 copy
[p
- *argptr
] = '\0';
759 && copy
[p
- *argptr
- 1]
760 && strchr (get_gdb_completer_quote_characters (),
761 copy
[p
- *argptr
- 1]) != NULL
)
762 copy
[p
- *argptr
- 1] = '\0';
765 /* no line number may be specified */
766 while (*p
== ' ' || *p
== '\t')
771 i1
= 0; /* counter for the symbol array */
772 sym_arr
= (struct symbol
**) alloca (total_number_of_methods (t
)
773 * sizeof (struct symbol
*));
775 if (destructor_name_p (copy
, t
))
777 /* Destructors are a special case. */
778 int m_index
, f_index
;
780 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
782 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, m_index
);
785 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, f_index
),
786 NULL
, VAR_NAMESPACE
, (int *) NULL
,
787 (struct symtab
**) NULL
);
793 i1
= find_methods (t
, copy
, sym_arr
);
796 /* There is exactly one field with that name. */
799 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
801 values
.sals
= (struct symtab_and_line
*)
802 xmalloc (sizeof (struct symtab_and_line
));
804 values
.sals
[0] = find_function_start_sal (sym
,
815 /* There is more than one field with that name
816 (overloaded). Ask the user which one to use. */
817 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
823 if (is_operator_name (copy
))
825 tmp
= (char *) alloca (strlen (copy
+ 3) + 9);
826 strcpy (tmp
, "operator ");
827 strcat (tmp
, copy
+ 3);
832 cplusplus_error (saved_arg
,
833 "the class `%s' does not have destructor defined\n",
834 SYMBOL_SOURCE_NAME (sym_class
));
836 cplusplus_error (saved_arg
,
837 "the class %s does not have any method named %s\n",
838 SYMBOL_SOURCE_NAME (sym_class
), tmp
);
842 /* Move pointer up to next possible class/namespace token */
843 p
= p2
+ 1; /* restart with old value +1 */
844 /* Move pointer ahead to next double-colon */
845 while (*p
&& (p
[0] != ' ') && (p
[0] != '\t') && (p
[0] != '\''))
849 temp_end
= find_template_name_end (p
);
851 error ("malformed template specification in command");
854 else if ((p
[0] == ':') && (p
[1] == ':'))
855 break; /* found double-colon */
861 break; /* out of the while (1) */
863 p2
= p
; /* save restart for next time around */
864 *argptr
= saved_arg2
; /* restore argptr */
867 /* Last chance attempt -- check entire name as a symbol */
868 /* Use "copy" in preparation for jumping out of this block,
869 to be consistent with usage following the jump target */
870 copy
= (char *) alloca (p
- saved_arg2
+ 1);
871 memcpy (copy
, saved_arg2
, p
- saved_arg2
);
872 /* Note: if is_quoted should be true, we snuff out quote here anyway */
873 copy
[p
- saved_arg2
] = '\000';
874 /* Set argptr to skip over the name */
875 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
876 /* Look up entire name */
877 sym
= lookup_symbol (copy
, 0, VAR_NAMESPACE
, 0, &sym_symtab
);
878 s
= (struct symtab
*) 0;
880 return symbol_found (funfirstline
, canonical
, copy
, sym
,
883 /* Couldn't find any interpretation as classes/namespaces, so give up */
884 /* The quotes are important if copy is empty. */
885 cplusplus_error (saved_arg
,
886 "Can't find member of namespace, class, struct, or union named \"%s\"\n",
892 /* Extract the file name. */
894 while (p
!= *argptr
&& p
[-1] == ' ')
896 if ((*p
== '"') && is_quote_enclosed
)
898 copy
= (char *) alloca (p
- *argptr
+ 1);
899 memcpy (copy
, *argptr
, p
- *argptr
);
900 /* It may have the ending quote right after the file name */
901 if (is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
902 copy
[p
- *argptr
- 1] = 0;
904 copy
[p
- *argptr
] = 0;
906 /* Find that file's data. */
907 s
= lookup_symtab (copy
);
910 if (!have_full_symbols () && !have_partial_symbols ())
911 error ("No symbol table is loaded. Use the \"file\" command.");
912 error ("No source file named %s.", copy
);
915 /* Discard the file name from the arg. */
917 while (*p
== ' ' || *p
== '\t')
922 /* No one really seems to know why this was added. It certainly
923 breaks the command line, though, whenever the passed
924 name is of the form ClassName::Method. This bit of code
925 singles out the class name, and if funfirstline is set (for
926 example, you are setting a breakpoint at this function),
927 you get an error. This did not occur with earlier
928 verions, so I am ifdef'ing this out. 3/29/99 */
931 /* Check if what we have till now is a symbol name */
933 /* We may be looking at a template instantiation such
934 as "foo<int>". Check here whether we know about it,
935 instead of falling through to the code below which
936 handles ordinary function names, because that code
937 doesn't like seeing '<' and '>' in a name -- the
938 skip_quoted call doesn't go past them. So see if we
939 can figure it out right now. */
941 copy
= (char *) alloca (p
- *argptr
+ 1);
942 memcpy (copy
, *argptr
, p
- *argptr
);
943 copy
[p
- *argptr
] = '\000';
944 sym
= lookup_symbol (copy
, 0, VAR_NAMESPACE
, 0, &sym_symtab
);
947 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
948 return symbol_found (funfirstline
, canonical
, copy
, sym
,
951 /* Otherwise fall out from here and go to file/line spec
956 /* S is specified file's symtab, or 0 if no file specified.
957 arg no longer contains the file name. */
959 /* Check whether arg is all digits (and sign) */
962 if (*q
== '-' || *q
== '+')
964 while (*q
>= '0' && *q
<= '9')
967 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ','))
969 /* We found a token consisting of all digits -- at least one digit. */
976 /* We might need a canonical line spec if no file was specified. */
977 int need_canonical
= (s
== 0) ? 1 : 0;
979 /* This is where we need to make sure that we have good defaults.
980 We must guarantee that this section of code is never executed
981 when we are called with just a function name, since
982 set_default_source_symtab_and_line uses
983 select_source_symtab that calls us with such an argument */
985 if (s
== 0 && default_symtab
== 0)
987 /* Make sure we have at least a default source file. */
988 set_default_source_symtab_and_line ();
989 initialize_defaults (&default_symtab
, &default_line
);
993 sign
= plus
, (*argptr
)++;
994 else if (**argptr
== '-')
995 sign
= minus
, (*argptr
)++;
996 val
.line
= atoi (*argptr
);
1003 val
.line
= default_line
+ val
.line
;
1009 val
.line
= default_line
- val
.line
;
1014 break; /* No need to adjust val.line. */
1017 while (*q
== ' ' || *q
== '\t')
1023 /* It is possible that this source file has more than one symtab,
1024 and that the new line number specification has moved us from the
1025 default (in s) to a new one. */
1026 val
.symtab
= find_line_symtab (s
, val
.line
, NULL
, NULL
);
1027 if (val
.symtab
== 0)
1031 values
.sals
= (struct symtab_and_line
*)
1032 xmalloc (sizeof (struct symtab_and_line
));
1033 values
.sals
[0] = val
;
1036 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1040 /* Arg token is not digits => try it as a variable name
1041 Find the next token (everything up to end or next whitespace). */
1043 if (**argptr
== '$') /* May be a convenience variable */
1044 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1)); /* One or two $ chars possible */
1047 p
= skip_quoted (*argptr
);
1049 error ("Unmatched single quote.");
1051 else if (paren_pointer
!= NULL
)
1053 p
= paren_pointer
+ 1;
1057 p
= skip_quoted (*argptr
);
1060 copy
= (char *) alloca (p
- *argptr
+ 1);
1061 memcpy (copy
, *argptr
, p
- *argptr
);
1062 copy
[p
- *argptr
] = '\0';
1065 && copy
[0] == copy
[p
- *argptr
- 1]
1066 && strchr (get_gdb_completer_quote_characters (), copy
[0]) != NULL
)
1068 copy
[p
- *argptr
- 1] = '\0';
1071 while (*p
== ' ' || *p
== '\t')
1075 /* If it starts with $: may be a legitimate variable or routine name
1076 (e.g. HP-UX millicode routines such as $$dyncall), or it may
1077 be history value, or it may be a convenience variable */
1083 int need_canonical
= 0;
1085 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
1086 while (*p
>= '0' && *p
<= '9')
1088 if (!*p
) /* reached end of token without hitting non-digit */
1090 /* We have a value history reference */
1091 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
1092 valx
= access_value_history ((copy
[1] == '$') ? -index
: index
);
1093 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
1094 error ("History values used in line specs must have integer values.");
1098 /* Not all digits -- may be user variable/function or a
1099 convenience variable */
1101 /* Look up entire name as a symbol first */
1102 sym
= lookup_symbol (copy
, 0, VAR_NAMESPACE
, 0, &sym_symtab
);
1103 s
= (struct symtab
*) 0;
1105 /* Symbol was found --> jump to normal symbol processing. */
1107 return symbol_found (funfirstline
, canonical
, copy
, sym
,
1110 /* If symbol was not found, look in minimal symbol tables */
1111 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1112 /* Min symbol was found --> jump to minsym processing. */
1114 return minsym_found (funfirstline
, msymbol
);
1116 /* Not a user variable or function -- must be convenience variable */
1117 need_canonical
= (s
== 0) ? 1 : 0;
1118 valx
= value_of_internalvar (lookup_internalvar (copy
+ 1));
1119 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
1120 error ("Convenience variables used in line specs must have integer values.");
1123 /* Either history value or convenience value from above, in valx */
1124 val
.symtab
= s
? s
: default_symtab
;
1125 val
.line
= value_as_long (valx
);
1128 values
.sals
= (struct symtab_and_line
*) xmalloc (sizeof val
);
1129 values
.sals
[0] = val
;
1133 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1139 /* Look up that token as a variable.
1140 If file specified, use that file's per-file block to start with. */
1142 sym
= lookup_symbol (copy
,
1143 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
1144 : get_selected_block (0)),
1145 VAR_NAMESPACE
, 0, &sym_symtab
);
1148 return symbol_found (funfirstline
, canonical
, copy
, sym
, s
, sym_symtab
);
1150 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1152 if (msymbol
!= NULL
)
1153 return minsym_found (funfirstline
, msymbol
);
1155 if (!have_full_symbols () &&
1156 !have_partial_symbols () && !have_minimal_symbols ())
1157 error ("No symbol table is loaded. Use the \"file\" command.");
1159 error ("Function \"%s\" not defined.", copy
);
1160 return values
; /* for lint */
1165 /* Now, still more helper functions. */
1167 /* NOTE: carlton/2002-11-07: Some of these have non-obvious side
1168 effects. In particular, if a function is passed ARGPTR as an
1169 argument, it modifies what ARGPTR points to. (Typically, it
1170 advances *ARGPTR past whatever substring it has just looked
1173 /* First, some functions to initialize stuff at the beggining of the
1177 initialize_defaults (struct symtab
**default_symtab
, int *default_line
)
1179 if (*default_symtab
== 0)
1181 /* Use whatever we have for the default source line. We don't use
1182 get_current_or_default_symtab_and_line as it can recurse and call
1184 struct symtab_and_line cursal
=
1185 get_current_source_symtab_and_line ();
1187 *default_symtab
= cursal
.symtab
;
1188 *default_line
= cursal
.line
;
1193 set_flags (char *arg
, int *is_quoted
, char **paren_pointer
)
1198 /* 'has_if' is for the syntax:
1199 * (gdb) break foo if (a==b)
1201 if ((ii
= strstr (arg
, " if ")) != NULL
||
1202 (ii
= strstr (arg
, "\tif ")) != NULL
||
1203 (ii
= strstr (arg
, " if\t")) != NULL
||
1204 (ii
= strstr (arg
, "\tif\t")) != NULL
||
1205 (ii
= strstr (arg
, " if(")) != NULL
||
1206 (ii
= strstr (arg
, "\tif( ")) != NULL
)
1208 /* Temporarily zap out "if (condition)" to not
1209 * confuse the parenthesis-checking code below.
1210 * This is undone below. Do not change ii!!
1218 && strchr (get_gdb_completer_quote_characters (),
1221 *paren_pointer
= strchr (arg
, '(');
1222 if (*paren_pointer
!= NULL
)
1223 *paren_pointer
= strrchr (*paren_pointer
, ')');
1225 /* Now that we're safely past the paren_pointer check,
1226 * put back " if (condition)" so outer layers can see it
1234 /* Decode arg of the form *PC. */
1236 static struct symtabs_and_lines
1237 decode_indirect (char **argptr
)
1239 struct symtabs_and_lines values
;
1243 pc
= parse_and_eval_address_1 (argptr
);
1245 values
.sals
= (struct symtab_and_line
*)
1246 xmalloc (sizeof (struct symtab_and_line
));
1249 values
.sals
[0] = find_pc_line (pc
, 0);
1250 values
.sals
[0].pc
= pc
;
1251 values
.sals
[0].section
= find_pc_overlay (pc
);
1258 /* Now come some functions that are called from multiple places within
1261 /* We've found a symbol SYM to associate with our linespec; build a
1262 corresponding struct symtabs_and_lines. */
1264 static struct symtabs_and_lines
1265 symbol_found (int funfirstline
, char ***canonical
, char *copy
,
1266 struct symbol
*sym
, struct symtab
*s
,
1267 struct symtab
*sym_symtab
)
1269 struct symtabs_and_lines values
;
1271 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1273 /* Arg is the name of a function */
1274 values
.sals
= (struct symtab_and_line
*)
1275 xmalloc (sizeof (struct symtab_and_line
));
1276 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
1279 /* Don't use the SYMBOL_LINE; if used at all it points to
1280 the line containing the parameters or thereabouts, not
1281 the first line of code. */
1283 /* We might need a canonical line spec if it is a static
1287 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
1288 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1289 if (lookup_block_symbol (b
, copy
, NULL
, VAR_NAMESPACE
) != NULL
)
1290 build_canonical_line_spec (values
.sals
, copy
, canonical
);
1297 error ("\"%s\" is not a function", copy
);
1298 else if (SYMBOL_LINE (sym
) != 0)
1300 /* We know its line number. */
1301 values
.sals
= (struct symtab_and_line
*)
1302 xmalloc (sizeof (struct symtab_and_line
));
1304 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
1305 values
.sals
[0].symtab
= sym_symtab
;
1306 values
.sals
[0].line
= SYMBOL_LINE (sym
);
1310 /* This can happen if it is compiled with a compiler which doesn't
1311 put out line numbers for variables. */
1312 /* FIXME: Shouldn't we just set .line and .symtab to zero
1313 and return? For example, "info line foo" could print
1315 error ("Line number not known for symbol \"%s\"", copy
);
1319 /* We've found a minimal symbol MSYMBOL to associate with our
1320 linespec; build a corresponding struct symtabs_and_lines. */
1322 static struct symtabs_and_lines
1323 minsym_found (int funfirstline
, struct minimal_symbol
*msymbol
)
1325 struct symtabs_and_lines values
;
1327 values
.sals
= (struct symtab_and_line
*)
1328 xmalloc (sizeof (struct symtab_and_line
));
1329 values
.sals
[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
1330 (struct sec
*) 0, 0);
1331 values
.sals
[0].section
= SYMBOL_BFD_SECTION (msymbol
);
1334 values
.sals
[0].pc
+= FUNCTION_START_OFFSET
;
1335 values
.sals
[0].pc
= SKIP_PROLOGUE (values
.sals
[0].pc
);