gdb/linespec.c

   1 /* Parser for linespec for the GNU debugger, GDB.
   2
   3    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   4    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
   5    2009, 2010, 2011 Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "frame.h"
  25 #include "command.h"
  26 #include "symfile.h"
  27 #include "objfiles.h"
  28 #include "source.h"
  29 #include "demangle.h"
  30 #include "value.h"
  31 #include "completer.h"
  32 #include "cp-abi.h"
  33 #include "cp-support.h"
  34 #include "parser-defs.h"
  35 #include "block.h"
  36 #include "objc-lang.h"
  37 #include "linespec.h"
  38 #include "exceptions.h"
  39 #include "language.h"
  40 #include "interps.h"
  41 #include "mi/mi-cmds.h"
  42 #include "target.h"
  43 #include "arch-utils.h"
  44 #include <ctype.h>
  45 #include "cli/cli-utils.h"
  46 #include "filenames.h"
  47 #include "ada-lang.h"
  48
  49 typedef struct symtab *symtab_p;
  50 DEF_VEC_P (symtab_p);
  51
  52 typedef struct symbol *symbolp;
  53 DEF_VEC_P (symbolp);
  54
  55 typedef struct type *typep;
  56 DEF_VEC_P (typep);
  57
  58 /* An address entry is used to ensure that any given location is only
  59    added to the result a single time.  It holds an address and the
  60    program space from which the address came.  */
  61
  62 struct address_entry
  63 {
  64   struct program_space *pspace;
  65   CORE_ADDR addr;
  66 };
  67
  68 /* An instance of this is used to keep all state while linespec
  69    operates.  This instance is passed around as a 'this' pointer to
  70    the various implementation methods.  */
  71
  72 struct linespec_state
  73 {
  74   /* The program space as seen when the module was entered.  */
  75   struct program_space *program_space;
  76
  77   /* The default symtab to use, if no other symtab is specified.  */
  78   struct symtab *default_symtab;
  79
  80   /* The default line to use.  */
  81   int default_line;
  82
  83   /* If the linespec started with "FILE:", this holds all the matching
  84      symtabs.  Otherwise, it will hold a single NULL entry, meaning
  85      that the default symtab should be used.  */
  86   VEC (symtab_p) *file_symtabs;
  87
  88   /* If the linespec started with "FILE:", this holds an xmalloc'd
  89      copy of "FILE".  */
  90   char *user_filename;
  91
  92   /* If the linespec is "FUNCTION:LABEL", this holds an xmalloc'd copy
  93      of "FUNCTION".  */
  94   char *user_function;
  95
  96   /* The 'funfirstline' value that was passed in to decode_line_1 or
  97      decode_line_full.  */
  98   int funfirstline;
  99
 100   /* Nonzero if we are running in 'list' mode; see decode_line_list.  */
 101   int list_mode;
 102
 103   /* The 'canonical' value passed to decode_line_full, or NULL.  */
 104   struct linespec_result *canonical;
 105
 106   /* Canonical strings that mirror the symtabs_and_lines result.  */
 107   char **canonical_names;
 108
 109   /* This is a set of address_entry objects which is used to prevent
 110      duplicate symbols from being entered into the result.  */
 111   htab_t addr_set;
 112 };
 113
 114 /* This is a helper object that is used when collecting symbols into a
 115    result.  */
 116
 117 struct collect_info
 118 {
 119   /* The linespec object in use.  */
 120   struct linespec_state *state;
 121
 122   /* The result being accumulated.  */
 123   struct symtabs_and_lines result;
 124 };
 125
 126 /* Prototypes for local functions.  */
 127
 128 static void initialize_defaults (struct symtab **default_symtab,
 129                                  int *default_line);
 130
 131 static struct symtabs_and_lines decode_indirect (struct linespec_state *self,
 132                                                  char **argptr);
 133
 134 static char *locate_first_half (char **argptr, int *is_quote_enclosed);
 135
 136 static struct symtabs_and_lines decode_objc (struct linespec_state *self,
 137                                              char **argptr);
 138
 139 static struct symtabs_and_lines decode_compound (struct linespec_state *self,
 140                                                  char **argptr,
 141                                                  char *saved_arg,
 142                                                  char *p);
 143
 144 static VEC (symbolp) *lookup_prefix_sym (char **argptr, char *p,
 145                                          VEC (symtab_p) *,
 146                                          char **);
 147
 148 static struct symtabs_and_lines find_method (struct linespec_state *self,
 149                                              char *saved_arg,
 150                                              char *copy,
 151                                              const char *class_name,
 152                                              VEC (symbolp) *sym_classes);
 153
 154 static void cplusplus_error (const char *name, const char *fmt, ...)
 155      ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3);
 156
 157 static char *find_toplevel_char (char *s, char c);
 158
 159 static int is_objc_method_format (const char *s);
 160
 161 static VEC (symtab_p) *symtabs_from_filename (char **argptr,
 162                                               char *p, int is_quote_enclosed,
 163                                               char **user_filename);
 164
 165 static VEC (symbolp) *find_function_symbols (char **argptr, char *p,
 166                                              int is_quote_enclosed,
 167                                              char **user_function);
 168
 169 static struct symtabs_and_lines decode_all_digits (struct linespec_state *self,
 170                                                    char **argptr,
 171                                                    char *q);
 172
 173 static struct symtabs_and_lines decode_dollar (struct linespec_state *self,
 174                                                char *copy);
 175
 176 static int decode_label (struct linespec_state *self,
 177                          VEC (symbolp) *function_symbols,
 178                          char *copy,
 179                          struct symtabs_and_lines *result);
 180
 181 static struct symtabs_and_lines decode_variable (struct linespec_state *self,
 182                                                  char *copy);
 183
 184 static int symbol_to_sal (struct symtab_and_line *result,
 185                           int funfirstline, struct symbol *sym);
 186
 187 static void add_matching_symbols_to_info (const char *name,
 188                                           struct collect_info *info,
 189                                           struct program_space *pspace);
 190
 191 static void add_all_symbol_names_from_pspace (struct collect_info *info,
 192                                               struct program_space *pspace,
 193                                               VEC (const_char_ptr) *names);
 194
 195 /* Helper functions.  */
 196
 197 /* Add SAL to SALS.  */
 198
 199 static void
 200 add_sal_to_sals_basic (struct symtabs_and_lines *sals,
 201                        struct symtab_and_line *sal)
 202 {
 203   ++sals->nelts;
 204   sals->sals = xrealloc (sals->sals, sals->nelts * sizeof (sals->sals[0]));
 205   sals->sals[sals->nelts - 1] = *sal;
 206 }
 207
 208 /* Add SAL to SALS, and also update SELF->CANONICAL_NAMES to reflect
 209    the new sal, if needed.  If not NULL, SYMNAME is the name of the
 210    symbol to use when constructing the new canonical name.  */
 211
 212 static void
 213 add_sal_to_sals (struct linespec_state *self,
 214                  struct symtabs_and_lines *sals,
 215                  struct symtab_and_line *sal,
 216                  const char *symname)
 217 {
 218   add_sal_to_sals_basic (sals, sal);
 219
 220   if (self->canonical)
 221     {
 222       char *canonical_name = NULL;
 223
 224       self->canonical_names = xrealloc (self->canonical_names,
 225                                         sals->nelts * sizeof (char *));
 226       if (sal->symtab && sal->symtab->filename)
 227         {
 228           char *filename = sal->symtab->filename;
 229
 230           /* Note that the filter doesn't have to be a valid linespec
 231              input.  We only apply the ":LINE" treatment to Ada for
 232              the time being.  */
 233           if (symname != NULL && sal->line != 0
 234               && current_language->la_language == language_ada)
 235             canonical_name = xstrprintf ("%s:%s:%d", filename, symname,
 236                                          sal->line);
 237           else if (symname != NULL)
 238             canonical_name = xstrprintf ("%s:%s", filename, symname);
 239           else
 240             canonical_name = xstrprintf ("%s:%d", filename, sal->line);
 241         }
 242
 243       self->canonical_names[sals->nelts - 1] = canonical_name;
 244     }
 245 }
 246
 247 /* A hash function for address_entry.  */
 248
 249 static hashval_t
 250 hash_address_entry (const void *p)
 251 {
 252   const struct address_entry *aep = p;
 253   hashval_t hash;
 254
 255   hash = iterative_hash_object (aep->pspace, 0);
 256   return iterative_hash_object (aep->addr, hash);
 257 }
 258
 259 /* An equality function for address_entry.  */
 260
 261 static int
 262 eq_address_entry (const void *a, const void *b)
 263 {
 264   const struct address_entry *aea = a;
 265   const struct address_entry *aeb = b;
 266
 267   return aea->pspace == aeb->pspace && aea->addr == aeb->addr;
 268 }
 269
 270 /* Check whether the address, represented by PSPACE and ADDR, is
 271    already in the set.  If so, return 0.  Otherwise, add it and return
 272    1.  */
 273
 274 static int
 275 maybe_add_address (htab_t set, struct program_space *pspace, CORE_ADDR addr)
 276 {
 277   struct address_entry e, *p;
 278   void **slot;
 279
 280   e.pspace = pspace;
 281   e.addr = addr;
 282   slot = htab_find_slot (set, &e, INSERT);
 283   if (*slot)
 284     return 0;
 285
 286   p = XNEW (struct address_entry);
 287   memcpy (p, &e, sizeof (struct address_entry));
 288   *slot = p;
 289
 290   return 1;
 291 }
 292
 293 /* Issue a helpful hint on using the command completion feature on
 294    single quoted demangled C++ symbols as part of the completion
 295    error.  */
 296
 297 static void
 298 cplusplus_error (const char *name, const char *fmt, ...)
 299 {
 300   struct ui_file *tmp_stream;
 301   char *message;
 302
 303   tmp_stream = mem_fileopen ();
 304   make_cleanup_ui_file_delete (tmp_stream);
 305
 306   {
 307     va_list args;
 308
 309     va_start (args, fmt);
 310     vfprintf_unfiltered (tmp_stream, fmt, args);
 311     va_end (args);
 312   }
 313
 314   while (*name == '\'')
 315     name++;
 316   fprintf_unfiltered (tmp_stream,
 317                       ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
 318                        "(Note leading single quote.)"),
 319                       name, name);
 320
 321   message = ui_file_xstrdup (tmp_stream, NULL);
 322   make_cleanup (xfree, message);
 323   throw_error (NOT_FOUND_ERROR, "%s", message);
 324 }
 325
 326 /* A helper for iterate_over_all_matching_symtabs that is passed as a
 327    callback to the expand_symtabs_matching method.  */
 328
 329 static int
 330 iterate_name_matcher (const struct language_defn *language,
 331                       const char *name, void *d)
 332 {
 333   const char **dname = d;
 334
 335   if (language->la_symbol_name_compare (name, *dname) == 0)
 336     return 1;
 337   return 0;
 338 }
 339
 340 /* A helper that walks over all matching symtabs in all objfiles and
 341    calls CALLBACK for each symbol matching NAME.  If SEARCH_PSPACE is
 342    not NULL, then the search is restricted to just that program
 343    space.  */
 344
 345 static void
 346 iterate_over_all_matching_symtabs (const char *name,
 347                                    const domain_enum domain,
 348                                    int (*callback) (struct symbol *, void *),
 349                                    void *data,
 350                                    struct program_space *search_pspace)
 351 {
 352   struct objfile *objfile;
 353   struct program_space *pspace;
 354
 355   ALL_PSPACES (pspace)
 356   {
 357     if (search_pspace != NULL && search_pspace != pspace)
 358       continue;
 359     if (pspace->executing_startup)
 360       continue;
 361
 362     set_current_program_space (pspace);
 363
 364     ALL_OBJFILES (objfile)
 365     {
 366       struct symtab *symtab;
 367
 368       if (objfile->sf)
 369         objfile->sf->qf->expand_symtabs_matching (objfile, NULL,
 370                                                   iterate_name_matcher,
 371                                                   ALL_DOMAIN,
 372                                                   &name);
 373
 374       ALL_OBJFILE_SYMTABS (objfile, symtab)
 375         {
 376           if (symtab->primary)
 377             {
 378               struct block *block;
 379
 380               block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
 381               LA_ITERATE_OVER_SYMBOLS (block, name, domain, callback, data);
 382             }
 383         }
 384     }
 385   }
 386 }
 387
 388 /* Returns the block to be used for symbol searches for the given SYMTAB,
 389    which may be NULL.  */
 390
 391 static struct block *
 392 get_search_block (struct symtab *symtab)
 393 {
 394   struct block *block;
 395
 396   if (symtab != NULL)
 397     block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
 398   else
 399     {
 400       enum language save_language;
 401
 402       /* get_selected_block can change the current language when there is
 403          no selected frame yet.  */
 404       save_language = current_language->la_language;
 405       block = get_selected_block (0);
 406       set_language (save_language);
 407     }
 408
 409   return block;
 410 }
 411
 412 /* A helper for find_method.  This finds all methods in type T which
 413    match NAME.  It adds resulting symbol names to RESULT_NAMES, and
 414    adds T's direct superclasses to SUPERCLASSES.  */
 415
 416 static void
 417 find_methods (struct type *t, const char *name,
 418               VEC (const_char_ptr) **result_names,
 419               VEC (typep) **superclasses)
 420 {
 421   int i1 = 0;
 422   int ibase;
 423   char *class_name = type_name_no_tag (t);
 424   char *canon;
 425
 426   /* Ignore this class if it doesn't have a name.  This is ugly, but
 427      unless we figure out how to get the physname without the name of
 428      the class, then the loop can't do any good.  */
 429   if (class_name)
 430     {
 431       int method_counter;
 432       int name_len = strlen (name);
 433
 434       CHECK_TYPEDEF (t);
 435
 436       /* Loop over each method name.  At this level, all overloads of a name
 437          are counted as a single name.  There is an inner loop which loops over
 438          each overload.  */
 439
 440       for (method_counter = TYPE_NFN_FIELDS (t) - 1;
 441            method_counter >= 0;
 442            --method_counter)
 443         {
 444           char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
 445           char dem_opname[64];
 446
 447           if (strncmp (method_name, "__", 2) == 0 ||
 448               strncmp (method_name, "op", 2) == 0 ||
 449               strncmp (method_name, "type", 4) == 0)
 450             {
 451               if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
 452                 method_name = dem_opname;
 453               else if (cplus_demangle_opname (method_name, dem_opname, 0))
 454                 method_name = dem_opname;
 455             }
 456
 457           if (strcmp_iw (method_name, name) == 0)
 458             {
 459               int field_counter;
 460
 461               for (field_counter = (TYPE_FN_FIELDLIST_LENGTH (t, method_counter)
 462                                     - 1);
 463                    field_counter >= 0;
 464                    --field_counter)
 465                 {
 466                   struct fn_field *f;
 467                   const char *phys_name;
 468
 469                   f = TYPE_FN_FIELDLIST1 (t, method_counter);
 470                   if (TYPE_FN_FIELD_STUB (f, field_counter))
 471                     continue;
 472                   phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
 473                   VEC_safe_push (const_char_ptr, *result_names, phys_name);
 474                 }
 475             }
 476         }
 477     }
 478
 479   for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
 480     VEC_safe_push (typep, *superclasses, TYPE_BASECLASS (t, ibase));
 481 }
 482
 483 /* Find an instance of the character C in the string S that is outside
 484    of all parenthesis pairs, single-quoted strings, and double-quoted
 485    strings.  Also, ignore the char within a template name, like a ','
 486    within foo<int, int>.  */
 487
 488 static char *
 489 find_toplevel_char (char *s, char c)
 490 {
 491   int quoted = 0;               /* zero if we're not in quotes;
 492                                    '"' if we're in a double-quoted string;
 493                                    '\'' if we're in a single-quoted string.  */
 494   int depth = 0;                /* Number of unclosed parens we've seen.  */
 495   char *scan;
 496
 497   for (scan = s; *scan; scan++)
 498     {
 499       if (quoted)
 500         {
 501           if (*scan == quoted)
 502             quoted = 0;
 503           else if (*scan == '\\' && *(scan + 1))
 504             scan++;
 505         }
 506       else if (*scan == c && ! quoted && depth == 0)
 507         return scan;
 508       else if (*scan == '"' || *scan == '\'')
 509         quoted = *scan;
 510       else if (*scan == '(' || *scan == '<')
 511         depth++;
 512       else if ((*scan == ')' || *scan == '>') && depth > 0)
 513         depth--;
 514     }
 515
 516   return 0;
 517 }
 518
 519 /* Determines if the gives string corresponds to an Objective-C method
 520    representation, such as -[Foo bar:] or +[Foo bar].  Objective-C symbols
 521    are allowed to have spaces and parentheses in them.  */
 522
 523 static int
 524 is_objc_method_format (const char *s)
 525 {
 526   if (s == NULL || *s == '\0')
 527     return 0;
 528   /* Handle arguments with the format FILENAME:SYMBOL.  */
 529   if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL)
 530       && (s[2] == '[') && strchr(s, ']'))
 531     return 1;
 532   /* Handle arguments that are just SYMBOL.  */
 533   else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']'))
 534     return 1;
 535   return 0;
 536 }
 537
 538 /* Given FILTERS, a list of canonical names, filter the sals in RESULT
 539    and store the result in SELF->CANONICAL.  */
 540
 541 static void
 542 filter_results (struct linespec_state *self,
 543                 struct symtabs_and_lines *result,
 544                 VEC (const_char_ptr) *filters)
 545 {
 546   int i;
 547   const char *name;
 548
 549   for (i = 0; VEC_iterate (const_char_ptr, filters, i, name); ++i)
 550     {
 551       struct linespec_sals lsal;
 552       int j;
 553
 554       memset (&lsal, 0, sizeof (lsal));
 555
 556       for (j = 0; j < result->nelts; ++j)
 557         {
 558           if (strcmp (name, self->canonical_names[j]) == 0)
 559             add_sal_to_sals_basic (&lsal.sals, &result->sals[j]);
 560         }
 561
 562       if (lsal.sals.nelts > 0)
 563         {
 564           lsal.canonical = xstrdup (name);
 565           VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
 566         }
 567     }
 568
 569   self->canonical->pre_expanded = 0;
 570 }
 571
 572 /* Store RESULT into SELF->CANONICAL.  */
 573
 574 static void
 575 convert_results_to_lsals (struct linespec_state *self,
 576                           struct symtabs_and_lines *result)
 577 {
 578   struct linespec_sals lsal;
 579
 580   lsal.canonical = NULL;
 581   lsal.sals = *result;
 582   VEC_safe_push (linespec_sals, self->canonical->sals, &lsal);
 583 }
 584
 585 /* Handle multiple results in RESULT depending on SELECT_MODE.  This
 586    will either return normally, throw an exception on multiple
 587    results, or present a menu to the user.  On return, the SALS vector
 588    in SELF->CANONICAL is set up properly.  */
 589
 590 static void
 591 decode_line_2 (struct linespec_state *self,
 592                struct symtabs_and_lines *result,
 593                const char *select_mode)
 594 {
 595   const char *iter;
 596   char *args, *prompt;
 597   int i;
 598   struct cleanup *old_chain;
 599   VEC (const_char_ptr) *item_names = NULL, *filters = NULL;
 600   struct get_number_or_range_state state;
 601
 602   gdb_assert (select_mode != multiple_symbols_all);
 603   gdb_assert (self->canonical != NULL);
 604
 605   old_chain = make_cleanup (VEC_cleanup (const_char_ptr), &item_names);
 606   make_cleanup (VEC_cleanup (const_char_ptr), &filters);
 607   for (i = 0; i < result->nelts; ++i)
 608     {
 609       int j, found = 0;
 610       const char *iter;
 611
 612       gdb_assert (self->canonical_names[i] != NULL);
 613       for (j = 0; VEC_iterate (const_char_ptr, item_names, j, iter); ++j)
 614         {
 615           if (strcmp (iter, self->canonical_names[i]) == 0)
 616             {
 617               found = 1;
 618               break;
 619             }
 620         }
 621
 622       if (!found)
 623         VEC_safe_push (const_char_ptr, item_names, self->canonical_names[i]);
 624     }
 625
 626   if (select_mode == multiple_symbols_cancel
 627       && VEC_length (const_char_ptr, item_names) > 1)
 628     error (_("canceled because the command is ambiguous\n"
 629              "See set/show multiple-symbol."));
 630
 631   if (select_mode == multiple_symbols_all
 632       || VEC_length (const_char_ptr, item_names) == 1)
 633     {
 634       do_cleanups (old_chain);
 635       convert_results_to_lsals (self, result);
 636       return;
 637     }
 638
 639   printf_unfiltered (_("[0] cancel\n[1] all\n"));
 640   for (i = 0; VEC_iterate (const_char_ptr, item_names, i, iter); ++i)
 641     printf_unfiltered ("[%d] %s\n", i + 2, iter);
 642
 643   prompt = getenv ("PS2");
 644   if (prompt == NULL)
 645     {
 646       prompt = "> ";
 647     }
 648   args = command_line_input (prompt, 0, "overload-choice");
 649
 650   if (args == 0 || *args == 0)
 651     error_no_arg (_("one or more choice numbers"));
 652
 653   init_number_or_range (&state, args);
 654   while (!state.finished)
 655     {
 656       int num;
 657
 658       num = get_number_or_range (&state);
 659
 660       if (num == 0)
 661         error (_("canceled"));
 662       else if (num == 1)
 663         {
 664           /* We intentionally make this result in a single breakpoint,
 665              contrary to what older versions of gdb did.  The
 666              rationale is that this lets a user get the
 667              multiple_symbols_all behavior even with the 'ask'
 668              setting; and he can get separate breakpoints by entering
 669              "2-57" at the query.  */
 670           do_cleanups (old_chain);
 671           convert_results_to_lsals (self, result);
 672           return;
 673         }
 674
 675       num -= 2;
 676       if (num >= VEC_length (const_char_ptr, item_names))
 677         printf_unfiltered (_("No choice number %d.\n"), num);
 678       else
 679         {
 680           const char *elt = VEC_index (const_char_ptr, item_names, num);
 681
 682           if (elt != NULL)
 683             {
 684               VEC_safe_push (const_char_ptr, filters, elt);
 685               VEC_replace (const_char_ptr, item_names, num, NULL);
 686             }
 687           else
 688             {
 689               printf_unfiltered (_("duplicate request for %d ignored.\n"),
 690                                  num);
 691             }
 692         }
 693     }
 694
 695   filter_results (self, result, filters);
 696   do_cleanups (old_chain);
 697 }
 698
 699 /* Valid delimiters for linespec keywords "if", "thread" or "task".  */
 700
 701 static int
 702 is_linespec_boundary (char c)
 703 {
 704   return c == ' ' || c == '\t' || c == '\0' || c == ',';
 705 }
 706
 707 /* A helper function for decode_line_1 and friends which skips P
 708    past any method overload information at the beginning of P, e.g.,
 709    "(const struct foo *)".
 710
 711    This function assumes that P has already been validated to contain
 712    overload information, and it will assert if *P != '('.  */
 713 static char *
 714 find_method_overload_end (char *p)
 715 {
 716   int depth = 0;
 717
 718   gdb_assert (*p == '(');
 719
 720   while (*p)
 721     {
 722       if (*p == '(')
 723         ++depth;
 724       else if (*p == ')')
 725         {
 726           if (--depth == 0)
 727             {
 728               ++p;
 729               break;
 730             }
 731         }
 732       ++p;
 733     }
 734
 735   return p;
 736 }
 737
 738 /* Keep important information used when looking up a name.  This includes
 739    template parameters, overload information, and important keywords, including
 740    the possible Java trailing type.  */
 741
 742 static char *
 743 keep_name_info (char *p, int on_boundary)
 744 {
 745   const char *quotes = get_gdb_completer_quote_characters ();
 746   char *saved_p = p;
 747   int nest = 0;
 748
 749   while (*p)
 750     {
 751       if (strchr (quotes, *p))
 752         break;
 753
 754       if (*p == ',' && !nest)
 755         break;
 756
 757       if (on_boundary && !nest)
 758         {
 759           const char *const words[] = { "if", "thread", "task" };
 760           int wordi;
 761
 762           for (wordi = 0; wordi < ARRAY_SIZE (words); wordi++)
 763             if (strncmp (p, words[wordi], strlen (words[wordi])) == 0
 764                 && is_linespec_boundary (p[strlen (words[wordi])]))
 765               break;
 766           if (wordi < ARRAY_SIZE (words))
 767             break;
 768         }
 769
 770       if (*p == '(' || *p == '<' || *p == '[')
 771         nest++;
 772       else if ((*p == ')' || *p == '>' || *p == ']') && nest > 0)
 773         nest--;
 774
 775       p++;
 776
 777       /* The ',' check could fail on "operator ,".  */
 778       p += cp_validate_operator (p);
 779
 780       on_boundary = is_linespec_boundary (p[-1]);
 781     }
 782
 783   while (p > saved_p && is_linespec_boundary (p[-1]))
 784     p--;
 785
 786   return p;
 787 }
 788
 789 \f
 790 /* The parser of linespec itself.  */
 791
 792 /* Parse a string that specifies a line number.
 793    Pass the address of a char * variable; that variable will be
 794    advanced over the characters actually parsed.
 795
 796    The string can be:
 797
 798    LINENUM -- that line number in current file.  PC returned is 0.
 799    FILE:LINENUM -- that line in that file.  PC returned is 0.
 800    FUNCTION -- line number of openbrace of that function.
 801    PC returned is the start of the function.
 802    LABEL -- a label in the current scope
 803    VARIABLE -- line number of definition of that variable.
 804    PC returned is 0.
 805    FILE:FUNCTION -- likewise, but prefer functions in that file.
 806    *EXPR -- line in which address EXPR appears.
 807
 808    This may all be followed by an "if EXPR", which we ignore.
 809
 810    FUNCTION may be an undebuggable function found in minimal symbol table.
 811
 812    If the argument FUNFIRSTLINE is nonzero, we want the first line
 813    of real code inside a function when a function is specified, and it is
 814    not OK to specify a variable or type to get its line number.
 815
 816    DEFAULT_SYMTAB specifies the file to use if none is specified.
 817    It defaults to current_source_symtab.
 818    DEFAULT_LINE specifies the line number to use for relative
 819    line numbers (that start with signs).  Defaults to current_source_line.
 820    If CANONICAL is non-NULL, store an array of strings containing the canonical
 821    line specs there if necessary.  Currently overloaded member functions and
 822    line numbers or static functions without a filename yield a canonical
 823    line spec.  The array and the line spec strings are allocated on the heap,
 824    it is the callers responsibility to free them.
 825
 826    Note that it is possible to return zero for the symtab
 827    if no file is validly specified.  Callers must check that.
 828    Also, the line number returned may be invalid.  */
 829
 830 /* We allow single quotes in various places.  This is a hideous
 831    kludge, which exists because the completer can't yet deal with the
 832    lack of single quotes.  FIXME: write a linespec_completer which we
 833    can use as appropriate instead of make_symbol_completion_list.  */
 834
 835 static struct symtabs_and_lines
 836 decode_line_internal (struct linespec_state *self, char **argptr)
 837 {
 838   char *p;
 839   char *q;
 840
 841   char *copy;
 842   /* This says whether or not something in *ARGPTR is quoted with
 843      completer_quotes (i.e. with single quotes).  */
 844   int is_quoted;
 845   /* Is *ARGPTR enclosed in double quotes?  */
 846   int is_quote_enclosed;
 847   int is_objc_method = 0;
 848   char *saved_arg = *argptr;
 849   /* If IS_QUOTED, the end of the quoted bit.  */
 850   char *end_quote = NULL;
 851   /* Is *ARGPTR enclosed in single quotes?  */
 852   int is_squote_enclosed = 0;
 853   /* The "first half" of the linespec.  */
 854   char *first_half;
 855
 856   /* If we are parsing `function:label', this holds the symbols
 857      matching the function name.  */
 858   VEC (symbolp) *function_symbols = NULL;
 859   /* If FUNCTION_SYMBOLS is not NULL, then this is the exception that
 860      was thrown when trying to parse a filename.  */
 861   volatile struct gdb_exception file_exception;
 862
 863   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
 864
 865   /* Defaults have defaults.  */
 866
 867   initialize_defaults (&self->default_symtab, &self->default_line);
 868
 869   /* See if arg is *PC.  */
 870
 871   if (**argptr == '*')
 872     {
 873       do_cleanups (cleanup);
 874       return decode_indirect (self, argptr);
 875     }
 876
 877   is_quoted = (strchr (get_gdb_completer_quote_characters (),
 878                        **argptr) != NULL);
 879
 880   if (is_quoted)
 881     {
 882       end_quote = skip_quoted (*argptr);
 883       if (*end_quote == '\0')
 884         is_squote_enclosed = 1;
 885     }
 886
 887   /* Check to see if it's a multipart linespec (with colons or
 888      periods).  */
 889
 890   /* Locate the end of the first half of the linespec.
 891      After the call, for instance, if the argptr string is "foo.c:123"
 892      p will point at "123".  If there is only one part, like "foo", p
 893      will point to "".  If this is a C++ name, like "A::B::foo", p will
 894      point to "::B::foo".  Argptr is not changed by this call.  */
 895
 896   first_half = p = locate_first_half (argptr, &is_quote_enclosed);
 897
 898   /* First things first: if ARGPTR starts with a filename, get its
 899      symtab and strip the filename from ARGPTR.  */
 900   TRY_CATCH (file_exception, RETURN_MASK_ERROR)
 901     {
 902       self->file_symtabs = symtabs_from_filename (argptr, p, is_quote_enclosed,
 903                                                   &self->user_filename);
 904     }
 905
 906   if (VEC_empty (symtab_p, self->file_symtabs))
 907     {
 908       /* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB.  */
 909       VEC_safe_push (symtab_p, self->file_symtabs, NULL);
 910     }
 911
 912   if (file_exception.reason >= 0)
 913     {
 914       /* Check for single quotes on the non-filename part.  */
 915       is_quoted = (**argptr
 916                    && strchr (get_gdb_completer_quote_characters (),
 917                               **argptr) != NULL);
 918       if (is_quoted)
 919         end_quote = skip_quoted (*argptr);
 920
 921       /* Locate the next "half" of the linespec.  */
 922       first_half = p = locate_first_half (argptr, &is_quote_enclosed);
 923     }
 924
 925   /* Check if this is an Objective-C method (anything that starts with
 926      a '+' or '-' and a '[').  */
 927   if (is_objc_method_format (p))
 928     is_objc_method = 1;
 929
 930   /* Check if the symbol could be an Objective-C selector.  */
 931
 932   {
 933     struct symtabs_and_lines values;
 934
 935     values = decode_objc (self, argptr);
 936     if (values.sals != NULL)
 937       {
 938         do_cleanups (cleanup);
 939         return values;
 940       }
 941   }
 942
 943   /* Does it look like there actually were two parts?  */
 944
 945   if (p[0] == ':' || p[0] == '.')
 946     {
 947       /* Is it a C++ or Java compound data structure?
 948          The check on p[1] == ':' is capturing the case of "::",
 949          since p[0]==':' was checked above.
 950          Note that the call to decode_compound does everything
 951          for us, including the lookup on the symbol table, so we
 952          can return now.  */
 953
 954       if (p[0] == '.' || p[1] == ':')
 955         {
 956           struct symtabs_and_lines values;
 957           volatile struct gdb_exception ex;
 958           char *saved_argptr = *argptr;
 959
 960           if (is_quote_enclosed)
 961             ++saved_arg;
 962
 963           /* Initialize it just to avoid a GCC false warning.  */
 964           memset (&values, 0, sizeof (values));
 965
 966           TRY_CATCH (ex, RETURN_MASK_ERROR)
 967             {
 968               values = decode_compound (self, argptr, saved_arg, p);
 969             }
 970           if ((is_quoted || is_squote_enclosed) && **argptr == '\'')
 971             *argptr = *argptr + 1;
 972
 973           if (ex.reason >= 0)
 974             {
 975               do_cleanups (cleanup);
 976               return values;
 977             }
 978
 979           if (ex.error != NOT_FOUND_ERROR)
 980             throw_exception (ex);
 981
 982           *argptr = saved_argptr;
 983         }
 984       else
 985         {
 986           /* If there was an exception looking up a specified filename earlier,
 987              then check whether we were really given `function:label'.   */
 988           if (file_exception.reason < 0)
 989             {
 990               function_symbols = find_function_symbols (argptr, p,
 991                                                         is_quote_enclosed,
 992                                                         &self->user_function);
 993
 994               /* If we did not find a function, re-throw the original
 995                  exception.  */
 996               if (!function_symbols)
 997                 throw_exception (file_exception);
 998
 999               make_cleanup (VEC_cleanup (symbolp), &function_symbols);
1000             }
1001
1002           /* Check for single quotes on the non-filename part.  */
1003           if (!is_quoted)
1004             {
1005               is_quoted = (**argptr
1006                            && strchr (get_gdb_completer_quote_characters (),
1007                                       **argptr) != NULL);
1008               if (is_quoted)
1009                 end_quote = skip_quoted (*argptr);
1010             }
1011         }
1012     }
1013
1014   /* self->file_symtabs holds the  specified file symtabs, or 0 if no file
1015      specified.
1016      If we are parsing `function:symbol', then FUNCTION_SYMBOLS holds the
1017      functions before the `:'.
1018      arg no longer contains the file name.  */
1019
1020   /* If the filename was quoted, we must re-check the quotation.  */
1021
1022   if (end_quote == first_half && *end_quote!= '\0')
1023     {
1024       is_quoted = (**argptr
1025                    && strchr (get_gdb_completer_quote_characters (),
1026                               **argptr) != NULL);
1027       if (is_quoted)
1028         end_quote = skip_quoted (*argptr);
1029     }
1030
1031   /* Check whether arg is all digits (and sign).  */
1032
1033   q = *argptr;
1034   if (*q == '-' || *q == '+')
1035     q++;
1036   while (*q >= '0' && *q <= '9')
1037     q++;
1038
1039   if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ',')
1040       && function_symbols == NULL)
1041     {
1042       struct symtabs_and_lines values;
1043
1044       /* We found a token consisting of all digits -- at least one digit.  */
1045       values = decode_all_digits (self, argptr, q);
1046       do_cleanups (cleanup);
1047       return values;
1048     }
1049
1050   /* Arg token is not digits => try it as a variable name
1051      Find the next token (everything up to end or next whitespace).  */
1052
1053   if (**argptr == '$')          /* May be a convenience variable.  */
1054     /* One or two $ chars possible.  */
1055     p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1));
1056   else if (is_quoted || is_squote_enclosed)
1057     {
1058       p = end_quote;
1059       if (p[-1] != '\'')
1060         error (_("Unmatched single quote."));
1061     }
1062   else if (is_objc_method)
1063     {
1064       /* allow word separators in method names for Obj-C.  */
1065       p = skip_quoted_chars (*argptr, NULL, "");
1066     }
1067   else
1068     {
1069       p = skip_quoted (*argptr);
1070     }
1071
1072   /* Keep any important naming information.  */
1073   p = keep_name_info (p, p == saved_arg || is_linespec_boundary (p[-1]));
1074
1075   copy = (char *) alloca (p - *argptr + 1);
1076   memcpy (copy, *argptr, p - *argptr);
1077   copy[p - *argptr] = '\0';
1078   if (p != *argptr
1079       && copy[0]
1080       && copy[0] == copy[p - *argptr - 1]
1081       && strchr (get_gdb_completer_quote_characters (), copy[0]) != NULL)
1082     {
1083       copy[p - *argptr - 1] = '\0';
1084       copy++;
1085     }
1086   else if (is_quoted || is_squote_enclosed)
1087     copy[p - *argptr - 1] = '\0';
1088
1089   *argptr = skip_spaces (p);
1090
1091   /* If it starts with $: may be a legitimate variable or routine name
1092      (e.g. HP-UX millicode routines such as $$dyncall), or it may
1093      be history value, or it may be a convenience variable.  */
1094
1095   if (*copy == '$' && function_symbols == NULL)
1096     {
1097       struct symtabs_and_lines values;
1098
1099       values = decode_dollar (self, copy);
1100       do_cleanups (cleanup);
1101       return values;
1102     }
1103
1104   /* Try the token as a label, but only if no file was specified,
1105      because we can only really find labels in the current scope.  */
1106
1107   if (VEC_length (symtab_p, self->file_symtabs) == 1
1108       && VEC_index (symtab_p, self->file_symtabs, 0) == NULL)
1109     {
1110       struct symtabs_and_lines label_result;
1111       if (decode_label (self, function_symbols, copy, &label_result))
1112         {
1113           do_cleanups (cleanup);
1114           return label_result;
1115         }
1116     }
1117
1118   if (function_symbols)
1119     throw_exception (file_exception);
1120
1121   /* Look up that token as a variable.
1122      If file specified, use that file's per-file block to start with.  */
1123
1124   {
1125     struct symtabs_and_lines values;
1126
1127     values = decode_variable (self, copy);
1128     do_cleanups (cleanup);
1129     return values;
1130   }
1131 }
1132
1133 /* A constructor for linespec_state.  */
1134
1135 static void
1136 linespec_state_constructor (struct linespec_state *self,
1137                             int flags,
1138                             struct symtab *default_symtab,
1139                             int default_line,
1140                             struct linespec_result *canonical)
1141 {
1142   memset (self, 0, sizeof (*self));
1143   self->funfirstline = (flags & DECODE_LINE_FUNFIRSTLINE) ? 1 : 0;
1144   self->list_mode = (flags & DECODE_LINE_LIST_MODE) ? 1 : 0;
1145   self->default_symtab = default_symtab;
1146   self->default_line = default_line;
1147   self->canonical = canonical;
1148   self->program_space = current_program_space;
1149   self->addr_set = htab_create_alloc (10, hash_address_entry, eq_address_entry,
1150                                       xfree, xcalloc, xfree);
1151 }
1152
1153 /* A destructor for linespec_state.  */
1154
1155 static void
1156 linespec_state_destructor (void *arg)
1157 {
1158   struct linespec_state *self = arg;
1159
1160   xfree (self->user_filename);
1161   xfree (self->user_function);
1162   VEC_free (symtab_p, self->file_symtabs);
1163   htab_delete (self->addr_set);
1164 }
1165
1166 /* See linespec.h.  */
1167
1168 void
1169 decode_line_full (char **argptr, int flags,
1170                   struct symtab *default_symtab,
1171                   int default_line, struct linespec_result *canonical,
1172                   const char *select_mode,
1173                   const char *filter)
1174 {
1175   struct symtabs_and_lines result;
1176   struct linespec_state state;
1177   struct cleanup *cleanups;
1178   char *arg_start = *argptr;
1179   VEC (const_char_ptr) *filters = NULL;
1180
1181   gdb_assert (canonical != NULL);
1182   /* The filter only makes sense for 'all'.  */
1183   gdb_assert (filter == NULL || select_mode == multiple_symbols_all);
1184   gdb_assert (select_mode == NULL
1185               || select_mode == multiple_symbols_all
1186               || select_mode == multiple_symbols_ask
1187               || select_mode == multiple_symbols_cancel);
1188   gdb_assert ((flags & DECODE_LINE_LIST_MODE) == 0);
1189
1190   linespec_state_constructor (&state, flags,
1191                               default_symtab, default_line, canonical);
1192   cleanups = make_cleanup (linespec_state_destructor, &state);
1193   save_current_program_space ();
1194
1195   result = decode_line_internal (&state, argptr);
1196
1197   gdb_assert (result.nelts == 1 || canonical->pre_expanded);
1198   gdb_assert (canonical->addr_string != NULL);
1199   canonical->pre_expanded = 1;
1200
1201   /* Fill in the missing canonical names.  */
1202   if (result.nelts > 0)
1203     {
1204       int i;
1205
1206       if (state.canonical_names == NULL)
1207         state.canonical_names = xcalloc (result.nelts, sizeof (char *));
1208       make_cleanup (xfree, state.canonical_names);
1209       for (i = 0; i < result.nelts; ++i)
1210         {
1211           if (state.canonical_names[i] == NULL)
1212             state.canonical_names[i] = savestring (arg_start,
1213                                                    *argptr - arg_start);
1214           make_cleanup (xfree, state.canonical_names[i]);
1215         }
1216     }
1217
1218   if (select_mode == NULL)
1219     {
1220       if (ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
1221         select_mode = multiple_symbols_all;
1222       else
1223         select_mode = multiple_symbols_select_mode ();
1224     }
1225
1226   if (select_mode == multiple_symbols_all)
1227     {
1228       if (filter != NULL)
1229         {
1230           make_cleanup (VEC_cleanup (const_char_ptr), &filters);
1231           VEC_safe_push (const_char_ptr, filters, filter);
1232           filter_results (&state, &result, filters);
1233         }
1234       else
1235         convert_results_to_lsals (&state, &result);
1236     }
1237   else
1238     decode_line_2 (&state, &result, select_mode);
1239
1240   do_cleanups (cleanups);
1241 }
1242
1243 struct symtabs_and_lines
1244 decode_line_1 (char **argptr, int flags,
1245                struct symtab *default_symtab,
1246                int default_line)
1247 {
1248   struct symtabs_and_lines result;
1249   struct linespec_state state;
1250   struct cleanup *cleanups;
1251
1252   linespec_state_constructor (&state, flags,
1253                               default_symtab, default_line, NULL);
1254   cleanups = make_cleanup (linespec_state_destructor, &state);
1255   save_current_program_space ();
1256
1257   result = decode_line_internal (&state, argptr);
1258   do_cleanups (cleanups);
1259   return result;
1260 }
1261
1262 \f
1263
1264 /* First, some functions to initialize stuff at the beggining of the
1265    function.  */
1266
1267 static void
1268 initialize_defaults (struct symtab **default_symtab, int *default_line)
1269 {
1270   if (*default_symtab == 0)
1271     {
1272       /* Use whatever we have for the default source line.  We don't use
1273          get_current_or_default_symtab_and_line as it can recurse and call
1274          us back!  */
1275       struct symtab_and_line cursal =
1276         get_current_source_symtab_and_line ();
1277
1278       *default_symtab = cursal.symtab;
1279       *default_line = cursal.line;
1280     }
1281 }
1282
1283 \f
1284
1285 /* Decode arg of the form *PC.  */
1286
1287 static struct symtabs_and_lines
1288 decode_indirect (struct linespec_state *self, char **argptr)
1289 {
1290   struct symtabs_and_lines values;
1291   CORE_ADDR pc;
1292   char *initial = *argptr;
1293
1294   if (current_program_space->executing_startup)
1295     /* The error message doesn't really matter, because this case
1296        should only hit during breakpoint reset.  */
1297     throw_error (NOT_FOUND_ERROR, _("cannot evaluate expressions while "
1298                                     "program space is in startup"));
1299
1300   (*argptr)++;
1301   pc = value_as_address (parse_to_comma_and_eval (argptr));
1302
1303   values.sals = (struct symtab_and_line *)
1304     xmalloc (sizeof (struct symtab_and_line));
1305
1306   values.nelts = 1;
1307   values.sals[0] = find_pc_line (pc, 0);
1308   values.sals[0].pc = pc;
1309   values.sals[0].section = find_pc_overlay (pc);
1310   values.sals[0].explicit_pc = 1;
1311
1312   if (self->canonical)
1313     self->canonical->addr_string = savestring (initial, *argptr - initial);
1314
1315   return values;
1316 }
1317
1318 \f
1319
1320 /* Locate the first half of the linespec, ending in a colon, period,
1321    or whitespace.  (More or less.)  Also, check to see if *ARGPTR is
1322    enclosed in double quotes; if so, set is_quote_enclosed, advance
1323    ARGPTR past that and zero out the trailing double quote.
1324    If ARGPTR is just a simple name like "main", p will point to ""
1325    at the end.  */
1326
1327 static char *
1328 locate_first_half (char **argptr, int *is_quote_enclosed)
1329 {
1330   char *ii;
1331   char *p, *p1;
1332   int has_comma;
1333
1334   /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1335      and we must isolate the first half.  Outer layers will call again later
1336      for the second half.
1337
1338      Don't count commas that appear in argument lists of overloaded
1339      functions, or in quoted strings.  It's stupid to go to this much
1340      trouble when the rest of the function is such an obvious roach hotel.  */
1341   ii = find_toplevel_char (*argptr, ',');
1342   has_comma = (ii != 0);
1343
1344   /* Temporarily zap out second half to not confuse the code below.
1345      This is undone below.  Do not change ii!!  */
1346   if (has_comma)
1347     {
1348       *ii = '\0';
1349     }
1350
1351   /* Maybe arg is FILE : LINENUM or FILE : FUNCTION.  May also be
1352      CLASS::MEMBER, or NAMESPACE::NAME.  Look for ':', but ignore
1353      inside of <>.  */
1354
1355   p = *argptr;
1356   if (p[0] == '"')
1357     {
1358       *is_quote_enclosed = 1;
1359       (*argptr)++;
1360       p++;
1361     }
1362   else
1363     {
1364       *is_quote_enclosed = 0;
1365       if (strchr (get_gdb_completer_quote_characters (), *p))
1366         {
1367           ++(*argptr);
1368           ++p;
1369         }
1370     }
1371
1372
1373   /* Check for a drive letter in the filename.  This is done on all hosts
1374      to capture cross-compilation environments.  On Unixen, directory
1375      separators are illegal in filenames, so if the user enters "e:/foo.c",
1376      he is referring to a directory named "e:" and a source file named
1377      "foo.c", and we still want to keep these two pieces together.  */
1378   if (isalpha (p[0]) && p[1] == ':' && IS_DIR_SEPARATOR (p[2]))
1379     p += 3;
1380
1381   for (; *p; p++)
1382     {
1383       if (p[0] == '<')
1384         {
1385           char *temp_end = find_template_name_end (p);
1386
1387           if (!temp_end)
1388             error (_("malformed template specification in command"));
1389           p = temp_end;
1390         }
1391
1392       if (p[0] == '(')
1393         p = find_method_overload_end (p);
1394
1395       /* Check for a colon and a plus or minus and a [ (which
1396          indicates an Objective-C method).  */
1397       if (is_objc_method_format (p))
1398         {
1399           break;
1400         }
1401       /* Check for the end of the first half of the linespec.  End of
1402          line, a tab, a colon or a space.  But if enclosed in double
1403          quotes we do not break on enclosed spaces.  */
1404       if (!*p
1405           || p[0] == '\t'
1406           || (p[0] == ':')
1407           || ((p[0] == ' ') && !*is_quote_enclosed))
1408         break;
1409       if (p[0] == '.' && strchr (p, ':') == NULL)
1410         {
1411           /* Java qualified method.  Find the *last* '.', since the
1412              others are package qualifiers.  Stop at any open parenthesis
1413              which might provide overload information.  */
1414           for (p1 = p; *p1 && *p1 != '('; p1++)
1415             {
1416               if (*p1 == '.')
1417                 p = p1;
1418             }
1419           break;
1420         }
1421     }
1422   p = skip_spaces (p);
1423
1424   /* If the closing double quote was left at the end, remove it.  */
1425   if (*is_quote_enclosed)
1426     {
1427       char *closing_quote = strchr (p - 1, '"');
1428
1429       if (closing_quote && closing_quote[1] == '\0')
1430         *closing_quote = '\0';
1431     }
1432
1433   /* Now that we've safely parsed the first half, put back ',' so
1434      outer layers can see it.  */
1435   if (has_comma)
1436     *ii = ',';
1437
1438   return p;
1439 }
1440
1441 \f
1442
1443 /* Here's where we recognise an Objective-C Selector.  An Objective C
1444    selector may be implemented by more than one class, therefore it
1445    may represent more than one method/function.  This gives us a
1446    situation somewhat analogous to C++ overloading.  If there's more
1447    than one method that could represent the selector, then use some of
1448    the existing C++ code to let the user choose one.  */
1449
1450 static struct symtabs_and_lines
1451 decode_objc (struct linespec_state *self, char **argptr)
1452 {
1453   struct collect_info info;
1454   VEC (const_char_ptr) *symbol_names = NULL;
1455   char *new_argptr;
1456   struct cleanup *cleanup = make_cleanup (VEC_cleanup (const_char_ptr),
1457                                           &symbol_names);
1458
1459   info.state = self;
1460   info.result.sals = NULL;
1461   info.result.nelts = 0;
1462
1463   new_argptr = find_imps (*argptr, &symbol_names);
1464   if (VEC_empty (const_char_ptr, symbol_names))
1465     {
1466       do_cleanups (cleanup);
1467       return info.result;
1468     }
1469
1470   add_all_symbol_names_from_pspace (&info, NULL, symbol_names);
1471
1472   if (info.result.nelts > 0)
1473     {
1474       char *saved_arg;
1475
1476       saved_arg = alloca (new_argptr - *argptr + 1);
1477       memcpy (saved_arg, *argptr, new_argptr - *argptr);
1478       saved_arg[new_argptr - *argptr] = '\0';
1479
1480       if (self->canonical)
1481         {
1482           self->canonical->pre_expanded = 1;
1483           if (self->user_filename)
1484             self->canonical->addr_string
1485               = xstrprintf ("%s:%s", self->user_filename, saved_arg);
1486           else
1487             self->canonical->addr_string = xstrdup (saved_arg);
1488         }
1489     }
1490
1491   *argptr = new_argptr;
1492
1493   do_cleanups (cleanup);
1494   return info.result;
1495 }
1496
1497 /* This handles C++ and Java compound data structures.  P should point
1498    at the first component separator, i.e. double-colon or period.  As
1499    an example, on entrance to this function we could have ARGPTR
1500    pointing to "AAA::inA::fun" and P pointing to "::inA::fun".  */
1501
1502 static struct symtabs_and_lines
1503 decode_compound (struct linespec_state *self,
1504                  char **argptr, char *the_real_saved_arg, char *p)
1505 {
1506   struct symtabs_and_lines values;
1507   char *p2;
1508   char *saved_arg2 = *argptr;
1509   char *temp_end;
1510   struct symbol *sym;
1511   char *copy;
1512   VEC (symbolp) *sym_classes;
1513   char *saved_arg, *class_name;
1514   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1515
1516   /* If the user specified any completer quote characters in the input,
1517      strip them.  They are superfluous.  */
1518   saved_arg = alloca (strlen (the_real_saved_arg) + 1);
1519   {
1520     char *dst = saved_arg;
1521     char *src = the_real_saved_arg;
1522     char *quotes = get_gdb_completer_quote_characters ();
1523     while (*src != '\0')
1524       {
1525         if (strchr (quotes, *src) == NULL)
1526           *dst++ = *src;
1527         ++src;
1528       }
1529     *dst = '\0';
1530   }
1531
1532   /* First check for "global" namespace specification, of the form
1533      "::foo".  If found, skip over the colons and jump to normal
1534      symbol processing.  I.e. the whole line specification starts with
1535      "::" (note the condition that *argptr == p).  */
1536   if (p[0] == ':'
1537       && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
1538     saved_arg2 += 2;
1539
1540   /* Given our example "AAA::inA::fun", we have two cases to consider:
1541
1542      1) AAA::inA is the name of a class.  In that case, presumably it
1543         has a method called "fun"; we then look up that method using
1544         find_method.
1545
1546      2) AAA::inA isn't the name of a class.  In that case, either the
1547         user made a typo, AAA::inA is the name of a namespace, or it is
1548         the name of a minimal symbol.
1549         In this case we just delegate to decode_variable.
1550
1551      Thus, our first task is to find everything before the last set of
1552      double-colons and figure out if it's the name of a class.  So we
1553      first loop through all of the double-colons.  */
1554
1555   p2 = p;               /* Save for restart.  */
1556
1557   /* This is very messy.  Following the example above we have now the
1558      following pointers:
1559      p -> "::inA::fun"
1560      argptr -> "AAA::inA::fun
1561      saved_arg -> "AAA::inA::fun
1562      saved_arg2 -> "AAA::inA::fun
1563      p2 -> "::inA::fun".  */
1564
1565   /* In the loop below, with these strings, we'll make 2 passes, each
1566      is marked in comments.  */
1567
1568   while (1)
1569     {
1570       static char *break_characters = " \t(";
1571
1572       /* Move pointer up to next possible class/namespace token.  */
1573
1574       p = p2 + 1;       /* Restart with old value +1.  */
1575
1576       /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1577          i.e. if there is a double-colon, p will now point to the
1578          second colon.  */
1579       /* PASS2: p2->"::fun", p->":fun" */
1580
1581       /* Move pointer ahead to next double-colon.  */
1582       while (*p
1583              && strchr (break_characters, *p) == NULL
1584              && strchr (get_gdb_completer_quote_characters (), *p) == NULL)
1585         {
1586           if (current_language->la_language == language_cplus)
1587             p += cp_validate_operator (p);
1588
1589           if (p[0] == '<')
1590             {
1591               temp_end = find_template_name_end (p);
1592               if (!temp_end)
1593                 error (_("malformed template specification in command"));
1594               p = temp_end;
1595             }
1596           /* Note that, since, at the start of this loop, p would be
1597              pointing to the second colon in a double-colon, we only
1598              satisfy the condition below if there is another
1599              double-colon to the right (after).  I.e. there is another
1600              component that can be a class or a namespace.  I.e, if at
1601              the beginning of this loop (PASS1), we had
1602              p->":inA::fun", we'll trigger this when p has been
1603              advanced to point to "::fun".  */
1604           /* PASS2: we will not trigger this.  */
1605           else if ((p[0] == ':') && (p[1] == ':'))
1606             break;      /* Found double-colon.  */
1607           else
1608             {
1609               /* PASS2: We'll keep getting here, until P points to one of the
1610                  break characters, at which point we exit this loop.  */
1611               if (*p)
1612                 {
1613                   if (p[1] == '('
1614                       && strncmp (&p[1], CP_ANONYMOUS_NAMESPACE_STR,
1615                                   CP_ANONYMOUS_NAMESPACE_LEN) == 0)
1616                     p += CP_ANONYMOUS_NAMESPACE_LEN;
1617                   else if (strchr (break_characters, *p) == NULL)
1618                     ++p;
1619                 }
1620             }
1621         }
1622
1623       if (*p != ':')
1624         break;          /* Out of the while (1).  This would happen
1625                            for instance if we have looked up
1626                            unsuccessfully all the components of the
1627                            string, and p->""(PASS2).  */
1628
1629       /* We get here if p points to one of the break characters or "" (i.e.,
1630          string ended).  */
1631       /* Save restart for next time around.  */
1632       p2 = p;
1633       /* Restore argptr as it was on entry to this function.  */
1634       *argptr = saved_arg2;
1635       /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1636          p2->"::fun".  */
1637
1638       /* All ready for next pass through the loop.  */
1639     }                   /* while (1) */
1640
1641
1642   /* Start of lookup in the symbol tables.  */
1643
1644   /* Lookup in the symbol table the substring between argptr and
1645      p.  Note, this call changes the value of argptr.  */
1646   /* Before the call, argptr->"AAA::inA::fun",
1647      p->"", p2->"::fun".  After the call: argptr->"fun", p, p2
1648      unchanged.  */
1649   sym_classes = lookup_prefix_sym (argptr, p2, self->file_symtabs,
1650                                    &class_name);
1651   make_cleanup (VEC_cleanup (symbolp), &sym_classes);
1652   make_cleanup (xfree, class_name);
1653
1654   /* If a class has been found, then we're in case 1 above.  So we
1655      look up "fun" as a method of those classes.  */
1656   if (!VEC_empty (symbolp, sym_classes))
1657     {
1658       /* Arg token is not digits => try it as a function name.
1659          Find the next token (everything up to end or next
1660          blank).  */
1661       if (**argptr
1662           && strchr (get_gdb_completer_quote_characters (),
1663                      **argptr) != NULL)
1664         {
1665           p = skip_quoted (*argptr);
1666           *argptr = *argptr + 1;
1667         }
1668       else
1669         {
1670           /* At this point argptr->"fun".  */
1671           char *a;
1672
1673           p = *argptr;
1674           while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':'
1675                  && *p != '(')
1676             p++;
1677           /* At this point p->"".  String ended.  */
1678           /* Nope, C++ operators could have spaces in them
1679              ("foo::operator <" or "foo::operator delete []").
1680              I apologize, this is a bit hacky...  */
1681           if (current_language->la_language == language_cplus
1682               && *p == ' ' && p - 8 - *argptr + 1 > 0)
1683             {
1684               /* The above loop has already swallowed "operator".  */
1685               p += cp_validate_operator (p - 8) - 8;
1686             }
1687
1688           /* Keep any important naming information.  */
1689           p = keep_name_info (p, 1);
1690         }
1691
1692       /* Allocate our own copy of the substring between argptr and
1693          p.  */
1694       copy = (char *) alloca (p - *argptr + 1);
1695       memcpy (copy, *argptr, p - *argptr);
1696       copy[p - *argptr] = '\0';
1697       if (p != *argptr
1698           && copy[p - *argptr - 1]
1699           && strchr (get_gdb_completer_quote_characters (),
1700                      copy[p - *argptr - 1]) != NULL)
1701         copy[p - *argptr - 1] = '\0';
1702
1703       /* At this point copy->"fun", p->"".  */
1704
1705       /* No line number may be specified.  */
1706       *argptr = skip_spaces (p);
1707       /* At this point arptr->"".  */
1708
1709       /* Look for copy as a method of sym_class.  */
1710       /* At this point copy->"fun", sym_class is "AAA:inA",
1711          saved_arg->"AAA::inA::fun".  This concludes the scanning of
1712          the string for possible components matches.  If we find it
1713          here, we return.  If not, and we are at the and of the string,
1714          we'll lookup the whole string in the symbol tables.  */
1715
1716       values = find_method (self, saved_arg, copy, class_name, sym_classes);
1717
1718       do_cleanups (cleanup);
1719       return values;
1720     } /* End if symbol found.  */
1721
1722
1723   /* We couldn't find a class, so we're in case 2 above.  We check the
1724      entire name as a symbol instead.  The simplest way to do this is
1725      to just throw an exception and let our caller fall through to
1726      decode_variable.  */
1727
1728   throw_error (NOT_FOUND_ERROR, _("see caller, this text doesn't matter"));
1729 }
1730
1731 /* An instance of this type is used when collecting prefix symbols for
1732    decode_compound.  */
1733
1734 struct decode_compound_collector
1735 {
1736   /* The result vector.  */
1737   VEC (symbolp) *symbols;
1738
1739   /* A hash table of all symbols we found.  We use this to avoid
1740      adding any symbol more than once.  */
1741   htab_t unique_syms;
1742 };
1743
1744 /* A callback for iterate_over_symbols that is used by
1745    lookup_prefix_sym to collect type symbols.  */
1746
1747 static int
1748 collect_one_symbol (struct symbol *sym, void *d)
1749 {
1750   struct decode_compound_collector *collector = d;
1751   void **slot;
1752   struct type *t;
1753
1754   if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1755     return 1;
1756
1757   t = SYMBOL_TYPE (sym);
1758   CHECK_TYPEDEF (t);
1759   if (TYPE_CODE (t) != TYPE_CODE_STRUCT
1760       && TYPE_CODE (t) != TYPE_CODE_UNION
1761       && TYPE_CODE (t) != TYPE_CODE_NAMESPACE)
1762     return 1;
1763
1764   slot = htab_find_slot (collector->unique_syms, sym, INSERT);
1765   if (!*slot)
1766     {
1767       *slot = sym;
1768       VEC_safe_push (symbolp, collector->symbols, sym);
1769     }
1770
1771   return 1;
1772 }
1773
1774 /* Return the symbol corresponding to the substring of *ARGPTR ending
1775    at P, allowing whitespace.  Also, advance *ARGPTR past the symbol
1776    name in question, the compound object separator ("::" or "."), and
1777    whitespace.  Note that *ARGPTR is changed whether or not the
1778    this call finds anything (i.e we return NULL).  As an
1779    example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun".  */
1780
1781 static VEC (symbolp) *
1782 lookup_prefix_sym (char **argptr, char *p, VEC (symtab_p) *file_symtabs,
1783                    char **class_name)
1784 {
1785   char *p1;
1786   char *copy;
1787   int ix;
1788   struct symtab *elt;
1789   struct decode_compound_collector collector;
1790   struct cleanup *outer;
1791   struct cleanup *cleanup;
1792   struct block *search_block;
1793
1794   /* Extract the class name.  */
1795   p1 = p;
1796   while (p != *argptr && p[-1] == ' ')
1797     --p;
1798   copy = (char *) xmalloc (p - *argptr + 1);
1799   memcpy (copy, *argptr, p - *argptr);
1800   copy[p - *argptr] = 0;
1801   *class_name = copy;
1802   outer = make_cleanup (xfree, copy);
1803
1804   /* Discard the class name from the argptr.  */
1805   p = p1 + (p1[0] == ':' ? 2 : 1);
1806   p = skip_spaces (p);
1807   *argptr = p;
1808
1809   /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1810      argptr->"inA::fun".  */
1811
1812   collector.symbols = NULL;
1813   make_cleanup (VEC_cleanup (symbolp), &collector.symbols);
1814
1815   collector.unique_syms = htab_create_alloc (1, htab_hash_pointer,
1816                                              htab_eq_pointer, NULL,
1817                                              xcalloc, xfree);
1818   cleanup = make_cleanup_htab_delete (collector.unique_syms);
1819
1820   for (ix = 0; VEC_iterate (symtab_p, file_symtabs, ix, elt); ++ix)
1821     {
1822       if (elt == NULL)
1823         {
1824           iterate_over_all_matching_symtabs (copy, STRUCT_DOMAIN,
1825                                              collect_one_symbol, &collector,
1826                                              NULL);
1827           iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
1828                                              collect_one_symbol, &collector,
1829                                              NULL);
1830         }
1831       else
1832         {
1833           struct block *search_block;
1834
1835           /* Program spaces that are executing startup should have
1836              been filtered out earlier.  */
1837           gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
1838           set_current_program_space (SYMTAB_PSPACE (elt));
1839           search_block = get_search_block (elt);
1840           LA_ITERATE_OVER_SYMBOLS (search_block, copy, STRUCT_DOMAIN,
1841                                    collect_one_symbol, &collector);
1842           LA_ITERATE_OVER_SYMBOLS (search_block, copy, VAR_DOMAIN,
1843                                    collect_one_symbol, &collector);
1844         }
1845     }
1846
1847   do_cleanups (cleanup);
1848   discard_cleanups (outer);
1849   return collector.symbols;
1850 }
1851
1852 /* A qsort comparison function for symbols.  The resulting order does
1853    not actually matter; we just need to be able to sort them so that
1854    symbols with the same program space end up next to each other.  */
1855
1856 static int
1857 compare_symbols (const void *a, const void *b)
1858 {
1859   struct symbol * const *sa = a;
1860   struct symbol * const *sb = b;
1861   uintptr_t uia, uib;
1862
1863   uia = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa));
1864   uib = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb));
1865
1866   if (uia < uib)
1867     return -1;
1868   if (uia > uib)
1869     return 1;
1870
1871   uia = (uintptr_t) *sa;
1872   uib = (uintptr_t) *sb;
1873
1874   if (uia < uib)
1875     return -1;
1876   if (uia > uib)
1877     return 1;
1878
1879   return 0;
1880 }
1881
1882 /* Look for all the matching instances of each symbol in NAMES.  Only
1883    instances from PSPACE are considered; other program spaces are
1884    handled by our caller.  If PSPACE is NULL, then all program spaces
1885    are considered.  Results are stored into INFO.  */
1886
1887 static void
1888 add_all_symbol_names_from_pspace (struct collect_info *info,
1889                                   struct program_space *pspace,
1890                                   VEC (const_char_ptr) *names)
1891 {
1892   int ix;
1893   const char *iter;
1894
1895   for (ix = 0; VEC_iterate (const_char_ptr, names, ix, iter); ++ix)
1896     add_matching_symbols_to_info (iter, info, pspace);
1897 }
1898
1899 static void
1900 find_superclass_methods (VEC (typep) *superclasses,
1901                          const char *name,
1902                          VEC (const_char_ptr) **result_names)
1903 {
1904   int old_len = VEC_length (const_char_ptr, *result_names);
1905   VEC (typep) *iter_classes;
1906   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1907
1908   iter_classes = superclasses;
1909   while (1)
1910     {
1911       VEC (typep) *new_supers = NULL;
1912       int ix;
1913       struct type *t;
1914
1915       make_cleanup (VEC_cleanup (typep), &new_supers);
1916       for (ix = 0; VEC_iterate (typep, iter_classes, ix, t); ++ix)
1917         find_methods (t, name, result_names, &new_supers);
1918
1919       if (VEC_length (const_char_ptr, *result_names) != old_len
1920           || VEC_empty (typep, new_supers))
1921         break;
1922
1923       iter_classes = new_supers;
1924     }
1925
1926   do_cleanups (cleanup);
1927 }
1928
1929 /* This finds the method COPY in the class whose type is given by one
1930    of the symbols in SYM_CLASSES.  */
1931
1932 static struct symtabs_and_lines
1933 find_method (struct linespec_state *self, char *saved_arg,
1934              char *copy, const char *class_name, VEC (symbolp) *sym_classes)
1935 {
1936   char *canon;
1937   struct symbol *sym;
1938   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1939   int ix;
1940   int last_result_len;
1941   VEC (typep) *superclass_vec;
1942   VEC (const_char_ptr) *result_names;
1943   struct collect_info info;
1944   char *name_iter;
1945
1946   /* NAME is typed by the user: it needs to be canonicalized before
1947      searching the symbol tables.  */
1948   canon = cp_canonicalize_string_no_typedefs (copy);
1949   if (canon != NULL)
1950     {
1951       copy = canon;
1952       make_cleanup (xfree, copy);
1953     }
1954
1955   /* Sort symbols so that symbols with the same program space are next
1956      to each other.  */
1957   qsort (VEC_address (symbolp, sym_classes),
1958          VEC_length (symbolp, sym_classes),
1959          sizeof (symbolp),
1960          compare_symbols);
1961
1962   info.state = self;
1963   info.result.sals = NULL;
1964   info.result.nelts = 0;
1965
1966   /* Iterate over all the types, looking for the names of existing
1967      methods matching COPY.  If we cannot find a direct method in a
1968      given program space, then we consider inherited methods; this is
1969      not ideal (ideal would be to respect C++ hiding rules), but it
1970      seems good enough and is what GDB has historically done.  We only
1971      need to collect the names because later we find all symbols with
1972      those names.  This loop is written in a somewhat funny way
1973      because we collect data across the program space before deciding
1974      what to do.  */
1975   superclass_vec = NULL;
1976   make_cleanup (VEC_cleanup (typep), &superclass_vec);
1977   result_names = NULL;
1978   make_cleanup (VEC_cleanup (const_char_ptr), &result_names);
1979   last_result_len = 0;
1980   for (ix = 0; VEC_iterate (symbolp, sym_classes, ix, sym); ++ix)
1981     {
1982       struct type *t;
1983       struct program_space *pspace;
1984
1985       /* Program spaces that are executing startup should have
1986          been filtered out earlier.  */
1987       gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym))->executing_startup);
1988       pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
1989       set_current_program_space (pspace);
1990       t = check_typedef (SYMBOL_TYPE (sym));
1991       find_methods (t, copy, &result_names, &superclass_vec);
1992
1993       /* Handle all items from a single program space at once; and be
1994          sure not to miss the last batch.  */
1995       if (ix == VEC_length (symbolp, sym_classes) - 1
1996           || (pspace
1997               != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp, sym_classes,
1998                                                           ix + 1)))))
1999         {
2000           /* If we did not find a direct implementation anywhere in
2001              this program space, consider superclasses.  */
2002           if (VEC_length (const_char_ptr, result_names) == last_result_len)
2003             find_superclass_methods (superclass_vec, copy, &result_names);
2004
2005           /* We have a list of candidate symbol names, so now we
2006              iterate over the symbol tables looking for all
2007              matches in this pspace.  */
2008           add_all_symbol_names_from_pspace (&info, pspace, result_names);
2009
2010           VEC_truncate (typep, superclass_vec, 0);
2011           last_result_len = VEC_length (const_char_ptr, result_names);
2012         }
2013     }
2014
2015   if (info.result.nelts > 0)
2016     {
2017       if (self->canonical)
2018         {
2019           self->canonical->pre_expanded = 1;
2020           if (self->user_filename)
2021             self->canonical->addr_string
2022               = xstrprintf ("%s:%s", self->user_filename, saved_arg);
2023           else
2024             self->canonical->addr_string = xstrdup (saved_arg);
2025         }
2026
2027       do_cleanups (cleanup);
2028
2029       return info.result;
2030     }
2031
2032   if (copy[0] == '~')
2033     cplusplus_error (saved_arg,
2034                      "the class `%s' does not have destructor defined\n",
2035                      class_name);
2036   else
2037     cplusplus_error (saved_arg,
2038                      "the class %s does not have any method named %s\n",
2039                      class_name, copy);
2040 }
2041
2042 \f
2043
2044 /* This object is used when collecting all matching symtabs.  */
2045
2046 struct symtab_collector
2047 {
2048   /* The result vector of symtabs.  */
2049   VEC (symtab_p) *symtabs;
2050
2051   /* This is used to ensure the symtabs are unique.  */
2052   htab_t symtab_table;
2053 };
2054
2055 /* Callback for iterate_over_symtabs.  */
2056
2057 static int
2058 add_symtabs_to_list (struct symtab *symtab, void *d)
2059 {
2060   struct symtab_collector *data = d;
2061   void **slot;
2062
2063   slot = htab_find_slot (data->symtab_table, symtab, INSERT);
2064   if (!*slot)
2065     {
2066       *slot = symtab;
2067       VEC_safe_push (symtab_p, data->symtabs, symtab);
2068     }
2069
2070   return 0;
2071 }
2072
2073 /* Given a file name, return a VEC of all matching symtabs.  */
2074
2075 static VEC (symtab_p) *
2076 collect_symtabs_from_filename (const char *file)
2077 {
2078   struct symtab_collector collector;
2079   struct cleanup *cleanups;
2080   struct program_space *pspace;
2081
2082   collector.symtabs = NULL;
2083   collector.symtab_table = htab_create (1, htab_hash_pointer, htab_eq_pointer,
2084                                         NULL);
2085   cleanups = make_cleanup_htab_delete (collector.symtab_table);
2086
2087   /* Find that file's data.  */
2088   ALL_PSPACES (pspace)
2089   {
2090     if (pspace->executing_startup)
2091       continue;
2092
2093     set_current_program_space (pspace);
2094     iterate_over_symtabs (file, add_symtabs_to_list, &collector);
2095   }
2096
2097   do_cleanups (cleanups);
2098   return collector.symtabs;
2099 }
2100
2101 /* Return all the symtabs associated to the filename given by the
2102    substring of *ARGPTR ending at P, and advance ARGPTR past that
2103    filename.  */
2104
2105 static VEC (symtab_p) *
2106 symtabs_from_filename (char **argptr, char *p, int is_quote_enclosed,
2107                        char **user_filename)
2108 {
2109   char *p1;
2110   char *copy;
2111   struct cleanup *outer;
2112   VEC (symtab_p) *result;
2113
2114   p1 = p;
2115   while (p != *argptr && p[-1] == ' ')
2116     --p;
2117   if ((*p == '"') && is_quote_enclosed)
2118     --p;
2119   copy = xmalloc (p - *argptr + 1);
2120   outer = make_cleanup (xfree, copy);
2121   memcpy (copy, *argptr, p - *argptr);
2122   /* It may have the ending quote right after the file name.  */
2123   if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
2124       || copy[p - *argptr - 1] == '\'')
2125     copy[p - *argptr - 1] = 0;
2126   else
2127     copy[p - *argptr] = 0;
2128
2129   result = collect_symtabs_from_filename (copy);
2130
2131   if (VEC_empty (symtab_p, result))
2132     {
2133       if (!have_full_symbols () && !have_partial_symbols ())
2134         throw_error (NOT_FOUND_ERROR,
2135                      _("No symbol table is loaded.  "
2136                        "Use the \"file\" command."));
2137       throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy);
2138     }
2139
2140   /* Discard the file name from the arg.  */
2141   if (*p1 == '\0')
2142     *argptr = p1;
2143   else
2144     *argptr = skip_spaces (p1 + 1);
2145
2146   discard_cleanups (outer);
2147   *user_filename = copy;
2148   return result;
2149 }
2150
2151 /* A callback used by iterate_over_all_matching_symtabs that collects
2152    symbols for find_function_symbols.  */
2153
2154 static int
2155 collect_function_symbols (struct symbol *sym, void *arg)
2156 {
2157   VEC (symbolp) **syms = arg;
2158
2159   if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2160     VEC_safe_push (symbolp, *syms, sym);
2161
2162   return 1;
2163 }
2164
2165 /* Look up a function symbol in *ARGPTR.  If found, advance *ARGPTR
2166    and return the symbol.  If not found, return NULL.  */
2167
2168 static VEC (symbolp) *
2169 find_function_symbols (char **argptr, char *p, int is_quote_enclosed,
2170                        char **user_function)
2171 {
2172   char *p1;
2173   char *copy;
2174   VEC (symbolp) *result = NULL;
2175
2176   p1 = p;
2177   while (p != *argptr && p[-1] == ' ')
2178     --p;
2179   if ((*p == '"') && is_quote_enclosed)
2180     --p;
2181   copy = (char *) xmalloc (p - *argptr + 1);
2182   *user_function = copy;
2183   memcpy (copy, *argptr, p - *argptr);
2184   /* It may have the ending quote right after the file name.  */
2185   if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
2186       || copy[p - *argptr - 1] == '\'')
2187     copy[p - *argptr - 1] = 0;
2188   else
2189     copy[p - *argptr] = 0;
2190
2191   iterate_over_all_matching_symtabs (copy, VAR_DOMAIN,
2192                                      collect_function_symbols, &result, NULL);
2193
2194   if (VEC_empty (symbolp, result))
2195     VEC_free (symbolp, result);
2196   else
2197     {
2198       /* Discard the file name from the arg.  */
2199       *argptr = skip_spaces (p1 + 1);
2200     }
2201
2202   return result;
2203 }
2204
2205 \f
2206
2207 /* A helper for decode_all_digits that handles the 'list_mode' case.  */
2208
2209 static void
2210 decode_digits_list_mode (struct linespec_state *self,
2211                          struct symtabs_and_lines *values,
2212                          struct symtab_and_line val)
2213 {
2214   int ix;
2215   struct symtab *elt;
2216
2217   gdb_assert (self->list_mode);
2218
2219   for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2220     {
2221       /* The logic above should ensure this.  */
2222       gdb_assert (elt != NULL);
2223
2224       set_current_program_space (SYMTAB_PSPACE (elt));
2225
2226       /* Simplistic search just for the list command.  */
2227       val.symtab = find_line_symtab (elt, val.line, NULL, NULL);
2228       if (val.symtab == NULL)
2229         val.symtab = elt;
2230       val.pspace = SYMTAB_PSPACE (elt);
2231       val.pc = 0;
2232       val.explicit_line = 1;
2233
2234       add_sal_to_sals (self, values, &val, NULL);
2235     }
2236 }
2237
2238 /* A helper for decode_all_digits that iterates over the symtabs,
2239    adding lines to the VEC.  */
2240
2241 static void
2242 decode_digits_ordinary (struct linespec_state *self,
2243                         int line,
2244                         struct symtabs_and_lines *sals,
2245                         struct linetable_entry **best_entry)
2246 {
2247   int ix;
2248   struct symtab *elt;
2249
2250   for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2251     {
2252       int i;
2253       VEC (CORE_ADDR) *pcs;
2254       CORE_ADDR pc;
2255
2256       /* The logic above should ensure this.  */
2257       gdb_assert (elt != NULL);
2258
2259       set_current_program_space (SYMTAB_PSPACE (elt));
2260
2261       pcs = find_pcs_for_symtab_line (elt, line, best_entry);
2262       for (i = 0; VEC_iterate (CORE_ADDR, pcs, i, pc); ++i)
2263         {
2264           struct symtab_and_line sal;
2265
2266           init_sal (&sal);
2267           sal.pspace = SYMTAB_PSPACE (elt);
2268           sal.symtab = elt;
2269           sal.line = line;
2270           sal.pc = pc;
2271           add_sal_to_sals_basic (sals, &sal);
2272         }
2273
2274       VEC_free (CORE_ADDR, pcs);
2275     }
2276 }
2277
2278 /* This decodes a line where the argument is all digits (possibly
2279    preceded by a sign).  Q should point to the end of those digits;
2280    the other arguments are as usual.  */
2281
2282 static struct symtabs_and_lines
2283 decode_all_digits (struct linespec_state *self,
2284                    char **argptr,
2285                    char *q)
2286 {
2287   struct symtabs_and_lines values;
2288   struct symtab_and_line val;
2289   int use_default = 0;
2290   char *saved_arg = *argptr;
2291
2292   enum sign
2293     {
2294       none, plus, minus
2295     }
2296   sign = none;
2297
2298   init_sal (&val);
2299   values.sals = NULL;
2300   values.nelts = 0;
2301
2302   /* This is where we need to make sure that we have good defaults.
2303      We must guarantee that this section of code is never executed
2304      when we are called with just a function name, since
2305      set_default_source_symtab_and_line uses
2306      select_source_symtab that calls us with such an argument.  */
2307
2308   if (VEC_length (symtab_p, self->file_symtabs) == 1
2309       && VEC_index (symtab_p, self->file_symtabs, 0) == NULL)
2310     {
2311       set_current_program_space (self->program_space);
2312
2313       /* Make sure we have at least a default source file.  */
2314       set_default_source_symtab_and_line ();
2315       initialize_defaults (&self->default_symtab, &self->default_line);
2316       VEC_pop (symtab_p, self->file_symtabs);
2317       VEC_free (symtab_p, self->file_symtabs);
2318       self->file_symtabs
2319         = collect_symtabs_from_filename (self->default_symtab->filename);
2320       use_default = 1;
2321     }
2322
2323   if (**argptr == '+')
2324     sign = plus, (*argptr)++;
2325   else if (**argptr == '-')
2326     sign = minus, (*argptr)++;
2327   val.line = atoi (*argptr);
2328   switch (sign)
2329     {
2330     case plus:
2331       if (q == *argptr)
2332         val.line = 5;
2333       if (use_default)
2334         val.line = self->default_line + val.line;
2335       break;
2336     case minus:
2337       if (q == *argptr)
2338         val.line = 15;
2339       if (use_default)
2340         val.line = self->default_line - val.line;
2341       else
2342         val.line = 1;
2343       break;
2344     case none:
2345       break;            /* No need to adjust val.line.  */
2346     }
2347
2348   *argptr = skip_spaces (q);
2349
2350   if (self->list_mode)
2351     decode_digits_list_mode (self, &values, val);
2352   else
2353     {
2354       struct linetable_entry *best_entry = NULL;
2355       int *filter;
2356       struct block **blocks;
2357       struct cleanup *cleanup;
2358       struct symtabs_and_lines intermediate_results;
2359       int i, j;
2360
2361       intermediate_results.sals = NULL;
2362       intermediate_results.nelts = 0;
2363
2364       decode_digits_ordinary (self, val.line, &intermediate_results,
2365                               &best_entry);
2366       if (intermediate_results.nelts == 0 && best_entry != NULL)
2367         decode_digits_ordinary (self, best_entry->line, &intermediate_results,
2368                                 &best_entry);
2369
2370       cleanup = make_cleanup (xfree, intermediate_results.sals);
2371
2372       /* For optimized code, compiler can scatter one source line
2373          accross disjoint ranges of PC values, even when no duplicate
2374          functions or inline functions are involved.  For example,
2375          'for (;;)' inside non-template non-inline non-ctor-or-dtor
2376          function can result in two PC ranges.  In this case, we don't
2377          want to set breakpoint on first PC of each range.  To filter
2378          such cases, we use containing blocks -- for each PC found
2379          above we see if there are other PCs that are in the same
2380          block.  If yes, the other PCs are filtered out.  */
2381
2382       filter = xmalloc (intermediate_results.nelts * sizeof (int));
2383       make_cleanup (xfree, filter);
2384       blocks = xmalloc (intermediate_results.nelts * sizeof (struct block *));
2385       make_cleanup (xfree, blocks);
2386
2387       for (i = 0; i < intermediate_results.nelts; ++i)
2388         {
2389           set_current_program_space (intermediate_results.sals[i].pspace);
2390
2391           filter[i] = 1;
2392           blocks[i] = block_for_pc_sect (intermediate_results.sals[i].pc,
2393                                          intermediate_results.sals[i].section);
2394         }
2395
2396       for (i = 0; i < intermediate_results.nelts; ++i)
2397         {
2398           if (blocks[i] != NULL)
2399             for (j = i + 1; j < intermediate_results.nelts; ++j)
2400               {
2401                 if (blocks[j] == blocks[i])
2402                   {
2403                     filter[j] = 0;
2404                     break;
2405                   }
2406               }
2407         }
2408
2409       for (i = 0; i < intermediate_results.nelts; ++i)
2410         if (filter[i])
2411           {
2412             struct symbol *sym = (blocks[i]
2413                                   ? block_containing_function (blocks[i])
2414                                   : NULL);
2415
2416             if (self->funfirstline)
2417               skip_prologue_sal (&intermediate_results.sals[i]);
2418             /* Make sure the line matches the request, not what was
2419                found.  */
2420             intermediate_results.sals[i].line = val.line;
2421             add_sal_to_sals (self, &values, &intermediate_results.sals[i],
2422                              sym ? SYMBOL_NATURAL_NAME (sym) : NULL);
2423           }
2424
2425       do_cleanups (cleanup);
2426     }
2427
2428   if (values.nelts == 0)
2429     {
2430       if (self->user_filename)
2431         throw_error (NOT_FOUND_ERROR, _("No line %d in file \"%s\"."),
2432                      val.line, self->user_filename);
2433       else
2434         throw_error (NOT_FOUND_ERROR, _("No line %d in the current file."),
2435                      val.line);
2436     }
2437
2438   if (self->canonical)
2439     {
2440       char *copy = savestring (saved_arg, q - saved_arg);
2441
2442       self->canonical->pre_expanded = 1;
2443       gdb_assert (self->user_filename || use_default);
2444       self->canonical->addr_string
2445         = xstrprintf ("%s:%s", (self->user_filename
2446                                 ? self->user_filename
2447                                 : self->default_symtab->filename),
2448                       copy);
2449       xfree (copy);
2450     }
2451
2452   return values;
2453 }
2454
2455 \f
2456
2457 /* Decode a linespec starting with a dollar sign.  */
2458
2459 static struct symtabs_and_lines
2460 decode_dollar (struct linespec_state *self, char *copy)
2461 {
2462   LONGEST valx;
2463   int index = 0;
2464   struct symtabs_and_lines values;
2465   struct symtab_and_line val;
2466   char *p;
2467   struct symbol *sym;
2468   struct minimal_symbol *msymbol;
2469   int ix;
2470   struct symtab *elt;
2471
2472   p = (copy[1] == '$') ? copy + 2 : copy + 1;
2473   while (*p >= '0' && *p <= '9')
2474     p++;
2475   if (!*p)              /* Reached end of token without hitting non-digit.  */
2476     {
2477       /* We have a value history reference.  */
2478       struct value *val_history;
2479
2480       sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index);
2481       val_history = access_value_history ((copy[1] == '$') ? -index : index);
2482       if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
2483         error (_("History values used in line "
2484                  "specs must have integer values."));
2485       valx = value_as_long (val_history);
2486     }
2487   else
2488     {
2489       /* Not all digits -- may be user variable/function or a
2490          convenience variable.  */
2491
2492       volatile struct gdb_exception exc;
2493
2494       /* Avoid "may be used uninitialized" warning.  */
2495       values.sals = NULL;
2496       values.nelts = 0;
2497
2498       TRY_CATCH (exc, RETURN_MASK_ERROR)
2499         {
2500           values = decode_variable (self, copy);
2501         }
2502
2503       if (exc.reason == 0)
2504         return values;
2505
2506       if (exc.error != NOT_FOUND_ERROR)
2507         throw_exception (exc);
2508
2509       /* Not a user variable or function -- must be convenience variable.  */
2510       if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx))
2511         error (_("Convenience variables used in line "
2512                  "specs must have integer values."));
2513     }
2514
2515   init_sal (&val);
2516
2517   values.sals = NULL;
2518   values.nelts = 0;
2519
2520   for (ix = 0; VEC_iterate (symtab_p, self->file_symtabs, ix, elt); ++ix)
2521     {
2522       if (elt == NULL)
2523         {
2524           elt = self->default_symtab;
2525           set_current_program_space (self->program_space);
2526         }
2527       else
2528         set_current_program_space (SYMTAB_PSPACE (elt));
2529
2530       /* Either history value or convenience value from above, in valx.  */
2531       val.symtab = elt;
2532       val.line = valx;
2533       val.pc = 0;
2534       val.pspace = elt ? SYMTAB_PSPACE (elt) : current_program_space;
2535
2536       add_sal_to_sals (self, &values, &val, NULL);
2537     }
2538
2539   if (self->canonical)
2540     {
2541       self->canonical->pre_expanded = 1;
2542       if (self->user_filename)
2543         self->canonical->addr_string = xstrprintf ("%s:%s",
2544                                                    self->user_filename, copy);
2545       else
2546         self->canonical->addr_string = xstrdup (copy);
2547     }
2548
2549   return values;
2550 }
2551
2552 \f
2553
2554 /* A helper for decode_line_1 that tries to find a label.  The label
2555    is searched for in the current block.
2556    FUNCTION_SYMBOLS is a list of the enclosing functions; or NULL if none
2557    specified.
2558    COPY is the name of the label to find.
2559    CANONICAL is the same as the "canonical" argument to decode_line_1.
2560    RESULT is a pointer to a symtabs_and_lines structure which will be
2561    filled in on success.
2562    This function returns 1 if a label was found, 0 otherwise.  */
2563
2564 static int
2565 decode_label (struct linespec_state *self,
2566               VEC (symbolp) *function_symbols, char *copy,
2567               struct symtabs_and_lines *result)
2568 {
2569   struct symbol *fn_sym;
2570   int ix;
2571
2572   if (function_symbols == NULL)
2573     {
2574       struct block *block;
2575       struct symbol *sym;
2576       struct symtab_and_line sal;
2577       struct symtabs_and_lines values;
2578
2579       values.nelts = 0;
2580       values.sals = NULL;
2581
2582       set_current_program_space (self->program_space);
2583       block = get_search_block (NULL);
2584
2585       for (;
2586            block && !BLOCK_FUNCTION (block);
2587            block = BLOCK_SUPERBLOCK (block))
2588         ;
2589       if (!block)
2590         return 0;
2591       fn_sym = BLOCK_FUNCTION (block);
2592
2593       sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2594
2595       if (sym == NULL)
2596         return 0;
2597
2598       symbol_to_sal (&sal, self->funfirstline, sym);
2599       add_sal_to_sals (self, &values, &sal,
2600                        SYMBOL_NATURAL_NAME (fn_sym));
2601
2602       if (self->canonical)
2603         {
2604           self->canonical->special_display = 1;
2605           self->canonical->addr_string
2606             = xstrprintf ("%s:%s", SYMBOL_NATURAL_NAME (fn_sym),
2607                           copy);
2608         }
2609
2610       *result = values;
2611
2612       return 1;
2613     }
2614
2615   result->sals = NULL;
2616   result->nelts = 0;
2617
2618   for (ix = 0; VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix)
2619     {
2620       struct block *block;
2621       struct symbol *sym;
2622
2623       set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym)));
2624       block = SYMBOL_BLOCK_VALUE (fn_sym);
2625       sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2626
2627       if (sym != NULL)
2628         {
2629           struct symtab_and_line sal;
2630           char *symname;
2631
2632           symbol_to_sal (&sal, self->funfirstline, sym);
2633           symname = xstrprintf ("%s:%s",
2634                                 SYMBOL_NATURAL_NAME (fn_sym),
2635                                 SYMBOL_NATURAL_NAME (sym));
2636           add_sal_to_sals (self, result, &sal, symname);
2637           xfree (symname);
2638         }
2639     }
2640
2641   if (self->canonical && result->nelts > 0)
2642     {
2643       self->canonical->pre_expanded = 1;
2644       self->canonical->special_display = 1;
2645
2646       gdb_assert (self->user_function);
2647       self->canonical->addr_string
2648         = xstrprintf ("%s:%s", self->user_function, copy);
2649     }
2650
2651   return result->nelts > 0;
2652 }
2653
2654 /* A callback used to possibly add a symbol to the results.  */
2655
2656 static int
2657 collect_symbols (struct symbol *sym, void *data)
2658 {
2659   struct collect_info *info = data;
2660   struct symtab_and_line sal;
2661
2662   if (symbol_to_sal (&sal, info->state->funfirstline, sym)
2663       && maybe_add_address (info->state->addr_set,
2664                             SYMTAB_PSPACE (SYMBOL_SYMTAB (sym)),
2665                             sal.pc))
2666     add_sal_to_sals (info->state, &info->result, &sal,
2667                      SYMBOL_NATURAL_NAME (sym));
2668
2669   return 1;
2670 }
2671
2672 /* We've found a minimal symbol MSYMBOL to associate with our
2673    linespec; add it to the result symtabs_and_lines.  */
2674
2675 static void
2676 minsym_found (struct linespec_state *self, struct objfile *objfile,
2677               struct minimal_symbol *msymbol,
2678               struct symtabs_and_lines *result)
2679 {
2680   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2681   CORE_ADDR pc;
2682   struct symtab_and_line sal;
2683
2684   sal = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
2685                            (struct obj_section *) 0, 0);
2686   sal.section = SYMBOL_OBJ_SECTION (msymbol);
2687
2688   /* The minimal symbol might point to a function descriptor;
2689      resolve it to the actual code address instead.  */
2690   pc = gdbarch_convert_from_func_ptr_addr (gdbarch, sal.pc, &current_target);
2691   if (pc != sal.pc)
2692     sal = find_pc_sect_line (pc, NULL, 0);
2693
2694   if (self->funfirstline)
2695     skip_prologue_sal (&sal);
2696
2697   if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc))
2698     add_sal_to_sals (self, result, &sal, SYMBOL_NATURAL_NAME (msymbol));
2699 }
2700
2701 /* A helper struct which just holds a minimal symbol and the object
2702    file from which it came.  */
2703
2704 typedef struct minsym_and_objfile
2705 {
2706   struct minimal_symbol *minsym;
2707   struct objfile *objfile;
2708 } minsym_and_objfile_d;
2709
2710 DEF_VEC_O (minsym_and_objfile_d);
2711
2712 /* A helper struct to pass some data through
2713    iterate_over_minimal_symbols.  */
2714
2715 struct collect_minsyms
2716 {
2717   /* The objfile we're examining.  */
2718   struct objfile *objfile;
2719
2720   /* The funfirstline setting from the initial call.  */
2721   int funfirstline;
2722
2723   /* The resulting symbols.  */
2724   VEC (minsym_and_objfile_d) *msyms;
2725 };
2726
2727 /* A helper function to classify a minimal_symbol_type according to
2728    priority.  */
2729
2730 static int
2731 classify_mtype (enum minimal_symbol_type t)
2732 {
2733   switch (t)
2734     {
2735     case mst_file_text:
2736     case mst_file_data:
2737     case mst_file_bss:
2738       /* Intermediate priority.  */
2739       return 1;
2740
2741     case mst_solib_trampoline:
2742       /* Lowest priority.  */
2743       return 2;
2744
2745     default:
2746       /* Highest priority.  */
2747       return 0;
2748     }
2749 }
2750
2751 /* Callback for qsort that sorts symbols by priority.  */
2752
2753 static int
2754 compare_msyms (const void *a, const void *b)
2755 {
2756   const minsym_and_objfile_d *moa = a;
2757   const minsym_and_objfile_d *mob = b;
2758   enum minimal_symbol_type ta = MSYMBOL_TYPE (moa->minsym);
2759   enum minimal_symbol_type tb = MSYMBOL_TYPE (mob->minsym);
2760
2761   return classify_mtype (ta) - classify_mtype (tb);
2762 }
2763
2764 /* Callback for iterate_over_minimal_symbols that adds the symbol to
2765    the result.  */
2766
2767 static void
2768 add_minsym (struct minimal_symbol *minsym, void *d)
2769 {
2770   struct collect_minsyms *info = d;
2771   minsym_and_objfile_d mo;
2772
2773   mo.minsym = minsym;
2774   mo.objfile = info->objfile;
2775   VEC_safe_push (minsym_and_objfile_d, info->msyms, &mo);
2776 }
2777
2778 /* Search minimal symbols in all objfiles for NAME.  If SEARCH_PSPACE
2779    is not NULL, the search is restricted to just that program
2780    space.  */
2781
2782 static void
2783 search_minsyms_for_name (struct collect_info *info, const char *name,
2784                          struct program_space *search_pspace)
2785 {
2786   struct objfile *objfile;
2787   struct program_space *pspace;
2788
2789   ALL_PSPACES (pspace)
2790   {
2791     struct collect_minsyms local;
2792     struct cleanup *cleanup;
2793
2794     if (search_pspace != NULL && search_pspace != pspace)
2795       continue;
2796     if (pspace->executing_startup)
2797       continue;
2798
2799     set_current_program_space (pspace);
2800
2801     memset (&local, 0, sizeof (local));
2802     local.funfirstline = info->state->funfirstline;
2803
2804     cleanup = make_cleanup (VEC_cleanup (minsym_and_objfile_d),
2805                             &local.msyms);
2806
2807     ALL_OBJFILES (objfile)
2808     {
2809       local.objfile = objfile;
2810       iterate_over_minimal_symbols (objfile, name, add_minsym, &local);
2811     }
2812
2813     if (!VEC_empty (minsym_and_objfile_d, local.msyms))
2814       {
2815         int classification;
2816         int ix;
2817         minsym_and_objfile_d *item;
2818
2819         qsort (VEC_address (minsym_and_objfile_d, local.msyms),
2820                VEC_length (minsym_and_objfile_d, local.msyms),
2821                sizeof (minsym_and_objfile_d),
2822                compare_msyms);
2823
2824         /* Now the minsyms are in classification order.  So, we walk
2825            over them and process just the minsyms with the same
2826            classification as the very first minsym in the list.  */
2827         item = VEC_index (minsym_and_objfile_d, local.msyms, 0);
2828         classification = classify_mtype (MSYMBOL_TYPE (item->minsym));
2829
2830         for (ix = 0;
2831              VEC_iterate (minsym_and_objfile_d, local.msyms, ix, item);
2832              ++ix)
2833           {
2834             if (classify_mtype (MSYMBOL_TYPE (item->minsym)) != classification)
2835               break;
2836
2837             minsym_found (info->state, item->objfile, item->minsym,
2838                           &info->result);
2839           }
2840       }
2841
2842     do_cleanups (cleanup);
2843   }
2844 }
2845
2846 /* A helper function to add all symbols matching NAME to INFO.  If
2847    PSPACE is not NULL, the search is restricted to just that program
2848    space.  */
2849
2850 static void
2851 add_matching_symbols_to_info (const char *name,
2852                               struct collect_info *info,
2853                               struct program_space *pspace)
2854 {
2855   int ix;
2856   struct symtab *elt;
2857
2858   for (ix = 0; VEC_iterate (symtab_p, info->state->file_symtabs, ix, elt); ++ix)
2859     {
2860       struct symbol *sym;
2861
2862       if (elt == NULL)
2863         {
2864           iterate_over_all_matching_symtabs (name, VAR_DOMAIN,
2865                                              collect_symbols, info,
2866                                              pspace);
2867           search_minsyms_for_name (info, name, pspace);
2868         }
2869       else if (pspace == NULL || pspace == SYMTAB_PSPACE (elt))
2870         {
2871           /* Program spaces that are executing startup should have
2872              been filtered out earlier.  */
2873           gdb_assert (!SYMTAB_PSPACE (elt)->executing_startup);
2874           set_current_program_space (SYMTAB_PSPACE (elt));
2875           LA_ITERATE_OVER_SYMBOLS (get_search_block (elt), name,
2876                                    VAR_DOMAIN, collect_symbols,
2877                                    info);
2878         }
2879     }
2880 }
2881
2882 /* Decode a linespec that's a variable.  If FILE_SYMTAB is non-NULL,
2883    look in that symtab's static variables first.  */
2884
2885 static struct symtabs_and_lines
2886 decode_variable (struct linespec_state *self, char *copy)
2887 {
2888   struct collect_info info;
2889   const char *lookup_name;
2890   char *canon;
2891   struct cleanup *cleanup;
2892
2893   info.state = self;
2894   info.result.sals = NULL;
2895   info.result.nelts = 0;
2896
2897   cleanup = demangle_for_lookup (copy, current_language->la_language,
2898                                  &lookup_name);
2899   if (current_language->la_language == language_ada)
2900     {
2901       /* In Ada, the symbol lookups are performed using the encoded
2902          name rather than the demangled name.  */
2903       lookup_name = ada_name_for_lookup (copy);
2904       make_cleanup (xfree, (void *) lookup_name);
2905     }
2906
2907   canon = cp_canonicalize_string_no_typedefs (lookup_name);
2908   if (canon != NULL)
2909     {
2910       make_cleanup (xfree, canon);
2911       lookup_name = canon;
2912     }
2913
2914   add_matching_symbols_to_info (lookup_name, &info, NULL);
2915
2916   if (info.result.nelts > 0)
2917     {
2918       if (self->canonical)
2919         {
2920           self->canonical->pre_expanded = 1;
2921           if (self->user_filename)
2922             self->canonical->addr_string
2923               = xstrprintf ("%s:%s", self->user_filename, copy);
2924           else
2925             self->canonical->addr_string = xstrdup (copy);
2926         }
2927       return info.result;
2928     }
2929
2930   if (!have_full_symbols ()
2931       && !have_partial_symbols ()
2932       && !have_minimal_symbols ())
2933     throw_error (NOT_FOUND_ERROR,
2934                  _("No symbol table is loaded.  Use the \"file\" command."));
2935   if (self->user_filename)
2936     throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined in \"%s\"."),
2937                  copy, self->user_filename);
2938   else
2939     throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy);
2940 }
2941
2942
2943 \f
2944
2945 /* Now come some functions that are called from multiple places within
2946    decode_line_1.  */
2947
2948 static int
2949 symbol_to_sal (struct symtab_and_line *result,
2950                int funfirstline, struct symbol *sym)
2951 {
2952   if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2953     {
2954       *result = find_function_start_sal (sym, funfirstline);
2955       return 1;
2956     }
2957   else
2958     {
2959       if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
2960         {
2961           init_sal (result);
2962           result->symtab = SYMBOL_SYMTAB (sym);
2963           result->line = SYMBOL_LINE (sym);
2964           result->pc = SYMBOL_VALUE_ADDRESS (sym);
2965           result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2966           result->explicit_pc = 1;
2967           return 1;
2968         }
2969       else if (funfirstline)
2970         {
2971           /* Nothing.  */
2972         }
2973       else if (SYMBOL_LINE (sym) != 0)
2974         {
2975           /* We know its line number.  */
2976           init_sal (result);
2977           result->symtab = SYMBOL_SYMTAB (sym);
2978           result->line = SYMBOL_LINE (sym);
2979           result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2980           return 1;
2981         }
2982     }
2983
2984   return 0;
2985 }
2986
2987 /* See the comment in linespec.h.  */
2988
2989 void
2990 init_linespec_result (struct linespec_result *lr)
2991 {
2992   memset (lr, 0, sizeof (*lr));
2993 }
2994
2995 /* See the comment in linespec.h.  */
2996
2997 void
2998 destroy_linespec_result (struct linespec_result *ls)
2999 {
3000   int i;
3001   struct linespec_sals *lsal;
3002
3003   xfree (ls->addr_string);
3004   for (i = 0; VEC_iterate (linespec_sals, ls->sals, i, lsal); ++i)
3005     {
3006       xfree (lsal->canonical);
3007       xfree (lsal->sals.sals);
3008     }
3009   VEC_free (linespec_sals, ls->sals);
3010 }
3011
3012 /* Cleanup function for a linespec_result.  */
3013
3014 static void
3015 cleanup_linespec_result (void *a)
3016 {
3017   destroy_linespec_result (a);
3018 }
3019
3020 /* See the comment in linespec.h.  */
3021
3022 struct cleanup *
3023 make_cleanup_destroy_linespec_result (struct linespec_result *ls)
3024 {
3025   return make_cleanup (cleanup_linespec_result, ls);
3026 }