Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / linespec.c
1 /* Parser for linespec for the GNU debugger, GDB.
2
3    Copyright (C) 1986-2013 Free Software Foundation, Inc.
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"
31 #include "cp-support.h"
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"
41 #include "arch-utils.h"
42 #include <ctype.h>
43 #include "cli/cli-utils.h"
44 #include "filenames.h"
45 #include "ada-lang.h"
46 #include "stack.h"
47
48 typedef struct symtab *symtab_p;
49 DEF_VEC_P (symtab_p);
50
51 typedef struct symbol *symbolp;
52 DEF_VEC_P (symbolp);
53
54 typedef struct type *typep;
55 DEF_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
61 struct address_entry
62 {
63   struct program_space *pspace;
64   CORE_ADDR addr;
65 };
66
67 /* A helper struct which just holds a minimal symbol and the object
68    file from which it came.  */
69
70 typedef struct minsym_and_objfile
71 {
72   struct minimal_symbol *minsym;
73   struct objfile *objfile;
74 } minsym_and_objfile_d;
75
76 DEF_VEC_O (minsym_and_objfile_d);
77
78 /* An enumeration of possible signs for a line offset.  */
79 enum 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
96 struct 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
107 struct 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 };
158 typedef 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
166 struct 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
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
179 struct linespec_state
180 {
181   /* The language in use during linespec processing.  */
182   const struct language_defn *language;
183
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
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.  */
204   struct linespec_canonical_name *canonical_names;
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
214 struct collect_info
215 {
216   /* The linespec object in use.  */
217   struct linespec_state *state;
218
219   /* A list of symtabs to which to restrict matches.  */
220   VEC (symtab_p) *file_symtabs;
221
222   /* The result being accumulated.  */
223   struct
224   {
225     VEC (symbolp) *symbols;
226     VEC (minsym_and_objfile_d) *minimal_symbols;
227   } result;
228 };
229
230 /* Token types  */
231
232 enum ls_token_type
233 {
234   /* A keyword  */
235   LSTOKEN_KEYWORD = 0,
236
237   /* A colon "separator"  */
238   LSTOKEN_COLON,
239
240   /* A string  */
241   LSTOKEN_STRING,
242
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 };
255 typedef enum ls_token_type linespec_token_type;
256
257 /* List of keywords  */
258
259 static const char * const linespec_keywords[] = { "if", "thread", "task" };
260
261 /* A token of the linespec lexer  */
262
263 struct 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 };
278 typedef 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
285 struct 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 };
317 typedef struct ls_parser linespec_parser;
318
319 /* Prototypes for local functions.  */
320
321 static void iterate_over_file_blocks (struct symtab *symtab,
322                                       const char *name, domain_enum domain,
323                                       symbol_found_callback_ftype *callback,
324                                       void *data);
325
326 static void initialize_defaults (struct symtab **default_symtab,
327                                  int *default_line);
328
329 static CORE_ADDR linespec_expression_to_pc (const char **exp_ptr);
330
331 static struct symtabs_and_lines decode_objc (struct linespec_state *self,
332                                              linespec_p ls,
333                                              char **argptr);
334
335 static VEC (symtab_p) *symtabs_from_filename (const char *);
336
337 static VEC (symbolp) *find_label_symbols (struct linespec_state *self,
338                                           VEC (symbolp) *function_symbols,
339                                           VEC (symbolp) **label_funcs_ret,
340                                           const char *name);
341
342 static 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);
347
348 static struct line_offset
349      linespec_parse_variable (struct linespec_state *self,
350                               const char *variable);
351
352 static int symbol_to_sal (struct symtab_and_line *result,
353                           int funfirstline, struct symbol *sym);
354
355 static void add_matching_symbols_to_info (const char *name,
356                                           struct collect_info *info,
357                                           struct program_space *pspace);
358
359 static void add_all_symbol_names_from_pspace (struct collect_info *info,
360                                               struct program_space *pspace,
361                                               VEC (const_char_ptr) *names);
362
363 static VEC (symtab_p) *collect_symtabs_from_filename (const char *file);
364
365 static 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);
370
371 static 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);
375
376 static void minsym_found (struct linespec_state *self, struct objfile *objfile,
377                           struct minimal_symbol *msymbol,
378                           struct symtabs_and_lines *result);
379
380 static int compare_symbols (const void *a, const void *b);
381
382 static int compare_msymbols (const void *a, const void *b);
383
384 static 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.  */
389 static 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
398 static int
399 linespec_lexer_lex_number (linespec_parser *parser, linespec_token *tokenp)
400 {
401   tokenp->type = LSTOKEN_NUMBER;
402   LS_TOKEN_STOKEN (*tokenp).length = 0;
403   LS_TOKEN_STOKEN (*tokenp).ptr = PARSER_STREAM (parser);
404
405   /* Keep any sign at the start of the stream.  */
406   if (*PARSER_STREAM (parser) == '+' || *PARSER_STREAM (parser) == '-')
407     {
408       ++LS_TOKEN_STOKEN (*tokenp).length;
409       ++(PARSER_STREAM (parser));
410     }
411
412   while (isdigit (*PARSER_STREAM (parser)))
413     {
414       ++LS_TOKEN_STOKEN (*tokenp).length;
415       ++(PARSER_STREAM (parser));
416     }
417
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;
427     }
428
429   return 1;
430 }
431
432 /* Does P represent one of the keywords?  If so, return
433    the keyword.  If not, return NULL.  */
434
435 static const char *
436 linespec_lexer_lex_keyword (const char *p)
437 {
438   int i;
439
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;
456 }
457
458 /* Does STRING represent an Ada operator?  If so, return the length
459    of the decoded operator name.  If not, return 0.  */
460
461 static int
462 is_ada_operator (const char *string)
463 {
464   const struct ada_opname_map *mapping;
465
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);
473 }
474
475 /* Find QUOTE_CHAR in STRING, accounting for the ':' terminal.  Return
476    the location of QUOTE_CHAR, or NULL if not found.  */
477
478 static const char *
479 skip_quote_char (const char *string, char quote_char)
480 {
481   const char *p, *last;
482
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     }
490
491   return last;
492 }
493
494 /* Make a writable copy of the string given in TOKEN, trimming
495    any trailing whitespace.  */
496
497 static char *
498 copy_token_string (linespec_token token)
499 {
500   char *str, *s;
501
502   if (token.type == LSTOKEN_KEYWORD)
503     return xstrdup (LS_TOKEN_KEYWORD (token));
504
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';
509
510   return str;
511 }
512
513 /* Does P represent the end of a quote-enclosed linespec?  */
514
515 static int
516 is_closing_quote_enclosed (const char *p)
517 {
518   if (strchr (linespec_quote_characters, *p))
519     ++p;
520   p = skip_spaces ((char *) p);
521   return (*p == '\0' || linespec_lexer_lex_keyword (p));
522 }
523
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.  */
527
528 static char *
529 find_parameter_list_end (char *input)
530 {
531   char end_char, start_char;
532   int depth;
533   char *p;
534
535   start_char = *input;
536   if (start_char == '(')
537     end_char = ')';
538   else if (start_char == '<')
539     end_char = '>';
540   else
541     return NULL;
542
543   p = input;
544   depth = 0;
545   while (*p)
546     {
547       if (*p == start_char)
548         ++depth;
549       else if (*p == end_char)
550         {
551           if (--depth == 0)
552             {
553               ++p;
554               break;
555             }
556         }
557       ++p;
558     }
559
560   return p;
561 }
562
563
564 /* Lex a string from the input in PARSER.  */
565
566 static linespec_token
567 linespec_lexer_lex_string (linespec_parser *parser)
568 {
569   linespec_token token;
570   char *start = PARSER_STREAM (parser);
571
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)))
577     {
578       const char *end;
579       char quote_char = *PARSER_STREAM (parser);
580
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));
586
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             }
596
597           /* The input does not represent an Ada operator -- fall through
598              to normal quoted string handling.  */
599         }
600
601       /* Skip past the beginning quote.  */
602       ++(PARSER_STREAM (parser));
603
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
619     {
620       char *p;
621
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.
626
627          This allows users to forgo quoting CV-qualifiers, template arguments,
628          and similar common language constructs.  */
629
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
738 static linespec_token
739 linespec_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
819 static linespec_token
820 linespec_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
828 static linespec_token
829 linespec_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
845 static void
846 add_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
861 static void
862 add_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
906 static hashval_t
907 hash_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
918 static int
919 eq_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
931 static int
932 maybe_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
952 struct 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
965 static int
966 iterate_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
979 struct 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
991 static int
992 iterate_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
1007 static void
1008 iterate_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
1071 static struct block *
1072 get_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
1088 static void
1089 iterate_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
1105 static void
1106 find_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;
1127            method_counter >= 0;
1128            --method_counter)
1129         {
1130           const char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
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
1143           if (strcmp_iw (method_name, name) == 0)
1144             {
1145               int field_counter;
1146
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             }
1162         }
1163     }
1164
1165   for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
1166     VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase));
1167 }
1168
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
1174 static const char *
1175 find_toplevel_char (const char *s, char c)
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.  */
1181   const char *scan;
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
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.  */
1208
1209 static const char *
1210 find_toplevel_string (const char *haystack, const char *needle)
1211 {
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
1238 static char *
1239 canonical_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);
1246 }
1247
1248 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
1249    and store the result in SELF->CANONICAL.  */
1250
1251 static void
1252 filter_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         {
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)
1277             add_sal_to_sals_basic (&lsal.sals, &result->sals[j]);
1278
1279           do_cleanups (cleanup);
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
1294 static void
1295 convert_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
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
1311 struct 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
1329 static int
1330 decode_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
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
1348 static void
1349 decode_line_2 (struct linespec_state *self,
1350                struct symtabs_and_lines *result,
1351                const char *select_mode)
1352 {
1353   char *args, *prompt;
1354   int i;
1355   struct cleanup *old_chain;
1356   VEC (const_char_ptr) *filters = NULL;
1357   struct get_number_or_range_state state;
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
1491 static void ATTRIBUTE_NORETURN
1492 symbol_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
1533 static void ATTRIBUTE_NORETURN
1534 unexpected_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
1564 static struct line_offset
1565 linespec_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
1587 static void
1588 linespec_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 }
1751
1752 /* Canonicalize the linespec contained in LS.  The result is saved into
1753    STATE->canonical.  */
1754
1755 static void
1756 canonicalize_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;
1761
1762   /* Shortcut expressions, which can only appear by themselves.  */
1763   if (ls->expression != NULL)
1764     state->canonical->addr_string = xstrdup (ls->expression);
1765   else
1766     {
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         }
1784
1785       if (ls->label_name)
1786         {
1787           if (need_colon)
1788             fputc_unfiltered (':', buf);
1789
1790           if (ls->function_name == NULL)
1791             {
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);
1801             }
1802
1803           fputs_unfiltered (ls->label_name, buf);
1804           need_colon = 1;
1805           state->canonical->special_display = 1;
1806         }
1807
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         }
1818
1819       state->canonical->addr_string = ui_file_xstrdup (buf, NULL);
1820       ui_file_delete (buf);
1821     }
1822 }
1823
1824 /* Given a line offset in LS, construct the relevant SALs.  */
1825
1826 static struct symtabs_and_lines
1827 create_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;
1833
1834   init_sal (&val);
1835   values.sals = NULL;
1836   values.nelts = 0;
1837
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)
1846     {
1847       const char *fullname;
1848
1849       set_current_program_space (self->program_space);
1850
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     }
1860
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;
1876       else
1877         val.line = -val.line;
1878       break;
1879
1880     case LINE_OFFSET_NONE:
1881       break;                    /* No need to adjust val.line.  */
1882     }
1883
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;
1894
1895       intermediate_results.sals = NULL;
1896       intermediate_results.nelts = 0;
1897
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);
1903
1904       cleanup = make_cleanup (xfree, intermediate_results.sals);
1905
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.  */
1915
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);
1920
1921       for (i = 0; i < intermediate_results.nelts; ++i)
1922         {
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);
1928         }
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);
1960     }
1961
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;
1973 }
1974
1975 /* Create and return SALs from the linespec LS.  */
1976
1977 static struct symtabs_and_lines
1978 convert_linespec_to_sals (struct linespec_state *state, linespec_p ls)
1979 {
1980   struct symtabs_and_lines sals = {NULL, 0};
1981
1982   if (ls->expression != NULL)
1983     {
1984       struct symtab_and_line sal;
1985
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;
1999
2000       for (i = 0; VEC_iterate (symbolp, ls->labels.label_symbols, i, sym); ++i)
2001         {
2002           if (symbol_to_sal (&sal, state->funfirstline, sym))
2003             add_sal_to_sals (state, &sals, &sal,
2004                              SYMBOL_NATURAL_NAME (sym), 0);
2005         }
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);
2023
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         }
2034
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);
2056
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);
2061
2062             ls->source_filename = xstrdup (fullname);
2063           }
2064     }
2065   else
2066     {
2067       /* We haven't found any results...  */
2068       return sals;
2069     }
2070
2071   canonicalize_linespec (state, ls);
2072
2073   if (sals.nelts > 0 && state->canonical != NULL)
2074     state->canonical->pre_expanded = 1;
2075
2076   return sals;
2077 }
2078
2079 /* Parse a string that specifies a linespec.
2080    Pass the address of a char * variable; that variable will be
2081    advanced over the characters actually parsed.
2082
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
2093
2094    opt_file_spec -> "" | file_name_spec ':'
2095    opt_label_spec -> "" | ':' label_name_spec
2096
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
2104
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.
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
2121    line specs there if necessary.  Currently overloaded member functions and
2122    line numbers or static functions without a filename yield a canonical
2123    line spec.  The array and the line spec strings are allocated on the heap,
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.
2128    Also, the line number returned may be invalid.  */
2129
2130 /* Parse the linespec in ARGPTR.  */
2131
2132 static struct symtabs_and_lines
2133 parse_linespec (linespec_parser *parser, char **argptr)
2134 {
2135   linespec_token token;
2136   struct symtabs_and_lines values;
2137   volatile struct gdb_exception file_exception;
2138   struct cleanup *cleanup;
2139
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)
2146     {
2147       const char *end;
2148
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         }
2157     }
2158
2159   /* A keyword at the start cannot be interpreted as such.
2160      Consider "b thread thread 42".  */
2161   parser->keyword_ok = 0;
2162
2163   parser->lexer.saved_arg = *argptr;
2164   parser->lexer.stream = argptr;
2165   file_exception.reason = 0;
2166
2167   /* Initialize the default symtab and line offset.  */
2168   initialize_defaults (&PARSER_STATE (parser)->default_symtab,
2169                        &PARSER_STATE (parser)->default_line);
2170
2171   /* Objective-C shortcut.  */
2172   values = decode_objc (PARSER_STATE (parser), PARSER_RESULT (parser), argptr);
2173   if (values.sals != NULL)
2174     return values;
2175
2176   /* Start parsing.  */
2177
2178   /* Get the first token.  */
2179   token = linespec_lexer_lex_one (parser);
2180
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;
2186
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;
2193
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')
2198         {
2199           PARSER_STREAM (parser) = strstr (parser->lexer.saved_arg, copy);
2200           gdb_assert (PARSER_STREAM (parser) != NULL);
2201         }
2202
2203       /* Consume the token.  */
2204       linespec_lexer_consume_token (parser);
2205
2206       goto convert_to_sals;
2207     }
2208   else if (token.type == LSTOKEN_STRING && *LS_TOKEN_STOKEN (token).ptr == '$')
2209     {
2210       char *var;
2211
2212       /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB.  */
2213       VEC_safe_push (symtab_p, PARSER_RESULT (parser)->file_symtabs, NULL);
2214
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);
2221
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)
2225         {
2226           /* Consume this token.  */
2227           linespec_lexer_consume_token (parser);
2228
2229           goto convert_to_sals;
2230         }
2231     }
2232   else if (token.type != LSTOKEN_STRING && token.type != LSTOKEN_NUMBER)
2233     unexpected_linespec_error (parser);
2234
2235   /* Now we can recognize keywords.  */
2236   parser->keyword_ok = 1;
2237
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);
2241
2242   if (token.type == LSTOKEN_COLON)
2243     {
2244       char *user_filename;
2245
2246       /* Get the current token again and extract the filename.  */
2247       token = linespec_lexer_lex_one (parser);
2248       user_filename = copy_token_string (token);
2249
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         }
2256
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;
2261
2262           /* Get the next token.  */
2263           token = linespec_lexer_consume_token (parser);
2264
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);
2272
2273           /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB.  */
2274           VEC_safe_push (symtab_p, PARSER_RESULT (parser)->file_symtabs, NULL);
2275         }
2276     }
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)
2280     {
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);
2285     }
2286   else
2287     {
2288       /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB.  */
2289       VEC_safe_push (symtab_p, PARSER_RESULT (parser)->file_symtabs, NULL);
2290     }
2291
2292   /* Parse the rest of the linespec.  */
2293   linespec_parse_basic (parser);
2294
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)
2299     {
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);
2304
2305       /* Otherwise, the symbol is not found.  */
2306       symbol_not_found_error (PARSER_RESULT (parser)->function_name,
2307                               PARSER_RESULT (parser)->source_filename);
2308     }
2309
2310  convert_to_sals:
2311
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;
2317
2318   /* Convert the data in PARSER_RESULT to SALs.  */
2319   values = convert_linespec_to_sals (PARSER_STATE (parser),
2320                                      PARSER_RESULT (parser));
2321
2322   return values;
2323 }
2324
2325
2326 /* A constructor for linespec_state.  */
2327
2328 static void
2329 linespec_state_constructor (struct linespec_state *self,
2330                             int flags, const struct language_defn *language,
2331                             struct symtab *default_symtab,
2332                             int default_line,
2333                             struct linespec_result *canonical)
2334 {
2335   memset (self, 0, sizeof (*self));
2336   self->language = language;
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 }
2346
2347 /* Initialize a new linespec parser.  */
2348
2349 static void
2350 linespec_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)
2355 {
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.  */
2364
2365 static void
2366 linespec_state_destructor (struct linespec_state *self)
2367 {
2368   htab_delete (self->addr_set);
2369 }
2370
2371 /* Delete a linespec parser.  */
2372
2373 static void
2374 linespec_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
2401 /* See linespec.h.  */
2402
2403 void
2404 decode_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)
2409 {
2410   struct symtabs_and_lines result;
2411   struct cleanup *cleanups;
2412   VEC (const_char_ptr) *filters = NULL;
2413   linespec_parser parser;
2414   struct linespec_state *state;
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
2425   linespec_parser_new (&parser, flags, current_language, default_symtab,
2426                        default_line, canonical);
2427   cleanups = make_cleanup (linespec_parser_delete, &parser);
2428   save_current_program_space ();
2429
2430   result = parse_linespec (&parser, argptr);
2431   state = PARSER_STATE (&parser);
2432
2433   gdb_assert (result.nelts == 1 || canonical->pre_expanded);
2434   gdb_assert (canonical->addr_string != NULL);
2435   canonical->pre_expanded = 1;
2436
2437   /* Arrange for allocated canonical names to be freed.  */
2438   if (result.nelts > 0)
2439     {
2440       int i;
2441
2442       make_cleanup (xfree, state->canonical_names);
2443       for (i = 0; i < result.nelts; ++i)
2444         {
2445           gdb_assert (state->canonical_names[i].suffix != NULL);
2446           make_cleanup (xfree, state->canonical_names[i].suffix);
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);
2464           filter_results (state, &result, filters);
2465         }
2466       else
2467         convert_results_to_lsals (state, &result);
2468     }
2469   else
2470     decode_line_2 (state, &result, select_mode);
2471
2472   do_cleanups (cleanups);
2473 }
2474
2475 /* See linespec.h.  */
2476
2477 struct symtabs_and_lines
2478 decode_line_1 (char **argptr, int flags,
2479                struct symtab *default_symtab,
2480                int default_line)
2481 {
2482   struct symtabs_and_lines result;
2483   linespec_parser parser;
2484   struct cleanup *cleanups;
2485
2486   linespec_parser_new (&parser, flags, current_language, default_symtab,
2487                        default_line, NULL);
2488   cleanups = make_cleanup (linespec_parser_delete, &parser);
2489   save_current_program_space ();
2490
2491   result = parse_linespec (&parser, argptr);
2492
2493   do_cleanups (cleanups);
2494   return result;
2495 }
2496
2497 /* See linespec.h.  */
2498
2499 struct symtabs_and_lines
2500 decode_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
2522 struct symtabs_and_lines
2523 decode_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
2542 \f
2543
2544 /* First, some functions to initialize stuff at the beggining of the
2545    function.  */
2546
2547 static void
2548 initialize_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
2565 /* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
2566    advancing EXP_PTR past any parsed text.  */
2567
2568 static CORE_ADDR
2569 linespec_expression_to_pc (const char **exp_ptr)
2570 {
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
2577   (*exp_ptr)++;
2578   return value_as_address (parse_to_comma_and_eval (exp_ptr));
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
2590 static struct symtabs_and_lines
2591 decode_objc (struct linespec_state *self, linespec_p ls, char **argptr)
2592 {
2593   struct collect_info info;
2594   VEC (const_char_ptr) *symbol_names = NULL;
2595   struct symtabs_and_lines values;
2596   char *new_argptr;
2597   struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
2598                                           &symbol_names);
2599
2600   info.state = self;
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;
2608
2609   new_argptr = find_imps (*argptr, &symbol_names); 
2610   if (VEC_empty (const_char_ptr, symbol_names))
2611     {
2612       do_cleanups (cleanup);
2613       return values;
2614     }
2615
2616   add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
2617
2618   if (!VEC_empty (symbolp, info.result.symbols)
2619       || !VEC_empty (minsym_and_objfile_d, info.result.minimal_symbols))
2620     {
2621       char *saved_arg;
2622
2623       saved_arg = alloca (new_argptr - *argptr + 1);
2624       memcpy (saved_arg, *argptr, new_argptr - *argptr);
2625       saved_arg[new_argptr - *argptr] = '\0';
2626
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
2632       if (self->canonical)
2633         {
2634           self->canonical->pre_expanded = 1;
2635           if (ls->source_filename)
2636             self->canonical->addr_string
2637               = xstrprintf ("%s:%s", ls->source_filename, saved_arg);
2638           else
2639             self->canonical->addr_string = xstrdup (saved_arg);
2640         }
2641     }
2642
2643   *argptr = new_argptr;
2644
2645   do_cleanups (cleanup);
2646
2647   return values;
2648 }
2649
2650 /* An instance of this type is used when collecting prefix symbols for
2651    decode_compound.  */
2652
2653 struct 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
2666 static int
2667 collect_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)
2674     return 1; /* Continue iterating.  */
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)
2681     return 1; /* Continue iterating.  */
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
2690   return 1; /* Continue iterating.  */
2691 }
2692
2693 /* Return any symbols corresponding to CLASS_NAME in FILE_SYMTABS.  */
2694
2695 static VEC (symbolp) *
2696 lookup_prefix_sym (struct linespec_state *state, VEC (symtab_p) *file_symtabs,
2697                    const char *class_name)
2698 {
2699   int ix;
2700   struct symtab *elt;
2701   struct decode_compound_collector collector;
2702   struct cleanup *outer;
2703   struct cleanup *cleanup;
2704
2705   collector.symbols = NULL;
2706   outer = make_cleanup (VEC_cleanup (symbolp), &collector.symbols);
2707
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);
2712
2713   for (ix = 0; VEC_iterate (symtab_p, file_symtabs, ix, elt); ++ix)
2714     {
2715       if (elt == NULL)
2716         {
2717           iterate_over_all_matching_symtabs (state, class_name, STRUCT_DOMAIN,
2718                                              collect_one_symbol, &collector,
2719                                              NULL, 0);
2720           iterate_over_all_matching_symtabs (state, class_name, VAR_DOMAIN,
2721                                              collect_one_symbol, &collector,
2722                                              NULL, 0);
2723         }
2724       else
2725         {
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));
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);
2734         }
2735     }
2736
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
2746 static int
2747 compare_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;
2770 }
2771
2772 /* Like compare_symbols but for minimal symbols.  */
2773
2774 static int
2775 compare_msymbols (const void *a, const void *b)
2776 {
2777   const struct minsym_and_objfile *sa = a;
2778   const struct minsym_and_objfile *sb = b;
2779   uintptr_t uia, uib;
2780
2781   uia = (uintptr_t) sa->objfile->pspace;
2782   uib = (uintptr_t) sa->objfile->pspace;
2783
2784   if (uia < uib)
2785     return -1;
2786   if (uia > uib)
2787     return 1;
2788
2789   uia = (uintptr_t) sa->minsym;
2790   uib = (uintptr_t) sb->minsym;
2791
2792   if (uia < uib)
2793     return -1;
2794   if (uia > uib)
2795     return 1;
2796
2797   return 0;
2798 }
2799
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
2805 static void
2806 add_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;
2812
2813   for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix)
2814     add_matching_symbols_to_info (iter, info, pspace);
2815 }
2816
2817 static void
2818 find_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)
2828     {
2829       VEC (typep) *new_supers = NULL;
2830       int ix;
2831       struct type *t;
2832
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
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).  */
2850
2851 static void
2852 find_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)
2856 {
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;
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;
2873   info.file_symtabs = file_symtabs;
2874   info.result.symbols = NULL;
2875   info.result.minimal_symbols = NULL;
2876
2877   /* Iterate over all the types, looking for the names of existing
2878      methods matching METHOD_NAME.  If we cannot find a direct method in a
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));
2902       find_methods (t, method_name, &result_names, &superclass_vec);
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)))))
2910         {
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)
2914             find_superclass_methods (superclass_vec, method_name,
2915                                      &result_names);
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);
2924         }
2925     }
2926
2927   if (!VEC_empty (symbolp, info.result.symbols)
2928       || !VEC_empty (minsym_and_objfile_d, info.result.minimal_symbols))
2929     {
2930       *symbols = info.result.symbols;
2931       *minsyms = info.result.minimal_symbols;
2932       do_cleanups (cleanup);
2933       return;
2934     }
2935
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"));
2939 }
2940
2941 \f
2942
2943 /* This object is used when collecting all matching symtabs.  */
2944
2945 struct 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
2956 static int
2957 add_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)
2964     {
2965       *slot = symtab;
2966       VEC_safe_push (symtab_p, data->symtabs, symtab);
2967     }
2968
2969   return 0;
2970 }
2971
2972 /* Given a file name, return a VEC of all matching symtabs.  */
2973
2974 static VEC (symtab_p) *
2975 collect_symtabs_from_filename (const char *file)
2976 {
2977   struct symtab_collector collector;
2978   struct cleanup *cleanups;
2979   struct program_space *pspace;
2980
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);
2985
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
3000 /* Return all the symtabs associated to the FILENAME.  */
3001
3002 static VEC (symtab_p) *
3003 symtabs_from_filename (const char *filename)
3004 {
3005   VEC (symtab_p) *result;
3006   
3007   result = collect_symtabs_from_filename (filename);
3008
3009   if (VEC_empty (symtab_p, result))
3010     {
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);
3016     }
3017
3018   return result;
3019 }
3020
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.  */
3024
3025 static void
3026 find_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)
3030 {
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);
3035
3036   info.state = state;
3037   info.result.symbols = NULL;
3038   info.result.minimal_symbols = NULL;
3039   info.file_symtabs = file_symtabs;
3040
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);
3045   else
3046     add_matching_symbols_to_info (name, &info, NULL);
3047
3048   do_cleanups (cleanup);
3049
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;
3057
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 }
3066
3067 /* Find all symbols named NAME in FILE_SYMTABS, returning debug symbols
3068    in SYMBOLS and minimal symbols in MINSYMS.  */
3069
3070 static void
3071 find_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;
3081
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);
3090     }
3091
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         }
3131
3132       last = NULL;
3133       while (p != NULL)
3134         {
3135           last = p;
3136           p = find_toplevel_string (p + strlen (scope_op), scope_op);
3137         }
3138
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)
3143         {
3144           do_cleanups (cleanup);
3145           return;
3146         }
3147
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';
3154
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);
3160
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         }
3179     }
3180
3181   do_cleanups (cleanup);
3182 }
3183
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.  */
3186
3187 static VEC (symbolp) *
3188 find_label_symbols (struct linespec_state *self,
3189                     VEC (symbolp) *function_symbols,
3190                     VEC (symbolp) **label_funcs_ret, const char *name)
3191 {
3192   int ix;
3193   struct block *block;
3194   struct symbol *sym;
3195   struct symbol *fn_sym;
3196   VEC (symbolp) *result = NULL;
3197
3198   if (function_symbols == NULL)
3199     {
3200       set_current_program_space (self->program_space);
3201       block = get_current_search_block ();
3202
3203       for (;
3204            block && !BLOCK_FUNCTION (block);
3205            block = BLOCK_SUPERBLOCK (block))
3206         ;
3207       if (!block)
3208         return NULL;
3209       fn_sym = BLOCK_FUNCTION (block);
3210
3211       sym = lookup_symbol (name, block, LABEL_DOMAIN, 0);
3212
3213       if (sym != NULL)
3214         {
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             }
3233         }
3234     }
3235
3236   return result;
3237 }
3238
3239 \f
3240
3241 /* A helper for create_sals_line_offset that handles the 'list_mode' case.  */
3242
3243 static void
3244 decode_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);
3271     }
3272 }
3273
3274 /* A helper for create_sals_line_offset that iterates over the symtabs,
3275    adding lines to the VEC.  */
3276
3277 static void
3278 decode_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;
3286
3287   for (ix = 0; VEC_iterate (symtab_p, ls->file_symtabs, ix, elt); ++ix)
3288     {
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);
3295
3296       set_current_program_space (SYMTAB_PSPACE (elt));
3297
3298       pcs = find_pcs_for_symtab_line (elt, line, best_entry);
3299       for (i = 0; VEC_iterate (CORE_ADDR, pcs, i, pc); ++i)
3300         {
3301           struct symtab_and_line sal;
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);
3309         }
3310
3311       VEC_free (CORE_ADDR, pcs);
3312     }
3313 }
3314
3315 \f
3316
3317 /* Return the line offset represented by VARIABLE.  */
3318
3319 static struct line_offset
3320 linespec_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};
3325
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.  */
3332     {
3333       /* We have a value history reference.  */
3334       struct value *val_history;
3335
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         }
3368     }
3369
3370   return offset;
3371 }
3372 \f
3373
3374 /* A callback used to possibly add a symbol to the results.  */
3375
3376 static int
3377 collect_symbols (struct symbol *sym, void *data)
3378 {
3379   struct collect_info *info = data;
3380
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.  */
3386 }
3387
3388 /* We've found a minimal symbol MSYMBOL in OBJFILE to associate with our
3389    linespec; return the SAL in RESULT.  */
3390
3391 static void
3392 minsym_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);
3409
3410   if (self->funfirstline)
3411     skip_prologue_sal (&sal);
3412
3413   if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc))
3414     add_sal_to_sals (self, result, &sal, SYMBOL_NATURAL_NAME (msymbol), 0);
3415 }
3416
3417 /* A helper struct to pass some data through
3418    iterate_over_minimal_symbols.  */
3419
3420 struct 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
3438 static int
3439 classify_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
3461 static int
3462 compare_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
3475 static void
3476 add_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
3513 static void
3514 search_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
3569             VEC_safe_push (minsym_and_objfile_d,
3570                            info->result.minimal_symbols, item);
3571           }
3572       }
3573
3574     do_cleanups (cleanup);
3575   }
3576 }
3577
3578 /* A helper function to add all symbols matching NAME to INFO.  If
3579    PSPACE is not NULL, the search is restricted to just that program
3580    space.  */
3581
3582 static void
3583 add_matching_symbols_to_info (const char *name,
3584                               struct collect_info *info,
3585                               struct program_space *pspace)
3586 {
3587   int ix;
3588   struct symtab *elt;
3589
3590   for (ix = 0; VEC_iterate (symtab_p, info->file_symtabs, ix, elt); ++ix)
3591     {
3592       if (elt == NULL)
3593         {
3594           iterate_over_all_matching_symtabs (info->state, name, VAR_DOMAIN,
3595                                              collect_symbols, info,
3596                                              pspace, 1);
3597           search_minsyms_for_name (info, name, pspace);
3598         }
3599       else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
3600         {
3601           /* Program spaces that are executing startup should have
3602              been filtered out earlier.  */
3603           gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
3604           set_current_program_space (SYMTAB_PSPACE (elt));
3605           iterate_over_file_blocks (elt, name, VAR_DOMAIN,
3606                                     collect_symbols, info);
3607         }
3608     }
3609 }
3610
3611 \f
3612
3613 /* Now come some functions that are called from multiple places within
3614    decode_line_1.  */
3615
3616 static int
3617 symbol_to_sal (struct symtab_and_line *result,
3618                int funfirstline, struct symbol *sym)
3619 {
3620   if (SYMBOL_CLASS (sym) == LOC_BLOCK)
3621     {
3622       *result = find_function_start_sal (sym, funfirstline);
3623       return 1;
3624     }
3625   else
3626     {
3627       if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
3628         {
3629           init_sal (result);
3630           result->symtab = SYMBOL_SYMTAB (sym);
3631           result->line = SYMBOL_LINE (sym);
3632           result->pc = SYMBOL_VALUE_ADDRESS (sym);
3633           result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
3634           result->explicit_pc = 1;
3635           return 1;
3636         }
3637       else if (funfirstline)
3638         {
3639           /* Nothing.  */
3640         }
3641       else if (SYMBOL_LINE (sym) != 0)
3642         {
3643           /* We know its line number.  */
3644           init_sal (result);
3645           result->symtab = SYMBOL_SYMTAB (sym);
3646           result->line = SYMBOL_LINE (sym);
3647           result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
3648           return 1;
3649         }
3650     }
3651
3652   return 0;
3653 }
3654
3655 /* See the comment in linespec.h.  */
3656
3657 void
3658 init_linespec_result (struct linespec_result *lr)
3659 {
3660   memset (lr, 0, sizeof (*lr));
3661 }
3662
3663 /* See the comment in linespec.h.  */
3664
3665 void
3666 destroy_linespec_result (struct linespec_result *ls)
3667 {
3668   int i;
3669   struct linespec_sals *lsal;
3670
3671   xfree (ls->addr_string);
3672   for (i = 0; VEC_iterate (linespec_sals, ls->sals, i, lsal); ++i)
3673     {
3674       xfree (lsal->canonical);
3675       xfree (lsal->sals.sals);
3676     }
3677   VEC_free (linespec_sals, ls->sals);
3678 }
3679
3680 /* Cleanup function for a linespec_result.  */
3681
3682 static void
3683 cleanup_linespec_result (void *a)
3684 {
3685   destroy_linespec_result (a);
3686 }
3687
3688 /* See the comment in linespec.h.  */
3689
3690 struct cleanup *
3691 make_cleanup_destroy_linespec_result (struct linespec_result *ls)
3692 {
3693   return make_cleanup (cleanup_linespec_result, ls);
3694 }