Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / linespec.c
CommitLineData
5796c8dc
SS
1/* Parser for linespec for the GNU debugger, GDB.
2
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "symtab.h"
22#include "frame.h"
23#include "command.h"
24#include "symfile.h"
25#include "objfiles.h"
26#include "source.h"
27#include "demangle.h"
28#include "value.h"
29#include "completer.h"
30#include "cp-abi.h"
cf7f2e2d 31#include "cp-support.h"
5796c8dc
SS
32#include "parser-defs.h"
33#include "block.h"
34#include "objc-lang.h"
35#include "linespec.h"
36#include "exceptions.h"
37#include "language.h"
38#include "interps.h"
39#include "mi/mi-cmds.h"
40#include "target.h"
cf7f2e2d 41#include "arch-utils.h"
c50c785c
JM
42#include <ctype.h>
43#include "cli/cli-utils.h"
a45ae5f8
JM
44#include "filenames.h"
45#include "ada-lang.h"
ef5ccd6c 46#include "stack.h"
5796c8dc 47
a45ae5f8
JM
48typedef struct symtab *symtab_p;
49DEF_VEC_P (symtab_p);
5796c8dc 50
a45ae5f8
JM
51typedef struct symbol *symbolp;
52DEF_VEC_P (symbolp);
53
54typedef struct type *typep;
55DEF_VEC_P (typep);
56
57/* An address entry is used to ensure that any given location is only
58 added to the result a single time. It holds an address and the
59 program space from which the address came. */
60
61struct address_entry
62{
63 struct program_space *pspace;
64 CORE_ADDR addr;
65};
66
ef5ccd6c
JM
67/* A helper struct which just holds a minimal symbol and the object
68 file from which it came. */
69
70typedef struct minsym_and_objfile
71{
72 struct minimal_symbol *minsym;
73 struct objfile *objfile;
74} minsym_and_objfile_d;
75
76DEF_VEC_O (minsym_and_objfile_d);
77
78/* An enumeration of possible signs for a line offset. */
79enum offset_relative_sign
80{
81 /* No sign */
82 LINE_OFFSET_NONE,
83
84 /* A plus sign ("+") */
85 LINE_OFFSET_PLUS,
86
87 /* A minus sign ("-") */
88 LINE_OFFSET_MINUS,
89
90 /* A special "sign" for unspecified offset. */
91 LINE_OFFSET_UNKNOWN
92};
93
94/* A line offset in a linespec. */
95
96struct line_offset
97{
98 /* Line offset and any specified sign. */
99 int offset;
100 enum offset_relative_sign sign;
101};
102
103/* A linespec. Elements of this structure are filled in by a parser
104 (either parse_linespec or some other function). The structure is
105 then converted into SALs by convert_linespec_to_sals. */
106
107struct linespec
108{
109 /* An expression and the resulting PC. Specifying an expression
110 currently precludes the use of other members. */
111
112 /* The expression entered by the user. */
113 const char *expression;
114
115 /* The resulting PC expression derived from evaluating EXPRESSION. */
116 CORE_ADDR expr_pc;
117
118 /* Any specified file symtabs. */
119
120 /* The user-supplied source filename or NULL if none was specified. */
121 const char *source_filename;
122
123 /* The list of symtabs to search to which to limit the search. May not
124 be NULL. If SOURCE_FILENAME is NULL (no user-specified filename),
125 FILE_SYMTABS should contain one single NULL member. This will
126 cause the code to use the default symtab. */
127 VEC (symtab_p) *file_symtabs;
128
129 /* The name of a function or method and any matching symbols. */
130
131 /* The user-specified function name. If no function name was
132 supplied, this may be NULL. */
133 const char *function_name;
134
135 /* A list of matching function symbols and minimal symbols. Both lists
136 may be NULL if no matching symbols were found. */
137 VEC (symbolp) *function_symbols;
138 VEC (minsym_and_objfile_d) *minimal_symbols;
139
140 /* The name of a label and matching symbols. */
141
142 /* The user-specified label name. */
143 const char *label_name;
144
145 /* A structure of matching label symbols and the corresponding
146 function symbol in which the label was found. Both may be NULL
147 or both must be non-NULL. */
148 struct
149 {
150 VEC (symbolp) *label_symbols;
151 VEC (symbolp) *function_symbols;
152 } labels;
153
154 /* Line offset. It may be LINE_OFFSET_UNKNOWN, meaning that no
155 offset was specified. */
156 struct line_offset line_offset;
157};
158typedef struct linespec *linespec_p;
159
160/* A canonical linespec represented as a symtab-related string.
161
162 Each entry represents the "SYMTAB:SUFFIX" linespec string.
163 SYMTAB can be converted for example by symtab_to_fullname or
164 symtab_to_filename_for_display as needed. */
165
166struct linespec_canonical_name
167{
168 /* Remaining text part of the linespec string. */
169 char *suffix;
170
171 /* If NULL then SUFFIX is the whole linespec string. */
172 struct symtab *symtab;
173};
174
a45ae5f8
JM
175/* An instance of this is used to keep all state while linespec
176 operates. This instance is passed around as a 'this' pointer to
177 the various implementation methods. */
178
179struct linespec_state
180{
ef5ccd6c
JM
181 /* The language in use during linespec processing. */
182 const struct language_defn *language;
183
a45ae5f8
JM
184 /* The program space as seen when the module was entered. */
185 struct program_space *program_space;
186
187 /* The default symtab to use, if no other symtab is specified. */
188 struct symtab *default_symtab;
189
190 /* The default line to use. */
191 int default_line;
192
a45ae5f8
JM
193 /* The 'funfirstline' value that was passed in to decode_line_1 or
194 decode_line_full. */
195 int funfirstline;
196
197 /* Nonzero if we are running in 'list' mode; see decode_line_list. */
198 int list_mode;
199
200 /* The 'canonical' value passed to decode_line_full, or NULL. */
201 struct linespec_result *canonical;
202
203 /* Canonical strings that mirror the symtabs_and_lines result. */
ef5ccd6c 204 struct linespec_canonical_name *canonical_names;
a45ae5f8
JM
205
206 /* This is a set of address_entry objects which is used to prevent
207 duplicate symbols from being entered into the result. */
208 htab_t addr_set;
209};
210
211/* This is a helper object that is used when collecting symbols into a
212 result. */
213
214struct collect_info
215{
216 /* The linespec object in use. */
217 struct linespec_state *state;
218
ef5ccd6c
JM
219 /* A list of symtabs to which to restrict matches. */
220 VEC (symtab_p) *file_symtabs;
221
a45ae5f8 222 /* The result being accumulated. */
ef5ccd6c
JM
223 struct
224 {
225 VEC (symbolp) *symbols;
226 VEC (minsym_and_objfile_d) *minimal_symbols;
227 } result;
a45ae5f8 228};
5796c8dc 229
ef5ccd6c 230/* Token types */
5796c8dc 231
ef5ccd6c
JM
232enum ls_token_type
233{
234 /* A keyword */
235 LSTOKEN_KEYWORD = 0,
5796c8dc 236
ef5ccd6c
JM
237 /* A colon "separator" */
238 LSTOKEN_COLON,
5796c8dc 239
ef5ccd6c
JM
240 /* A string */
241 LSTOKEN_STRING,
5796c8dc 242
ef5ccd6c
JM
243 /* A number */
244 LSTOKEN_NUMBER,
245
246 /* A comma */
247 LSTOKEN_COMMA,
248
249 /* EOI (end of input) */
250 LSTOKEN_EOI,
251
252 /* Consumed token */
253 LSTOKEN_CONSUMED
254};
255typedef enum ls_token_type linespec_token_type;
5796c8dc 256
ef5ccd6c 257/* List of keywords */
5796c8dc 258
ef5ccd6c 259static const char * const linespec_keywords[] = { "if", "thread", "task" };
5796c8dc 260
ef5ccd6c 261/* A token of the linespec lexer */
5796c8dc 262
ef5ccd6c
JM
263struct ls_token
264{
265 /* The type of the token */
266 linespec_token_type type;
267
268 /* Data for the token */
269 union
270 {
271 /* A string, given as a stoken */
272 struct stoken string;
273
274 /* A keyword */
275 const char *keyword;
276 } data;
277};
278typedef struct ls_token linespec_token;
279
280#define LS_TOKEN_STOKEN(TOK) (TOK).data.string
281#define LS_TOKEN_KEYWORD(TOK) (TOK).data.keyword
282
283/* An instance of the linespec parser. */
284
285struct ls_parser
286{
287 /* Lexer internal data */
288 struct
289 {
290 /* Save head of input stream. */
291 char *saved_arg;
292
293 /* Head of the input stream. */
294 char **stream;
295#define PARSER_STREAM(P) (*(P)->lexer.stream)
296
297 /* The current token. */
298 linespec_token current;
299 } lexer;
300
301 /* Is the entire linespec quote-enclosed? */
302 int is_quote_enclosed;
303
304 /* Is a keyword syntactically valid at this point?
305 In, e.g., "break thread thread 1", the leading "keyword" must not
306 be interpreted as such. */
307 int keyword_ok;
308
309 /* The state of the parse. */
310 struct linespec_state state;
311#define PARSER_STATE(PPTR) (&(PPTR)->state)
312
313 /* The result of the parse. */
314 struct linespec result;
315#define PARSER_RESULT(PPTR) (&(PPTR)->result)
316};
317typedef struct ls_parser linespec_parser;
318
319/* Prototypes for local functions. */
5796c8dc 320
ef5ccd6c
JM
321static void iterate_over_file_blocks (struct symtab *symtab,
322 const char *name, domain_enum domain,
323 symbol_found_callback_ftype *callback,
324 void *data);
5796c8dc 325
ef5ccd6c
JM
326static void initialize_defaults (struct symtab **default_symtab,
327 int *default_line);
5796c8dc 328
ef5ccd6c 329static CORE_ADDR linespec_expression_to_pc (const char **exp_ptr);
5796c8dc 330
ef5ccd6c
JM
331static struct symtabs_and_lines decode_objc (struct linespec_state *self,
332 linespec_p ls,
333 char **argptr);
5796c8dc 334
ef5ccd6c 335static VEC (symtab_p) *symtabs_from_filename (const char *);
5796c8dc 336
ef5ccd6c
JM
337static VEC (symbolp) *find_label_symbols (struct linespec_state *self,
338 VEC (symbolp) *function_symbols,
339 VEC (symbolp) **label_funcs_ret,
340 const char *name);
5796c8dc 341
ef5ccd6c
JM
342static void find_linespec_symbols (struct linespec_state *self,
343 VEC (symtab_p) *file_symtabs,
344 const char *name,
345 VEC (symbolp) **symbols,
346 VEC (minsym_and_objfile_d) **minsyms);
5796c8dc 347
ef5ccd6c
JM
348static struct line_offset
349 linespec_parse_variable (struct linespec_state *self,
350 const char *variable);
5796c8dc 351
a45ae5f8
JM
352static int symbol_to_sal (struct symtab_and_line *result,
353 int funfirstline, struct symbol *sym);
c50c785c 354
a45ae5f8
JM
355static void add_matching_symbols_to_info (const char *name,
356 struct collect_info *info,
357 struct program_space *pspace);
5796c8dc 358
a45ae5f8
JM
359static void add_all_symbol_names_from_pspace (struct collect_info *info,
360 struct program_space *pspace,
361 VEC (const_char_ptr) *names);
5796c8dc 362
ef5ccd6c 363static VEC (symtab_p) *collect_symtabs_from_filename (const char *file);
5796c8dc 364
ef5ccd6c
JM
365static void decode_digits_ordinary (struct linespec_state *self,
366 linespec_p ls,
367 int line,
368 struct symtabs_and_lines *sals,
369 struct linetable_entry **best_entry);
a45ae5f8 370
ef5ccd6c
JM
371static void decode_digits_list_mode (struct linespec_state *self,
372 linespec_p ls,
373 struct symtabs_and_lines *values,
374 struct symtab_and_line val);
c50c785c 375
ef5ccd6c
JM
376static void minsym_found (struct linespec_state *self, struct objfile *objfile,
377 struct minimal_symbol *msymbol,
378 struct symtabs_and_lines *result);
5796c8dc 379
ef5ccd6c
JM
380static int compare_symbols (const void *a, const void *b);
381
382static int compare_msymbols (const void *a, const void *b);
383
384static const char *find_toplevel_char (const char *s, char c);
385
386/* Permitted quote characters for the parser. This is different from the
387 completer's quote characters to allow backward compatibility with the
388 previous parser. */
389static const char *const linespec_quote_characters = "\"\'";
390
391/* Lexer functions. */
392
393/* Lex a number from the input in PARSER. This only supports
394 decimal numbers.
395
396 Return true if input is decimal numbers. Return false if not. */
397
398static int
399linespec_lexer_lex_number (linespec_parser *parser, linespec_token *tokenp)
a45ae5f8 400{
ef5ccd6c
JM
401 tokenp->type = LSTOKEN_NUMBER;
402 LS_TOKEN_STOKEN (*tokenp).length = 0;
403 LS_TOKEN_STOKEN (*tokenp).ptr = PARSER_STREAM (parser);
5796c8dc 404
ef5ccd6c
JM
405 /* Keep any sign at the start of the stream. */
406 if (*PARSER_STREAM (parser) == '+' || *PARSER_STREAM (parser) == '-')
a45ae5f8 407 {
ef5ccd6c
JM
408 ++LS_TOKEN_STOKEN (*tokenp).length;
409 ++(PARSER_STREAM (parser));
410 }
a45ae5f8 411
ef5ccd6c
JM
412 while (isdigit (*PARSER_STREAM (parser)))
413 {
414 ++LS_TOKEN_STOKEN (*tokenp).length;
415 ++(PARSER_STREAM (parser));
416 }
a45ae5f8 417
ef5ccd6c
JM
418 /* If the next character in the input buffer is not a space, comma,
419 quote, or colon, this input does not represent a number. */
420 if (*PARSER_STREAM (parser) != '\0'
421 && !isspace (*PARSER_STREAM (parser)) && *PARSER_STREAM (parser) != ','
422 && *PARSER_STREAM (parser) != ':'
423 && !strchr (linespec_quote_characters, *PARSER_STREAM (parser)))
424 {
425 PARSER_STREAM (parser) = LS_TOKEN_STOKEN (*tokenp).ptr;
426 return 0;
a45ae5f8 427 }
ef5ccd6c
JM
428
429 return 1;
a45ae5f8
JM
430}
431
ef5ccd6c
JM
432/* Does P represent one of the keywords? If so, return
433 the keyword. If not, return NULL. */
a45ae5f8 434
ef5ccd6c
JM
435static const char *
436linespec_lexer_lex_keyword (const char *p)
a45ae5f8 437{
ef5ccd6c 438 int i;
a45ae5f8 439
ef5ccd6c
JM
440 if (p != NULL)
441 {
442 for (i = 0; i < ARRAY_SIZE (linespec_keywords); ++i)
443 {
444 int len = strlen (linespec_keywords[i]);
445
446 /* If P begins with one of the keywords and the next
447 character is not a valid identifier character,
448 we have found a keyword. */
449 if (strncmp (p, linespec_keywords[i], len) == 0
450 && !(isalnum (p[len]) || p[len] == '_'))
451 return linespec_keywords[i];
452 }
453 }
454
455 return NULL;
a45ae5f8
JM
456}
457
ef5ccd6c
JM
458/* Does STRING represent an Ada operator? If so, return the length
459 of the decoded operator name. If not, return 0. */
a45ae5f8
JM
460
461static int
ef5ccd6c 462is_ada_operator (const char *string)
a45ae5f8 463{
ef5ccd6c 464 const struct ada_opname_map *mapping;
a45ae5f8 465
ef5ccd6c
JM
466 for (mapping = ada_opname_table;
467 mapping->encoded != NULL
468 && strncmp (mapping->decoded, string,
469 strlen (mapping->decoded)) != 0; ++mapping)
470 ;
471
472 return mapping->decoded == NULL ? 0 : strlen (mapping->decoded);
a45ae5f8
JM
473}
474
ef5ccd6c
JM
475/* Find QUOTE_CHAR in STRING, accounting for the ':' terminal. Return
476 the location of QUOTE_CHAR, or NULL if not found. */
a45ae5f8 477
ef5ccd6c
JM
478static const char *
479skip_quote_char (const char *string, char quote_char)
a45ae5f8 480{
ef5ccd6c 481 const char *p, *last;
a45ae5f8 482
ef5ccd6c
JM
483 p = last = find_toplevel_char (string, quote_char);
484 while (p && *p != '\0' && *p != ':')
485 {
486 p = find_toplevel_char (p, quote_char);
487 if (p != NULL)
488 last = p++;
489 }
a45ae5f8 490
ef5ccd6c 491 return last;
a45ae5f8 492}
5796c8dc 493
ef5ccd6c
JM
494/* Make a writable copy of the string given in TOKEN, trimming
495 any trailing whitespace. */
5796c8dc 496
ef5ccd6c
JM
497static char *
498copy_token_string (linespec_token token)
5796c8dc 499{
ef5ccd6c 500 char *str, *s;
cf7f2e2d 501
ef5ccd6c
JM
502 if (token.type == LSTOKEN_KEYWORD)
503 return xstrdup (LS_TOKEN_KEYWORD (token));
5796c8dc 504
ef5ccd6c
JM
505 str = savestring (LS_TOKEN_STOKEN (token).ptr,
506 LS_TOKEN_STOKEN (token).length);
507 s = remove_trailing_whitespace (str, str + LS_TOKEN_STOKEN (token).length);
508 *s = '\0';
5796c8dc 509
ef5ccd6c 510 return str;
5796c8dc
SS
511}
512
ef5ccd6c 513/* Does P represent the end of a quote-enclosed linespec? */
5796c8dc
SS
514
515static int
ef5ccd6c 516is_closing_quote_enclosed (const char *p)
5796c8dc 517{
ef5ccd6c
JM
518 if (strchr (linespec_quote_characters, *p))
519 ++p;
520 p = skip_spaces ((char *) p);
521 return (*p == '\0' || linespec_lexer_lex_keyword (p));
a45ae5f8
JM
522}
523
ef5ccd6c
JM
524/* Find the end of the parameter list that starts with *INPUT.
525 This helper function assists with lexing string segments
526 which might contain valid (non-terminating) commas. */
a45ae5f8 527
ef5ccd6c
JM
528static char *
529find_parameter_list_end (char *input)
a45ae5f8 530{
ef5ccd6c
JM
531 char end_char, start_char;
532 int depth;
533 char *p;
5796c8dc 534
ef5ccd6c
JM
535 start_char = *input;
536 if (start_char == '(')
537 end_char = ')';
538 else if (start_char == '<')
539 end_char = '>';
540 else
541 return NULL;
5796c8dc 542
ef5ccd6c
JM
543 p = input;
544 depth = 0;
545 while (*p)
a45ae5f8 546 {
ef5ccd6c
JM
547 if (*p == start_char)
548 ++depth;
549 else if (*p == end_char)
a45ae5f8 550 {
ef5ccd6c 551 if (--depth == 0)
a45ae5f8 552 {
ef5ccd6c
JM
553 ++p;
554 break;
a45ae5f8
JM
555 }
556 }
ef5ccd6c 557 ++p;
a45ae5f8 558 }
ef5ccd6c
JM
559
560 return p;
5796c8dc
SS
561}
562
c50c785c 563
ef5ccd6c
JM
564/* Lex a string from the input in PARSER. */
565
566static linespec_token
567linespec_lexer_lex_string (linespec_parser *parser)
c50c785c 568{
ef5ccd6c
JM
569 linespec_token token;
570 char *start = PARSER_STREAM (parser);
c50c785c 571
ef5ccd6c
JM
572 token.type = LSTOKEN_STRING;
573
574 /* If the input stream starts with a quote character, skip to the next
575 quote character, regardless of the content. */
576 if (strchr (linespec_quote_characters, *PARSER_STREAM (parser)))
c50c785c 577 {
ef5ccd6c
JM
578 const char *end;
579 char quote_char = *PARSER_STREAM (parser);
c50c785c 580
ef5ccd6c
JM
581 /* Special case: Ada operators. */
582 if (PARSER_STATE (parser)->language->la_language == language_ada
583 && quote_char == '\"')
584 {
585 int len = is_ada_operator (PARSER_STREAM (parser));
c50c785c 586
ef5ccd6c
JM
587 if (len != 0)
588 {
589 /* The input is an Ada operator. Return the quoted string
590 as-is. */
591 LS_TOKEN_STOKEN (token).ptr = PARSER_STREAM (parser);
592 LS_TOKEN_STOKEN (token).length = len;
593 PARSER_STREAM (parser) += len;
594 return token;
595 }
c50c785c 596
ef5ccd6c
JM
597 /* The input does not represent an Ada operator -- fall through
598 to normal quoted string handling. */
599 }
5796c8dc 600
ef5ccd6c
JM
601 /* Skip past the beginning quote. */
602 ++(PARSER_STREAM (parser));
c50c785c 603
ef5ccd6c
JM
604 /* Mark the start of the string. */
605 LS_TOKEN_STOKEN (token).ptr = PARSER_STREAM (parser);
606
607 /* Skip to the ending quote. */
608 end = skip_quote_char (PARSER_STREAM (parser), quote_char);
609
610 /* Error if the input did not terminate properly. */
611 if (end == NULL)
612 error (_("unmatched quote"));
613
614 /* Skip over the ending quote and mark the length of the string. */
615 PARSER_STREAM (parser) = (char *) ++end;
616 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - 2 - start;
617 }
618 else
5796c8dc 619 {
ef5ccd6c 620 char *p;
5796c8dc 621
ef5ccd6c
JM
622 /* Otherwise, only identifier characters are permitted.
623 Spaces are the exception. In general, we keep spaces,
624 but only if the next characters in the input do not resolve
625 to one of the keywords.
5796c8dc 626
ef5ccd6c
JM
627 This allows users to forgo quoting CV-qualifiers, template arguments,
628 and similar common language constructs. */
5796c8dc 629
ef5ccd6c
JM
630 while (1)
631 {
632 if (isspace (*PARSER_STREAM (parser)))
633 {
634 p = skip_spaces (PARSER_STREAM (parser));
635 /* When we get here we know we've found something followed by
636 a space (we skip over parens and templates below).
637 So if we find a keyword now, we know it is a keyword and not,
638 say, a function name. */
639 if (linespec_lexer_lex_keyword (p) != NULL)
640 {
641 LS_TOKEN_STOKEN (token).ptr = start;
642 LS_TOKEN_STOKEN (token).length
643 = PARSER_STREAM (parser) - start;
644 return token;
645 }
646
647 /* Advance past the whitespace. */
648 PARSER_STREAM (parser) = p;
649 }
650
651 /* If the next character is EOI or (single) ':', the
652 string is complete; return the token. */
653 if (*PARSER_STREAM (parser) == 0)
654 {
655 LS_TOKEN_STOKEN (token).ptr = start;
656 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start;
657 return token;
658 }
659 else if (PARSER_STREAM (parser)[0] == ':')
660 {
661 /* Do not tokenize the C++ scope operator. */
662 if (PARSER_STREAM (parser)[1] == ':')
663 ++(PARSER_STREAM (parser));
664
665 /* Do not tokenify if the input length so far is one
666 (i.e, a single-letter drive name) and the next character
667 is a directory separator. This allows Windows-style
668 paths to be recognized as filenames without quoting it. */
669 else if ((PARSER_STREAM (parser) - start) != 1
670 || !IS_DIR_SEPARATOR (PARSER_STREAM (parser)[1]))
671 {
672 LS_TOKEN_STOKEN (token).ptr = start;
673 LS_TOKEN_STOKEN (token).length
674 = PARSER_STREAM (parser) - start;
675 return token;
676 }
677 }
678 /* Special case: permit quote-enclosed linespecs. */
679 else if (parser->is_quote_enclosed
680 && strchr (linespec_quote_characters,
681 *PARSER_STREAM (parser))
682 && is_closing_quote_enclosed (PARSER_STREAM (parser)))
683 {
684 LS_TOKEN_STOKEN (token).ptr = start;
685 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start;
686 return token;
687 }
688 /* Because commas may terminate a linespec and appear in
689 the middle of valid string input, special cases for
690 '<' and '(' are necessary. */
691 else if (*PARSER_STREAM (parser) == '<'
692 || *PARSER_STREAM (parser) == '(')
693 {
694 char *p;
695
696 p = find_parameter_list_end (PARSER_STREAM (parser));
697 if (p != NULL)
698 {
699 PARSER_STREAM (parser) = p;
700 continue;
701 }
702 }
703 /* Commas are terminators, but not if they are part of an
704 operator name. */
705 else if (*PARSER_STREAM (parser) == ',')
706 {
707 if ((PARSER_STATE (parser)->language->la_language
708 == language_cplus)
709 && (PARSER_STREAM (parser) - start) > 8
710 /* strlen ("operator") */)
711 {
712 char *p = strstr (start, "operator");
713
714 if (p != NULL && is_operator_name (p))
715 {
716 /* This is an operator name. Keep going. */
717 ++(PARSER_STREAM (parser));
718 continue;
719 }
720 }
721
722 /* Comma terminates the string. */
723 LS_TOKEN_STOKEN (token).ptr = start;
724 LS_TOKEN_STOKEN (token).length = PARSER_STREAM (parser) - start;
725 return token;
726 }
727
728 /* Advance the stream. */
729 ++(PARSER_STREAM (parser));
730 }
731 }
732
733 return token;
734}
735
736/* Lex a single linespec token from PARSER. */
737
738static linespec_token
739linespec_lexer_lex_one (linespec_parser *parser)
740{
741 const char *keyword;
742
743 if (parser->lexer.current.type == LSTOKEN_CONSUMED)
744 {
745 /* Skip any whitespace. */
746 PARSER_STREAM (parser) = skip_spaces (PARSER_STREAM (parser));
747
748 /* Check for a keyword, they end the linespec. */
749 keyword = NULL;
750 if (parser->keyword_ok)
751 keyword = linespec_lexer_lex_keyword (PARSER_STREAM (parser));
752 if (keyword != NULL)
753 {
754 parser->lexer.current.type = LSTOKEN_KEYWORD;
755 LS_TOKEN_KEYWORD (parser->lexer.current) = keyword;
756 return parser->lexer.current;
757 }
758
759 /* Handle other tokens. */
760 switch (*PARSER_STREAM (parser))
761 {
762 case 0:
763 parser->lexer.current.type = LSTOKEN_EOI;
764 break;
765
766 case '+': case '-':
767 case '0': case '1': case '2': case '3': case '4':
768 case '5': case '6': case '7': case '8': case '9':
769 if (!linespec_lexer_lex_number (parser, &(parser->lexer.current)))
770 parser->lexer.current = linespec_lexer_lex_string (parser);
771 break;
772
773 case ':':
774 /* If we have a scope operator, lex the input as a string.
775 Otherwise, return LSTOKEN_COLON. */
776 if (PARSER_STREAM (parser)[1] == ':')
777 parser->lexer.current = linespec_lexer_lex_string (parser);
778 else
779 {
780 parser->lexer.current.type = LSTOKEN_COLON;
781 ++(PARSER_STREAM (parser));
782 }
783 break;
784
785 case '\'': case '\"':
786 /* Special case: permit quote-enclosed linespecs. */
787 if (parser->is_quote_enclosed
788 && is_closing_quote_enclosed (PARSER_STREAM (parser)))
789 {
790 ++(PARSER_STREAM (parser));
791 parser->lexer.current.type = LSTOKEN_EOI;
792 }
793 else
794 parser->lexer.current = linespec_lexer_lex_string (parser);
795 break;
796
797 case ',':
798 parser->lexer.current.type = LSTOKEN_COMMA;
799 LS_TOKEN_STOKEN (parser->lexer.current).ptr
800 = PARSER_STREAM (parser);
801 LS_TOKEN_STOKEN (parser->lexer.current).length = 1;
802 ++(PARSER_STREAM (parser));
803 break;
804
805 default:
806 /* If the input is not a number, it must be a string.
807 [Keywords were already considered above.] */
808 parser->lexer.current = linespec_lexer_lex_string (parser);
809 break;
810 }
811 }
812
813 return parser->lexer.current;
814}
815
816/* Consume the current token and return the next token in PARSER's
817 input stream. */
818
819static linespec_token
820linespec_lexer_consume_token (linespec_parser *parser)
821{
822 parser->lexer.current.type = LSTOKEN_CONSUMED;
823 return linespec_lexer_lex_one (parser);
824}
825
826/* Return the next token without consuming the current token. */
827
828static linespec_token
829linespec_lexer_peek_token (linespec_parser *parser)
830{
831 linespec_token next;
832 char *saved_stream = PARSER_STREAM (parser);
833 linespec_token saved_token = parser->lexer.current;
834
835 next = linespec_lexer_consume_token (parser);
836 PARSER_STREAM (parser) = saved_stream;
837 parser->lexer.current = saved_token;
838 return next;
839}
840
841/* Helper functions. */
842
843/* Add SAL to SALS. */
844
845static void
846add_sal_to_sals_basic (struct symtabs_and_lines *sals,
847 struct symtab_and_line *sal)
848{
849 ++sals->nelts;
850 sals->sals = xrealloc (sals->sals, sals->nelts * sizeof (sals->sals[0]));
851 sals->sals[sals->nelts - 1] = *sal;
852}
853
854/* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
855 the new sal, if needed. If not NULL, SYMNAME is the name of the
856 symbol to use when constructing the new canonical name.
857
858 If LITERAL_CANONICAL is non-zero, SYMNAME will be used as the
859 canonical name for the SAL. */
860
861static void
862add_sal_to_sals (struct linespec_state *self,
863 struct symtabs_and_lines *sals,
864 struct symtab_and_line *sal,
865 const char *symname, int literal_canonical)
866{
867 add_sal_to_sals_basic (sals, sal);
868
869 if (self->canonical)
870 {
871 struct linespec_canonical_name *canonical;
872
873 self->canonical_names = xrealloc (self->canonical_names,
874 (sals->nelts
875 * sizeof (*self->canonical_names)));
876 canonical = &self->canonical_names[sals->nelts - 1];
877 if (!literal_canonical && sal->symtab)
878 {
879 const char *fullname = symtab_to_fullname (sal->symtab);
880
881 /* Note that the filter doesn't have to be a valid linespec
882 input. We only apply the ":LINE" treatment to Ada for
883 the time being. */
884 if (symname != NULL && sal->line != 0
885 && self->language->la_language == language_ada)
886 canonical->suffix = xstrprintf ("%s:%d", symname, sal->line);
887 else if (symname != NULL)
888 canonical->suffix = xstrdup (symname);
889 else
890 canonical->suffix = xstrprintf ("%d", sal->line);
891 canonical->symtab = sal->symtab;
892 }
893 else
894 {
895 if (symname != NULL)
896 canonical->suffix = xstrdup (symname);
897 else
898 canonical->suffix = NULL;
899 canonical->symtab = NULL;
900 }
901 }
902}
903
904/* A hash function for address_entry. */
905
906static hashval_t
907hash_address_entry (const void *p)
908{
909 const struct address_entry *aep = p;
910 hashval_t hash;
911
912 hash = iterative_hash_object (aep->pspace, 0);
913 return iterative_hash_object (aep->addr, hash);
914}
915
916/* An equality function for address_entry. */
917
918static int
919eq_address_entry (const void *a, const void *b)
920{
921 const struct address_entry *aea = a;
922 const struct address_entry *aeb = b;
923
924 return aea->pspace == aeb->pspace && aea->addr == aeb->addr;
925}
926
927/* Check whether the address, represented by PSPACE and ADDR, is
928 already in the set. If so, return 0. Otherwise, add it and return
929 1. */
930
931static int
932maybe_add_address (htab_t set, struct program_space *pspace, CORE_ADDR addr)
933{
934 struct address_entry e, *p;
935 void **slot;
936
937 e.pspace = pspace;
938 e.addr = addr;
939 slot = htab_find_slot (set, &e, INSERT);
940 if (*slot)
941 return 0;
942
943 p = XNEW (struct address_entry);
944 memcpy (p, &e, sizeof (struct address_entry));
945 *slot = p;
946
947 return 1;
948}
949
950/* A callback function and the additional data to call it with. */
951
952struct symbol_and_data_callback
953{
954 /* The callback to use. */
955 symbol_found_callback_ftype *callback;
956
957 /* Data to be passed to the callback. */
958 void *data;
959};
960
961/* A helper for iterate_over_all_matching_symtabs that is used to
962 restrict calls to another callback to symbols representing inline
963 symbols only. */
964
965static int
966iterate_inline_only (struct symbol *sym, void *d)
967{
968 if (SYMBOL_INLINED (sym))
969 {
970 struct symbol_and_data_callback *cad = d;
971
972 return cad->callback (sym, cad->data);
973 }
974 return 1; /* Continue iterating. */
975}
976
977/* Some data for the expand_symtabs_matching callback. */
978
979struct symbol_matcher_data
980{
981 /* The lookup name against which symbol name should be compared. */
982 const char *lookup_name;
983
984 /* The routine to be used for comparison. */
985 symbol_name_cmp_ftype symbol_name_cmp;
986};
987
988/* A helper for iterate_over_all_matching_symtabs that is passed as a
989 callback to the expand_symtabs_matching method. */
990
991static int
992iterate_name_matcher (const char *name, void *d)
993{
994 const struct symbol_matcher_data *data = d;
995
996 if (data->symbol_name_cmp (name, data->lookup_name) == 0)
997 return 1; /* Expand this symbol's symbol table. */
998 return 0; /* Skip this symbol. */
999}
1000
1001/* A helper that walks over all matching symtabs in all objfiles and
1002 calls CALLBACK for each symbol matching NAME. If SEARCH_PSPACE is
1003 not NULL, then the search is restricted to just that program
1004 space. If INCLUDE_INLINE is nonzero then symbols representing
1005 inlined instances of functions will be included in the result. */
1006
1007static void
1008iterate_over_all_matching_symtabs (struct linespec_state *state,
1009 const char *name,
1010 const domain_enum domain,
1011 symbol_found_callback_ftype *callback,
1012 void *data,
1013 struct program_space *search_pspace,
1014 int include_inline)
1015{
1016 struct objfile *objfile;
1017 struct program_space *pspace;
1018 struct symbol_matcher_data matcher_data;
1019
1020 matcher_data.lookup_name = name;
1021 matcher_data.symbol_name_cmp =
1022 state->language->la_get_symbol_name_cmp != NULL
1023 ? state->language->la_get_symbol_name_cmp (name)
1024 : strcmp_iw;
1025
1026 ALL_PSPACES (pspace)
1027 {
1028 if (search_pspace != NULL && search_pspace != pspace)
1029 continue;
1030 if (pspace->executing_startup)
1031 continue;
1032
1033 set_current_program_space (pspace);
1034
1035 ALL_OBJFILES (objfile)
1036 {
1037 struct symtab *symtab;
1038
1039 if (objfile->sf)
1040 objfile->sf->qf->expand_symtabs_matching (objfile, NULL,
1041 iterate_name_matcher,
1042 ALL_DOMAIN,
1043 &matcher_data);
1044
1045 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, symtab)
1046 {
1047 iterate_over_file_blocks (symtab, name, domain, callback, data);
1048
1049 if (include_inline)
1050 {
1051 struct symbol_and_data_callback cad = { callback, data };
1052 struct block *block;
1053 int i;
1054
1055 for (i = FIRST_LOCAL_BLOCK;
1056 i < BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (symtab)); i++)
1057 {
1058 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), i);
1059 state->language->la_iterate_over_symbols
1060 (block, name, domain, iterate_inline_only, &cad);
1061 }
1062 }
1063 }
1064 }
1065 }
1066}
1067
1068/* Returns the block to be used for symbol searches from
1069 the current location. */
1070
1071static struct block *
1072get_current_search_block (void)
1073{
1074 struct block *block;
1075 enum language save_language;
1076
1077 /* get_selected_block can change the current language when there is
1078 no selected frame yet. */
1079 save_language = current_language->la_language;
1080 block = get_selected_block (0);
1081 set_language (save_language);
1082
1083 return block;
1084}
1085
1086/* Iterate over static and global blocks. */
1087
1088static void
1089iterate_over_file_blocks (struct symtab *symtab,
1090 const char *name, domain_enum domain,
1091 symbol_found_callback_ftype *callback, void *data)
1092{
1093 struct block *block;
1094
1095 for (block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1096 block != NULL;
1097 block = BLOCK_SUPERBLOCK (block))
1098 LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
1099}
1100
1101/* A helper for find_method. This finds all methods in type T which
1102 match NAME. It adds matching symbol names to RESULT_NAMES, and
1103 adds T's direct superclasses to SUPERCLASSES. */
1104
1105static void
1106find_methods (struct type *t, const char *name,
1107 VEC (const_char_ptr) **result_names,
1108 VEC (typep) **superclasses)
1109{
1110 int ibase;
1111 const char *class_name = type_name_no_tag (t);
1112
1113 /* Ignore this class if it doesn't have a name. This is ugly, but
1114 unless we figure out how to get the physname without the name of
1115 the class, then the loop can't do any good. */
1116 if (class_name)
1117 {
1118 int method_counter;
1119
1120 CHECK_TYPEDEF (t);
1121
1122 /* Loop over each method name. At this level, all overloads of a name
1123 are counted as a single name. There is an inner loop which loops over
1124 each overload. */
1125
1126 for (method_counter = TYPE_NFN_FIELDS (t) - 1;
5796c8dc
SS
1127 method_counter >= 0;
1128 --method_counter)
1129 {
ef5ccd6c 1130 const char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
5796c8dc
SS
1131 char dem_opname[64];
1132
1133 if (strncmp (method_name, "__", 2) == 0 ||
1134 strncmp (method_name, "op", 2) == 0 ||
1135 strncmp (method_name, "type", 4) == 0)
1136 {
1137 if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
1138 method_name = dem_opname;
1139 else if (cplus_demangle_opname (method_name, dem_opname, 0))
1140 method_name = dem_opname;
1141 }
1142
a45ae5f8
JM
1143 if (strcmp_iw (method_name, name) == 0)
1144 {
1145 int field_counter;
5796c8dc 1146
a45ae5f8
JM
1147 for (field_counter = (TYPE_FN_FIELDLIST_LENGTH (t, method_counter)
1148 - 1);
1149 field_counter >= 0;
1150 --field_counter)
1151 {
1152 struct fn_field *f;
1153 const char *phys_name;
1154
1155 f = TYPE_FN_FIELDLIST1 (t, method_counter);
1156 if (TYPE_FN_FIELD_STUB (f, field_counter))
1157 continue;
1158 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
1159 VEC_safe_push (const_char_ptr, *result_names, phys_name);
1160 }
1161 }
5796c8dc
SS
1162 }
1163 }
1164
a45ae5f8
JM
1165 for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
1166 VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase));
5796c8dc
SS
1167}
1168
5796c8dc
SS
1169/* Find an instance of the character C in the string S that is outside
1170 of all parenthesis pairs, single-quoted strings, and double-quoted
1171 strings. Also, ignore the char within a template name, like a ','
1172 within foo<int, int>. */
1173
ef5ccd6c
JM
1174static const char *
1175find_toplevel_char (const char *s, char c)
5796c8dc
SS
1176{
1177 int quoted = 0; /* zero if we're not in quotes;
1178 '"' if we're in a double-quoted string;
1179 '\'' if we're in a single-quoted string. */
1180 int depth = 0; /* Number of unclosed parens we've seen. */
ef5ccd6c 1181 const char *scan;
5796c8dc
SS
1182
1183 for (scan = s; *scan; scan++)
1184 {
1185 if (quoted)
1186 {
1187 if (*scan == quoted)
1188 quoted = 0;
1189 else if (*scan == '\\' && *(scan + 1))
1190 scan++;
1191 }
1192 else if (*scan == c && ! quoted && depth == 0)
1193 return scan;
1194 else if (*scan == '"' || *scan == '\'')
1195 quoted = *scan;
1196 else if (*scan == '(' || *scan == '<')
1197 depth++;
1198 else if ((*scan == ')' || *scan == '>') && depth > 0)
1199 depth--;
1200 }
1201
1202 return 0;
1203}
1204
ef5ccd6c
JM
1205/* The string equivalent of find_toplevel_char. Returns a pointer
1206 to the location of NEEDLE in HAYSTACK, ignoring any occurrences
1207 inside "()" and "<>". Returns NULL if NEEDLE was not found. */
5796c8dc 1208
ef5ccd6c
JM
1209static const char *
1210find_toplevel_string (const char *haystack, const char *needle)
5796c8dc 1211{
ef5ccd6c
JM
1212 const char *s = haystack;
1213
1214 do
1215 {
1216 s = find_toplevel_char (s, *needle);
1217
1218 if (s != NULL)
1219 {
1220 /* Found first char in HAYSTACK; check rest of string. */
1221 if (strncmp (s, needle, strlen (needle)) == 0)
1222 return s;
1223
1224 /* Didn't find it; loop over HAYSTACK, looking for the next
1225 instance of the first character of NEEDLE. */
1226 ++s;
1227 }
1228 }
1229 while (s != NULL && *s != '\0');
1230
1231 /* NEEDLE was not found in HAYSTACK. */
1232 return NULL;
1233}
1234
1235/* Convert CANONICAL to its string representation using
1236 symtab_to_fullname for SYMTAB. The caller must xfree the result. */
1237
1238static char *
1239canonical_to_fullform (const struct linespec_canonical_name *canonical)
1240{
1241 if (canonical->symtab == NULL)
1242 return xstrdup (canonical->suffix);
1243 else
1244 return xstrprintf ("%s:%s", symtab_to_fullname (canonical->symtab),
1245 canonical->suffix);
5796c8dc
SS
1246}
1247
a45ae5f8
JM
1248/* Given FILTERS, a list of canonical names, filter the sals in RESULT
1249 and store the result in SELF->CANONICAL. */
5796c8dc 1250
a45ae5f8
JM
1251static void
1252filter_results (struct linespec_state *self,
1253 struct symtabs_and_lines *result,
1254 VEC (const_char_ptr) *filters)
1255{
1256 int i;
1257 const char *name;
1258
1259 for (i = 0; VEC_iterate (const_char_ptr, filters, i, name); ++i)
1260 {
1261 struct linespec_sals lsal;
1262 int j;
1263
1264 memset (&lsal, 0, sizeof (lsal));
1265
1266 for (j = 0; j < result->nelts; ++j)
1267 {
ef5ccd6c
JM
1268 const struct linespec_canonical_name *canonical;
1269 char *fullform;
1270 struct cleanup *cleanup;
1271
1272 canonical = &self->canonical_names[j];
1273 fullform = canonical_to_fullform (canonical);
1274 cleanup = make_cleanup (xfree, fullform);
1275
1276 if (strcmp (name, fullform) == 0)
a45ae5f8 1277 add_sal_to_sals_basic (&lsal.sals, &result->sals[j]);
ef5ccd6c
JM
1278
1279 do_cleanups (cleanup);
a45ae5f8
JM
1280 }
1281
1282 if (lsal.sals.nelts > 0)
1283 {
1284 lsal.canonical = xstrdup (name);
1285 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
1286 }
1287 }
1288
1289 self->canonical->pre_expanded = 0;
1290}
1291
1292/* Store RESULT into SELF->CANONICAL. */
1293
1294static void
1295convert_results_to_lsals (struct linespec_state *self,
1296 struct symtabs_and_lines *result)
1297{
1298 struct linespec_sals lsal;
1299
1300 lsal.canonical = NULL;
1301 lsal.sals = *result;
1302 VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
1303}
1304
ef5ccd6c
JM
1305/* A structure that contains two string representations of a struct
1306 linespec_canonical_name:
1307 - one where the the symtab's fullname is used;
1308 - one where the filename followed the "set filename-display"
1309 setting. */
1310
1311struct decode_line_2_item
1312{
1313 /* The form using symtab_to_fullname.
1314 It must be xfree'ed after use. */
1315 char *fullform;
1316
1317 /* The form using symtab_to_filename_for_display.
1318 It must be xfree'ed after use. */
1319 char *displayform;
1320
1321 /* Field is initialized to zero and it is set to one if the user
1322 requested breakpoint for this entry. */
1323 unsigned int selected : 1;
1324};
1325
1326/* Helper for qsort to sort decode_line_2_item entries by DISPLAYFORM and
1327 secondarily by FULLFORM. */
1328
1329static int
1330decode_line_2_compare_items (const void *ap, const void *bp)
1331{
1332 const struct decode_line_2_item *a = ap;
1333 const struct decode_line_2_item *b = bp;
1334 int retval;
1335
1336 retval = strcmp (a->displayform, b->displayform);
1337 if (retval != 0)
1338 return retval;
1339
1340 return strcmp (a->fullform, b->fullform);
1341}
1342
a45ae5f8
JM
1343/* Handle multiple results in RESULT depending on SELECT_MODE. This
1344 will either return normally, throw an exception on multiple
1345 results, or present a menu to the user. On return, the SALS vector
1346 in SELF->CANONICAL is set up properly. */
1347
1348static void
1349decode_line_2 (struct linespec_state *self,
1350 struct symtabs_and_lines *result,
1351 const char *select_mode)
5796c8dc 1352{
a45ae5f8 1353 char *args, *prompt;
5796c8dc 1354 int i;
5796c8dc 1355 struct cleanup *old_chain;
ef5ccd6c 1356 VEC (const_char_ptr) *filters = NULL;
a45ae5f8 1357 struct get_number_or_range_state state;
ef5ccd6c
JM
1358 struct decode_line_2_item *items;
1359 int items_count;
1360
1361 gdb_assert (select_mode != multiple_symbols_all);
1362 gdb_assert (self->canonical != NULL);
1363 gdb_assert (result->nelts >= 1);
1364
1365 old_chain = make_cleanup (VEC_cleanup (const_char_ptr), &filters);
1366
1367 /* Prepare ITEMS array. */
1368 items_count = result->nelts;
1369 items = xmalloc (sizeof (*items) * items_count);
1370 make_cleanup (xfree, items);
1371 for (i = 0; i < items_count; ++i)
1372 {
1373 const struct linespec_canonical_name *canonical;
1374 struct decode_line_2_item *item;
1375
1376 canonical = &self->canonical_names[i];
1377 gdb_assert (canonical->suffix != NULL);
1378 item = &items[i];
1379
1380 item->fullform = canonical_to_fullform (canonical);
1381 make_cleanup (xfree, item->fullform);
1382
1383 if (canonical->symtab == NULL)
1384 item->displayform = canonical->suffix;
1385 else
1386 {
1387 const char *fn_for_display;
1388
1389 fn_for_display = symtab_to_filename_for_display (canonical->symtab);
1390 item->displayform = xstrprintf ("%s:%s", fn_for_display,
1391 canonical->suffix);
1392 make_cleanup (xfree, item->displayform);
1393 }
1394
1395 item->selected = 0;
1396 }
1397
1398 /* Sort the list of method names. */
1399 qsort (items, items_count, sizeof (*items), decode_line_2_compare_items);
1400
1401 /* Remove entries with the same FULLFORM. */
1402 if (items_count >= 2)
1403 {
1404 struct decode_line_2_item *dst, *src;
1405
1406 dst = items;
1407 for (src = &items[1]; src < &items[items_count]; src++)
1408 if (strcmp (src->fullform, dst->fullform) != 0)
1409 *++dst = *src;
1410 items_count = dst + 1 - items;
1411 }
1412
1413 if (select_mode == multiple_symbols_cancel && items_count > 1)
1414 error (_("canceled because the command is ambiguous\n"
1415 "See set/show multiple-symbol."));
1416
1417 if (select_mode == multiple_symbols_all || items_count == 1)
1418 {
1419 do_cleanups (old_chain);
1420 convert_results_to_lsals (self, result);
1421 return;
1422 }
1423
1424 printf_unfiltered (_("[0] cancel\n[1] all\n"));
1425 for (i = 0; i < items_count; i++)
1426 printf_unfiltered ("[%d] %s\n", i + 2, items[i].displayform);
1427
1428 prompt = getenv ("PS2");
1429 if (prompt == NULL)
1430 {
1431 prompt = "> ";
1432 }
1433 args = command_line_input (prompt, 0, "overload-choice");
1434
1435 if (args == 0 || *args == 0)
1436 error_no_arg (_("one or more choice numbers"));
1437
1438 init_number_or_range (&state, args);
1439 while (!state.finished)
1440 {
1441 int num;
1442
1443 num = get_number_or_range (&state);
1444
1445 if (num == 0)
1446 error (_("canceled"));
1447 else if (num == 1)
1448 {
1449 /* We intentionally make this result in a single breakpoint,
1450 contrary to what older versions of gdb did. The
1451 rationale is that this lets a user get the
1452 multiple_symbols_all behavior even with the 'ask'
1453 setting; and he can get separate breakpoints by entering
1454 "2-57" at the query. */
1455 do_cleanups (old_chain);
1456 convert_results_to_lsals (self, result);
1457 return;
1458 }
1459
1460 num -= 2;
1461 if (num >= items_count)
1462 printf_unfiltered (_("No choice number %d.\n"), num);
1463 else
1464 {
1465 struct decode_line_2_item *item = &items[num];
1466
1467 if (!item->selected)
1468 {
1469 VEC_safe_push (const_char_ptr, filters, item->fullform);
1470 item->selected = 1;
1471 }
1472 else
1473 {
1474 printf_unfiltered (_("duplicate request for %d ignored.\n"),
1475 num + 2);
1476 }
1477 }
1478 }
1479
1480 filter_results (self, result, filters);
1481 do_cleanups (old_chain);
1482}
1483
1484\f
1485
1486/* The parser of linespec itself. */
1487
1488/* Throw an appropriate error when SYMBOL is not found (optionally in
1489 FILENAME). */
1490
1491static void ATTRIBUTE_NORETURN
1492symbol_not_found_error (const char *symbol, const char *filename)
1493{
1494 if (symbol == NULL)
1495 symbol = "";
1496
1497 if (!have_full_symbols ()
1498 && !have_partial_symbols ()
1499 && !have_minimal_symbols ())
1500 throw_error (NOT_FOUND_ERROR,
1501 _("No symbol table is loaded. Use the \"file\" command."));
1502
1503 /* If SYMBOL starts with '$', the user attempted to either lookup
1504 a function/variable in his code starting with '$' or an internal
1505 variable of that name. Since we do not know which, be concise and
1506 explain both possibilities. */
1507 if (*symbol == '$')
1508 {
1509 if (filename)
1510 throw_error (NOT_FOUND_ERROR,
1511 _("Undefined convenience variable or function \"%s\" "
1512 "not defined in \"%s\"."), symbol, filename);
1513 else
1514 throw_error (NOT_FOUND_ERROR,
1515 _("Undefined convenience variable or function \"%s\" "
1516 "not defined."), symbol);
1517 }
1518 else
1519 {
1520 if (filename)
1521 throw_error (NOT_FOUND_ERROR,
1522 _("Function \"%s\" not defined in \"%s\"."),
1523 symbol, filename);
1524 else
1525 throw_error (NOT_FOUND_ERROR,
1526 _("Function \"%s\" not defined."), symbol);
1527 }
1528}
1529
1530/* Throw an appropriate error when an unexpected token is encountered
1531 in the input. */
1532
1533static void ATTRIBUTE_NORETURN
1534unexpected_linespec_error (linespec_parser *parser)
1535{
1536 linespec_token token;
1537 static const char * token_type_strings[]
1538 = {"keyword", "colon", "string", "number", "comma", "end of input"};
1539
1540 /* Get the token that generated the error. */
1541 token = linespec_lexer_lex_one (parser);
1542
1543 /* Finally, throw the error. */
1544 if (token.type == LSTOKEN_STRING || token.type == LSTOKEN_NUMBER
1545 || token.type == LSTOKEN_KEYWORD)
1546 {
1547 char *string;
1548 struct cleanup *cleanup;
1549
1550 string = copy_token_string (token);
1551 cleanup = make_cleanup (xfree, string);
1552 throw_error (GENERIC_ERROR,
1553 _("malformed linespec error: unexpected %s, \"%s\""),
1554 token_type_strings[token.type], string);
1555 }
1556 else
1557 throw_error (GENERIC_ERROR,
1558 _("malformed linespec error: unexpected %s"),
1559 token_type_strings[token.type]);
1560}
1561
1562/* Parse and return a line offset in STRING. */
1563
1564static struct line_offset
1565linespec_parse_line_offset (const char *string)
1566{
1567 struct line_offset line_offset = {0, LINE_OFFSET_NONE};
1568
1569 if (*string == '+')
1570 {
1571 line_offset.sign = LINE_OFFSET_PLUS;
1572 ++string;
1573 }
1574 else if (*string == '-')
1575 {
1576 line_offset.sign = LINE_OFFSET_MINUS;
1577 ++string;
1578 }
1579
1580 /* Right now, we only allow base 10 for offsets. */
1581 line_offset.offset = atoi (string);
1582 return line_offset;
1583}
1584
1585/* Parse the basic_spec in PARSER's input. */
1586
1587static void
1588linespec_parse_basic (linespec_parser *parser)
1589{
1590 char *name;
1591 linespec_token token;
1592 VEC (symbolp) *symbols, *labels;
1593 VEC (minsym_and_objfile_d) *minimal_symbols;
1594 struct cleanup *cleanup;
1595
1596 /* Get the next token. */
1597 token = linespec_lexer_lex_one (parser);
1598
1599 /* If it is EOI or KEYWORD, issue an error. */
1600 if (token.type == LSTOKEN_KEYWORD || token.type == LSTOKEN_EOI)
1601 unexpected_linespec_error (parser);
1602 /* If it is a LSTOKEN_NUMBER, we have an offset. */
1603 else if (token.type == LSTOKEN_NUMBER)
1604 {
1605 /* Record the line offset and get the next token. */
1606 name = copy_token_string (token);
1607 cleanup = make_cleanup (xfree, name);
1608 PARSER_RESULT (parser)->line_offset = linespec_parse_line_offset (name);
1609 do_cleanups (cleanup);
1610
1611 /* Get the next token. */
1612 token = linespec_lexer_consume_token (parser);
1613
1614 /* If the next token is a comma, stop parsing and return. */
1615 if (token.type == LSTOKEN_COMMA)
1616 return;
1617
1618 /* If the next token is anything but EOI or KEYWORD, issue
1619 an error. */
1620 if (token.type != LSTOKEN_KEYWORD && token.type != LSTOKEN_EOI)
1621 unexpected_linespec_error (parser);
1622 }
1623
1624 if (token.type == LSTOKEN_KEYWORD || token.type == LSTOKEN_EOI)
1625 return;
1626
1627 /* Next token must be LSTOKEN_STRING. */
1628 if (token.type != LSTOKEN_STRING)
1629 unexpected_linespec_error (parser);
1630
1631 /* The current token will contain the name of a function, method,
1632 or label. */
1633 name = copy_token_string (token);
1634 cleanup = make_cleanup (xfree, name);
1635
1636 /* Try looking it up as a function/method. */
1637 find_linespec_symbols (PARSER_STATE (parser),
1638 PARSER_RESULT (parser)->file_symtabs, name,
1639 &symbols, &minimal_symbols);
1640
1641 if (symbols != NULL || minimal_symbols != NULL)
1642 {
1643 PARSER_RESULT (parser)->function_symbols = symbols;
1644 PARSER_RESULT (parser)->minimal_symbols = minimal_symbols;
1645 PARSER_RESULT (parser)->function_name = name;
1646 symbols = NULL;
1647 discard_cleanups (cleanup);
1648 }
1649 else
1650 {
1651 /* NAME was not a function or a method. So it must be a label
1652 name. */
1653 labels = find_label_symbols (PARSER_STATE (parser), NULL,
1654 &symbols, name);
1655 if (labels != NULL)
1656 {
1657 PARSER_RESULT (parser)->labels.label_symbols = labels;
1658 PARSER_RESULT (parser)->labels.function_symbols = symbols;
1659 PARSER_RESULT (parser)->label_name = name;
1660 symbols = NULL;
1661 discard_cleanups (cleanup);
1662 }
1663 else
1664 {
1665 /* The name is also not a label. Abort parsing. Do not throw
1666 an error here. parse_linespec will do it for us. */
1667
1668 /* Save a copy of the name we were trying to lookup. */
1669 PARSER_RESULT (parser)->function_name = name;
1670 discard_cleanups (cleanup);
1671 return;
1672 }
1673 }
1674
1675 /* Get the next token. */
1676 token = linespec_lexer_consume_token (parser);
1677
1678 if (token.type == LSTOKEN_COLON)
1679 {
1680 /* User specified a label or a lineno. */
1681 token = linespec_lexer_consume_token (parser);
1682
1683 if (token.type == LSTOKEN_NUMBER)
1684 {
1685 /* User specified an offset. Record the line offset and
1686 get the next token. */
1687 name = copy_token_string (token);
1688 cleanup = make_cleanup (xfree, name);
1689 PARSER_RESULT (parser)->line_offset
1690 = linespec_parse_line_offset (name);
1691 do_cleanups (cleanup);
1692
1693 /* Ge the next token. */
1694 token = linespec_lexer_consume_token (parser);
1695 }
1696 else if (token.type == LSTOKEN_STRING)
1697 {
1698 /* Grab a copy of the label's name and look it up. */
1699 name = copy_token_string (token);
1700 cleanup = make_cleanup (xfree, name);
1701 labels = find_label_symbols (PARSER_STATE (parser),
1702 PARSER_RESULT (parser)->function_symbols,
1703 &symbols, name);
1704
1705 if (labels != NULL)
1706 {
1707 PARSER_RESULT (parser)->labels.label_symbols = labels;
1708 PARSER_RESULT (parser)->labels.function_symbols = symbols;
1709 PARSER_RESULT (parser)->label_name = name;
1710 symbols = NULL;
1711 discard_cleanups (cleanup);
1712 }
1713 else
1714 {
1715 /* We don't know what it was, but it isn't a label. */
1716 throw_error (NOT_FOUND_ERROR,
1717 _("No label \"%s\" defined in function \"%s\"."),
1718 name, PARSER_RESULT (parser)->function_name);
1719 }
1720
1721 /* Check for a line offset. */
1722 token = linespec_lexer_consume_token (parser);
1723 if (token.type == LSTOKEN_COLON)
1724 {
1725 /* Get the next token. */
1726 token = linespec_lexer_consume_token (parser);
1727
1728 /* It must be a line offset. */
1729 if (token.type != LSTOKEN_NUMBER)
1730 unexpected_linespec_error (parser);
1731
1732 /* Record the lione offset and get the next token. */
1733 name = copy_token_string (token);
1734 cleanup = make_cleanup (xfree, name);
1735
1736 PARSER_RESULT (parser)->line_offset
1737 = linespec_parse_line_offset (name);
1738 do_cleanups (cleanup);
1739
1740 /* Get the next token. */
1741 token = linespec_lexer_consume_token (parser);
1742 }
1743 }
1744 else
1745 {
1746 /* Trailing ':' in the input. Issue an error. */
1747 unexpected_linespec_error (parser);
1748 }
1749 }
1750}
5796c8dc 1751
ef5ccd6c
JM
1752/* Canonicalize the linespec contained in LS. The result is saved into
1753 STATE->canonical. */
1754
1755static void
1756canonicalize_linespec (struct linespec_state *state, linespec_p ls)
1757{
1758 /* If canonicalization was not requested, no need to do anything. */
1759 if (!state->canonical)
1760 return;
5796c8dc 1761
ef5ccd6c
JM
1762 /* Shortcut expressions, which can only appear by themselves. */
1763 if (ls->expression != NULL)
1764 state->canonical->addr_string = xstrdup (ls->expression);
1765 else
5796c8dc 1766 {
ef5ccd6c
JM
1767 struct ui_file *buf;
1768 int need_colon = 0;
1769
1770 buf = mem_fileopen ();
1771 if (ls->source_filename)
1772 {
1773 fputs_unfiltered (ls->source_filename, buf);
1774 need_colon = 1;
1775 }
1776
1777 if (ls->function_name)
1778 {
1779 if (need_colon)
1780 fputc_unfiltered (':', buf);
1781 fputs_unfiltered (ls->function_name, buf);
1782 need_colon = 1;
1783 }
a45ae5f8 1784
ef5ccd6c 1785 if (ls->label_name)
a45ae5f8 1786 {
ef5ccd6c
JM
1787 if (need_colon)
1788 fputc_unfiltered (':', buf);
1789
1790 if (ls->function_name == NULL)
a45ae5f8 1791 {
ef5ccd6c
JM
1792 struct symbol *s;
1793
1794 /* No function was specified, so add the symbol name. */
1795 gdb_assert (ls->labels.function_symbols != NULL
1796 && (VEC_length (symbolp, ls->labels.function_symbols)
1797 == 1));
1798 s = VEC_index (symbolp, ls->labels.function_symbols, 0);
1799 fputs_unfiltered (SYMBOL_NATURAL_NAME (s), buf);
1800 fputc_unfiltered (':', buf);
a45ae5f8 1801 }
ef5ccd6c
JM
1802
1803 fputs_unfiltered (ls->label_name, buf);
1804 need_colon = 1;
1805 state->canonical->special_display = 1;
a45ae5f8
JM
1806 }
1807
ef5ccd6c
JM
1808 if (ls->line_offset.sign != LINE_OFFSET_UNKNOWN)
1809 {
1810 if (need_colon)
1811 fputc_unfiltered (':', buf);
1812 fprintf_filtered (buf, "%s%d",
1813 (ls->line_offset.sign == LINE_OFFSET_NONE ? ""
1814 : (ls->line_offset.sign
1815 == LINE_OFFSET_PLUS ? "+" : "-")),
1816 ls->line_offset.offset);
1817 }
5796c8dc 1818
ef5ccd6c
JM
1819 state->canonical->addr_string = ui_file_xstrdup (buf, NULL);
1820 ui_file_delete (buf);
5796c8dc 1821 }
ef5ccd6c 1822}
5796c8dc 1823
ef5ccd6c 1824/* Given a line offset in LS, construct the relevant SALs. */
a45ae5f8 1825
ef5ccd6c
JM
1826static struct symtabs_and_lines
1827create_sals_line_offset (struct linespec_state *self,
1828 linespec_p ls)
1829{
1830 struct symtabs_and_lines values;
1831 struct symtab_and_line val;
1832 int use_default = 0;
5796c8dc 1833
ef5ccd6c
JM
1834 init_sal (&val);
1835 values.sals = NULL;
1836 values.nelts = 0;
5796c8dc 1837
ef5ccd6c
JM
1838 /* This is where we need to make sure 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. */
1843
1844 if (VEC_length (symtab_p, ls->file_symtabs) == 1
1845 && VEC_index (symtab_p, ls->file_symtabs, 0) == NULL)
5796c8dc 1846 {
ef5ccd6c 1847 const char *fullname;
5796c8dc 1848
ef5ccd6c 1849 set_current_program_space (self->program_space);
5796c8dc 1850
ef5ccd6c
JM
1851 /* Make sure we have at least a default source line. */
1852 set_default_source_symtab_and_line ();
1853 initialize_defaults (&self->default_symtab, &self->default_line);
1854 fullname = symtab_to_fullname (self->default_symtab);
1855 VEC_pop (symtab_p, ls->file_symtabs);
1856 VEC_free (symtab_p, ls->file_symtabs);
1857 ls->file_symtabs = collect_symtabs_from_filename (fullname);
1858 use_default = 1;
1859 }
5796c8dc 1860
ef5ccd6c
JM
1861 val.line = ls->line_offset.offset;
1862 switch (ls->line_offset.sign)
1863 {
1864 case LINE_OFFSET_PLUS:
1865 if (ls->line_offset.offset == 0)
1866 val.line = 5;
1867 if (use_default)
1868 val.line = self->default_line + val.line;
1869 break;
1870
1871 case LINE_OFFSET_MINUS:
1872 if (ls->line_offset.offset == 0)
1873 val.line = 15;
1874 if (use_default)
1875 val.line = self->default_line - val.line;
5796c8dc 1876 else
ef5ccd6c
JM
1877 val.line = -val.line;
1878 break;
a45ae5f8 1879
ef5ccd6c
JM
1880 case LINE_OFFSET_NONE:
1881 break; /* No need to adjust val.line. */
5796c8dc 1882 }
a45ae5f8 1883
ef5ccd6c
JM
1884 if (self->list_mode)
1885 decode_digits_list_mode (self, ls, &values, val);
1886 else
1887 {
1888 struct linetable_entry *best_entry = NULL;
1889 int *filter;
1890 struct block **blocks;
1891 struct cleanup *cleanup;
1892 struct symtabs_and_lines intermediate_results;
1893 int i, j;
cf7f2e2d 1894
ef5ccd6c
JM
1895 intermediate_results.sals = NULL;
1896 intermediate_results.nelts = 0;
c50c785c 1897
ef5ccd6c
JM
1898 decode_digits_ordinary (self, ls, val.line, &intermediate_results,
1899 &best_entry);
1900 if (intermediate_results.nelts == 0 && best_entry != NULL)
1901 decode_digits_ordinary (self, ls, best_entry->line,
1902 &intermediate_results, &best_entry);
c50c785c 1903
ef5ccd6c 1904 cleanup = make_cleanup (xfree, intermediate_results.sals);
cf7f2e2d 1905
ef5ccd6c
JM
1906 /* For optimized code, the compiler can scatter one source line
1907 across disjoint ranges of PC values, even when no duplicate
1908 functions or inline functions are involved. For example,
1909 'for (;;)' inside a non-template, non-inline, and non-ctor-or-dtor
1910 function can result in two PC ranges. In this case, we don't
1911 want to set a breakpoint on the first PC of each range. To filter
1912 such cases, we use containing blocks -- for each PC found
1913 above, we see if there are other PCs that are in the same
1914 block. If yes, the other PCs are filtered out. */
cf7f2e2d 1915
ef5ccd6c
JM
1916 filter = XNEWVEC (int, intermediate_results.nelts);
1917 make_cleanup (xfree, filter);
1918 blocks = XNEWVEC (struct block *, intermediate_results.nelts);
1919 make_cleanup (xfree, blocks);
cf7f2e2d 1920
ef5ccd6c 1921 for (i = 0; i < intermediate_results.nelts; ++i)
cf7f2e2d 1922 {
ef5ccd6c
JM
1923 set_current_program_space (intermediate_results.sals[i].pspace);
1924
1925 filter[i] = 1;
1926 blocks[i] = block_for_pc_sect (intermediate_results.sals[i].pc,
1927 intermediate_results.sals[i].section);
cf7f2e2d 1928 }
ef5ccd6c
JM
1929
1930 for (i = 0; i < intermediate_results.nelts; ++i)
1931 {
1932 if (blocks[i] != NULL)
1933 for (j = i + 1; j < intermediate_results.nelts; ++j)
1934 {
1935 if (blocks[j] == blocks[i])
1936 {
1937 filter[j] = 0;
1938 break;
1939 }
1940 }
1941 }
1942
1943 for (i = 0; i < intermediate_results.nelts; ++i)
1944 if (filter[i])
1945 {
1946 struct symbol *sym = (blocks[i]
1947 ? block_containing_function (blocks[i])
1948 : NULL);
1949
1950 if (self->funfirstline)
1951 skip_prologue_sal (&intermediate_results.sals[i]);
1952 /* Make sure the line matches the request, not what was
1953 found. */
1954 intermediate_results.sals[i].line = val.line;
1955 add_sal_to_sals (self, &values, &intermediate_results.sals[i],
1956 sym ? SYMBOL_NATURAL_NAME (sym) : NULL, 0);
1957 }
1958
1959 do_cleanups (cleanup);
cf7f2e2d
JM
1960 }
1961
ef5ccd6c
JM
1962 if (values.nelts == 0)
1963 {
1964 if (ls->source_filename)
1965 throw_error (NOT_FOUND_ERROR, _("No line %d in file \"%s\"."),
1966 val.line, ls->source_filename);
1967 else
1968 throw_error (NOT_FOUND_ERROR, _("No line %d in the current file."),
1969 val.line);
1970 }
1971
1972 return values;
cf7f2e2d 1973}
c50c785c 1974
ef5ccd6c 1975/* Create and return SALs from the linespec LS. */
c50c785c 1976
ef5ccd6c
JM
1977static struct symtabs_and_lines
1978convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
c50c785c 1979{
ef5ccd6c 1980 struct symtabs_and_lines sals = {NULL, 0};
c50c785c 1981
ef5ccd6c 1982 if (ls->expression != NULL)
c50c785c 1983 {
ef5ccd6c 1984 struct symtab_and_line sal;
c50c785c 1985
ef5ccd6c
JM
1986 /* We have an expression. No other attribute is allowed. */
1987 sal = find_pc_line (ls->expr_pc, 0);
1988 sal.pc = ls->expr_pc;
1989 sal.section = find_pc_overlay (ls->expr_pc);
1990 sal.explicit_pc = 1;
1991 add_sal_to_sals (state, &sals, &sal, ls->expression, 1);
1992 }
1993 else if (ls->labels.label_symbols != NULL)
1994 {
1995 /* We have just a bunch of functions/methods or labels. */
1996 int i;
1997 struct symtab_and_line sal;
1998 struct symbol *sym;
c50c785c 1999
ef5ccd6c 2000 for (i = 0; VEC_iterate (symbolp, ls->labels.label_symbols, i, sym); ++i)
c50c785c 2001 {
ef5ccd6c
JM
2002 if (symbol_to_sal (&sal, state->funfirstline, sym))
2003 add_sal_to_sals (state, &sals, &sal,
2004 SYMBOL_NATURAL_NAME (sym), 0);
c50c785c 2005 }
ef5ccd6c
JM
2006 }
2007 else if (ls->function_symbols != NULL || ls->minimal_symbols != NULL)
2008 {
2009 /* We have just a bunch of functions and/or methods. */
2010 int i;
2011 struct symtab_and_line sal;
2012 struct symbol *sym;
2013 minsym_and_objfile_d *elem;
2014 struct program_space *pspace;
2015
2016 if (ls->function_symbols != NULL)
2017 {
2018 /* Sort symbols so that symbols with the same program space are next
2019 to each other. */
2020 qsort (VEC_address (symbolp, ls->function_symbols),
2021 VEC_length (symbolp, ls->function_symbols),
2022 sizeof (symbolp), compare_symbols);
c50c785c 2023
ef5ccd6c
JM
2024 for (i = 0; VEC_iterate (symbolp, ls->function_symbols, i, sym); ++i)
2025 {
2026 pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2027 set_current_program_space (pspace);
2028 if (symbol_to_sal (&sal, state->funfirstline, sym)
2029 && maybe_add_address (state->addr_set, pspace, sal.pc))
2030 add_sal_to_sals (state, &sals, &sal,
2031 SYMBOL_NATURAL_NAME (sym), 0);
2032 }
2033 }
c50c785c 2034
ef5ccd6c
JM
2035 if (ls->minimal_symbols != NULL)
2036 {
2037 /* Sort minimal symbols by program space, too. */
2038 qsort (VEC_address (minsym_and_objfile_d, ls->minimal_symbols),
2039 VEC_length (minsym_and_objfile_d, ls->minimal_symbols),
2040 sizeof (minsym_and_objfile_d), compare_msymbols);
2041
2042 for (i = 0;
2043 VEC_iterate (minsym_and_objfile_d, ls->minimal_symbols, i, elem);
2044 ++i)
2045 {
2046 pspace = elem->objfile->pspace;
2047 set_current_program_space (pspace);
2048 minsym_found (state, elem->objfile, elem->minsym, &sals);
2049 }
2050 }
2051 }
2052 else if (ls->line_offset.sign != LINE_OFFSET_UNKNOWN)
2053 {
2054 /* Only an offset was specified. */
2055 sals = create_sals_line_offset (state, ls);
c50c785c 2056
ef5ccd6c
JM
2057 /* Make sure we have a filename for canonicalization. */
2058 if (ls->source_filename == NULL)
2059 {
2060 const char *fullname = symtab_to_fullname (state->default_symtab);
c50c785c 2061
ef5ccd6c
JM
2062 ls->source_filename = xstrdup (fullname);
2063 }
2064 }
2065 else
2066 {
2067 /* We haven't found any results... */
2068 return sals;
c50c785c
JM
2069 }
2070
ef5ccd6c 2071 canonicalize_linespec (state, ls);
c50c785c 2072
ef5ccd6c
JM
2073 if (sals.nelts > 0 && state->canonical != NULL)
2074 state->canonical->pre_expanded = 1;
c50c785c 2075
ef5ccd6c
JM
2076 return sals;
2077}
5796c8dc 2078
ef5ccd6c 2079/* Parse a string that specifies a linespec.
5796c8dc
SS
2080 Pass the address of a char * variable; that variable will be
2081 advanced over the characters actually parsed.
2082
ef5ccd6c
JM
2083 The basic grammar of linespecs:
2084
2085 linespec -> expr_spec | var_spec | basic_spec
2086 expr_spec -> '*' STRING
2087 var_spec -> '$' (STRING | NUMBER)
2088
2089 basic_spec -> file_offset_spec | function_spec | label_spec
2090 file_offset_spec -> opt_file_spec offset_spec
2091 function_spec -> opt_file_spec function_name_spec opt_label_spec
2092 label_spec -> label_name_spec
5796c8dc 2093
ef5ccd6c
JM
2094 opt_file_spec -> "" | file_name_spec ':'
2095 opt_label_spec -> "" | ':' label_name_spec
5796c8dc 2096
ef5ccd6c
JM
2097 file_name_spec -> STRING
2098 function_name_spec -> STRING
2099 label_name_spec -> STRING
2100 function_name_spec -> STRING
2101 offset_spec -> NUMBER
2102 -> '+' NUMBER
2103 -> '-' NUMBER
5796c8dc 2104
ef5ccd6c
JM
2105 This may all be followed by several keywords such as "if EXPR",
2106 which we ignore.
2107
2108 A comma will terminate parsing.
2109
2110 The function may be an undebuggable function found in minimal symbol table.
5796c8dc
SS
2111
2112 If the argument FUNFIRSTLINE is nonzero, we want the first line
2113 of real code inside a function when a function is specified, and it is
2114 not OK to specify a variable or type to get its line number.
2115
2116 DEFAULT_SYMTAB specifies the file to use if none is specified.
2117 It defaults to current_source_symtab.
2118 DEFAULT_LINE specifies the line number to use for relative
2119 line numbers (that start with signs). Defaults to current_source_line.
2120 If CANONICAL is non-NULL, store an array of strings containing the canonical
c50c785c 2121 line specs there if necessary. Currently overloaded member functions and
5796c8dc 2122 line numbers or static functions without a filename yield a canonical
c50c785c 2123 line spec. The array and the line spec strings are allocated on the heap,
5796c8dc
SS
2124 it is the callers responsibility to free them.
2125
2126 Note that it is possible to return zero for the symtab
2127 if no file is validly specified. Callers must check that.
c50c785c 2128 Also, the line number returned may be invalid. */
5796c8dc 2129
ef5ccd6c 2130/* Parse the linespec in ARGPTR. */
5796c8dc 2131
ef5ccd6c
JM
2132static struct symtabs_and_lines
2133parse_linespec (linespec_parser *parser, char **argptr)
5796c8dc 2134{
ef5ccd6c
JM
2135 linespec_token token;
2136 struct symtabs_and_lines values;
c50c785c 2137 volatile struct gdb_exception file_exception;
ef5ccd6c 2138 struct cleanup *cleanup;
5796c8dc 2139
ef5ccd6c
JM
2140 /* A special case to start. It has become quite popular for
2141 IDEs to work around bugs in the previous parser by quoting
2142 the entire linespec, so we attempt to deal with this nicely. */
2143 parser->is_quote_enclosed = 0;
2144 if (!is_ada_operator (*argptr)
2145 && strchr (linespec_quote_characters, **argptr) != NULL)
c50c785c 2146 {
ef5ccd6c 2147 const char *end;
5796c8dc 2148
ef5ccd6c
JM
2149 end = skip_quote_char (*argptr + 1, **argptr);
2150 if (end != NULL && is_closing_quote_enclosed (end))
2151 {
2152 /* Here's the special case. Skip ARGPTR past the initial
2153 quote. */
2154 ++(*argptr);
2155 parser->is_quote_enclosed = 1;
2156 }
a45ae5f8
JM
2157 }
2158
ef5ccd6c
JM
2159 /* A keyword at the start cannot be interpreted as such.
2160 Consider "b thread thread 42". */
2161 parser->keyword_ok = 0;
c50c785c 2162
ef5ccd6c
JM
2163 parser->lexer.saved_arg = *argptr;
2164 parser->lexer.stream = argptr;
2165 file_exception.reason = 0;
c50c785c 2166
ef5ccd6c
JM
2167 /* Initialize the default symtab and line offset. */
2168 initialize_defaults (&PARSER_STATE (parser)->default_symtab,
2169 &PARSER_STATE (parser)->default_line);
c50c785c 2170
ef5ccd6c
JM
2171 /* Objective-C shortcut. */
2172 values = decode_objc (PARSER_STATE (parser), PARSER_RESULT (parser), argptr);
2173 if (values.sals != NULL)
2174 return values;
5796c8dc 2175
ef5ccd6c 2176 /* Start parsing. */
5796c8dc 2177
ef5ccd6c
JM
2178 /* Get the first token. */
2179 token = linespec_lexer_lex_one (parser);
cf7f2e2d 2180
ef5ccd6c
JM
2181 /* It must be either LSTOKEN_STRING or LSTOKEN_NUMBER. */
2182 if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '*')
2183 {
2184 char *expr;
2185 const char *copy;
5796c8dc 2186
ef5ccd6c
JM
2187 /* User specified an expression, *EXPR. */
2188 copy = expr = copy_token_string (token);
2189 cleanup = make_cleanup (xfree, expr);
2190 PARSER_RESULT (parser)->expr_pc = linespec_expression_to_pc (&copy);
2191 discard_cleanups (cleanup);
2192 PARSER_RESULT (parser)->expression = expr;
5796c8dc 2193
ef5ccd6c
JM
2194 /* This is a little hacky/tricky. If linespec_expression_to_pc
2195 did not evaluate the entire token, then we must find the
2196 string COPY inside the original token buffer. */
2197 if (*copy != '\0')
cf7f2e2d 2198 {
ef5ccd6c
JM
2199 PARSER_STREAM (parser) = strstr (parser->lexer.saved_arg, copy);
2200 gdb_assert (PARSER_STREAM (parser) != NULL);
2201 }
c50c785c 2202
ef5ccd6c
JM
2203 /* Consume the token. */
2204 linespec_lexer_consume_token (parser);
c50c785c 2205
ef5ccd6c
JM
2206 goto convert_to_sals;
2207 }
2208 else if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '$')
2209 {
2210 char *var;
5796c8dc 2211
ef5ccd6c
JM
2212 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2213 VEC_safe_push (symtab_p, PARSER_RESULT (parser)->file_symtabs, NULL);
5796c8dc 2214
ef5ccd6c
JM
2215 /* User specified a convenience variable or history value. */
2216 var = copy_token_string (token);
2217 cleanup = make_cleanup (xfree, var);
2218 PARSER_RESULT (parser)->line_offset
2219 = linespec_parse_variable (PARSER_STATE (parser), var);
2220 do_cleanups (cleanup);
5796c8dc 2221
ef5ccd6c
JM
2222 /* If a line_offset wasn't found (VAR is the name of a user
2223 variable/function), then skip to normal symbol processing. */
2224 if (PARSER_RESULT (parser)->line_offset.sign != LINE_OFFSET_UNKNOWN)
5796c8dc 2225 {
ef5ccd6c
JM
2226 /* Consume this token. */
2227 linespec_lexer_consume_token (parser);
c50c785c 2228
ef5ccd6c 2229 goto convert_to_sals;
5796c8dc 2230 }
5796c8dc 2231 }
ef5ccd6c
JM
2232 else if (token.type != LSTOKEN_STRING && token.type != LSTOKEN_NUMBER)
2233 unexpected_linespec_error (parser);
5796c8dc 2234
ef5ccd6c
JM
2235 /* Now we can recognize keywords. */
2236 parser->keyword_ok = 1;
5796c8dc 2237
ef5ccd6c
JM
2238 /* Shortcut: If the next token is not LSTOKEN_COLON, we know that
2239 this token cannot represent a filename. */
2240 token = linespec_lexer_peek_token (parser);
cf7f2e2d 2241
ef5ccd6c 2242 if (token.type == LSTOKEN_COLON)
cf7f2e2d 2243 {
ef5ccd6c 2244 char *user_filename;
cf7f2e2d 2245
ef5ccd6c
JM
2246 /* Get the current token again and extract the filename. */
2247 token = linespec_lexer_lex_one (parser);
2248 user_filename = copy_token_string (token);
5796c8dc 2249
ef5ccd6c
JM
2250 /* Check if the input is a filename. */
2251 TRY_CATCH (file_exception, RETURN_MASK_ERROR)
2252 {
2253 PARSER_RESULT (parser)->file_symtabs
2254 = symtabs_from_filename (user_filename);
2255 }
5796c8dc 2256
ef5ccd6c
JM
2257 if (file_exception.reason >= 0)
2258 {
2259 /* Symtabs were found for the file. Record the filename. */
2260 PARSER_RESULT (parser)->source_filename = user_filename;
a45ae5f8 2261
ef5ccd6c
JM
2262 /* Get the next token. */
2263 token = linespec_lexer_consume_token (parser);
5796c8dc 2264
ef5ccd6c
JM
2265 /* This is LSTOKEN_COLON; consume it. */
2266 linespec_lexer_consume_token (parser);
2267 }
2268 else
2269 {
2270 /* No symtabs found -- discard user_filename. */
2271 xfree (user_filename);
5796c8dc 2272
ef5ccd6c
JM
2273 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2274 VEC_safe_push (symtab_p, PARSER_RESULT (parser)->file_symtabs, NULL);
2275 }
5796c8dc 2276 }
ef5ccd6c
JM
2277 /* If the next token is not EOI, KEYWORD, or COMMA, issue an error. */
2278 else if (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD
2279 && token.type != LSTOKEN_COMMA)
5796c8dc 2280 {
ef5ccd6c
JM
2281 /* TOKEN is the _next_ token, not the one currently in the parser.
2282 Consuming the token will give the correct error message. */
2283 linespec_lexer_consume_token (parser);
2284 unexpected_linespec_error (parser);
5796c8dc 2285 }
5796c8dc
SS
2286 else
2287 {
ef5ccd6c
JM
2288 /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
2289 VEC_safe_push (symtab_p, PARSER_RESULT (parser)->file_symtabs, NULL);
5796c8dc 2290 }
5796c8dc 2291
ef5ccd6c
JM
2292 /* Parse the rest of the linespec. */
2293 linespec_parse_basic (parser);
5796c8dc 2294
ef5ccd6c
JM
2295 if (PARSER_RESULT (parser)->function_symbols == NULL
2296 && PARSER_RESULT (parser)->labels.label_symbols == NULL
2297 && PARSER_RESULT (parser)->line_offset.sign == LINE_OFFSET_UNKNOWN
2298 && PARSER_RESULT (parser)->minimal_symbols == NULL)
a45ae5f8 2299 {
ef5ccd6c
JM
2300 /* The linespec didn't parse. Re-throw the file exception if
2301 there was one. */
2302 if (file_exception.reason < 0)
2303 throw_exception (file_exception);
c50c785c 2304
ef5ccd6c
JM
2305 /* Otherwise, the symbol is not found. */
2306 symbol_not_found_error (PARSER_RESULT (parser)->function_name,
2307 PARSER_RESULT (parser)->source_filename);
c50c785c
JM
2308 }
2309
ef5ccd6c 2310 convert_to_sals:
c50c785c 2311
ef5ccd6c
JM
2312 /* Get the last token and record how much of the input was parsed,
2313 if necessary. */
2314 token = linespec_lexer_lex_one (parser);
2315 if (token.type != LSTOKEN_EOI && token.type != LSTOKEN_KEYWORD)
2316 PARSER_STREAM (parser) = LS_TOKEN_STOKEN (token).ptr;
5796c8dc 2317
ef5ccd6c
JM
2318 /* Convert the data in PARSER_RESULT to SALs. */
2319 values = convert_linespec_to_sals (PARSER_STATE (parser),
2320 PARSER_RESULT (parser));
a45ae5f8 2321
ef5ccd6c 2322 return values;
5796c8dc
SS
2323}
2324
ef5ccd6c 2325
a45ae5f8 2326/* A constructor for linespec_state. */
5796c8dc 2327
a45ae5f8
JM
2328static void
2329linespec_state_constructor (struct linespec_state *self,
ef5ccd6c 2330 int flags, const struct language_defn *language,
a45ae5f8
JM
2331 struct symtab *default_symtab,
2332 int default_line,
2333 struct linespec_result *canonical)
2334{
2335 memset (self, 0, sizeof (*self));
ef5ccd6c 2336 self->language = language;
a45ae5f8
JM
2337 self->funfirstline = (flags & DECODE_LINE_FUNFIRSTLINE) ? 1 : 0;
2338 self->list_mode = (flags & DECODE_LINE_LIST_MODE) ? 1 : 0;
2339 self->default_symtab = default_symtab;
2340 self->default_line = default_line;
2341 self->canonical = canonical;
2342 self->program_space = current_program_space;
2343 self->addr_set = htab_create_alloc (10, hash_address_entry, eq_address_entry,
2344 xfree, xcalloc, xfree);
2345}
5796c8dc 2346
ef5ccd6c 2347/* Initialize a new linespec parser. */
5796c8dc
SS
2348
2349static void
ef5ccd6c
JM
2350linespec_parser_new (linespec_parser *parser,
2351 int flags, const struct language_defn *language,
2352 struct symtab *default_symtab,
2353 int default_line,
2354 struct linespec_result *canonical)
5796c8dc 2355{
ef5ccd6c
JM
2356 parser->lexer.current.type = LSTOKEN_CONSUMED;
2357 memset (PARSER_RESULT (parser), 0, sizeof (struct linespec));
2358 PARSER_RESULT (parser)->line_offset.sign = LINE_OFFSET_UNKNOWN;
2359 linespec_state_constructor (PARSER_STATE (parser), flags, language,
2360 default_symtab, default_line, canonical);
2361}
2362
2363/* A destructor for linespec_state. */
5796c8dc 2364
ef5ccd6c
JM
2365static void
2366linespec_state_destructor (struct linespec_state *self)
2367{
a45ae5f8
JM
2368 htab_delete (self->addr_set);
2369}
5796c8dc 2370
ef5ccd6c
JM
2371/* Delete a linespec parser. */
2372
2373static void
2374linespec_parser_delete (void *arg)
2375{
2376 linespec_parser *parser = (linespec_parser *) arg;
2377
2378 xfree ((char *) PARSER_RESULT (parser)->expression);
2379 xfree ((char *) PARSER_RESULT (parser)->source_filename);
2380 xfree ((char *) PARSER_RESULT (parser)->label_name);
2381 xfree ((char *) PARSER_RESULT (parser)->function_name);
2382
2383 if (PARSER_RESULT (parser)->file_symtabs != NULL)
2384 VEC_free (symtab_p, PARSER_RESULT (parser)->file_symtabs);
2385
2386 if (PARSER_RESULT (parser)->function_symbols != NULL)
2387 VEC_free (symbolp, PARSER_RESULT (parser)->function_symbols);
2388
2389 if (PARSER_RESULT (parser)->minimal_symbols != NULL)
2390 VEC_free (minsym_and_objfile_d, PARSER_RESULT (parser)->minimal_symbols);
2391
2392 if (PARSER_RESULT (parser)->labels.label_symbols != NULL)
2393 VEC_free (symbolp, PARSER_RESULT (parser)->labels.label_symbols);
2394
2395 if (PARSER_RESULT (parser)->labels.function_symbols != NULL)
2396 VEC_free (symbolp, PARSER_RESULT (parser)->labels.function_symbols);
2397
2398 linespec_state_destructor (PARSER_STATE (parser));
2399}
2400
a45ae5f8 2401/* See linespec.h. */
5796c8dc 2402
a45ae5f8
JM
2403void
2404decode_line_full (char **argptr, int flags,
2405 struct symtab *default_symtab,
2406 int default_line, struct linespec_result *canonical,
2407 const char *select_mode,
2408 const char *filter)
5796c8dc 2409{
a45ae5f8 2410 struct symtabs_and_lines result;
a45ae5f8 2411 struct cleanup *cleanups;
a45ae5f8 2412 VEC (const_char_ptr) *filters = NULL;
ef5ccd6c
JM
2413 linespec_parser parser;
2414 struct linespec_state *state;
a45ae5f8
JM
2415
2416 gdb_assert (canonical != NULL);
2417 /* The filter only makes sense for 'all'. */
2418 gdb_assert (filter == NULL || select_mode == multiple_symbols_all);
2419 gdb_assert (select_mode == NULL
2420 || select_mode == multiple_symbols_all
2421 || select_mode == multiple_symbols_ask
2422 || select_mode == multiple_symbols_cancel);
2423 gdb_assert ((flags & DECODE_LINE_LIST_MODE) == 0);
2424
ef5ccd6c
JM
2425 linespec_parser_new (&parser, flags, current_language, default_symtab,
2426 default_line, canonical);
2427 cleanups = make_cleanup (linespec_parser_delete, &parser);
a45ae5f8
JM
2428 save_current_program_space ();
2429
ef5ccd6c
JM
2430 result = parse_linespec (&parser, argptr);
2431 state = PARSER_STATE (&parser);
a45ae5f8
JM
2432
2433 gdb_assert (result.nelts == 1 || canonical->pre_expanded);
2434 gdb_assert (canonical->addr_string != NULL);
2435 canonical->pre_expanded = 1;
2436
ef5ccd6c 2437 /* Arrange for allocated canonical names to be freed. */
a45ae5f8
JM
2438 if (result.nelts > 0)
2439 {
2440 int i;
2441
ef5ccd6c 2442 make_cleanup (xfree, state->canonical_names);
a45ae5f8
JM
2443 for (i = 0; i < result.nelts; ++i)
2444 {
ef5ccd6c
JM
2445 gdb_assert (state->canonical_names[i].suffix != NULL);
2446 make_cleanup (xfree, state->canonical_names[i].suffix);
a45ae5f8
JM
2447 }
2448 }
2449
2450 if (select_mode == NULL)
2451 {
2452 if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
2453 select_mode = multiple_symbols_all;
2454 else
2455 select_mode = multiple_symbols_select_mode ();
2456 }
2457
2458 if (select_mode == multiple_symbols_all)
2459 {
2460 if (filter != NULL)
2461 {
2462 make_cleanup (VEC_cleanup (const_char_ptr), &filters);
2463 VEC_safe_push (const_char_ptr, filters, filter);
ef5ccd6c 2464 filter_results (state, &result, filters);
a45ae5f8
JM
2465 }
2466 else
ef5ccd6c 2467 convert_results_to_lsals (state, &result);
a45ae5f8
JM
2468 }
2469 else
ef5ccd6c 2470 decode_line_2 (state, &result, select_mode);
a45ae5f8
JM
2471
2472 do_cleanups (cleanups);
2473}
2474
ef5ccd6c
JM
2475/* See linespec.h. */
2476
a45ae5f8
JM
2477struct symtabs_and_lines
2478decode_line_1 (char **argptr, int flags,
2479 struct symtab *default_symtab,
2480 int default_line)
2481{
2482 struct symtabs_and_lines result;
ef5ccd6c 2483 linespec_parser parser;
a45ae5f8
JM
2484 struct cleanup *cleanups;
2485
ef5ccd6c
JM
2486 linespec_parser_new (&parser, flags, current_language, default_symtab,
2487 default_line, NULL);
2488 cleanups = make_cleanup (linespec_parser_delete, &parser);
a45ae5f8
JM
2489 save_current_program_space ();
2490
ef5ccd6c
JM
2491 result = parse_linespec (&parser, argptr);
2492
a45ae5f8
JM
2493 do_cleanups (cleanups);
2494 return result;
2495}
2496
ef5ccd6c
JM
2497/* See linespec.h. */
2498
2499struct symtabs_and_lines
2500decode_line_with_current_source (char *string, int flags)
2501{
2502 struct symtabs_and_lines sals;
2503 struct symtab_and_line cursal;
2504
2505 if (string == 0)
2506 error (_("Empty line specification."));
2507
2508 /* We use whatever is set as the current source line. We do not try
2509 and get a default source symtab+line or it will recursively call us! */
2510 cursal = get_current_source_symtab_and_line ();
2511
2512 sals = decode_line_1 (&string, flags,
2513 cursal.symtab, cursal.line);
2514
2515 if (*string)
2516 error (_("Junk at end of line specification: %s"), string);
2517 return sals;
2518}
2519
2520/* See linespec.h. */
2521
2522struct symtabs_and_lines
2523decode_line_with_last_displayed (char *string, int flags)
2524{
2525 struct symtabs_and_lines sals;
2526
2527 if (string == 0)
2528 error (_("Empty line specification."));
2529
2530 if (last_displayed_sal_is_valid ())
2531 sals = decode_line_1 (&string, flags,
2532 get_last_displayed_symtab (),
2533 get_last_displayed_line ());
2534 else
2535 sals = decode_line_1 (&string, flags, (struct symtab *) NULL, 0);
2536
2537 if (*string)
2538 error (_("Junk at end of line specification: %s"), string);
2539 return sals;
2540}
2541
a45ae5f8
JM
2542\f
2543
2544/* First, some functions to initialize stuff at the beggining of the
2545 function. */
2546
2547static void
2548initialize_defaults (struct symtab **default_symtab, int *default_line)
2549{
2550 if (*default_symtab == 0)
2551 {
2552 /* Use whatever we have for the default source line. We don't use
2553 get_current_or_default_symtab_and_line as it can recurse and call
2554 us back! */
2555 struct symtab_and_line cursal =
2556 get_current_source_symtab_and_line ();
2557
2558 *default_symtab = cursal.symtab;
2559 *default_line = cursal.line;
2560 }
2561}
2562
2563\f
2564
ef5ccd6c
JM
2565/* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
2566 advancing EXP_PTR past any parsed text. */
a45ae5f8 2567
ef5ccd6c
JM
2568static CORE_ADDR
2569linespec_expression_to_pc (const char **exp_ptr)
a45ae5f8 2570{
a45ae5f8
JM
2571 if (current_program_space->executing_startup)
2572 /* The error message doesn't really matter, because this case
2573 should only hit during breakpoint reset. */
2574 throw_error (NOT_FOUND_ERROR, _("cannot evaluate expressions while "
2575 "program space is in startup"));
2576
ef5ccd6c
JM
2577 (*exp_ptr)++;
2578 return value_as_address (parse_to_comma_and_eval (exp_ptr));
5796c8dc
SS
2579}
2580
2581\f
2582
2583/* Here's where we recognise an Objective-C Selector. An Objective C
2584 selector may be implemented by more than one class, therefore it
2585 may represent more than one method/function. This gives us a
2586 situation somewhat analogous to C++ overloading. If there's more
2587 than one method that could represent the selector, then use some of
2588 the existing C++ code to let the user choose one. */
2589
a45ae5f8 2590static struct symtabs_and_lines
ef5ccd6c 2591decode_objc (struct linespec_state *self, linespec_p ls, char **argptr)
5796c8dc 2592{
a45ae5f8
JM
2593 struct collect_info info;
2594 VEC (const_char_ptr) *symbol_names = NULL;
ef5ccd6c 2595 struct symtabs_and_lines values;
a45ae5f8
JM
2596 char *new_argptr;
2597 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
2598 &symbol_names);
2599
2600 info.state = self;
ef5ccd6c
JM
2601 info.file_symtabs = NULL;
2602 VEC_safe_push (symtab_p, info.file_symtabs, NULL);
2603 make_cleanup (VEC_cleanup (symtab_p), &info.file_symtabs);
2604 info.result.symbols = NULL;
2605 info.result.minimal_symbols = NULL;
2606 values.nelts = 0;
2607 values.sals = NULL;
a45ae5f8
JM
2608
2609 new_argptr = find_imps (*argptr, &symbol_names);
2610 if (VEC_empty (const_char_ptr, symbol_names))
2611 {
2612 do_cleanups (cleanup);
ef5ccd6c 2613 return values;
a45ae5f8 2614 }
5796c8dc 2615
a45ae5f8 2616 add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
5796c8dc 2617
ef5ccd6c
JM
2618 if (!VEC_empty (symbolp, info.result.symbols)
2619 || !VEC_empty (minsym_and_objfile_d, info.result.minimal_symbols))
5796c8dc 2620 {
a45ae5f8 2621 char *saved_arg;
5796c8dc 2622
a45ae5f8
JM
2623 saved_arg = alloca (new_argptr - *argptr + 1);
2624 memcpy (saved_arg, *argptr, new_argptr - *argptr);
2625 saved_arg[new_argptr - *argptr] = '\0';
5796c8dc 2626
ef5ccd6c
JM
2627 ls->function_name = xstrdup (saved_arg);
2628 ls->function_symbols = info.result.symbols;
2629 ls->minimal_symbols = info.result.minimal_symbols;
2630 values = convert_linespec_to_sals (self, ls);
2631
a45ae5f8 2632 if (self->canonical)
5796c8dc 2633 {
a45ae5f8 2634 self->canonical->pre_expanded = 1;
ef5ccd6c 2635 if (ls->source_filename)
a45ae5f8 2636 self->canonical->addr_string
ef5ccd6c 2637 = xstrprintf ("%s:%s", ls->source_filename, saved_arg);
a45ae5f8
JM
2638 else
2639 self->canonical->addr_string = xstrdup (saved_arg);
5796c8dc 2640 }
5796c8dc
SS
2641 }
2642
a45ae5f8 2643 *argptr = new_argptr;
5796c8dc 2644
a45ae5f8 2645 do_cleanups (cleanup);
5796c8dc 2646
ef5ccd6c 2647 return values;
5796c8dc
SS
2648}
2649
a45ae5f8
JM
2650/* An instance of this type is used when collecting prefix symbols for
2651 decode_compound. */
2652
2653struct decode_compound_collector
2654{
2655 /* The result vector. */
2656 VEC (symbolp) *symbols;
2657
2658 /* A hash table of all symbols we found. We use this to avoid
2659 adding any symbol more than once. */
2660 htab_t unique_syms;
2661};
2662
2663/* A callback for iterate_over_symbols that is used by
2664 lookup_prefix_sym to collect type symbols. */
2665
2666static int
2667collect_one_symbol (struct symbol *sym, void *d)
2668{
2669 struct decode_compound_collector *collector = d;
2670 void **slot;
2671 struct type *t;
2672
2673 if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
ef5ccd6c 2674 return 1; /* Continue iterating. */
a45ae5f8
JM
2675
2676 t = SYMBOL_TYPE (sym);
2677 CHECK_TYPEDEF (t);
2678 if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2679 && TYPE_CODE (t) != TYPE_CODE_UNION
2680 && TYPE_CODE (t) != TYPE_CODE_NAMESPACE)
ef5ccd6c 2681 return 1; /* Continue iterating. */
a45ae5f8
JM
2682
2683 slot = htab_find_slot (collector->unique_syms, sym, INSERT);
2684 if (!*slot)
2685 {
2686 *slot = sym;
2687 VEC_safe_push (symbolp, collector->symbols, sym);
2688 }
2689
ef5ccd6c 2690 return 1; /* Continue iterating. */
a45ae5f8 2691}
5796c8dc 2692
ef5ccd6c 2693/* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS. */
5796c8dc 2694
a45ae5f8 2695static VEC (symbolp) *
ef5ccd6c
JM
2696lookup_prefix_sym (struct linespec_state *state, VEC (symtab_p) *file_symtabs,
2697 const char *class_name)
5796c8dc 2698{
a45ae5f8
JM
2699 int ix;
2700 struct symtab *elt;
2701 struct decode_compound_collector collector;
2702 struct cleanup *outer;
2703 struct cleanup *cleanup;
5796c8dc 2704
a45ae5f8 2705 collector.symbols = NULL;
ef5ccd6c 2706 outer = make_cleanup (VEC_cleanup (symbolp), &collector.symbols);
cf7f2e2d 2707
a45ae5f8
JM
2708 collector.unique_syms = htab_create_alloc (1, htab_hash_pointer,
2709 htab_eq_pointer, NULL,
2710 xcalloc, xfree);
2711 cleanup = make_cleanup_htab_delete (collector.unique_syms);
cf7f2e2d 2712
a45ae5f8
JM
2713 for (ix = 0; VEC_iterate (symtab_p, file_symtabs, ix, elt); ++ix)
2714 {
2715 if (elt == NULL)
2716 {
ef5ccd6c 2717 iterate_over_all_matching_symtabs (state, class_name, STRUCT_DOMAIN,
a45ae5f8 2718 collect_one_symbol, &collector,
ef5ccd6c
JM
2719 NULL, 0);
2720 iterate_over_all_matching_symtabs (state, class_name, VAR_DOMAIN,
a45ae5f8 2721 collect_one_symbol, &collector,
ef5ccd6c 2722 NULL, 0);
a45ae5f8
JM
2723 }
2724 else
2725 {
a45ae5f8
JM
2726 /* Program spaces that are executing startup should have
2727 been filtered out earlier. */
2728 gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
2729 set_current_program_space (SYMTAB_PSPACE (elt));
ef5ccd6c
JM
2730 iterate_over_file_blocks (elt, class_name, STRUCT_DOMAIN,
2731 collect_one_symbol, &collector);
2732 iterate_over_file_blocks (elt, class_name, VAR_DOMAIN,
2733 collect_one_symbol, &collector);
cf7f2e2d
JM
2734 }
2735 }
2736
ef5ccd6c
JM
2737 do_cleanups (cleanup);
2738 discard_cleanups (outer);
2739 return collector.symbols;
2740}
2741
2742/* A qsort comparison function for symbols. The resulting order does
2743 not actually matter; we just need to be able to sort them so that
2744 symbols with the same program space end up next to each other. */
2745
2746static int
2747compare_symbols (const void *a, const void *b)
2748{
2749 struct symbol * const *sa = a;
2750 struct symbol * const *sb = b;
2751 uintptr_t uia, uib;
2752
2753 uia = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa));
2754 uib = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb));
2755
2756 if (uia < uib)
2757 return -1;
2758 if (uia > uib)
2759 return 1;
2760
2761 uia = (uintptr_t) *sa;
2762 uib = (uintptr_t) *sb;
2763
2764 if (uia < uib)
2765 return -1;
2766 if (uia > uib)
2767 return 1;
2768
2769 return 0;
5796c8dc
SS
2770}
2771
ef5ccd6c 2772/* Like compare_symbols but for minimal symbols. */
5796c8dc 2773
a45ae5f8 2774static int
ef5ccd6c 2775compare_msymbols (const void *a, const void *b)
5796c8dc 2776{
ef5ccd6c
JM
2777 const struct minsym_and_objfile *sa = a;
2778 const struct minsym_and_objfile *sb = b;
a45ae5f8
JM
2779 uintptr_t uia, uib;
2780
ef5ccd6c
JM
2781 uia = (uintptr_t) sa->objfile->pspace;
2782 uib = (uintptr_t) sa->objfile->pspace;
a45ae5f8
JM
2783
2784 if (uia < uib)
2785 return -1;
2786 if (uia > uib)
2787 return 1;
2788
ef5ccd6c
JM
2789 uia = (uintptr_t) sa->minsym;
2790 uib = (uintptr_t) sb->minsym;
a45ae5f8
JM
2791
2792 if (uia < uib)
2793 return -1;
2794 if (uia > uib)
2795 return 1;
2796
2797 return 0;
2798}
5796c8dc 2799
a45ae5f8
JM
2800/* Look for all the matching instances of each symbol in NAMES. Only
2801 instances from PSPACE are considered; other program spaces are
2802 handled by our caller. If PSPACE is NULL, then all program spaces
2803 are considered. Results are stored into INFO. */
2804
2805static void
2806add_all_symbol_names_from_pspace (struct collect_info *info,
2807 struct program_space *pspace,
2808 VEC (const_char_ptr) *names)
2809{
2810 int ix;
2811 const char *iter;
5796c8dc 2812
a45ae5f8
JM
2813 for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix)
2814 add_matching_symbols_to_info (iter, info, pspace);
2815}
5796c8dc 2816
a45ae5f8
JM
2817static void
2818find_superclass_methods (VEC (typep) *superclasses,
2819 const char *name,
2820 VEC (const_char_ptr) **result_names)
2821{
2822 int old_len = VEC_length (const_char_ptr, *result_names);
2823 VEC (typep) *iter_classes;
2824 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
2825
2826 iter_classes = superclasses;
2827 while (1)
5796c8dc 2828 {
a45ae5f8
JM
2829 VEC (typep) *new_supers = NULL;
2830 int ix;
2831 struct type *t;
5796c8dc 2832
a45ae5f8
JM
2833 make_cleanup (VEC_cleanup (typep), &new_supers);
2834 for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix)
2835 find_methods (t, name, result_names, &new_supers);
2836
2837 if (VEC_length (const_char_ptr, *result_names) != old_len
2838 || VEC_empty (typep, new_supers))
2839 break;
2840
2841 iter_classes = new_supers;
2842 }
2843
2844 do_cleanups (cleanup);
2845}
2846
ef5ccd6c
JM
2847/* This finds the method METHOD_NAME in the class CLASS_NAME whose type is
2848 given by one of the symbols in SYM_CLASSES. Matches are returned
2849 in SYMBOLS (for debug symbols) and MINSYMS (for minimal symbols). */
a45ae5f8 2850
ef5ccd6c
JM
2851static void
2852find_method (struct linespec_state *self, VEC (symtab_p) *file_symtabs,
2853 const char *class_name, const char *method_name,
2854 VEC (symbolp) *sym_classes, VEC (symbolp) **symbols,
2855 VEC (minsym_and_objfile_d) **minsyms)
a45ae5f8 2856{
a45ae5f8
JM
2857 struct symbol *sym;
2858 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
2859 int ix;
2860 int last_result_len;
2861 VEC (typep) *superclass_vec;
2862 VEC (const_char_ptr) *result_names;
2863 struct collect_info info;
a45ae5f8
JM
2864
2865 /* Sort symbols so that symbols with the same program space are next
2866 to each other. */
2867 qsort (VEC_address (symbolp, sym_classes),
2868 VEC_length (symbolp, sym_classes),
2869 sizeof (symbolp),
2870 compare_symbols);
2871
2872 info.state = self;
ef5ccd6c
JM
2873 info.file_symtabs = file_symtabs;
2874 info.result.symbols = NULL;
2875 info.result.minimal_symbols = NULL;
a45ae5f8
JM
2876
2877 /* Iterate over all the types, looking for the names of existing
ef5ccd6c 2878 methods matching METHOD_NAME. If we cannot find a direct method in a
a45ae5f8
JM
2879 given program space, then we consider inherited methods; this is
2880 not ideal (ideal would be to respect C++ hiding rules), but it
2881 seems good enough and is what GDB has historically done. We only
2882 need to collect the names because later we find all symbols with
2883 those names. This loop is written in a somewhat funny way
2884 because we collect data across the program space before deciding
2885 what to do. */
2886 superclass_vec = NULL;
2887 make_cleanup (VEC_cleanup (typep), &superclass_vec);
2888 result_names = NULL;
2889 make_cleanup (VEC_cleanup (const_char_ptr), &result_names);
2890 last_result_len = 0;
2891 for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix)
2892 {
2893 struct type *t;
2894 struct program_space *pspace;
2895
2896 /* Program spaces that are executing startup should have
2897 been filtered out earlier. */
2898 gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym))->executing_startup);
2899 pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2900 set_current_program_space (pspace);
2901 t = check_typedef (SYMBOL_TYPE (sym));
ef5ccd6c 2902 find_methods (t, method_name, &result_names, &superclass_vec);
a45ae5f8
JM
2903
2904 /* Handle all items from a single program space at once; and be
2905 sure not to miss the last batch. */
2906 if (ix == VEC_length (symbolp, sym_classes) - 1
2907 || (pspace
2908 != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp, sym_classes,
2909 ix + 1)))))
5796c8dc 2910 {
a45ae5f8
JM
2911 /* If we did not find a direct implementation anywhere in
2912 this program space, consider superclasses. */
2913 if (VEC_length (const_char_ptr, result_names) == last_result_len)
ef5ccd6c
JM
2914 find_superclass_methods (superclass_vec, method_name,
2915 &result_names);
a45ae5f8
JM
2916
2917 /* We have a list of candidate symbol names, so now we
2918 iterate over the symbol tables looking for all
2919 matches in this pspace. */
2920 add_all_symbol_names_from_pspace (&info, pspace, result_names);
2921
2922 VEC_truncate (typep, superclass_vec, 0);
2923 last_result_len = VEC_length (const_char_ptr, result_names);
5796c8dc 2924 }
5796c8dc 2925 }
a45ae5f8 2926
ef5ccd6c
JM
2927 if (!VEC_empty (symbolp, info.result.symbols)
2928 || !VEC_empty (minsym_and_objfile_d, info.result.minimal_symbols))
5796c8dc 2929 {
ef5ccd6c
JM
2930 *symbols = info.result.symbols;
2931 *minsyms = info.result.minimal_symbols;
a45ae5f8 2932 do_cleanups (cleanup);
ef5ccd6c 2933 return;
5796c8dc 2934 }
a45ae5f8 2935
ef5ccd6c
JM
2936 /* Throw an NOT_FOUND_ERROR. This will be caught by the caller
2937 and other attempts to locate the symbol will be made. */
2938 throw_error (NOT_FOUND_ERROR, _("see caller, this text doesn't matter"));
a45ae5f8
JM
2939}
2940
2941\f
2942
2943/* This object is used when collecting all matching symtabs. */
2944
2945struct symtab_collector
2946{
2947 /* The result vector of symtabs. */
2948 VEC (symtab_p) *symtabs;
2949
2950 /* This is used to ensure the symtabs are unique. */
2951 htab_t symtab_table;
2952};
2953
2954/* Callback for iterate_over_symtabs. */
2955
2956static int
2957add_symtabs_to_list (struct symtab *symtab, void *d)
2958{
2959 struct symtab_collector *data = d;
2960 void **slot;
2961
2962 slot = htab_find_slot (data->symtab_table, symtab, INSERT);
2963 if (!*slot)
5796c8dc 2964 {
a45ae5f8
JM
2965 *slot = symtab;
2966 VEC_safe_push (symtab_p, data->symtabs, symtab);
5796c8dc 2967 }
a45ae5f8
JM
2968
2969 return 0;
5796c8dc
SS
2970}
2971
a45ae5f8
JM
2972/* Given a file name, return a VEC of all matching symtabs. */
2973
2974static VEC (symtab_p) *
2975collect_symtabs_from_filename (const char *file)
2976{
2977 struct symtab_collector collector;
2978 struct cleanup *cleanups;
2979 struct program_space *pspace;
5796c8dc 2980
a45ae5f8
JM
2981 collector.symtabs = NULL;
2982 collector.symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
2983 NULL);
2984 cleanups = make_cleanup_htab_delete (collector.symtab_table);
5796c8dc 2985
a45ae5f8
JM
2986 /* Find that file's data. */
2987 ALL_PSPACES (pspace)
2988 {
2989 if (pspace->executing_startup)
2990 continue;
2991
2992 set_current_program_space (pspace);
2993 iterate_over_symtabs (file, add_symtabs_to_list, &collector);
2994 }
2995
2996 do_cleanups (cleanups);
2997 return collector.symtabs;
2998}
2999
ef5ccd6c 3000/* Return all the symtabs associated to the FILENAME. */
a45ae5f8
JM
3001
3002static VEC (symtab_p) *
ef5ccd6c 3003symtabs_from_filename (const char *filename)
5796c8dc 3004{
a45ae5f8 3005 VEC (symtab_p) *result;
5796c8dc 3006
ef5ccd6c 3007 result = collect_symtabs_from_filename (filename);
a45ae5f8 3008
ef5ccd6c 3009 if (VEC_empty (symtab_p, result))
a45ae5f8 3010 {
ef5ccd6c
JM
3011 if (!have_full_symbols () && !have_partial_symbols ())
3012 throw_error (NOT_FOUND_ERROR,
3013 _("No symbol table is loaded. "
3014 "Use the \"file\" command."));
3015 throw_error (NOT_FOUND_ERROR, _("No source file named %s."), filename);
a45ae5f8
JM
3016 }
3017
ef5ccd6c 3018 return result;
5796c8dc
SS
3019}
3020
ef5ccd6c
JM
3021/* Look up a function symbol named NAME in symtabs FILE_SYMTABS. Matching
3022 debug symbols are returned in SYMBOLS. Matching minimal symbols are
3023 returned in MINSYMS. */
5796c8dc 3024
ef5ccd6c
JM
3025static void
3026find_function_symbols (struct linespec_state *state,
3027 VEC (symtab_p) *file_symtabs, const char *name,
3028 VEC (symbolp) **symbols,
3029 VEC (minsym_and_objfile_d) **minsyms)
5796c8dc 3030{
ef5ccd6c
JM
3031 struct collect_info info;
3032 VEC (const_char_ptr) *symbol_names = NULL;
3033 struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
3034 &symbol_names);
5796c8dc 3035
ef5ccd6c
JM
3036 info.state = state;
3037 info.result.symbols = NULL;
3038 info.result.minimal_symbols = NULL;
3039 info.file_symtabs = file_symtabs;
cf7f2e2d 3040
ef5ccd6c
JM
3041 /* Try NAME as an Objective-C selector. */
3042 find_imps ((char *) name, &symbol_names);
3043 if (!VEC_empty (const_char_ptr, symbol_names))
3044 add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
5796c8dc 3045 else
ef5ccd6c 3046 add_matching_symbols_to_info (name, &info, NULL);
5796c8dc 3047
ef5ccd6c 3048 do_cleanups (cleanup);
a45ae5f8 3049
ef5ccd6c
JM
3050 if (VEC_empty (symbolp, info.result.symbols))
3051 {
3052 VEC_free (symbolp, info.result.symbols);
3053 *symbols = NULL;
3054 }
3055 else
3056 *symbols = info.result.symbols;
5796c8dc 3057
ef5ccd6c
JM
3058 if (VEC_empty (minsym_and_objfile_d, info.result.minimal_symbols))
3059 {
3060 VEC_free (minsym_and_objfile_d, info.result.minimal_symbols);
3061 *minsyms = NULL;
3062 }
3063 else
3064 *minsyms = info.result.minimal_symbols;
3065}
a45ae5f8 3066
ef5ccd6c
JM
3067/* Find all symbols named NAME in FILE_SYMTABS, returning debug symbols
3068 in SYMBOLS and minimal symbols in MINSYMS. */
a45ae5f8 3069
ef5ccd6c
JM
3070static void
3071find_linespec_symbols (struct linespec_state *state,
3072 VEC (symtab_p) *file_symtabs,
3073 const char *name,
3074 VEC (symbolp) **symbols,
3075 VEC (minsym_and_objfile_d) **minsyms)
3076{
3077 struct cleanup *cleanup;
3078 char *canon;
3079 const char *lookup_name;
3080 volatile struct gdb_exception except;
5796c8dc 3081
ef5ccd6c
JM
3082 cleanup = demangle_for_lookup (name, state->language->la_language,
3083 &lookup_name);
3084 if (state->language->la_language == language_ada)
3085 {
3086 /* In Ada, the symbol lookups are performed using the encoded
3087 name rather than the demangled name. */
3088 lookup_name = ada_name_for_lookup (name);
3089 make_cleanup (xfree, (void *) lookup_name);
5796c8dc
SS
3090 }
3091
ef5ccd6c
JM
3092 canon = cp_canonicalize_string_no_typedefs (lookup_name);
3093 if (canon != NULL)
3094 {
3095 lookup_name = canon;
3096 cleanup = make_cleanup (xfree, canon);
3097 }
3098
3099 /* It's important to not call expand_symtabs_matching unnecessarily
3100 as it can really slow things down (by unnecessarily expanding
3101 potentially 1000s of symtabs, which when debugging some apps can
3102 cost 100s of seconds). Avoid this to some extent by *first* calling
3103 find_function_symbols, and only if that doesn't find anything
3104 *then* call find_method. This handles two important cases:
3105 1) break (anonymous namespace)::foo
3106 2) break class::method where method is in class (and not a baseclass) */
3107
3108 find_function_symbols (state, file_symtabs, lookup_name,
3109 symbols, minsyms);
3110
3111 /* If we were unable to locate a symbol of the same name, try dividing
3112 the name into class and method names and searching the class and its
3113 baseclasses. */
3114 if (VEC_empty (symbolp, *symbols)
3115 && VEC_empty (minsym_and_objfile_d, *minsyms))
3116 {
3117 char *klass, *method;
3118 const char *last, *p, *scope_op;
3119 VEC (symbolp) *classes;
3120
3121 /* See if we can find a scope operator and break this symbol
3122 name into namespaces${SCOPE_OPERATOR}class_name and method_name. */
3123 scope_op = "::";
3124 p = find_toplevel_string (lookup_name, scope_op);
3125 if (p == NULL)
3126 {
3127 /* No C++ scope operator. Try Java. */
3128 scope_op = ".";
3129 p = find_toplevel_string (lookup_name, scope_op);
3130 }
5796c8dc 3131
ef5ccd6c
JM
3132 last = NULL;
3133 while (p != NULL)
3134 {
3135 last = p;
3136 p = find_toplevel_string (p + strlen (scope_op), scope_op);
3137 }
5796c8dc 3138
ef5ccd6c
JM
3139 /* If no scope operator was found, there is nothing more we can do;
3140 we already attempted to lookup the entire name as a symbol
3141 and failed. */
3142 if (last == NULL)
a45ae5f8 3143 {
ef5ccd6c
JM
3144 do_cleanups (cleanup);
3145 return;
a45ae5f8 3146 }
a45ae5f8 3147
ef5ccd6c
JM
3148 /* LOOKUP_NAME points to the class name.
3149 LAST points to the method name. */
3150 klass = xmalloc ((last - lookup_name + 1) * sizeof (char));
3151 make_cleanup (xfree, klass);
3152 strncpy (klass, lookup_name, last - lookup_name);
3153 klass[last - lookup_name] = '\0';
5796c8dc 3154
ef5ccd6c
JM
3155 /* Skip past the scope operator. */
3156 last += strlen (scope_op);
3157 method = xmalloc ((strlen (last) + 1) * sizeof (char));
3158 make_cleanup (xfree, method);
3159 strcpy (method, last);
a45ae5f8 3160
ef5ccd6c
JM
3161 /* Find a list of classes named KLASS. */
3162 classes = lookup_prefix_sym (state, file_symtabs, klass);
3163 make_cleanup (VEC_cleanup (symbolp), &classes);
3164
3165 if (!VEC_empty (symbolp, classes))
3166 {
3167 /* Now locate a list of suitable methods named METHOD. */
3168 TRY_CATCH (except, RETURN_MASK_ERROR)
3169 {
3170 find_method (state, file_symtabs, klass, method, classes,
3171 symbols, minsyms);
3172 }
3173
3174 /* If successful, we're done. If NOT_FOUND_ERROR
3175 was not thrown, rethrow the exception that we did get. */
3176 if (except.reason < 0 && except.error != NOT_FOUND_ERROR)
3177 throw_exception (except);
3178 }
a45ae5f8 3179 }
5796c8dc 3180
ef5ccd6c 3181 do_cleanups (cleanup);
5796c8dc
SS
3182}
3183
ef5ccd6c
JM
3184/* Return all labels named NAME in FUNCTION_SYMBOLS. Return the
3185 actual function symbol in which the label was found in LABEL_FUNC_RET. */
c50c785c 3186
ef5ccd6c
JM
3187static VEC (symbolp) *
3188find_label_symbols (struct linespec_state *self,
3189 VEC (symbolp) *function_symbols,
3190 VEC (symbolp) **label_funcs_ret, const char *name)
c50c785c 3191{
a45ae5f8 3192 int ix;
ef5ccd6c
JM
3193 struct block *block;
3194 struct symbol *sym;
3195 struct symbol *fn_sym;
3196 VEC (symbolp) *result = NULL;
c50c785c 3197
a45ae5f8 3198 if (function_symbols == NULL)
c50c785c 3199 {
a45ae5f8 3200 set_current_program_space (self->program_space);
ef5ccd6c 3201 block = get_current_search_block ();
a45ae5f8 3202
c50c785c
JM
3203 for (;
3204 block && !BLOCK_FUNCTION (block);
3205 block = BLOCK_SUPERBLOCK (block))
3206 ;
3207 if (!block)
ef5ccd6c 3208 return NULL;
a45ae5f8
JM
3209 fn_sym = BLOCK_FUNCTION (block);
3210
ef5ccd6c 3211 sym = lookup_symbol (name, block, LABEL_DOMAIN, 0);
a45ae5f8 3212
ef5ccd6c 3213 if (sym != NULL)
a45ae5f8 3214 {
ef5ccd6c
JM
3215 VEC_safe_push (symbolp, result, sym);
3216 VEC_safe_push (symbolp, *label_funcs_ret, fn_sym);
3217 }
3218 }
3219 else
3220 {
3221 for (ix = 0;
3222 VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix)
3223 {
3224 set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym)));
3225 block = SYMBOL_BLOCK_VALUE (fn_sym);
3226 sym = lookup_symbol (name, block, LABEL_DOMAIN, 0);
3227
3228 if (sym != NULL)
3229 {
3230 VEC_safe_push (symbolp, result, sym);
3231 VEC_safe_push (symbolp, *label_funcs_ret, fn_sym);
3232 }
a45ae5f8 3233 }
ef5ccd6c 3234 }
a45ae5f8 3235
ef5ccd6c
JM
3236 return result;
3237}
a45ae5f8 3238
ef5ccd6c
JM
3239\f
3240
3241/* A helper for create_sals_line_offset that handles the 'list_mode' case. */
3242
3243static void
3244decode_digits_list_mode (struct linespec_state *self,
3245 linespec_p ls,
3246 struct symtabs_and_lines *values,
3247 struct symtab_and_line val)
3248{
3249 int ix;
3250 struct symtab *elt;
3251
3252 gdb_assert (self->list_mode);
3253
3254 for (ix = 0; VEC_iterate (symtab_p, ls->file_symtabs, ix, elt);
3255 ++ix)
3256 {
3257 /* The logic above should ensure this. */
3258 gdb_assert (elt != NULL);
3259
3260 set_current_program_space (SYMTAB_PSPACE (elt));
3261
3262 /* Simplistic search just for the list command. */
3263 val.symtab = find_line_symtab (elt, val.line, NULL, NULL);
3264 if (val.symtab == NULL)
3265 val.symtab = elt;
3266 val.pspace = SYMTAB_PSPACE (elt);
3267 val.pc = 0;
3268 val.explicit_line = 1;
3269
3270 add_sal_to_sals (self, values, &val, NULL, 0);
a45ae5f8 3271 }
ef5ccd6c 3272}
a45ae5f8 3273
ef5ccd6c
JM
3274/* A helper for create_sals_line_offset that iterates over the symtabs,
3275 adding lines to the VEC. */
3276
3277static void
3278decode_digits_ordinary (struct linespec_state *self,
3279 linespec_p ls,
3280 int line,
3281 struct symtabs_and_lines *sals,
3282 struct linetable_entry **best_entry)
3283{
3284 int ix;
3285 struct symtab *elt;
a45ae5f8 3286
ef5ccd6c 3287 for (ix = 0; VEC_iterate (symtab_p, ls->file_symtabs, ix, elt); ++ix)
a45ae5f8 3288 {
ef5ccd6c
JM
3289 int i;
3290 VEC (CORE_ADDR) *pcs;
3291 CORE_ADDR pc;
3292
3293 /* The logic above should ensure this. */
3294 gdb_assert (elt != NULL);
a45ae5f8 3295
ef5ccd6c 3296 set_current_program_space (SYMTAB_PSPACE (elt));
a45ae5f8 3297
ef5ccd6c
JM
3298 pcs = find_pcs_for_symtab_line (elt, line, best_entry);
3299 for (i = 0; VEC_iterate (CORE_ADDR, pcs, i, pc); ++i)
a45ae5f8
JM
3300 {
3301 struct symtab_and_line sal;
ef5ccd6c
JM
3302
3303 init_sal (&sal);
3304 sal.pspace = SYMTAB_PSPACE (elt);
3305 sal.symtab = elt;
3306 sal.line = line;
3307 sal.pc = pc;
3308 add_sal_to_sals_basic (sals, &sal);
a45ae5f8 3309 }
ef5ccd6c
JM
3310
3311 VEC_free (CORE_ADDR, pcs);
a45ae5f8 3312 }
ef5ccd6c
JM
3313}
3314
3315\f
3316
3317/* Return the line offset represented by VARIABLE. */
3318
3319static struct line_offset
3320linespec_parse_variable (struct linespec_state *self, const char *variable)
3321{
3322 int index = 0;
3323 const char *p;
3324 struct line_offset offset = {0, LINE_OFFSET_NONE};
a45ae5f8 3325
ef5ccd6c
JM
3326 p = (variable[1] == '$') ? variable + 2 : variable + 1;
3327 if (*p == '$')
3328 ++p;
3329 while (*p >= '0' && *p <= '9')
3330 ++p;
3331 if (!*p) /* Reached end of token without hitting non-digit. */
a45ae5f8 3332 {
ef5ccd6c
JM
3333 /* We have a value history reference. */
3334 struct value *val_history;
a45ae5f8 3335
ef5ccd6c
JM
3336 sscanf ((variable[1] == '$') ? variable + 2 : variable + 1, "%d", &index);
3337 val_history
3338 = access_value_history ((variable[1] == '$') ? -index : index);
3339 if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
3340 error (_("History values used in line "
3341 "specs must have integer values."));
3342 offset.offset = value_as_long (val_history);
3343 }
3344 else
3345 {
3346 /* Not all digits -- may be user variable/function or a
3347 convenience variable. */
3348 LONGEST valx;
3349 struct internalvar *ivar;
3350
3351 /* Try it as a convenience variable. If it is not a convenience
3352 variable, return and allow normal symbol lookup to occur. */
3353 ivar = lookup_only_internalvar (variable + 1);
3354 if (ivar == NULL)
3355 /* No internal variable with that name. Mark the offset
3356 as unknown to allow the name to be looked up as a symbol. */
3357 offset.sign = LINE_OFFSET_UNKNOWN;
3358 else
3359 {
3360 /* We found a valid variable name. If it is not an integer,
3361 throw an error. */
3362 if (!get_internalvar_integer (ivar, &valx))
3363 error (_("Convenience variables used in line "
3364 "specs must have integer values."));
3365 else
3366 offset.offset = valx;
3367 }
c50c785c
JM
3368 }
3369
ef5ccd6c 3370 return offset;
a45ae5f8 3371}
ef5ccd6c 3372\f
a45ae5f8
JM
3373
3374/* A callback used to possibly add a symbol to the results. */
3375
3376static int
3377collect_symbols (struct symbol *sym, void *data)
3378{
3379 struct collect_info *info = data;
a45ae5f8 3380
ef5ccd6c
JM
3381 /* In list mode, add all matching symbols, regardless of class.
3382 This allows the user to type "list a_global_variable". */
3383 if (SYMBOL_CLASS (sym) == LOC_BLOCK || info->state->list_mode)
3384 VEC_safe_push (symbolp, info->result.symbols, sym);
3385 return 1; /* Continue iterating. */
a45ae5f8
JM
3386}
3387
ef5ccd6c
JM
3388/* We've found a minimal symbol MSYMBOL in OBJFILE to associate with our
3389 linespec; return the SAL in RESULT. */
a45ae5f8
JM
3390
3391static void
3392minsym_found (struct linespec_state *self, struct objfile *objfile,
3393 struct minimal_symbol *msymbol,
3394 struct symtabs_and_lines *result)
3395{
3396 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3397 CORE_ADDR pc;
3398 struct symtab_and_line sal;
3399
3400 sal = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
3401 (struct obj_section *) 0, 0);
3402 sal.section = SYMBOL_OBJ_SECTION (msymbol);
3403
3404 /* The minimal symbol might point to a function descriptor;
3405 resolve it to the actual code address instead. */
3406 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, &current_target);
3407 if (pc != sal.pc)
3408 sal = find_pc_sect_line (pc, NULL, 0);
c50c785c 3409
a45ae5f8
JM
3410 if (self->funfirstline)
3411 skip_prologue_sal (&sal);
c50c785c 3412
a45ae5f8 3413 if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc))
ef5ccd6c 3414 add_sal_to_sals (self, result, &sal, SYMBOL_NATURAL_NAME (msymbol), 0);
a45ae5f8
JM
3415}
3416
a45ae5f8
JM
3417/* A helper struct to pass some data through
3418 iterate_over_minimal_symbols. */
3419
3420struct collect_minsyms
3421{
3422 /* The objfile we're examining. */
3423 struct objfile *objfile;
3424
3425 /* The funfirstline setting from the initial call. */
3426 int funfirstline;
3427
3428 /* The list_mode setting from the initial call. */
3429 int list_mode;
3430
3431 /* The resulting symbols. */
3432 VEC (minsym_and_objfile_d) *msyms;
3433};
3434
3435/* A helper function to classify a minimal_symbol_type according to
3436 priority. */
3437
3438static int
3439classify_mtype (enum minimal_symbol_type t)
3440{
3441 switch (t)
3442 {
3443 case mst_file_text:
3444 case mst_file_data:
3445 case mst_file_bss:
3446 /* Intermediate priority. */
3447 return 1;
3448
3449 case mst_solib_trampoline:
3450 /* Lowest priority. */
3451 return 2;
3452
3453 default:
3454 /* Highest priority. */
3455 return 0;
3456 }
3457}
3458
3459/* Callback for qsort that sorts symbols by priority. */
3460
3461static int
3462compare_msyms (const void *a, const void *b)
3463{
3464 const minsym_and_objfile_d *moa = a;
3465 const minsym_and_objfile_d *mob = b;
3466 enum minimal_symbol_type ta = MSYMBOL_TYPE (moa->minsym);
3467 enum minimal_symbol_type tb = MSYMBOL_TYPE (mob->minsym);
3468
3469 return classify_mtype (ta) - classify_mtype (tb);
3470}
3471
3472/* Callback for iterate_over_minimal_symbols that adds the symbol to
3473 the result. */
3474
3475static void
3476add_minsym (struct minimal_symbol *minsym, void *d)
3477{
3478 struct collect_minsyms *info = d;
3479 minsym_and_objfile_d mo;
3480
3481 /* Exclude data symbols when looking for breakpoint locations. */
3482 if (!info->list_mode)
3483 switch (minsym->type)
3484 {
3485 case mst_slot_got_plt:
3486 case mst_data:
3487 case mst_bss:
3488 case mst_abs:
3489 case mst_file_data:
3490 case mst_file_bss:
3491 {
3492 /* Make sure this minsym is not a function descriptor
3493 before we decide to discard it. */
3494 struct gdbarch *gdbarch = info->objfile->gdbarch;
3495 CORE_ADDR addr = gdbarch_convert_from_func_ptr_addr
3496 (gdbarch, SYMBOL_VALUE_ADDRESS (minsym),
3497 &current_target);
3498
3499 if (addr == SYMBOL_VALUE_ADDRESS (minsym))
3500 return;
3501 }
3502 }
3503
3504 mo.minsym = minsym;
3505 mo.objfile = info->objfile;
3506 VEC_safe_push (minsym_and_objfile_d, info->msyms, &mo);
3507}
3508
3509/* Search minimal symbols in all objfiles for NAME. If SEARCH_PSPACE
3510 is not NULL, the search is restricted to just that program
3511 space. */
3512
3513static void
3514search_minsyms_for_name (struct collect_info *info, const char *name,
3515 struct program_space *search_pspace)
3516{
3517 struct objfile *objfile;
3518 struct program_space *pspace;
3519
3520 ALL_PSPACES (pspace)
3521 {
3522 struct collect_minsyms local;
3523 struct cleanup *cleanup;
3524
3525 if (search_pspace != NULL && search_pspace != pspace)
3526 continue;
3527 if (pspace->executing_startup)
3528 continue;
3529
3530 set_current_program_space (pspace);
3531
3532 memset (&local, 0, sizeof (local));
3533 local.funfirstline = info->state->funfirstline;
3534 local.list_mode = info->state->list_mode;
3535
3536 cleanup = make_cleanup (VEC_cleanup (minsym_and_objfile_d),
3537 &local.msyms);
3538
3539 ALL_OBJFILES (objfile)
3540 {
3541 local.objfile = objfile;
3542 iterate_over_minimal_symbols (objfile, name, add_minsym, &local);
3543 }
3544
3545 if (!VEC_empty (minsym_and_objfile_d, local.msyms))
3546 {
3547 int classification;
3548 int ix;
3549 minsym_and_objfile_d *item;
3550
3551 qsort (VEC_address (minsym_and_objfile_d, local.msyms),
3552 VEC_length (minsym_and_objfile_d, local.msyms),
3553 sizeof (minsym_and_objfile_d),
3554 compare_msyms);
3555
3556 /* Now the minsyms are in classification order. So, we walk
3557 over them and process just the minsyms with the same
3558 classification as the very first minsym in the list. */
3559 item = VEC_index (minsym_and_objfile_d, local.msyms, 0);
3560 classification = classify_mtype (MSYMBOL_TYPE (item->minsym));
3561
3562 for (ix = 0;
3563 VEC_iterate (minsym_and_objfile_d, local.msyms, ix, item);
3564 ++ix)
3565 {
3566 if (classify_mtype (MSYMBOL_TYPE (item->minsym)) != classification)
3567 break;
3568
ef5ccd6c
JM
3569 VEC_safe_push (minsym_and_objfile_d,
3570 info->result.minimal_symbols, item);
a45ae5f8
JM
3571 }
3572 }