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. */
31 #include "completer.h"
34 /* Prototype for one function in parser-defs.h,
35 instead of including that entire file. */
37 extern char *find_template_name_end (char *);
39 /* We share this one with symtab.c, but it is not exported widely. */
41 extern char *operator_chars (char *, char **);
43 /* Prototypes for local functions */
45 static void cplusplus_error (const char *name
, const char *fmt
, ...) ATTR_FORMAT (printf
, 2, 3);
47 static int total_number_of_methods (struct type
*type
);
49 static int find_methods (struct type
*, char *, struct symbol
**);
51 static void build_canonical_line_spec (struct symtab_and_line
*,
54 static char *find_toplevel_char (char *s
, char c
);
56 static struct symtabs_and_lines
decode_line_2 (struct symbol
*[],
59 /* Helper functions. */
61 /* Issue a helpful hint on using the command completion feature on
62 single quoted demangled C++ symbols as part of the completion
66 cplusplus_error (const char *name
, const char *fmt
, ...)
68 struct ui_file
*tmp_stream
;
69 tmp_stream
= mem_fileopen ();
70 make_cleanup_ui_file_delete (tmp_stream
);
75 vfprintf_unfiltered (tmp_stream
, fmt
, args
);
81 fprintf_unfiltered (tmp_stream
,
82 ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
83 "(Note leading single quote.)"),
85 error_stream (tmp_stream
);
88 /* Return the number of methods described for TYPE, including the
89 methods from types it derives from. This can't be done in the symbol
90 reader because the type of the baseclass might still be stubbed
91 when the definition of the derived class is parsed. */
94 total_number_of_methods (struct type
*type
)
100 if (TYPE_CPLUS_SPECIFIC (type
) == NULL
)
102 count
= TYPE_NFN_FIELDS_TOTAL (type
);
104 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
105 count
+= total_number_of_methods (TYPE_BASECLASS (type
, n
));
110 /* Recursive helper function for decode_line_1.
111 Look for methods named NAME in type T.
112 Return number of matches.
113 Put matches in SYM_ARR, which should have been allocated with
114 a size of total_number_of_methods (T) * sizeof (struct symbol *).
115 Note that this function is g++ specific. */
118 find_methods (struct type
*t
, char *name
, struct symbol
**sym_arr
)
122 char *class_name
= type_name_no_tag (t
);
124 /* Ignore this class if it doesn't have a name. This is ugly, but
125 unless we figure out how to get the physname without the name of
126 the class, then the loop can't do any good. */
128 && (lookup_symbol (class_name
, (struct block
*) NULL
,
129 STRUCT_NAMESPACE
, (int *) NULL
,
130 (struct symtab
**) NULL
)))
136 /* Loop over each method name. At this level, all overloads of a name
137 are counted as a single name. There is an inner loop which loops over
140 for (method_counter
= TYPE_NFN_FIELDS (t
) - 1;
145 char *method_name
= TYPE_FN_FIELDLIST_NAME (t
, method_counter
);
148 if (strncmp (method_name
, "__", 2) == 0 ||
149 strncmp (method_name
, "op", 2) == 0 ||
150 strncmp (method_name
, "type", 4) == 0)
152 if (cplus_demangle_opname (method_name
, dem_opname
, DMGL_ANSI
))
153 method_name
= dem_opname
;
154 else if (cplus_demangle_opname (method_name
, dem_opname
, 0))
155 method_name
= dem_opname
;
158 if (strcmp_iw (name
, method_name
) == 0)
159 /* Find all the overloaded methods with that name. */
160 for (field_counter
= TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
167 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
169 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
173 tmp_name
= gdb_mangle_name (t
,
176 phys_name
= alloca (strlen (tmp_name
) + 1);
177 strcpy (phys_name
, tmp_name
);
181 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
183 /* Destructor is handled by caller, dont add it to the list */
184 if (is_destructor_name (phys_name
) != 0)
187 sym_arr
[i1
] = lookup_symbol (phys_name
,
190 (struct symtab
**) NULL
);
195 /* This error message gets printed, but the method
196 still seems to be found
197 fputs_filtered("(Cannot find method ", gdb_stdout);
198 fprintf_symbol_filtered (gdb_stdout, phys_name,
200 DMGL_PARAMS | DMGL_ANSI);
201 fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
205 else if (strcmp_iw (class_name
, name
) == 0)
207 /* For GCC 3.x and stabs, constructors and destructors have names
208 like __base_ctor and __complete_dtor. Check the physname for now
209 if we're looking for a constructor. */
211 = TYPE_FN_FIELDLIST_LENGTH (t
, method_counter
) - 1;
218 f
= TYPE_FN_FIELDLIST1 (t
, method_counter
);
220 /* GCC 3.x will never produce stabs stub methods, so we don't need
221 to handle this case. */
222 if (TYPE_FN_FIELD_STUB (f
, field_counter
))
224 phys_name
= TYPE_FN_FIELD_PHYSNAME (f
, field_counter
);
225 if (! is_constructor_name (phys_name
))
228 /* If this method is actually defined, include it in the
230 sym_arr
[i1
] = lookup_symbol (phys_name
,
233 (struct symtab
**) NULL
);
241 /* Only search baseclasses if there is no match yet, since names in
242 derived classes override those in baseclasses.
244 FIXME: The above is not true; it is only true of member functions
245 if they have the same number of arguments (??? - section 13.1 of the
246 ARM says the function members are not in the same scope but doesn't
247 really spell out the rules in a way I understand. In any case, if
248 the number of arguments differ this is a case in which we can overload
249 rather than hiding without any problem, and gcc 2.4.5 does overload
250 rather than hiding in this case). */
253 for (ibase
= 0; ibase
< TYPE_N_BASECLASSES (t
); ibase
++)
254 i1
+= find_methods (TYPE_BASECLASS (t
, ibase
), name
, sym_arr
+ i1
);
259 /* Helper function for decode_line_1.
260 Build a canonical line spec in CANONICAL if it is non-NULL and if
261 the SAL has a symtab.
262 If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
263 If SYMNAME is NULL the line number from SAL is used and the canonical
264 line spec is `filename:linenum'. */
267 build_canonical_line_spec (struct symtab_and_line
*sal
, char *symname
,
270 char **canonical_arr
;
271 char *canonical_name
;
273 struct symtab
*s
= sal
->symtab
;
275 if (s
== (struct symtab
*) NULL
276 || s
->filename
== (char *) NULL
277 || canonical
== (char ***) NULL
)
280 canonical_arr
= (char **) xmalloc (sizeof (char *));
281 *canonical
= canonical_arr
;
283 filename
= s
->filename
;
286 canonical_name
= xmalloc (strlen (filename
) + strlen (symname
) + 2);
287 sprintf (canonical_name
, "%s:%s", filename
, symname
);
291 canonical_name
= xmalloc (strlen (filename
) + 30);
292 sprintf (canonical_name
, "%s:%d", filename
, sal
->line
);
294 canonical_arr
[0] = canonical_name
;
299 /* Find an instance of the character C in the string S that is outside
300 of all parenthesis pairs, single-quoted strings, and double-quoted
301 strings. Also, ignore the char within a template name, like a ','
302 within foo<int, int>. */
305 find_toplevel_char (char *s
, char c
)
307 int quoted
= 0; /* zero if we're not in quotes;
308 '"' if we're in a double-quoted string;
309 '\'' if we're in a single-quoted string. */
310 int depth
= 0; /* number of unclosed parens we've seen */
313 for (scan
= s
; *scan
; scan
++)
319 else if (*scan
== '\\' && *(scan
+ 1))
322 else if (*scan
== c
&& ! quoted
&& depth
== 0)
324 else if (*scan
== '"' || *scan
== '\'')
326 else if (*scan
== '(' || *scan
== '<')
328 else if ((*scan
== ')' || *scan
== '>') && depth
> 0)
335 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
336 operate on (ask user if necessary).
337 If CANONICAL is non-NULL return a corresponding array of mangled names
338 as canonical line specs there. */
340 static struct symtabs_and_lines
341 decode_line_2 (struct symbol
*sym_arr
[], int nelts
, int funfirstline
,
344 struct symtabs_and_lines values
, return_values
;
349 struct cleanup
*old_chain
;
350 char **canonical_arr
= (char **) NULL
;
352 values
.sals
= (struct symtab_and_line
*)
353 alloca (nelts
* sizeof (struct symtab_and_line
));
354 return_values
.sals
= (struct symtab_and_line
*)
355 xmalloc (nelts
* sizeof (struct symtab_and_line
));
356 old_chain
= make_cleanup (xfree
, return_values
.sals
);
360 canonical_arr
= (char **) xmalloc (nelts
* sizeof (char *));
361 make_cleanup (xfree
, canonical_arr
);
362 memset (canonical_arr
, 0, nelts
* sizeof (char *));
363 *canonical
= canonical_arr
;
367 printf_unfiltered ("[0] cancel\n[1] all\n");
370 INIT_SAL (&return_values
.sals
[i
]); /* initialize to zeroes */
371 INIT_SAL (&values
.sals
[i
]);
372 if (sym_arr
[i
] && SYMBOL_CLASS (sym_arr
[i
]) == LOC_BLOCK
)
374 values
.sals
[i
] = find_function_start_sal (sym_arr
[i
], funfirstline
);
375 printf_unfiltered ("[%d] %s at %s:%d\n",
377 SYMBOL_SOURCE_NAME (sym_arr
[i
]),
378 values
.sals
[i
].symtab
->filename
,
379 values
.sals
[i
].line
);
382 printf_unfiltered ("?HERE\n");
386 if ((prompt
= getenv ("PS2")) == NULL
)
390 args
= command_line_input (prompt
, 0, "overload-choice");
392 if (args
== 0 || *args
== 0)
393 error_no_arg ("one or more choice numbers");
401 while (*arg1
>= '0' && *arg1
<= '9')
403 if (*arg1
&& *arg1
!= ' ' && *arg1
!= '\t')
404 error ("Arguments must be choice numbers.");
414 for (i
= 0; i
< nelts
; i
++)
416 if (canonical_arr
[i
] == NULL
)
418 symname
= SYMBOL_NAME (sym_arr
[i
]);
419 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
423 memcpy (return_values
.sals
, values
.sals
,
424 (nelts
* sizeof (struct symtab_and_line
)));
425 return_values
.nelts
= nelts
;
426 discard_cleanups (old_chain
);
427 return return_values
;
430 if (num
>= nelts
+ 2)
432 printf_unfiltered ("No choice number %d.\n", num
);
437 if (values
.sals
[num
].pc
)
441 symname
= SYMBOL_NAME (sym_arr
[num
]);
442 make_cleanup (xfree
, symname
);
443 canonical_arr
[i
] = savestring (symname
, strlen (symname
));
445 return_values
.sals
[i
++] = values
.sals
[num
];
446 values
.sals
[num
].pc
= 0;
450 printf_unfiltered ("duplicate request for %d ignored.\n", num
);
455 while (*args
== ' ' || *args
== '\t')
458 return_values
.nelts
= i
;
459 discard_cleanups (old_chain
);
460 return return_values
;
463 /* The parser of linespec itself. */
465 /* Parse a string that specifies a line number.
466 Pass the address of a char * variable; that variable will be
467 advanced over the characters actually parsed.
471 LINENUM -- that line number in current file. PC returned is 0.
472 FILE:LINENUM -- that line in that file. PC returned is 0.
473 FUNCTION -- line number of openbrace of that function.
474 PC returned is the start of the function.
475 VARIABLE -- line number of definition of that variable.
477 FILE:FUNCTION -- likewise, but prefer functions in that file.
478 *EXPR -- line in which address EXPR appears.
480 This may all be followed by an "if EXPR", which we ignore.
482 FUNCTION may be an undebuggable function found in minimal symbol table.
484 If the argument FUNFIRSTLINE is nonzero, we want the first line
485 of real code inside a function when a function is specified, and it is
486 not OK to specify a variable or type to get its line number.
488 DEFAULT_SYMTAB specifies the file to use if none is specified.
489 It defaults to current_source_symtab.
490 DEFAULT_LINE specifies the line number to use for relative
491 line numbers (that start with signs). Defaults to current_source_line.
492 If CANONICAL is non-NULL, store an array of strings containing the canonical
493 line specs there if necessary. Currently overloaded member functions and
494 line numbers or static functions without a filename yield a canonical
495 line spec. The array and the line spec strings are allocated on the heap,
496 it is the callers responsibility to free them.
498 Note that it is possible to return zero for the symtab
499 if no file is validly specified. Callers must check that.
500 Also, the line number returned may be invalid. */
502 /* We allow single quotes in various places. This is a hideous
503 kludge, which exists because the completer can't yet deal with the
504 lack of single quotes. FIXME: write a linespec_completer which we
505 can use as appropriate instead of make_symbol_completion_list. */
507 struct symtabs_and_lines
508 decode_line_1 (char **argptr
, int funfirstline
, struct symtab
*default_symtab
,
509 int default_line
, char ***canonical
)
511 struct symtabs_and_lines values
;
512 struct symtab_and_line val
;
513 register char *p
, *p1
;
514 char *q
, *pp
, *ii
, *p2
;
518 register struct symtab
*s
;
520 register struct symbol
*sym
;
521 /* The symtab that SYM was found in. */
522 struct symtab
*sym_symtab
;
524 register CORE_ADDR pc
;
525 register struct minimal_symbol
*msymbol
;
527 struct symbol
*sym_class
;
530 int is_quote_enclosed
;
534 struct symbol
**sym_arr
;
536 char *saved_arg
= *argptr
;
537 extern char *gdb_completer_quote_characters
;
539 INIT_SAL (&val
); /* initialize to zeroes */
541 /* Defaults have defaults. */
543 if (default_symtab
== 0)
545 default_symtab
= current_source_symtab
;
546 default_line
= current_source_line
;
549 /* See if arg is *PC */
554 pc
= parse_and_eval_address_1 (argptr
);
556 values
.sals
= (struct symtab_and_line
*)
557 xmalloc (sizeof (struct symtab_and_line
));
560 values
.sals
[0] = find_pc_line (pc
, 0);
561 values
.sals
[0].pc
= pc
;
562 values
.sals
[0].section
= find_pc_overlay (pc
);
567 /* 'has_if' is for the syntax:
568 * (gdb) break foo if (a==b)
570 if ((ii
= strstr (*argptr
, " if ")) != NULL
||
571 (ii
= strstr (*argptr
, "\tif ")) != NULL
||
572 (ii
= strstr (*argptr
, " if\t")) != NULL
||
573 (ii
= strstr (*argptr
, "\tif\t")) != NULL
||
574 (ii
= strstr (*argptr
, " if(")) != NULL
||
575 (ii
= strstr (*argptr
, "\tif( ")) != NULL
)
577 /* Temporarily zap out "if (condition)" to not
578 * confuse the parenthesis-checking code below.
579 * This is undone below. Do not change ii!!
586 /* Set various flags.
587 * 'has_parens' is important for overload checking, where
588 * we allow things like:
589 * (gdb) break c::f(int)
592 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
594 is_quoted
= (**argptr
595 && strchr (get_gdb_completer_quote_characters (),
598 has_parens
= ((pp
= strchr (*argptr
, '(')) != NULL
599 && (pp
= strrchr (pp
, ')')) != NULL
);
601 /* Now that we're safely past the has_parens check,
602 * put back " if (condition)" so outer layers can see it
607 /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
608 and we must isolate the first half. Outer layers will call again later
611 Don't count commas that appear in argument lists of overloaded
612 functions, or in quoted strings. It's stupid to go to this much
613 trouble when the rest of the function is such an obvious roach hotel. */
614 ii
= find_toplevel_char (*argptr
, ',');
615 has_comma
= (ii
!= 0);
617 /* Temporarily zap out second half to not
618 * confuse the code below.
619 * This is undone below. Do not change ii!!
626 /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
627 /* May also be CLASS::MEMBER, or NAMESPACE::NAME */
628 /* Look for ':', but ignore inside of <> */
634 is_quote_enclosed
= 1;
639 is_quote_enclosed
= 0;
644 char *temp_end
= find_template_name_end (p
);
646 error ("malformed template specification in command");
649 /* Check for the end of the first half of the linespec. End of line,
650 a tab, a double colon or the last single colon, or a space. But
651 if enclosed in double quotes we do not break on enclosed spaces */
655 && ((p
[1] == ':') || (strchr (p
+ 1, ':') == NULL
)))
656 || ((p
[0] == ' ') && !is_quote_enclosed
))
658 if (p
[0] == '.' && strchr (p
, ':') == NULL
) /* Java qualified method. */
660 /* Find the *last* '.', since the others are package qualifiers. */
661 for (p1
= p
; *p1
; p1
++)
669 while (p
[0] == ' ' || p
[0] == '\t')
672 /* if the closing double quote was left at the end, remove it */
673 if (is_quote_enclosed
)
675 char *closing_quote
= strchr (p
- 1, '"');
676 if (closing_quote
&& closing_quote
[1] == '\0')
677 *closing_quote
= '\0';
680 /* Now that we've safely parsed the first half,
681 * put back ',' so outer layers can see it
686 if ((p
[0] == ':' || p
[0] == '.') && !has_parens
)
691 *argptr
= *argptr
+ 1;
692 if (p
[0] == '.' || p
[1] == ':')
694 char *saved_arg2
= *argptr
;
696 /* First check for "global" namespace specification,
697 of the form "::foo". If found, skip over the colons
698 and jump to normal symbol processing */
700 && ((*argptr
== p
) || (p
[-1] == ' ') || (p
[-1] == '\t')))
703 /* We have what looks like a class or namespace
704 scope specification (A::B), possibly with many
705 levels of namespaces or classes (A::B::C::D).
707 Some versions of the HP ANSI C++ compiler (as also possibly
708 other compilers) generate class/function/member names with
709 embedded double-colons if they are inside namespaces. To
710 handle this, we loop a few times, considering larger and
711 larger prefixes of the string as though they were single
712 symbols. So, if the initially supplied string is
713 A::B::C::D::foo, we have to look up "A", then "A::B",
714 then "A::B::C", then "A::B::C::D", and finally
715 "A::B::C::D::foo" as single, monolithic symbols, because
716 A, B, C or D may be namespaces.
718 Note that namespaces can nest only inside other
719 namespaces, and not inside classes. So we need only
720 consider *prefixes* of the string; there is no need to look up
721 "B::C" separately as a symbol in the previous example. */
723 p2
= p
; /* save for restart */
726 /* Extract the class name. */
728 while (p
!= *argptr
&& p
[-1] == ' ')
730 copy
= (char *) alloca (p
- *argptr
+ 1);
731 memcpy (copy
, *argptr
, p
- *argptr
);
732 copy
[p
- *argptr
] = 0;
734 /* Discard the class name from the arg. */
735 p
= p1
+ (p1
[0] == ':' ? 2 : 1);
736 while (*p
== ' ' || *p
== '\t')
740 sym_class
= lookup_symbol (copy
, 0, STRUCT_NAMESPACE
, 0,
741 (struct symtab
**) NULL
);
744 (t
= check_typedef (SYMBOL_TYPE (sym_class
)),
745 (TYPE_CODE (t
) == TYPE_CODE_STRUCT
746 || TYPE_CODE (t
) == TYPE_CODE_UNION
)))
748 /* Arg token is not digits => try it as a function name
749 Find the next token(everything up to end or next blank). */
751 && strchr (get_gdb_completer_quote_characters (),
754 p
= skip_quoted (*argptr
);
755 *argptr
= *argptr
+ 1;
760 while (*p
&& *p
!= ' ' && *p
!= '\t' && *p
!= ',' && *p
!= ':')
764 q = operator_chars (*argptr, &q1);
768 char *tmp = alloca (q1 - q + 1);
769 memcpy (tmp, q, q1 - q);
771 opname = cplus_mangle_opname (tmp, DMGL_ANSI);
774 cplusplus_error (saved_arg, "no mangling for \"%s\"\n", tmp);
776 copy = (char*) alloca (3 + strlen(opname));
777 sprintf (copy, "__%s", opname);
783 copy
= (char *) alloca (p
- *argptr
+ 1);
784 memcpy (copy
, *argptr
, p
- *argptr
);
785 copy
[p
- *argptr
] = '\0';
787 && copy
[p
- *argptr
- 1]
788 && strchr (get_gdb_completer_quote_characters (),
789 copy
[p
- *argptr
- 1]) != NULL
)
790 copy
[p
- *argptr
- 1] = '\0';
793 /* no line number may be specified */
794 while (*p
== ' ' || *p
== '\t')
799 i1
= 0; /* counter for the symbol array */
800 sym_arr
= (struct symbol
**) alloca (total_number_of_methods (t
)
801 * sizeof (struct symbol
*));
803 if (destructor_name_p (copy
, t
))
805 /* Destructors are a special case. */
806 int m_index
, f_index
;
808 if (get_destructor_fn_field (t
, &m_index
, &f_index
))
810 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (t
, m_index
);
813 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f
, f_index
),
814 NULL
, VAR_NAMESPACE
, (int *) NULL
,
815 (struct symtab
**) NULL
);
821 i1
= find_methods (t
, copy
, sym_arr
);
824 /* There is exactly one field with that name. */
827 if (sym
&& SYMBOL_CLASS (sym
) == LOC_BLOCK
)
829 values
.sals
= (struct symtab_and_line
*)
830 xmalloc (sizeof (struct symtab_and_line
));
832 values
.sals
[0] = find_function_start_sal (sym
,
843 /* There is more than one field with that name
844 (overloaded). Ask the user which one to use. */
845 return decode_line_2 (sym_arr
, i1
, funfirstline
, canonical
);
851 if (is_operator_name (copy
))
853 tmp
= (char *) alloca (strlen (copy
+ 3) + 9);
854 strcpy (tmp
, "operator ");
855 strcat (tmp
, copy
+ 3);
860 cplusplus_error (saved_arg
,
861 "the class `%s' does not have destructor defined\n",
862 SYMBOL_SOURCE_NAME (sym_class
));
864 cplusplus_error (saved_arg
,
865 "the class %s does not have any method named %s\n",
866 SYMBOL_SOURCE_NAME (sym_class
), tmp
);
870 /* Move pointer up to next possible class/namespace token */
871 p
= p2
+ 1; /* restart with old value +1 */
872 /* Move pointer ahead to next double-colon */
873 while (*p
&& (p
[0] != ' ') && (p
[0] != '\t') && (p
[0] != '\''))
877 temp_end
= find_template_name_end (p
);
879 error ("malformed template specification in command");
882 else if ((p
[0] == ':') && (p
[1] == ':'))
883 break; /* found double-colon */
889 break; /* out of the while (1) */
891 p2
= p
; /* save restart for next time around */
892 *argptr
= saved_arg2
; /* restore argptr */
895 /* Last chance attempt -- check entire name as a symbol */
896 /* Use "copy" in preparation for jumping out of this block,
897 to be consistent with usage following the jump target */
898 copy
= (char *) alloca (p
- saved_arg2
+ 1);
899 memcpy (copy
, saved_arg2
, p
- saved_arg2
);
900 /* Note: if is_quoted should be true, we snuff out quote here anyway */
901 copy
[p
- saved_arg2
] = '\000';
902 /* Set argptr to skip over the name */
903 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
904 /* Look up entire name */
905 sym
= lookup_symbol (copy
, 0, VAR_NAMESPACE
, 0, &sym_symtab
);
906 s
= (struct symtab
*) 0;
907 /* Prepare to jump: restore the " if (condition)" so outer layers see it */
908 /* Symbol was found --> jump to normal symbol processing.
909 Code following "symbol_found" expects "copy" to have the
910 symbol name, "sym" to have the symbol pointer, "s" to be
911 a specified file's symtab, and sym_symtab to be the symbol's
913 /* By jumping there we avoid falling through the FILE:LINE and
914 FILE:FUNC processing stuff below */
918 /* Couldn't find any interpretation as classes/namespaces, so give up */
919 /* The quotes are important if copy is empty. */
920 cplusplus_error (saved_arg
,
921 "Can't find member of namespace, class, struct, or union named \"%s\"\n",
927 /* Extract the file name. */
929 while (p
!= *argptr
&& p
[-1] == ' ')
931 if ((*p
== '"') && is_quote_enclosed
)
933 copy
= (char *) alloca (p
- *argptr
+ 1);
934 memcpy (copy
, *argptr
, p
- *argptr
);
935 /* It may have the ending quote right after the file name */
936 if (is_quote_enclosed
&& copy
[p
- *argptr
- 1] == '"')
937 copy
[p
- *argptr
- 1] = 0;
939 copy
[p
- *argptr
] = 0;
941 /* Find that file's data. */
942 s
= lookup_symtab (copy
);
945 if (!have_full_symbols () && !have_partial_symbols ())
946 error ("No symbol table is loaded. Use the \"file\" command.");
947 error ("No source file named %s.", copy
);
950 /* Discard the file name from the arg. */
952 while (*p
== ' ' || *p
== '\t')
957 /* No one really seems to know why this was added. It certainly
958 breaks the command line, though, whenever the passed
959 name is of the form ClassName::Method. This bit of code
960 singles out the class name, and if funfirstline is set (for
961 example, you are setting a breakpoint at this function),
962 you get an error. This did not occur with earlier
963 verions, so I am ifdef'ing this out. 3/29/99 */
966 /* Check if what we have till now is a symbol name */
968 /* We may be looking at a template instantiation such
969 as "foo<int>". Check here whether we know about it,
970 instead of falling through to the code below which
971 handles ordinary function names, because that code
972 doesn't like seeing '<' and '>' in a name -- the
973 skip_quoted call doesn't go past them. So see if we
974 can figure it out right now. */
976 copy
= (char *) alloca (p
- *argptr
+ 1);
977 memcpy (copy
, *argptr
, p
- *argptr
);
978 copy
[p
- *argptr
] = '\000';
979 sym
= lookup_symbol (copy
, 0, VAR_NAMESPACE
, 0, &sym_symtab
);
982 /* Yes, we have a symbol; jump to symbol processing */
983 /* Code after symbol_found expects S, SYM_SYMTAB, SYM,
984 and COPY to be set correctly */
985 *argptr
= (*p
== '\'') ? p
+ 1 : p
;
986 s
= (struct symtab
*) 0;
989 /* Otherwise fall out from here and go to file/line spec
994 /* S is specified file's symtab, or 0 if no file specified.
995 arg no longer contains the file name. */
997 /* Check whether arg is all digits (and sign) */
1000 if (*q
== '-' || *q
== '+')
1002 while (*q
>= '0' && *q
<= '9')
1005 if (q
!= *argptr
&& (*q
== 0 || *q
== ' ' || *q
== '\t' || *q
== ','))
1007 /* We found a token consisting of all digits -- at least one digit. */
1014 /* We might need a canonical line spec if no file was specified. */
1015 int need_canonical
= (s
== 0) ? 1 : 0;
1017 /* This is where we need to make sure that we have good defaults.
1018 We must guarantee that this section of code is never executed
1019 when we are called with just a function name, since
1020 select_source_symtab calls us with such an argument */
1022 if (s
== 0 && default_symtab
== 0)
1024 select_source_symtab (0);
1025 default_symtab
= current_source_symtab
;
1026 default_line
= current_source_line
;
1029 if (**argptr
== '+')
1030 sign
= plus
, (*argptr
)++;
1031 else if (**argptr
== '-')
1032 sign
= minus
, (*argptr
)++;
1033 val
.line
= atoi (*argptr
);
1040 val
.line
= default_line
+ val
.line
;
1046 val
.line
= default_line
- val
.line
;
1051 break; /* No need to adjust val.line. */
1054 while (*q
== ' ' || *q
== '\t')
1060 /* It is possible that this source file has more than one symtab,
1061 and that the new line number specification has moved us from the
1062 default (in s) to a new one. */
1063 val
.symtab
= find_line_symtab (s
, val
.line
, NULL
, NULL
);
1064 if (val
.symtab
== 0)
1068 values
.sals
= (struct symtab_and_line
*)
1069 xmalloc (sizeof (struct symtab_and_line
));
1070 values
.sals
[0] = val
;
1073 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1077 /* Arg token is not digits => try it as a variable name
1078 Find the next token (everything up to end or next whitespace). */
1080 if (**argptr
== '$') /* May be a convenience variable */
1081 p
= skip_quoted (*argptr
+ (((*argptr
)[1] == '$') ? 2 : 1)); /* One or two $ chars possible */
1084 p
= skip_quoted (*argptr
);
1086 error ("Unmatched single quote.");
1088 else if (has_parens
)
1094 p
= skip_quoted (*argptr
);
1097 copy
= (char *) alloca (p
- *argptr
+ 1);
1098 memcpy (copy
, *argptr
, p
- *argptr
);
1099 copy
[p
- *argptr
] = '\0';
1102 && copy
[0] == copy
[p
- *argptr
- 1]
1103 && strchr (get_gdb_completer_quote_characters (), copy
[0]) != NULL
)
1105 copy
[p
- *argptr
- 1] = '\0';
1108 while (*p
== ' ' || *p
== '\t')
1112 /* If it starts with $: may be a legitimate variable or routine name
1113 (e.g. HP-UX millicode routines such as $$dyncall), or it may
1114 be history value, or it may be a convenience variable */
1120 int need_canonical
= 0;
1122 p
= (copy
[1] == '$') ? copy
+ 2 : copy
+ 1;
1123 while (*p
>= '0' && *p
<= '9')
1125 if (!*p
) /* reached end of token without hitting non-digit */
1127 /* We have a value history reference */
1128 sscanf ((copy
[1] == '$') ? copy
+ 2 : copy
+ 1, "%d", &index
);
1129 valx
= access_value_history ((copy
[1] == '$') ? -index
: index
);
1130 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
1131 error ("History values used in line specs must have integer values.");
1135 /* Not all digits -- may be user variable/function or a
1136 convenience variable */
1138 /* Look up entire name as a symbol first */
1139 sym
= lookup_symbol (copy
, 0, VAR_NAMESPACE
, 0, &sym_symtab
);
1140 s
= (struct symtab
*) 0;
1142 /* Symbol was found --> jump to normal symbol processing.
1143 Code following "symbol_found" expects "copy" to have the
1144 symbol name, "sym" to have the symbol pointer, "s" to be
1145 a specified file's symtab, and sym_symtab to be the symbol's
1150 /* If symbol was not found, look in minimal symbol tables */
1151 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1152 /* Min symbol was found --> jump to minsym processing. */
1154 goto minimal_symbol_found
;
1156 /* Not a user variable or function -- must be convenience variable */
1157 need_canonical
= (s
== 0) ? 1 : 0;
1158 valx
= value_of_internalvar (lookup_internalvar (copy
+ 1));
1159 if (TYPE_CODE (VALUE_TYPE (valx
)) != TYPE_CODE_INT
)
1160 error ("Convenience variables used in line specs must have integer values.");
1163 /* Either history value or convenience value from above, in valx */
1164 val
.symtab
= s
? s
: default_symtab
;
1165 val
.line
= value_as_long (valx
);
1168 values
.sals
= (struct symtab_and_line
*) xmalloc (sizeof val
);
1169 values
.sals
[0] = val
;
1173 build_canonical_line_spec (values
.sals
, NULL
, canonical
);
1179 /* Look up that token as a variable.
1180 If file specified, use that file's per-file block to start with. */
1182 sym
= lookup_symbol (copy
,
1183 (s
? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s
), STATIC_BLOCK
)
1184 : get_selected_block (0)),
1185 VAR_NAMESPACE
, 0, &sym_symtab
);
1187 symbol_found
: /* We also jump here from inside the C++ class/namespace
1188 code on finding a symbol of the form "A::B::C" */
1192 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
1194 /* Arg is the name of a function */
1195 values
.sals
= (struct symtab_and_line
*)
1196 xmalloc (sizeof (struct symtab_and_line
));
1197 values
.sals
[0] = find_function_start_sal (sym
, funfirstline
);
1200 /* Don't use the SYMBOL_LINE; if used at all it points to
1201 the line containing the parameters or thereabouts, not
1202 the first line of code. */
1204 /* We might need a canonical line spec if it is a static
1208 struct blockvector
*bv
= BLOCKVECTOR (sym_symtab
);
1209 struct block
*b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1210 if (lookup_block_symbol (b
, copy
, NULL
, VAR_NAMESPACE
) != NULL
)
1211 build_canonical_line_spec (values
.sals
, copy
, canonical
);
1218 error ("\"%s\" is not a function", copy
);
1219 else if (SYMBOL_LINE (sym
) != 0)
1221 /* We know its line number. */
1222 values
.sals
= (struct symtab_and_line
*)
1223 xmalloc (sizeof (struct symtab_and_line
));
1225 memset (&values
.sals
[0], 0, sizeof (values
.sals
[0]));
1226 values
.sals
[0].symtab
= sym_symtab
;
1227 values
.sals
[0].line
= SYMBOL_LINE (sym
);
1231 /* This can happen if it is compiled with a compiler which doesn't
1232 put out line numbers for variables. */
1233 /* FIXME: Shouldn't we just set .line and .symtab to zero
1234 and return? For example, "info line foo" could print
1236 error ("Line number not known for symbol \"%s\"", copy
);
1240 msymbol
= lookup_minimal_symbol (copy
, NULL
, NULL
);
1242 minimal_symbol_found
: /* We also jump here from the case for variables
1243 that begin with '$' */
1245 if (msymbol
!= NULL
)
1247 values
.sals
= (struct symtab_and_line
*)
1248 xmalloc (sizeof (struct symtab_and_line
));
1249 values
.sals
[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol
),
1250 (struct sec
*) 0, 0);
1251 values
.sals
[0].section
= SYMBOL_BFD_SECTION (msymbol
);
1254 values
.sals
[0].pc
+= FUNCTION_START_OFFSET
;
1255 values
.sals
[0].pc
= SKIP_PROLOGUE (values
.sals
[0].pc
);
1261 if (!have_full_symbols () &&
1262 !have_partial_symbols () && !have_minimal_symbols ())
1263 error ("No symbol table is loaded. Use the \"file\" command.");
1265 error ("Function \"%s\" not defined.", copy
);
1266 return values
; /* for lint */