contrib/gdb-7/gdb/linespec.c

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