gdb/linespec.c

   1 /* Parser for linespec for the GNU debugger, GDB.
   2
   3    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   4    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
   5    2009, 2010, 2011 Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "frame.h"
  25 #include "command.h"
  26 #include "symfile.h"
  27 #include "objfiles.h"
  28 #include "source.h"
  29 #include "demangle.h"
  30 #include "value.h"
  31 #include "completer.h"
  32 #include "cp-abi.h"
  33 #include "cp-support.h"
  34 #include "parser-defs.h"
  35 #include "block.h"
  36 #include "objc-lang.h"
  37 #include "linespec.h"
  38 #include "exceptions.h"
  39 #include "language.h"
  40 #include "interps.h"
  41 #include "mi/mi-cmds.h"
  42 #include "target.h"
  43 #include "arch-utils.h"
  44 #include <ctype.h>
  45 #include "cli/cli-utils.h"
  46
  47 /* We share this one with symtab.c, but it is not exported widely.  */
  48
  49 extern char *operator_chars (char *, char **);
  50
  51 /* Prototypes for local functions.  */
  52
  53 static void initialize_defaults (struct symtab **default_symtab,
  54                                  int *default_line);
  55
  56 static struct symtabs_and_lines decode_indirect (char **argptr);
  57
  58 static char *locate_first_half (char **argptr, int *is_quote_enclosed);
  59
  60 static struct symtabs_and_lines decode_objc (char **argptr,
  61                                              int funfirstline,
  62                                              struct symtab *file_symtab,
  63                                              struct linespec_result *canonical,
  64                                              char *saved_arg);
  65
  66 static struct symtabs_and_lines decode_compound (char **argptr,
  67                                                  int funfirstline,
  68                                                  struct linespec_result *canonical,
  69                                                  struct symtab *file_symtab,
  70                                                  char *saved_arg,
  71                                                  char *p);
  72
  73 static struct symbol *lookup_prefix_sym (char **argptr, char *p,
  74                                          struct symtab *);
  75
  76 static struct symtabs_and_lines find_method (int funfirstline,
  77                                              struct linespec_result *canonical,
  78                                              char *saved_arg,
  79                                              char *copy,
  80                                              struct type *t,
  81                                              struct symbol *sym_class,
  82                                              struct symtab *);
  83
  84 static void cplusplus_error (const char *name, const char *fmt, ...)
  85      ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (2, 3);
  86
  87 static int total_number_of_methods (struct type *type);
  88
  89 static int find_methods (struct type *, char *,
  90                          enum language, struct symbol **, struct symtab *);
  91
  92 static int add_matching_methods (int method_counter, struct type *t,
  93                                  enum language language,
  94                                  struct symbol **sym_arr);
  95
  96 static int add_constructors (int method_counter, struct type *t,
  97                              enum language language,
  98                              struct symbol **sym_arr);
  99
 100 static void build_canonical_line_spec (struct symtab_and_line *,
 101                                        char *, struct linespec_result *);
 102
 103 static char *find_toplevel_char (char *s, char c);
 104
 105 static int is_objc_method_format (const char *s);
 106
 107 static struct symtabs_and_lines decode_line_2 (struct symbol *[],
 108                                                int, int,
 109                                                struct linespec_result *);
 110
 111 static struct symtab *symtab_from_filename (char **argptr,
 112                                             char *p, int is_quote_enclosed);
 113
 114 static struct symbol *find_function_symbol (char **argptr, char *p,
 115                                             int is_quote_enclosed);
 116
 117 static struct
 118 symtabs_and_lines decode_all_digits (char **argptr,
 119                                      struct symtab *default_symtab,
 120                                      int default_line,
 121                                      struct linespec_result *canonical,
 122                                      struct symtab *file_symtab,
 123                                      char *q);
 124
 125 static struct symtabs_and_lines decode_dollar (char *copy,
 126                                                int funfirstline,
 127                                                struct symtab *default_symtab,
 128                                                struct linespec_result *canonical,
 129                                                struct symtab *file_symtab);
 130
 131 static int decode_label (struct symbol *function_symbol,
 132                          char *copy, struct linespec_result *canonical,
 133                          struct symtabs_and_lines *result);
 134
 135 static struct symtabs_and_lines decode_variable (char *copy,
 136                                                  int funfirstline,
 137                                                  struct linespec_result *canonical,
 138                                                  struct symtab *file_symtab);
 139
 140 static struct
 141 symtabs_and_lines symbol_found (int funfirstline,
 142                                 struct linespec_result *canonical,
 143                                 char *copy,
 144                                 struct symbol *sym,
 145                                 struct symtab *file_symtab,
 146                                 struct symbol *function_symbol);
 147
 148 static struct
 149 symtabs_and_lines minsym_found (int funfirstline,
 150                                 struct minimal_symbol *msymbol);
 151
 152 /* Helper functions.  */
 153
 154 /* Issue a helpful hint on using the command completion feature on
 155    single quoted demangled C++ symbols as part of the completion
 156    error.  */
 157
 158 static void
 159 cplusplus_error (const char *name, const char *fmt, ...)
 160 {
 161   struct ui_file *tmp_stream;
 162   char *message;
 163
 164   tmp_stream = mem_fileopen ();
 165   make_cleanup_ui_file_delete (tmp_stream);
 166
 167   {
 168     va_list args;
 169
 170     va_start (args, fmt);
 171     vfprintf_unfiltered (tmp_stream, fmt, args);
 172     va_end (args);
 173   }
 174
 175   while (*name == '\'')
 176     name++;
 177   fprintf_unfiltered (tmp_stream,
 178                       ("Hint: try '%s<TAB> or '%s<ESC-?>\n"
 179                        "(Note leading single quote.)"),
 180                       name, name);
 181
 182   message = ui_file_xstrdup (tmp_stream, NULL);
 183   make_cleanup (xfree, message);
 184   throw_error (NOT_FOUND_ERROR, "%s", message);
 185 }
 186
 187 /* Return the number of methods described for TYPE, including the
 188    methods from types it derives from.  This can't be done in the symbol
 189    reader because the type of the baseclass might still be stubbed
 190    when the definition of the derived class is parsed.  */
 191
 192 static int
 193 total_number_of_methods (struct type *type)
 194 {
 195   int n;
 196   int count;
 197
 198   CHECK_TYPEDEF (type);
 199   if (! HAVE_CPLUS_STRUCT (type))
 200     return 0;
 201   count = TYPE_NFN_FIELDS_TOTAL (type);
 202
 203   for (n = 0; n < TYPE_N_BASECLASSES (type); n++)
 204     count += total_number_of_methods (TYPE_BASECLASS (type, n));
 205
 206   return count;
 207 }
 208
 209 /* Returns the block to be used for symbol searches for the given SYMTAB,
 210    which may be NULL.  */
 211
 212 static struct block *
 213 get_search_block (struct symtab *symtab)
 214 {
 215   struct block *block;
 216
 217   if (symtab != NULL)
 218     block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
 219   else
 220     {
 221       enum language save_language;
 222
 223       /* get_selected_block can change the current language when there is
 224          no selected frame yet.  */
 225       save_language = current_language->la_language;
 226       block = get_selected_block (0);
 227       set_language (save_language);
 228     }
 229
 230   return block;
 231 }
 232
 233 /* Recursive helper function for decode_line_1.
 234    Look for methods named NAME in type T.
 235    Return number of matches.
 236    Put matches in SYM_ARR, which should have been allocated with
 237    a size of total_number_of_methods (T) * sizeof (struct symbol *).
 238    Note that this function is g++ specific.  */
 239
 240 static int
 241 find_methods (struct type *t, char *name, enum language language,
 242               struct symbol **sym_arr, struct symtab *file_symtab)
 243 {
 244   int i1 = 0;
 245   int ibase;
 246   char *class_name = type_name_no_tag (t);
 247   struct cleanup *cleanup;
 248   char *canon;
 249
 250   /* NAME is typed by the user: it needs to be canonicalized before
 251      passing to lookup_symbol.  */
 252   canon = cp_canonicalize_string (name);
 253   if (canon != NULL)
 254     {
 255       name = canon;
 256       cleanup = make_cleanup (xfree, name);
 257     }
 258   else
 259     cleanup = make_cleanup (null_cleanup, NULL);
 260
 261   /* Ignore this class if it doesn't have a name.  This is ugly, but
 262      unless we figure out how to get the physname without the name of
 263      the class, then the loop can't do any good.  */
 264   if (class_name
 265       && (lookup_symbol_in_language (class_name, get_search_block (file_symtab),
 266                          STRUCT_DOMAIN, language, (int *) NULL)))
 267     {
 268       int method_counter;
 269       int name_len = strlen (name);
 270
 271       CHECK_TYPEDEF (t);
 272
 273       /* Loop over each method name.  At this level, all overloads of a name
 274          are counted as a single name.  There is an inner loop which loops over
 275          each overload.  */
 276
 277       for (method_counter = TYPE_NFN_FIELDS (t) - 1;
 278            method_counter >= 0;
 279            --method_counter)
 280         {
 281           char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
 282           char dem_opname[64];
 283
 284           if (strncmp (method_name, "__", 2) == 0 ||
 285               strncmp (method_name, "op", 2) == 0 ||
 286               strncmp (method_name, "type", 4) == 0)
 287             {
 288               if (cplus_demangle_opname (method_name, dem_opname, DMGL_ANSI))
 289                 method_name = dem_opname;
 290               else if (cplus_demangle_opname (method_name, dem_opname, 0))
 291                 method_name = dem_opname;
 292             }
 293
 294           if (strcmp_iw (name, method_name) == 0)
 295             /* Find all the overloaded methods with that name.  */
 296             i1 += add_matching_methods (method_counter, t, language,
 297                                         sym_arr + i1);
 298           else if (strncmp (class_name, name, name_len) == 0
 299                    && (class_name[name_len] == '\0'
 300                        || class_name[name_len] == '<'))
 301             i1 += add_constructors (method_counter, t, language,
 302                                     sym_arr + i1);
 303         }
 304     }
 305
 306   /* Only search baseclasses if there is no match yet, since names in
 307      derived classes override those in baseclasses.
 308
 309      FIXME: The above is not true; it is only true of member functions
 310      if they have the same number of arguments (??? - section 13.1 of the
 311      ARM says the function members are not in the same scope but doesn't
 312      really spell out the rules in a way I understand.  In any case, if
 313      the number of arguments differ this is a case in which we can overload
 314      rather than hiding without any problem, and gcc 2.4.5 does overload
 315      rather than hiding in this case).  */
 316
 317   if (i1 == 0)
 318     for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
 319       i1 += find_methods (TYPE_BASECLASS (t, ibase), name,
 320                           language, sym_arr + i1, file_symtab);
 321
 322   do_cleanups (cleanup);
 323   return i1;
 324 }
 325
 326 /* Add the symbols associated to methods of the class whose type is T
 327    and whose name matches the method indexed by METHOD_COUNTER in the
 328    array SYM_ARR.  Return the number of methods added.  */
 329
 330 static int
 331 add_matching_methods (int method_counter, struct type *t,
 332                       enum language language, struct symbol **sym_arr)
 333 {
 334   int field_counter;
 335   int i1 = 0;
 336
 337   for (field_counter = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1;
 338        field_counter >= 0;
 339        --field_counter)
 340     {
 341       struct fn_field *f;
 342       const char *phys_name;
 343
 344       f = TYPE_FN_FIELDLIST1 (t, method_counter);
 345
 346       if (TYPE_FN_FIELD_STUB (f, field_counter))
 347         {
 348           char *tmp_name, *tmp2;
 349
 350           tmp_name = gdb_mangle_name (t,
 351                                       method_counter,
 352                                       field_counter);
 353           tmp2 = alloca (strlen (tmp_name) + 1);
 354           strcpy (tmp2, tmp_name);
 355           xfree (tmp_name);
 356           phys_name = tmp2;
 357         }
 358       else
 359         phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
 360
 361       sym_arr[i1] = lookup_symbol_in_language (phys_name,
 362                                    NULL, VAR_DOMAIN,
 363                                    language,
 364                                    (int *) NULL);
 365       if (sym_arr[i1])
 366         i1++;
 367       else
 368         {
 369           /* This error message gets printed, but the method
 370              still seems to be found.
 371              fputs_filtered("(Cannot find method ", gdb_stdout);
 372              fprintf_symbol_filtered (gdb_stdout, phys_name,
 373                                       language_cplus,
 374                                       DMGL_PARAMS | DMGL_ANSI);
 375              fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
 376           */
 377         }
 378     }
 379
 380   return i1;
 381 }
 382
 383 /* Add the symbols associated to constructors of the class whose type
 384    is CLASS_TYPE and which are indexed by by METHOD_COUNTER to the
 385    array SYM_ARR.  Return the number of methods added.  */
 386
 387 static int
 388 add_constructors (int method_counter, struct type *t,
 389                   enum language language, struct symbol **sym_arr)
 390 {
 391   int field_counter;
 392   int i1 = 0;
 393
 394   /* For GCC 3.x and stabs, constructors and destructors
 395      have names like __base_ctor and __complete_dtor.
 396      Check the physname for now if we're looking for a
 397      constructor.  */
 398   for (field_counter
 399          = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1;
 400        field_counter >= 0;
 401        --field_counter)
 402     {
 403       struct fn_field *f;
 404       const char *phys_name;
 405
 406       f = TYPE_FN_FIELDLIST1 (t, method_counter);
 407
 408       /* GCC 3.x will never produce stabs stub methods, so
 409          we don't need to handle this case.  */
 410       if (TYPE_FN_FIELD_STUB (f, field_counter))
 411         continue;
 412       phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
 413       if (! is_constructor_name (phys_name))
 414         continue;
 415
 416       /* If this method is actually defined, include it in the
 417          list.  */
 418       sym_arr[i1] = lookup_symbol_in_language (phys_name,
 419                                    NULL, VAR_DOMAIN,
 420                                    language,
 421                                    (int *) NULL);
 422       if (sym_arr[i1])
 423         i1++;
 424     }
 425
 426   return i1;
 427 }
 428
 429 /* Helper function for decode_line_1.
 430    Build a canonical line spec in CANONICAL if it is non-NULL and if
 431    the SAL has a symtab.
 432    If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
 433    If SYMNAME is NULL the line number from SAL is used and the canonical
 434    line spec is `filename:linenum'.  */
 435
 436 static void
 437 build_canonical_line_spec (struct symtab_and_line *sal, char *symname,
 438                            struct linespec_result *canonical)
 439 {
 440   char **canonical_arr;
 441   char *canonical_name;
 442   char *filename;
 443   struct symtab *s = sal->symtab;
 444
 445   if (s == (struct symtab *) NULL
 446       || s->filename == (char *) NULL
 447       || canonical == NULL)
 448     return;
 449
 450   canonical_arr = (char **) xmalloc (sizeof (char *));
 451   canonical->canonical = canonical_arr;
 452
 453   filename = s->filename;
 454   if (symname != NULL)
 455     {
 456       canonical_name = xmalloc (strlen (filename) + strlen (symname) + 2);
 457       sprintf (canonical_name, "%s:%s", filename, symname);
 458     }
 459   else
 460     {
 461       canonical_name = xmalloc (strlen (filename) + 30);
 462       sprintf (canonical_name, "%s:%d", filename, sal->line);
 463     }
 464   canonical_arr[0] = canonical_name;
 465 }
 466
 467
 468
 469 /* Find an instance of the character C in the string S that is outside
 470    of all parenthesis pairs, single-quoted strings, and double-quoted
 471    strings.  Also, ignore the char within a template name, like a ','
 472    within foo<int, int>.  */
 473
 474 static char *
 475 find_toplevel_char (char *s, char c)
 476 {
 477   int quoted = 0;               /* zero if we're not in quotes;
 478                                    '"' if we're in a double-quoted string;
 479                                    '\'' if we're in a single-quoted string.  */
 480   int depth = 0;                /* Number of unclosed parens we've seen.  */
 481   char *scan;
 482
 483   for (scan = s; *scan; scan++)
 484     {
 485       if (quoted)
 486         {
 487           if (*scan == quoted)
 488             quoted = 0;
 489           else if (*scan == '\\' && *(scan + 1))
 490             scan++;
 491         }
 492       else if (*scan == c && ! quoted && depth == 0)
 493         return scan;
 494       else if (*scan == '"' || *scan == '\'')
 495         quoted = *scan;
 496       else if (*scan == '(' || *scan == '<')
 497         depth++;
 498       else if ((*scan == ')' || *scan == '>') && depth > 0)
 499         depth--;
 500     }
 501
 502   return 0;
 503 }
 504
 505 /* Determines if the gives string corresponds to an Objective-C method
 506    representation, such as -[Foo bar:] or +[Foo bar].  Objective-C symbols
 507    are allowed to have spaces and parentheses in them.  */
 508
 509 static int
 510 is_objc_method_format (const char *s)
 511 {
 512   if (s == NULL || *s == '\0')
 513     return 0;
 514   /* Handle arguments with the format FILENAME:SYMBOL.  */
 515   if ((s[0] == ':') && (strchr ("+-", s[1]) != NULL)
 516       && (s[2] == '[') && strchr(s, ']'))
 517     return 1;
 518   /* Handle arguments that are just SYMBOL.  */
 519   else if ((strchr ("+-", s[0]) != NULL) && (s[1] == '[') && strchr(s, ']'))
 520     return 1;
 521   return 0;
 522 }
 523
 524 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
 525    operate on (ask user if necessary).
 526    If CANONICAL is non-NULL return a corresponding array of mangled names
 527    as canonical line specs there.  */
 528
 529 static struct symtabs_and_lines
 530 decode_line_2 (struct symbol *sym_arr[], int nelts, int funfirstline,
 531                struct linespec_result *canonical)
 532 {
 533   struct symtabs_and_lines values, return_values;
 534   char *args, *arg1;
 535   int i;
 536   char *prompt;
 537   char *symname;
 538   struct cleanup *old_chain;
 539   char **canonical_arr = (char **) NULL;
 540   const char *select_mode = multiple_symbols_select_mode ();
 541
 542   if (select_mode == multiple_symbols_cancel)
 543     error (_("canceled because the command is ambiguous\n"
 544              "See set/show multiple-symbol."));
 545
 546   values.sals = (struct symtab_and_line *)
 547     alloca (nelts * sizeof (struct symtab_and_line));
 548   return_values.sals = (struct symtab_and_line *)
 549     xmalloc (nelts * sizeof (struct symtab_and_line));
 550   old_chain = make_cleanup (xfree, return_values.sals);
 551
 552   if (canonical)
 553     {
 554       canonical_arr = (char **) xmalloc (nelts * sizeof (char *));
 555       make_cleanup (xfree, canonical_arr);
 556       memset (canonical_arr, 0, nelts * sizeof (char *));
 557       canonical->canonical = canonical_arr;
 558     }
 559
 560   i = 0;
 561   while (i < nelts)
 562     {
 563       init_sal (&return_values.sals[i]);        /* Initialize to zeroes.  */
 564       init_sal (&values.sals[i]);
 565       if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
 566         values.sals[i] = find_function_start_sal (sym_arr[i], funfirstline);
 567       i++;
 568     }
 569
 570   /* If select_mode is "all", then do not print the multiple-choice
 571      menu and act as if the user had chosen choice "1" (all).  */
 572   if (select_mode == multiple_symbols_all
 573       || ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
 574     args = "1";
 575   else
 576     {
 577       i = 0;
 578       printf_unfiltered (_("[0] cancel\n[1] all\n"));
 579       while (i < nelts)
 580         {
 581           if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
 582             {
 583               if (values.sals[i].symtab)
 584                 printf_unfiltered ("[%d] %s at %s:%d\n",
 585                                    (i + 2),
 586                                    SYMBOL_PRINT_NAME (sym_arr[i]),
 587                                    values.sals[i].symtab->filename,
 588                                    values.sals[i].line);
 589               else
 590                 printf_unfiltered (_("[%d] %s at ?FILE:%d [No symtab? "
 591                                      "Probably broken debug info...]\n"),
 592                                    (i + 2),
 593                                    SYMBOL_PRINT_NAME (sym_arr[i]),
 594                                    values.sals[i].line);
 595
 596             }
 597           else
 598             printf_unfiltered (_("?HERE\n"));
 599           i++;
 600         }
 601
 602       prompt = getenv ("PS2");
 603       if (prompt == NULL)
 604         {
 605           prompt = "> ";
 606         }
 607       args = command_line_input (prompt, 0, "overload-choice");
 608     }
 609
 610   if (args == 0 || *args == 0)
 611     error_no_arg (_("one or more choice numbers"));
 612
 613   i = 0;
 614   while (*args)
 615     {
 616       int num;
 617
 618       arg1 = args;
 619       while (*arg1 >= '0' && *arg1 <= '9')
 620         arg1++;
 621       if (*arg1 && *arg1 != ' ' && *arg1 != '\t')
 622         error (_("Arguments must be choice numbers."));
 623
 624       num = atoi (args);
 625
 626       if (num == 0)
 627         error (_("canceled"));
 628       else if (num == 1)
 629         {
 630           if (canonical_arr)
 631             {
 632               for (i = 0; i < nelts; i++)
 633                 {
 634                   if (canonical_arr[i] == NULL)
 635                     {
 636                       symname = SYMBOL_LINKAGE_NAME (sym_arr[i]);
 637                       canonical_arr[i] = xstrdup (symname);
 638                     }
 639                 }
 640             }
 641           memcpy (return_values.sals, values.sals,
 642                   (nelts * sizeof (struct symtab_and_line)));
 643           return_values.nelts = nelts;
 644           discard_cleanups (old_chain);
 645           return return_values;
 646         }
 647
 648       if (num >= nelts + 2)
 649         {
 650           printf_unfiltered (_("No choice number %d.\n"), num);
 651         }
 652       else
 653         {
 654           num -= 2;
 655           if (values.sals[num].pc)
 656             {
 657               if (canonical_arr)
 658                 {
 659                   symname = SYMBOL_LINKAGE_NAME (sym_arr[num]);
 660                   make_cleanup (xfree, symname);
 661                   canonical_arr[i] = xstrdup (symname);
 662                 }
 663               return_values.sals[i++] = values.sals[num];
 664               values.sals[num].pc = 0;
 665             }
 666           else
 667             {
 668               printf_unfiltered (_("duplicate request for %d ignored.\n"),
 669                                  num);
 670             }
 671         }
 672
 673       args = arg1;
 674       while (*args == ' ' || *args == '\t')
 675         args++;
 676     }
 677   return_values.nelts = i;
 678   discard_cleanups (old_chain);
 679   return return_values;
 680 }
 681
 682 /* Valid delimiters for linespec keywords "if", "thread" or "task".  */
 683
 684 static int
 685 is_linespec_boundary (char c)
 686 {
 687   return c == ' ' || c == '\t' || c == '\0' || c == ',';
 688 }
 689
 690 /* A helper function for decode_line_1 and friends which skips P
 691    past any method overload information at the beginning of P, e.g.,
 692    "(const struct foo *)".
 693
 694    This function assumes that P has already been validated to contain
 695    overload information, and it will assert if *P != '('.  */
 696 static char *
 697 find_method_overload_end (char *p)
 698 {
 699   int depth = 0;
 700
 701   gdb_assert (*p == '(');
 702
 703   while (*p)
 704     {
 705       if (*p == '(')
 706         ++depth;
 707       else if (*p == ')')
 708         {
 709           if (--depth == 0)
 710             {
 711               ++p;
 712               break;
 713             }
 714         }
 715       ++p;
 716     }
 717
 718   return p;
 719 }
 720
 721 /* Keep important information used when looking up a name.  This includes
 722    template parameters, overload information, and important keywords, including
 723    the possible Java trailing type.  */
 724
 725 static char *
 726 keep_name_info (char *p, int on_boundary)
 727 {
 728   const char *quotes = get_gdb_completer_quote_characters ();
 729   char *saved_p = p;
 730   int nest = 0;
 731
 732   while (*p)
 733     {
 734       if (strchr (quotes, *p))
 735         break;
 736
 737       if (*p == ',' && !nest)
 738         break;
 739
 740       if (on_boundary && !nest)
 741         {
 742           const char *const words[] = { "if", "thread", "task" };
 743           int wordi;
 744
 745           for (wordi = 0; wordi < ARRAY_SIZE (words); wordi++)
 746             if (strncmp (p, words[wordi], strlen (words[wordi])) == 0
 747                 && is_linespec_boundary (p[strlen (words[wordi])]))
 748               break;
 749           if (wordi < ARRAY_SIZE (words))
 750             break;
 751         }
 752
 753       if (*p == '(' || *p == '<' || *p == '[')
 754         nest++;
 755       else if ((*p == ')' || *p == '>' || *p == ']') && nest > 0)
 756         nest--;
 757
 758       p++;
 759
 760       /* The ',' check could fail on "operator ,".  */
 761       p += cp_validate_operator (p);
 762
 763       on_boundary = is_linespec_boundary (p[-1]);
 764     }
 765
 766   while (p > saved_p && is_linespec_boundary (p[-1]))
 767     p--;
 768
 769   return p;
 770 }
 771
 772 \f
 773 /* The parser of linespec itself.  */
 774
 775 /* Parse a string that specifies a line number.
 776    Pass the address of a char * variable; that variable will be
 777    advanced over the characters actually parsed.
 778
 779    The string can be:
 780
 781    LINENUM -- that line number in current file.  PC returned is 0.
 782    FILE:LINENUM -- that line in that file.  PC returned is 0.
 783    FUNCTION -- line number of openbrace of that function.
 784    PC returned is the start of the function.
 785    LABEL -- a label in the current scope
 786    VARIABLE -- line number of definition of that variable.
 787    PC returned is 0.
 788    FILE:FUNCTION -- likewise, but prefer functions in that file.
 789    *EXPR -- line in which address EXPR appears.
 790
 791    This may all be followed by an "if EXPR", which we ignore.
 792
 793    FUNCTION may be an undebuggable function found in minimal symbol table.
 794
 795    If the argument FUNFIRSTLINE is nonzero, we want the first line
 796    of real code inside a function when a function is specified, and it is
 797    not OK to specify a variable or type to get its line number.
 798
 799    DEFAULT_SYMTAB specifies the file to use if none is specified.
 800    It defaults to current_source_symtab.
 801    DEFAULT_LINE specifies the line number to use for relative
 802    line numbers (that start with signs).  Defaults to current_source_line.
 803    If CANONICAL is non-NULL, store an array of strings containing the canonical
 804    line specs there if necessary.  Currently overloaded member functions and
 805    line numbers or static functions without a filename yield a canonical
 806    line spec.  The array and the line spec strings are allocated on the heap,
 807    it is the callers responsibility to free them.
 808
 809    Note that it is possible to return zero for the symtab
 810    if no file is validly specified.  Callers must check that.
 811    Also, the line number returned may be invalid.  */
 812
 813 /* We allow single quotes in various places.  This is a hideous
 814    kludge, which exists because the completer can't yet deal with the
 815    lack of single quotes.  FIXME: write a linespec_completer which we
 816    can use as appropriate instead of make_symbol_completion_list.  */
 817
 818 struct symtabs_and_lines
 819 decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab,
 820                int default_line, struct linespec_result *canonical)
 821 {
 822   char *p;
 823   char *q;
 824   /* If a file name is specified, this is its symtab.  */
 825   struct symtab *file_symtab = NULL;
 826
 827   char *copy;
 828   /* This says whether or not something in *ARGPTR is quoted with
 829      completer_quotes (i.e. with single quotes).  */
 830   int is_quoted;
 831   /* Is *ARGPTR is enclosed in double quotes?  */
 832   int is_quote_enclosed;
 833   int is_objc_method = 0;
 834   char *saved_arg = *argptr;
 835   /* If IS_QUOTED, the end of the quoted bit.  */
 836   char *end_quote = NULL;
 837   /* Is *ARGPTR enclosed in single quotes?  */
 838   int is_squote_enclosed = 0;
 839   /* The "first half" of the linespec.  */
 840   char *first_half;
 841
 842   /* If we are parsing `function:label', this holds the symbol for the
 843      function.  */
 844   struct symbol *function_symbol = NULL;
 845   /* If FUNCTION_SYMBOL is not NULL, then this is the exception that
 846      was thrown when trying to parse a filename.  */
 847   volatile struct gdb_exception file_exception;
 848
 849   /* Defaults have defaults.  */
 850
 851   initialize_defaults (&default_symtab, &default_line);
 852
 853   /* See if arg is *PC.  */
 854
 855   if (**argptr == '*')
 856     return decode_indirect (argptr);
 857
 858   is_quoted = (strchr (get_gdb_completer_quote_characters (),
 859                        **argptr) != NULL);
 860
 861   if (is_quoted)
 862     {
 863       end_quote = skip_quoted (*argptr);
 864       if (*end_quote == '\0')
 865         is_squote_enclosed = 1;
 866     }
 867
 868   /* Check to see if it's a multipart linespec (with colons or
 869      periods).  */
 870
 871   /* Locate the end of the first half of the linespec.
 872      After the call, for instance, if the argptr string is "foo.c:123"
 873      p will point at "123".  If there is only one part, like "foo", p
 874      will point to "".  If this is a C++ name, like "A::B::foo", p will
 875      point to "::B::foo".  Argptr is not changed by this call.  */
 876
 877   first_half = p = locate_first_half (argptr, &is_quote_enclosed);
 878
 879   /* First things first: if ARGPTR starts with a filename, get its
 880      symtab and strip the filename from ARGPTR.  */
 881   TRY_CATCH (file_exception, RETURN_MASK_ERROR)
 882     {
 883       file_symtab = symtab_from_filename (argptr, p, is_quote_enclosed);
 884     }
 885
 886   if (file_exception.reason >= 0)
 887     {
 888       /* Check for single quotes on the non-filename part.  */
 889       is_quoted = (**argptr
 890                    && strchr (get_gdb_completer_quote_characters (),
 891                               **argptr) != NULL);
 892       if (is_quoted)
 893         end_quote = skip_quoted (*argptr);
 894
 895       /* Locate the next "half" of the linespec.  */
 896       first_half = p = locate_first_half (argptr, &is_quote_enclosed);
 897     }
 898
 899   /* Check if this is an Objective-C method (anything that starts with
 900      a '+' or '-' and a '[').  */
 901   if (is_objc_method_format (p))
 902     is_objc_method = 1;
 903
 904   /* Check if the symbol could be an Objective-C selector.  */
 905
 906   {
 907     struct symtabs_and_lines values;
 908
 909     values = decode_objc (argptr, funfirstline, file_symtab,
 910                           canonical, saved_arg);
 911     if (values.sals != NULL)
 912       return values;
 913   }
 914
 915   /* Does it look like there actually were two parts?  */
 916
 917   if (p[0] == ':' || p[0] == '.')
 918     {
 919       /* Is it a C++ or Java compound data structure?
 920          The check on p[1] == ':' is capturing the case of "::",
 921          since p[0]==':' was checked above.
 922          Note that the call to decode_compound does everything
 923          for us, including the lookup on the symbol table, so we
 924          can return now.  */
 925
 926       if (p[0] == '.' || p[1] == ':')
 927         {
 928           struct symtabs_and_lines values;
 929           volatile struct gdb_exception ex;
 930           char *saved_argptr = *argptr;
 931
 932           if (is_quote_enclosed)
 933             ++saved_arg;
 934
 935           TRY_CATCH (ex, RETURN_MASK_ERROR)
 936             {
 937               values = decode_compound (argptr, funfirstline, canonical,
 938                                         file_symtab, saved_arg, p);
 939             }
 940           if ((is_quoted || is_squote_enclosed) && **argptr == '\'')
 941             *argptr = *argptr + 1;
 942
 943           if (ex.reason >= 0)
 944             return values;
 945
 946           if (ex.error != NOT_FOUND_ERROR)
 947             throw_exception (ex);
 948
 949           *argptr = saved_argptr;
 950         }
 951       else
 952         {
 953           /* If there was an exception looking up a specified filename earlier,
 954              then check whether we were really given `function:label'.   */
 955           if (file_exception.reason < 0)
 956             {
 957               function_symbol = find_function_symbol (argptr, p,
 958                                                       is_quote_enclosed);
 959               /* If we did not find a function, re-throw the original
 960                  exception.  */
 961               if (!function_symbol)
 962                 throw_exception (file_exception);
 963             }
 964
 965           /* Check for single quotes on the non-filename part.  */
 966           if (!is_quoted)
 967             {
 968               is_quoted = (**argptr
 969                            && strchr (get_gdb_completer_quote_characters (),
 970                                       **argptr) != NULL);
 971               if (is_quoted)
 972                 end_quote = skip_quoted (*argptr);
 973             }
 974         }
 975     }
 976
 977   /* file_symtab is specified file's symtab, or 0 if no file specified.
 978      If we are parsing `function:symbol', then FUNCTION_SYMBOL is the
 979      function before the `:'.
 980      arg no longer contains the file name.  */
 981
 982   /* If the filename was quoted, we must re-check the quotation.  */
 983
 984   if (end_quote == first_half && *end_quote!= '\0')
 985     {
 986       is_quoted = (**argptr
 987                    && strchr (get_gdb_completer_quote_characters (),
 988                               **argptr) != NULL);
 989       if (is_quoted)
 990         end_quote = skip_quoted (*argptr);
 991     }
 992
 993   /* Check whether arg is all digits (and sign).  */
 994
 995   q = *argptr;
 996   if (*q == '-' || *q == '+')
 997     q++;
 998   while (*q >= '0' && *q <= '9')
 999     q++;
1000
1001   if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ',')
1002       && function_symbol == NULL)
1003     /* We found a token consisting of all digits -- at least one digit.  */
1004     return decode_all_digits (argptr, default_symtab, default_line,
1005                               canonical, file_symtab, q);
1006
1007   /* Arg token is not digits => try it as a variable name
1008      Find the next token (everything up to end or next whitespace).  */
1009
1010   if (**argptr == '$')          /* May be a convenience variable.  */
1011     /* One or two $ chars possible.  */
1012     p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1));
1013   else if (is_quoted || is_squote_enclosed)
1014     {
1015       p = end_quote;
1016       if (p[-1] != '\'')
1017         error (_("Unmatched single quote."));
1018     }
1019   else if (is_objc_method)
1020     {
1021       /* allow word separators in method names for Obj-C.  */
1022       p = skip_quoted_chars (*argptr, NULL, "");
1023     }
1024   else
1025     {
1026       p = skip_quoted (*argptr);
1027     }
1028
1029   /* Keep any important naming information.  */
1030   p = keep_name_info (p, p == saved_arg || is_linespec_boundary (p[-1]));
1031
1032   copy = (char *) alloca (p - *argptr + 1);
1033   memcpy (copy, *argptr, p - *argptr);
1034   copy[p - *argptr] = '\0';
1035   if (p != *argptr
1036       && copy[0]
1037       && copy[0] == copy[p - *argptr - 1]
1038       && strchr (get_gdb_completer_quote_characters (), copy[0]) != NULL)
1039     {
1040       copy[p - *argptr - 1] = '\0';
1041       copy++;
1042     }
1043   else if (is_quoted || is_squote_enclosed)
1044     copy[p - *argptr - 1] = '\0';
1045   while (*p == ' ' || *p == '\t')
1046     p++;
1047   *argptr = p;
1048
1049   /* If it starts with $: may be a legitimate variable or routine name
1050      (e.g. HP-UX millicode routines such as $$dyncall), or it may
1051      be history value, or it may be a convenience variable.  */
1052
1053   if (*copy == '$' && function_symbol == NULL)
1054     return decode_dollar (copy, funfirstline, default_symtab,
1055                           canonical, file_symtab);
1056
1057   /* Try the token as a label, but only if no file was specified,
1058      because we can only really find labels in the current scope.  */
1059
1060   if (!file_symtab)
1061     {
1062       struct symtabs_and_lines label_result;
1063       if (decode_label (function_symbol, copy, canonical, &label_result))
1064         return label_result;
1065     }
1066
1067   if (function_symbol)
1068     throw_exception (file_exception);
1069
1070   /* Look up that token as a variable.
1071      If file specified, use that file's per-file block to start with.  */
1072
1073   return decode_variable (copy, funfirstline, canonical, file_symtab);
1074 }
1075
1076 \f
1077
1078 /* Now, more helper functions for decode_line_1.  Some conventions
1079    that these functions follow:
1080
1081    Decode_line_1 typically passes along some of its arguments or local
1082    variables to the subfunctions.  It passes the variables by
1083    reference if they are modified by the subfunction, and by value
1084    otherwise.
1085
1086    Some of the functions have side effects that don't arise from
1087    variables that are passed by reference.  In particular, if a
1088    function is passed ARGPTR as an argument, it modifies what ARGPTR
1089    points to; typically, it advances *ARGPTR past whatever substring
1090    it has just looked at.  (If it doesn't modify *ARGPTR, then the
1091    function gets passed *ARGPTR instead, which is then called ARG.)
1092    Also, functions that return a struct symtabs_and_lines may modify
1093    CANONICAL, as in the description of decode_line_1.
1094
1095    If a function returns a struct symtabs_and_lines, then that struct
1096    will immediately make its way up the call chain to be returned by
1097    decode_line_1.  In particular, all of the functions decode_XXX
1098    calculate the appropriate struct symtabs_and_lines, under the
1099    assumption that their argument is of the form XXX.  */
1100
1101 /* First, some functions to initialize stuff at the beggining of the
1102    function.  */
1103
1104 static void
1105 initialize_defaults (struct symtab **default_symtab, int *default_line)
1106 {
1107   if (*default_symtab == 0)
1108     {
1109       /* Use whatever we have for the default source line.  We don't use
1110          get_current_or_default_symtab_and_line as it can recurse and call
1111          us back!  */
1112       struct symtab_and_line cursal =
1113         get_current_source_symtab_and_line ();
1114
1115       *default_symtab = cursal.symtab;
1116       *default_line = cursal.line;
1117     }
1118 }
1119
1120 \f
1121
1122 /* Decode arg of the form *PC.  */
1123
1124 static struct symtabs_and_lines
1125 decode_indirect (char **argptr)
1126 {
1127   struct symtabs_and_lines values;
1128   CORE_ADDR pc;
1129
1130   (*argptr)++;
1131   pc = value_as_address (parse_to_comma_and_eval (argptr));
1132
1133   values.sals = (struct symtab_and_line *)
1134     xmalloc (sizeof (struct symtab_and_line));
1135
1136   values.nelts = 1;
1137   values.sals[0] = find_pc_line (pc, 0);
1138   values.sals[0].pc = pc;
1139   values.sals[0].section = find_pc_overlay (pc);
1140   values.sals[0].explicit_pc = 1;
1141
1142   return values;
1143 }
1144
1145 \f
1146
1147 /* Locate the first half of the linespec, ending in a colon, period,
1148    or whitespace.  (More or less.)  Also, check to see if *ARGPTR is
1149    enclosed in double quotes; if so, set is_quote_enclosed, advance
1150    ARGPTR past that and zero out the trailing double quote.
1151    If ARGPTR is just a simple name like "main", p will point to ""
1152    at the end.  */
1153
1154 static char *
1155 locate_first_half (char **argptr, int *is_quote_enclosed)
1156 {
1157   char *ii;
1158   char *p, *p1;
1159   int has_comma;
1160
1161   /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1162      and we must isolate the first half.  Outer layers will call again later
1163      for the second half.
1164
1165      Don't count commas that appear in argument lists of overloaded
1166      functions, or in quoted strings.  It's stupid to go to this much
1167      trouble when the rest of the function is such an obvious roach hotel.  */
1168   ii = find_toplevel_char (*argptr, ',');
1169   has_comma = (ii != 0);
1170
1171   /* Temporarily zap out second half to not confuse the code below.
1172      This is undone below.  Do not change ii!!  */
1173   if (has_comma)
1174     {
1175       *ii = '\0';
1176     }
1177
1178   /* Maybe arg is FILE : LINENUM or FILE : FUNCTION.  May also be
1179      CLASS::MEMBER, or NAMESPACE::NAME.  Look for ':', but ignore
1180      inside of <>.  */
1181
1182   p = *argptr;
1183   if (p[0] == '"')
1184     {
1185       *is_quote_enclosed = 1;
1186       (*argptr)++;
1187       p++;
1188     }
1189   else
1190     {
1191       *is_quote_enclosed = 0;
1192       if (strchr (get_gdb_completer_quote_characters (), *p))
1193         {
1194           ++(*argptr);
1195           ++p;
1196         }
1197     }
1198   for (; *p; p++)
1199     {
1200       if (p[0] == '<')
1201         {
1202           char *temp_end = find_template_name_end (p);
1203
1204           if (!temp_end)
1205             error (_("malformed template specification in command"));
1206           p = temp_end;
1207         }
1208
1209       if (p[0] == '(')
1210         p = find_method_overload_end (p);
1211
1212       /* Check for a colon and a plus or minus and a [ (which
1213          indicates an Objective-C method).  */
1214       if (is_objc_method_format (p))
1215         {
1216           break;
1217         }
1218       /* Check for the end of the first half of the linespec.  End of
1219          line, a tab, a colon or a space.  But if enclosed in double
1220          quotes we do not break on enclosed spaces.  */
1221       if (!*p
1222           || p[0] == '\t'
1223           || (p[0] == ':')
1224           || ((p[0] == ' ') && !*is_quote_enclosed))
1225         break;
1226       if (p[0] == '.' && strchr (p, ':') == NULL)
1227         {
1228           /* Java qualified method.  Find the *last* '.', since the
1229              others are package qualifiers.  Stop at any open parenthesis
1230              which might provide overload information.  */
1231           for (p1 = p; *p1 && *p1 != '('; p1++)
1232             {
1233               if (*p1 == '.')
1234                 p = p1;
1235             }
1236           break;
1237         }
1238     }
1239   while (p[0] == ' ' || p[0] == '\t')
1240     p++;
1241
1242   /* If the closing double quote was left at the end, remove it.  */
1243   if (*is_quote_enclosed)
1244     {
1245       char *closing_quote = strchr (p - 1, '"');
1246
1247       if (closing_quote && closing_quote[1] == '\0')
1248         *closing_quote = '\0';
1249     }
1250
1251   /* Now that we've safely parsed the first half, put back ',' so
1252      outer layers can see it.  */
1253   if (has_comma)
1254     *ii = ',';
1255
1256   return p;
1257 }
1258
1259 \f
1260
1261 /* Here's where we recognise an Objective-C Selector.  An Objective C
1262    selector may be implemented by more than one class, therefore it
1263    may represent more than one method/function.  This gives us a
1264    situation somewhat analogous to C++ overloading.  If there's more
1265    than one method that could represent the selector, then use some of
1266    the existing C++ code to let the user choose one.  */
1267
1268 struct symtabs_and_lines
1269 decode_objc (char **argptr, int funfirstline, struct symtab *file_symtab,
1270              struct linespec_result *canonical, char *saved_arg)
1271 {
1272   struct symtabs_and_lines values;
1273   struct symbol **sym_arr = NULL;
1274   struct symbol *sym = NULL;
1275   struct block *block = NULL;
1276   unsigned i1 = 0;
1277   unsigned i2 = 0;
1278
1279   values.sals = NULL;
1280   values.nelts = 0;
1281
1282   find_imps (file_symtab, get_search_block (file_symtab), *argptr,
1283              NULL, &i1, &i2);
1284
1285   if (i1 > 0)
1286     {
1287       sym_arr = (struct symbol **)
1288         alloca ((i1 + 1) * sizeof (struct symbol *));
1289       sym_arr[i1] = NULL;
1290
1291       *argptr = find_imps (file_symtab, block, *argptr, sym_arr, &i1, &i2);
1292     }
1293
1294   /* i1 now represents the TOTAL number of matches found.
1295      i2 represents how many HIGH-LEVEL (struct symbol) matches,
1296      which will come first in the sym_arr array.  Any low-level
1297      (minimal_symbol) matches will follow those.  */
1298
1299   if (i1 == 1)
1300     {
1301       if (i2 > 0)
1302         {
1303           /* Already a struct symbol.  */
1304           sym = sym_arr[0];
1305         }
1306       else
1307         {
1308           sym = find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr[0]));
1309           if ((sym != NULL) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr[0]),
1310                                        SYMBOL_LINKAGE_NAME (sym)) != 0)
1311             {
1312               warning (_("debugging symbol \"%s\" does "
1313                          "not match selector; ignoring"),
1314                        SYMBOL_LINKAGE_NAME (sym));
1315               sym = NULL;
1316             }
1317         }
1318
1319       values.sals = (struct symtab_and_line *)
1320         xmalloc (sizeof (struct symtab_and_line));
1321       values.nelts = 1;
1322
1323       if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1324         {
1325           /* Canonicalize this, so it remains resolved for dylib loads.  */
1326           values.sals[0] = find_function_start_sal (sym, funfirstline);
1327           build_canonical_line_spec (values.sals,
1328                                      SYMBOL_NATURAL_NAME (sym), canonical);
1329         }
1330       else
1331         {
1332           /* The only match was a non-debuggable symbol, which might point
1333              to a function descriptor; resolve it to the actual code address
1334              instead.  */
1335           struct minimal_symbol *msymbol = (struct minimal_symbol *)sym_arr[0];
1336           struct objfile *objfile = msymbol_objfile (msymbol);
1337           struct gdbarch *gdbarch = get_objfile_arch (objfile);
1338           CORE_ADDR pc = SYMBOL_VALUE_ADDRESS (msymbol);
1339
1340           pc = gdbarch_convert_from_func_ptr_addr (gdbarch, pc,
1341                                                    &current_target);
1342
1343           init_sal (&values.sals[0]);
1344           values.sals[0].pc = pc;
1345         }
1346       return values;
1347     }
1348
1349   if (i1 > 1)
1350     {
1351       /* More than one match.  The user must choose one or more.  */
1352       return decode_line_2 (sym_arr, i2, funfirstline, canonical);
1353     }
1354
1355   return values;
1356 }
1357
1358 /* This handles C++ and Java compound data structures.  P should point
1359    at the first component separator, i.e. double-colon or period.  As
1360    an example, on entrance to this function we could have ARGPTR
1361    pointing to "AAA::inA::fun" and P pointing to "::inA::fun".  */
1362
1363 static struct symtabs_and_lines
1364 decode_compound (char **argptr, int funfirstline,
1365                  struct linespec_result *canonical, struct symtab *file_symtab,
1366                  char *the_real_saved_arg, char *p)
1367 {
1368   struct symtabs_and_lines values;
1369   char *p2;
1370   char *saved_arg2 = *argptr;
1371   char *temp_end;
1372   struct symbol *sym;
1373   char *copy;
1374   struct symbol *sym_class;
1375   struct type *t;
1376   char *saved_arg;
1377
1378   /* If the user specified any completer quote characters in the input,
1379      strip them.  They are superfluous.  */
1380   saved_arg = alloca (strlen (the_real_saved_arg) + 1);
1381   {
1382     char *dst = saved_arg;
1383     char *src = the_real_saved_arg;
1384     char *quotes = get_gdb_completer_quote_characters ();
1385     while (*src != '\0')
1386       {
1387         if (strchr (quotes, *src) == NULL)
1388           *dst++ = *src;
1389         ++src;
1390       }
1391     *dst = '\0';
1392   }
1393
1394   /* First check for "global" namespace specification, of the form
1395      "::foo".  If found, skip over the colons and jump to normal
1396      symbol processing.  I.e. the whole line specification starts with
1397      "::" (note the condition that *argptr == p).  */
1398   if (p[0] == ':'
1399       && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
1400     saved_arg2 += 2;
1401
1402   /* Given our example "AAA::inA::fun", we have two cases to consider:
1403
1404      1) AAA::inA is the name of a class.  In that case, presumably it
1405         has a method called "fun"; we then look up that method using
1406         find_method.
1407
1408      2) AAA::inA isn't the name of a class.  In that case, either the
1409         user made a typo, AAA::inA is the name of a namespace, or it is
1410         the name of a minimal symbol.
1411         We just look up AAA::inA::fun with lookup_symbol.  If that fails,
1412         try lookup_minimal_symbol.
1413
1414      Thus, our first task is to find everything before the last set of
1415      double-colons and figure out if it's the name of a class.  So we
1416      first loop through all of the double-colons.  */
1417
1418   p2 = p;               /* Save for restart.  */
1419
1420   /* This is very messy.  Following the example above we have now the
1421      following pointers:
1422      p -> "::inA::fun"
1423      argptr -> "AAA::inA::fun
1424      saved_arg -> "AAA::inA::fun
1425      saved_arg2 -> "AAA::inA::fun
1426      p2 -> "::inA::fun".  */
1427
1428   /* In the loop below, with these strings, we'll make 2 passes, each
1429      is marked in comments.  */
1430
1431   while (1)
1432     {
1433       static char *break_characters = " \t(";
1434
1435       /* Move pointer up to next possible class/namespace token.  */
1436
1437       p = p2 + 1;       /* Restart with old value +1.  */
1438
1439       /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1440          i.e. if there is a double-colon, p will now point to the
1441          second colon.  */
1442       /* PASS2: p2->"::fun", p->":fun" */
1443
1444       /* Move pointer ahead to next double-colon.  */
1445       while (*p
1446              && strchr (break_characters, *p) == NULL
1447              && strchr (get_gdb_completer_quote_characters (), *p) == NULL)
1448         {
1449           if (current_language->la_language == language_cplus)
1450             p += cp_validate_operator (p);
1451
1452           if (p[0] == '<')
1453             {
1454               temp_end = find_template_name_end (p);
1455               if (!temp_end)
1456                 error (_("malformed template specification in command"));
1457               p = temp_end;
1458             }
1459           /* Note that, since, at the start of this loop, p would be
1460              pointing to the second colon in a double-colon, we only
1461              satisfy the condition below if there is another
1462              double-colon to the right (after).  I.e. there is another
1463              component that can be a class or a namespace.  I.e, if at
1464              the beginning of this loop (PASS1), we had
1465              p->":inA::fun", we'll trigger this when p has been
1466              advanced to point to "::fun".  */
1467           /* PASS2: we will not trigger this.  */
1468           else if ((p[0] == ':') && (p[1] == ':'))
1469             break;      /* Found double-colon.  */
1470           else
1471             {
1472               /* PASS2: We'll keep getting here, until P points to one of the
1473                  break characters, at which point we exit this loop.  */
1474               if (*p)
1475                 {
1476                   if (p[1] == '('
1477                       && strncmp (&p[1], CP_ANONYMOUS_NAMESPACE_STR,
1478                                   CP_ANONYMOUS_NAMESPACE_LEN) == 0)
1479                     p += CP_ANONYMOUS_NAMESPACE_LEN;
1480                   else if (strchr (break_characters, *p) == NULL)
1481                     ++p;
1482                 }
1483             }
1484         }
1485
1486       if (*p != ':')
1487         break;          /* Out of the while (1).  This would happen
1488                            for instance if we have looked up
1489                            unsuccessfully all the components of the
1490                            string, and p->""(PASS2).  */
1491
1492       /* We get here if p points to one of the break characters or "" (i.e.,
1493          string ended).  */
1494       /* Save restart for next time around.  */
1495       p2 = p;
1496       /* Restore argptr as it was on entry to this function.  */
1497       *argptr = saved_arg2;
1498       /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1499          p2->"::fun".  */
1500
1501       /* All ready for next pass through the loop.  */
1502     }                   /* while (1) */
1503
1504
1505   /* Start of lookup in the symbol tables.  */
1506
1507   /* Lookup in the symbol table the substring between argptr and
1508      p.  Note, this call changes the value of argptr.  */
1509   /* Before the call, argptr->"AAA::inA::fun",
1510      p->"", p2->"::fun".  After the call: argptr->"fun", p, p2
1511      unchanged.  */
1512   sym_class = lookup_prefix_sym (argptr, p2, file_symtab);
1513
1514   /* If sym_class has been found, and if "AAA::inA" is a class, then
1515      we're in case 1 above.  So we look up "fun" as a method of that
1516      class.  */
1517   if (sym_class &&
1518       (t = check_typedef (SYMBOL_TYPE (sym_class)),
1519        (TYPE_CODE (t) == TYPE_CODE_STRUCT
1520         || TYPE_CODE (t) == TYPE_CODE_UNION)))
1521     {
1522       /* Arg token is not digits => try it as a function name.
1523          Find the next token (everything up to end or next
1524          blank).  */
1525       if (**argptr
1526           && strchr (get_gdb_completer_quote_characters (),
1527                      **argptr) != NULL)
1528         {
1529           p = skip_quoted (*argptr);
1530           *argptr = *argptr + 1;
1531         }
1532       else
1533         {
1534           /* At this point argptr->"fun".  */
1535           char *a;
1536
1537           p = *argptr;
1538           while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':'
1539                  && *p != '(')
1540             p++;
1541           /* At this point p->"".  String ended.  */
1542           /* Nope, C++ operators could have spaces in them
1543              ("foo::operator <" or "foo::operator delete []").
1544              I apologize, this is a bit hacky...  */
1545           if (current_language->la_language == language_cplus
1546               && *p == ' ' && p - 8 - *argptr + 1 > 0)
1547             {
1548               /* The above loop has already swallowed "operator".  */
1549               p += cp_validate_operator (p - 8) - 8;
1550             }
1551
1552           /* Keep any important naming information.  */
1553           p = keep_name_info (p, 1);
1554         }
1555
1556       /* Allocate our own copy of the substring between argptr and
1557          p.  */
1558       copy = (char *) alloca (p - *argptr + 1);
1559       memcpy (copy, *argptr, p - *argptr);
1560       copy[p - *argptr] = '\0';
1561       if (p != *argptr
1562           && copy[p - *argptr - 1]
1563           && strchr (get_gdb_completer_quote_characters (),
1564                      copy[p - *argptr - 1]) != NULL)
1565         copy[p - *argptr - 1] = '\0';
1566
1567       /* At this point copy->"fun", p->"".  */
1568
1569       /* No line number may be specified.  */
1570       while (*p == ' ' || *p == '\t')
1571         p++;
1572       *argptr = p;
1573       /* At this point arptr->"".  */
1574
1575       /* Look for copy as a method of sym_class.  */
1576       /* At this point copy->"fun", sym_class is "AAA:inA",
1577          saved_arg->"AAA::inA::fun".  This concludes the scanning of
1578          the string for possible components matches.  If we find it
1579          here, we return.  If not, and we are at the and of the string,
1580          we'll lookup the whole string in the symbol tables.  */
1581
1582       return find_method (funfirstline, canonical, saved_arg, copy, t,
1583                           sym_class, file_symtab);
1584     } /* End if symbol found.  */
1585
1586
1587   /* We couldn't find a class, so we're in case 2 above.  We check the
1588      entire name as a symbol instead.  */
1589
1590   p = keep_name_info (p, 1);
1591
1592   copy = (char *) alloca (p - saved_arg2 + 1);
1593   memcpy (copy, saved_arg2, p - saved_arg2);
1594   /* Note: if is_quoted should be true, we snuff out quote here
1595      anyway.  */
1596   copy[p - saved_arg2] = '\000';
1597   /* Set argptr to skip over the name.  */
1598   *argptr = (*p == '\'') ? p + 1 : p;
1599
1600   /* Look up entire name.  */
1601   sym = lookup_symbol (copy, get_selected_block (0), VAR_DOMAIN, 0);
1602   if (sym)
1603     return symbol_found (funfirstline, canonical, copy, sym, NULL, NULL);
1604   else
1605     {
1606       struct minimal_symbol *msym;
1607
1608       /* Couldn't find any interpretation as classes/namespaces.  As a last
1609          resort, try the minimal symbol tables.  */
1610       msym = lookup_minimal_symbol (copy, NULL, NULL);
1611       if (msym != NULL)
1612         return minsym_found (funfirstline, msym);
1613     }
1614
1615   /* Couldn't find a minimal symbol, either, so give up.  */
1616   cplusplus_error (the_real_saved_arg,
1617                    "Can't find member of namespace, "
1618                    "class, struct, or union named \"%s\"\n",
1619                    copy);
1620 }
1621
1622 /* Next come some helper functions for decode_compound.  */
1623
1624 /* Return the symbol corresponding to the substring of *ARGPTR ending
1625    at P, allowing whitespace.  Also, advance *ARGPTR past the symbol
1626    name in question, the compound object separator ("::" or "."), and
1627    whitespace.  Note that *ARGPTR is changed whether or not the
1628    lookup_symbol call finds anything (i.e we return NULL).  As an
1629    example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun".  */
1630
1631 static struct symbol *
1632 lookup_prefix_sym (char **argptr, char *p, struct symtab *file_symtab)
1633 {
1634   char *p1;
1635   char *copy;
1636   struct symbol *sym;
1637
1638   /* Extract the class name.  */
1639   p1 = p;
1640   while (p != *argptr && p[-1] == ' ')
1641     --p;
1642   copy = (char *) alloca (p - *argptr + 1);
1643   memcpy (copy, *argptr, p - *argptr);
1644   copy[p - *argptr] = 0;
1645
1646   /* Discard the class name from the argptr.  */
1647   p = p1 + (p1[0] == ':' ? 2 : 1);
1648   while (*p == ' ' || *p == '\t')
1649     p++;
1650   *argptr = p;
1651
1652   /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1653      argptr->"inA::fun".  */
1654
1655   sym = lookup_symbol (copy, get_search_block (file_symtab), STRUCT_DOMAIN, 0);
1656   if (sym == NULL)
1657     {
1658       /* Typedefs are in VAR_DOMAIN so the above symbol lookup will
1659          fail when the user attempts to lookup a method of a class
1660          via a typedef'd name (NOT via the class's name, which is already
1661          handled in symbol_matches_domain).  So try the lookup again
1662          using VAR_DOMAIN (where typedefs live) and double-check that we
1663          found a struct/class type.  */
1664       struct symbol *s = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
1665
1666       if (s != NULL)
1667         {
1668           struct type *t = SYMBOL_TYPE (s);
1669
1670           CHECK_TYPEDEF (t);
1671           if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
1672             return s;
1673         }
1674     }
1675
1676   return sym;
1677 }
1678
1679 /* This finds the method COPY in the class whose type is T and whose
1680    symbol is SYM_CLASS.  */
1681
1682 static struct symtabs_and_lines
1683 find_method (int funfirstline, struct linespec_result *canonical,
1684              char *saved_arg,
1685              char *copy, struct type *t, struct symbol *sym_class,
1686              struct symtab *file_symtab)
1687 {
1688   struct symtabs_and_lines values;
1689   struct symbol *sym = NULL;
1690   int i1;       /*  Counter for the symbol array.  */
1691   struct symbol **sym_arr =  alloca (total_number_of_methods (t)
1692                                      * sizeof (struct symbol *));
1693
1694   /* Find all methods with a matching name, and put them in
1695      sym_arr.  */
1696
1697   i1 = find_methods (t, copy, SYMBOL_LANGUAGE (sym_class), sym_arr,
1698                      file_symtab);
1699
1700   /* If we were given a specific overload instance in COPY, defer the field
1701      acceptance till the strcmp_iw verification below, even if we found just
1702      a single field with that name.  */
1703   if (i1 == 1 && strchr (copy, '(') == NULL)
1704     {
1705       /* There is exactly one field with that name.  */
1706       sym = sym_arr[0];
1707
1708       if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1709         {
1710           values.sals = (struct symtab_and_line *)
1711             xmalloc (sizeof (struct symtab_and_line));
1712           values.nelts = 1;
1713           values.sals[0] = find_function_start_sal (sym,
1714                                                     funfirstline);
1715         }
1716       else
1717         {
1718           values.sals = NULL;
1719           values.nelts = 0;
1720         }
1721       return values;
1722     }
1723   if (i1 > 0)
1724     {
1725       /* If we were given a specific overload instance, use that
1726          (or error if no matches were found).  Otherwise ask the user
1727          which one to use.  */
1728       if (strchr (copy, '('))
1729         {
1730           int i;
1731           char *name;
1732           char *canon;
1733           struct cleanup *cleanup;
1734
1735           /* Construct the proper search name based on SYM_CLASS and COPY.
1736              SAVED_ARG may contain a valid name, but that name might not be
1737              what is actually stored in the symbol table.  For example,
1738              if SAVED_ARG (and SYM_CLASS) were found via an import
1739              ("using namespace" in C++), then the physname of
1740              SYM_CLASS ("A::myclass") may not be the same as SAVED_ARG
1741              ("myclass").  */
1742           name = xmalloc (strlen (SYMBOL_NATURAL_NAME (sym_class))
1743                           + 2 /* "::" */ + strlen (copy) + 1);
1744           strcpy (name, SYMBOL_NATURAL_NAME (sym_class));
1745           strcat (name, "::");
1746           strcat (name, copy);
1747           canon = cp_canonicalize_string (name);
1748           if (canon != NULL)
1749             {
1750               xfree (name);
1751               name = canon;
1752             }
1753           cleanup = make_cleanup (xfree, name);
1754
1755           for (i = 0; i < i1; ++i)
1756             {
1757               if (strcmp_iw (name, SYMBOL_LINKAGE_NAME (sym_arr[i])) == 0)
1758                 {
1759                   values.sals = (struct symtab_and_line *)
1760                     xmalloc (sizeof (struct symtab_and_line));
1761                   values.nelts = 1;
1762                   values.sals[0] = find_function_start_sal (sym_arr[i],
1763                                                             funfirstline);
1764                   do_cleanups (cleanup);
1765                   return values;
1766                 }
1767             }
1768
1769           cplusplus_error (saved_arg, _("the class `%s' does not have "
1770                                         "any method instance named %s"),
1771                                       SYMBOL_PRINT_NAME (sym_class), copy);
1772         }
1773
1774       return decode_line_2 (sym_arr, i1, funfirstline, canonical);
1775     }
1776   else
1777     {
1778       if (copy[0] == '~')
1779         cplusplus_error (saved_arg,
1780                          "the class `%s' does not have destructor defined\n",
1781                          SYMBOL_PRINT_NAME (sym_class));
1782       else
1783         cplusplus_error (saved_arg,
1784                          "the class %s does not have any method named %s\n",
1785                          SYMBOL_PRINT_NAME (sym_class), copy);
1786     }
1787 }
1788
1789 \f
1790
1791 /* Return the symtab associated to the filename given by the substring
1792    of *ARGPTR ending at P, and advance ARGPTR past that filename.  */
1793
1794 static struct symtab *
1795 symtab_from_filename (char **argptr, char *p, int is_quote_enclosed)
1796 {
1797   char *p1;
1798   char *copy;
1799   struct symtab *file_symtab;
1800
1801   p1 = p;
1802   while (p != *argptr && p[-1] == ' ')
1803     --p;
1804   if ((*p == '"') && is_quote_enclosed)
1805     --p;
1806   copy = (char *) alloca (p - *argptr + 1);
1807   memcpy (copy, *argptr, p - *argptr);
1808   /* It may have the ending quote right after the file name.  */
1809   if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
1810       || copy[p - *argptr - 1] == '\'')
1811     copy[p - *argptr - 1] = 0;
1812   else
1813     copy[p - *argptr] = 0;
1814
1815   /* Find that file's data.  */
1816   file_symtab = lookup_symtab (copy);
1817   if (file_symtab == 0)
1818     {
1819       if (!have_full_symbols () && !have_partial_symbols ())
1820         throw_error (NOT_FOUND_ERROR,
1821                      _("No symbol table is loaded.  "
1822                        "Use the \"file\" command."));
1823       throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy);
1824     }
1825
1826   /* Discard the file name from the arg.  */
1827   p = p1 + 1;
1828   while (*p == ' ' || *p == '\t')
1829     p++;
1830   *argptr = p;
1831
1832   return file_symtab;
1833 }
1834
1835 /* Look up a function symbol in *ARGPTR.  If found, advance *ARGPTR
1836    and return the symbol.  If not found, return NULL.  */
1837
1838 static struct symbol *
1839 find_function_symbol (char **argptr, char *p, int is_quote_enclosed)
1840 {
1841   char *p1;
1842   char *copy;
1843   struct symbol *function_symbol;
1844
1845   p1 = p;
1846   while (p != *argptr && p[-1] == ' ')
1847     --p;
1848   if ((*p == '"') && is_quote_enclosed)
1849     --p;
1850   copy = (char *) alloca (p - *argptr + 1);
1851   memcpy (copy, *argptr, p - *argptr);
1852   /* It may have the ending quote right after the file name.  */
1853   if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
1854       || copy[p - *argptr - 1] == '\'')
1855     copy[p - *argptr - 1] = 0;
1856   else
1857     copy[p - *argptr] = 0;
1858
1859   function_symbol = lookup_symbol (copy, get_selected_block (0),
1860                                    VAR_DOMAIN, 0);
1861   if (!function_symbol || SYMBOL_CLASS (function_symbol) != LOC_BLOCK)
1862     return NULL;
1863
1864   /* Discard the file name from the arg.  */
1865   p = p1 + 1;
1866   while (*p == ' ' || *p == '\t')
1867     p++;
1868   *argptr = p;
1869
1870   return function_symbol;
1871 }
1872
1873 \f
1874
1875 /* This decodes a line where the argument is all digits (possibly
1876    preceded by a sign).  Q should point to the end of those digits;
1877    the other arguments are as usual.  */
1878
1879 static struct symtabs_and_lines
1880 decode_all_digits (char **argptr, struct symtab *default_symtab,
1881                    int default_line, struct linespec_result *canonical,
1882                    struct symtab *file_symtab, char *q)
1883
1884 {
1885   struct symtabs_and_lines values;
1886   struct symtab_and_line val;
1887
1888   enum sign
1889     {
1890       none, plus, minus
1891     }
1892   sign = none;
1893
1894   /* We might need a canonical line spec if no file was specified.  */
1895   int need_canonical = (file_symtab == NULL) ? 1 : 0;
1896
1897   init_sal (&val);
1898
1899   val.pspace = current_program_space;
1900
1901   /* This is where we need to make sure that we have good defaults.
1902      We must guarantee that this section of code is never executed
1903      when we are called with just a function name, since
1904      set_default_source_symtab_and_line uses
1905      select_source_symtab that calls us with such an argument.  */
1906
1907   if (file_symtab == 0 && default_symtab == 0)
1908     {
1909       /* Make sure we have at least a default source file.  */
1910       set_default_source_symtab_and_line ();
1911       initialize_defaults (&default_symtab, &default_line);
1912     }
1913
1914   if (**argptr == '+')
1915     sign = plus, (*argptr)++;
1916   else if (**argptr == '-')
1917     sign = minus, (*argptr)++;
1918   val.line = atoi (*argptr);
1919   switch (sign)
1920     {
1921     case plus:
1922       if (q == *argptr)
1923         val.line = 5;
1924       if (file_symtab == 0)
1925         val.line = default_line + val.line;
1926       break;
1927     case minus:
1928       if (q == *argptr)
1929         val.line = 15;
1930       if (file_symtab == 0)
1931         val.line = default_line - val.line;
1932       else
1933         val.line = 1;
1934       break;
1935     case none:
1936       break;            /* No need to adjust val.line.  */
1937     }
1938
1939   while (*q == ' ' || *q == '\t')
1940     q++;
1941   *argptr = q;
1942   if (file_symtab == 0)
1943     file_symtab = default_symtab;
1944
1945   /* It is possible that this source file has more than one symtab,
1946      and that the new line number specification has moved us from the
1947      default (in file_symtab) to a new one.  */
1948   val.symtab = find_line_symtab (file_symtab, val.line, NULL, NULL);
1949   if (val.symtab == 0)
1950     val.symtab = file_symtab;
1951
1952   val.pspace = SYMTAB_PSPACE (val.symtab);
1953   val.pc = 0;
1954   values.sals = (struct symtab_and_line *)
1955     xmalloc (sizeof (struct symtab_and_line));
1956   values.sals[0] = val;
1957   values.nelts = 1;
1958   if (need_canonical)
1959     build_canonical_line_spec (values.sals, NULL, canonical);
1960   values.sals[0].explicit_line = 1;
1961   return values;
1962 }
1963
1964 \f
1965
1966 /* Decode a linespec starting with a dollar sign.  */
1967
1968 static struct symtabs_and_lines
1969 decode_dollar (char *copy, int funfirstline, struct symtab *default_symtab,
1970                struct linespec_result *canonical, struct symtab *file_symtab)
1971 {
1972   LONGEST valx;
1973   int index = 0;
1974   int need_canonical = 0;
1975   struct symtabs_and_lines values;
1976   struct symtab_and_line val;
1977   char *p;
1978   struct symbol *sym;
1979   struct minimal_symbol *msymbol;
1980
1981   p = (copy[1] == '$') ? copy + 2 : copy + 1;
1982   while (*p >= '0' && *p <= '9')
1983     p++;
1984   if (!*p)              /* Reached end of token without hitting non-digit.  */
1985     {
1986       /* We have a value history reference.  */
1987       struct value *val_history;
1988
1989       sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index);
1990       val_history = access_value_history ((copy[1] == '$') ? -index : index);
1991       if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
1992         error (_("History values used in line "
1993                  "specs must have integer values."));
1994       valx = value_as_long (val_history);
1995     }
1996   else
1997     {
1998       /* Not all digits -- may be user variable/function or a
1999          convenience variable.  */
2000
2001       /* Look up entire name as a symbol first.  */
2002       sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
2003       file_symtab = (struct symtab *) NULL;
2004       need_canonical = 1;
2005       /* Symbol was found --> jump to normal symbol processing.  */
2006       if (sym)
2007         return symbol_found (funfirstline, canonical, copy, sym, NULL, NULL);
2008
2009       /* If symbol was not found, look in minimal symbol tables.  */
2010       msymbol = lookup_minimal_symbol (copy, NULL, NULL);
2011       /* Min symbol was found --> jump to minsym processing.  */
2012       if (msymbol)
2013         return minsym_found (funfirstline, msymbol);
2014
2015       /* Not a user variable or function -- must be convenience variable.  */
2016       if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx))
2017         error (_("Convenience variables used in line "
2018                  "specs must have integer values."));
2019     }
2020
2021   init_sal (&val);
2022
2023   /* Either history value or convenience value from above, in valx.  */
2024   val.symtab = file_symtab ? file_symtab : default_symtab;
2025   val.line = valx;
2026   val.pc = 0;
2027   val.pspace = current_program_space;
2028
2029   values.sals = (struct symtab_and_line *) xmalloc (sizeof val);
2030   values.sals[0] = val;
2031   values.nelts = 1;
2032
2033   if (need_canonical)
2034     build_canonical_line_spec (values.sals, NULL, canonical);
2035
2036   return values;
2037 }
2038
2039 \f
2040
2041 /* A helper for decode_line_1 that tries to find a label.  The label
2042    is searched for in the current block.
2043    FUNCTION_SYMBOL is the enclosing function; or NULL if none
2044    specified.
2045    COPY is the name of the label to find.
2046    CANONICAL is the same as the "canonical" argument to decode_line_1.
2047    RESULT is a pointer to a symtabs_and_lines structure which will be
2048    filled in on success.
2049    This function returns 1 if a label was found, 0 otherwise.  */
2050
2051 static int
2052 decode_label (struct symbol *function_symbol, char *copy,
2053               struct linespec_result *canonical,
2054               struct symtabs_and_lines *result)
2055 {
2056   struct symbol *sym;
2057   struct block *block;
2058
2059   if (function_symbol)
2060     block = SYMBOL_BLOCK_VALUE (function_symbol);
2061   else
2062     {
2063       block = get_selected_block (0);
2064       for (;
2065            block && !BLOCK_FUNCTION (block);
2066            block = BLOCK_SUPERBLOCK (block))
2067         ;
2068       if (!block)
2069         return 0;
2070       function_symbol = BLOCK_FUNCTION (block);
2071     }
2072
2073   sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2074
2075   if (sym != NULL)
2076     *result = symbol_found (0, canonical, copy, sym, NULL, function_symbol);
2077
2078   return sym != NULL;
2079 }
2080
2081 /* Decode a linespec that's a variable.  If FILE_SYMTAB is non-NULL,
2082    look in that symtab's static variables first.  */
2083
2084 static struct symtabs_and_lines
2085 decode_variable (char *copy, int funfirstline,
2086                  struct linespec_result *canonical,
2087                  struct symtab *file_symtab)
2088 {
2089   struct symbol *sym;
2090   struct minimal_symbol *msymbol;
2091
2092   sym = lookup_symbol (copy, get_search_block (file_symtab),
2093                        VAR_DOMAIN, 0);
2094
2095   if (sym != NULL)
2096     return symbol_found (funfirstline, canonical, copy, sym, file_symtab, NULL);
2097
2098   msymbol = lookup_minimal_symbol (copy, NULL, NULL);
2099
2100   if (msymbol != NULL)
2101     return minsym_found (funfirstline, msymbol);
2102
2103   if (!have_full_symbols ()
2104       && !have_partial_symbols ()
2105       && !have_minimal_symbols ())
2106     throw_error (NOT_FOUND_ERROR,
2107                  _("No symbol table is loaded.  Use the \"file\" command."));
2108   throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy);
2109 }
2110
2111
2112 \f
2113
2114 /* Now come some functions that are called from multiple places within
2115    decode_line_1.  */
2116
2117 /* We've found a symbol SYM to associate with our linespec; build a
2118    corresponding struct symtabs_and_lines.  */
2119
2120 static struct symtabs_and_lines
2121 symbol_found (int funfirstline, struct linespec_result *canonical, char *copy,
2122               struct symbol *sym, struct symtab *file_symtab,
2123               struct symbol *function_symbol)
2124 {
2125   struct symtabs_and_lines values;
2126
2127   if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2128     {
2129       /* Arg is the name of a function.  */
2130       values.sals = (struct symtab_and_line *)
2131         xmalloc (sizeof (struct symtab_and_line));
2132       values.sals[0] = find_function_start_sal (sym, funfirstline);
2133       values.nelts = 1;
2134
2135       /* Don't use the SYMBOL_LINE; if used at all it points to
2136          the line containing the parameters or thereabouts, not
2137          the first line of code.  */
2138
2139       /* We might need a canonical line spec if it is a static
2140          function.  */
2141       if (file_symtab == 0)
2142         {
2143           struct blockvector *bv = BLOCKVECTOR (SYMBOL_SYMTAB (sym));
2144           struct block *b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2145
2146           if (lookup_block_symbol (b, copy, VAR_DOMAIN) != NULL)
2147             build_canonical_line_spec (values.sals, copy, canonical);
2148         }
2149       return values;
2150     }
2151   else
2152     {
2153       if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
2154         {
2155           /* We know its line number.  */
2156           values.sals = (struct symtab_and_line *)
2157             xmalloc (sizeof (struct symtab_and_line));
2158           values.nelts = 1;
2159           init_sal (&values.sals[0]);
2160           values.sals[0].symtab = SYMBOL_SYMTAB (sym);
2161           values.sals[0].line = SYMBOL_LINE (sym);
2162           values.sals[0].pc = SYMBOL_VALUE_ADDRESS (sym);
2163           values.sals[0].pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2164           values.sals[0].explicit_pc = 1;
2165
2166           if (canonical)
2167             {
2168               canonical->special_display = 1;
2169               canonical->canonical = xmalloc (sizeof (char *));
2170               canonical->canonical[0]
2171                 = xstrprintf ("%s:%s",
2172                               SYMBOL_NATURAL_NAME (function_symbol),
2173                               SYMBOL_NATURAL_NAME (sym));
2174             }
2175
2176           return values;
2177         }
2178       else if (funfirstline)
2179         {
2180           /* NOT_FOUND_ERROR is not correct but it ensures COPY will be
2181              searched also as a minimal symbol.  */
2182
2183           throw_error (NOT_FOUND_ERROR, _("\"%s\" is not a function"), copy);
2184         }
2185       else if (SYMBOL_LINE (sym) != 0)
2186         {
2187           /* We know its line number.  */
2188           values.sals = (struct symtab_and_line *)
2189             xmalloc (sizeof (struct symtab_and_line));
2190           values.nelts = 1;
2191           memset (&values.sals[0], 0, sizeof (values.sals[0]));
2192           values.sals[0].symtab = SYMBOL_SYMTAB (sym);
2193           values.sals[0].line = SYMBOL_LINE (sym);
2194           values.sals[0].pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2195           return values;
2196         }
2197       else
2198         /* This can happen if it is compiled with a compiler which doesn't
2199            put out line numbers for variables.  */
2200         /* FIXME: Shouldn't we just set .line and .symtab to zero
2201            and return?  For example, "info line foo" could print
2202            the address.  */
2203         error (_("Line number not known for symbol \"%s\""), copy);
2204     }
2205 }
2206
2207 /* We've found a minimal symbol MSYMBOL to associate with our
2208    linespec; build a corresponding struct symtabs_and_lines.  */
2209
2210 static struct symtabs_and_lines
2211 minsym_found (int funfirstline, struct minimal_symbol *msymbol)
2212 {
2213   struct objfile *objfile = msymbol_objfile (msymbol);
2214   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2215   struct symtabs_and_lines values;
2216   CORE_ADDR pc;
2217
2218   values.sals = (struct symtab_and_line *)
2219     xmalloc (sizeof (struct symtab_and_line));
2220   values.sals[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
2221                                       (struct obj_section *) 0, 0);
2222   values.sals[0].section = SYMBOL_OBJ_SECTION (msymbol);
2223
2224   /* The minimal symbol might point to a function descriptor;
2225      resolve it to the actual code address instead.  */
2226   pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
2227                                            values.sals[0].pc,
2228                                            &current_target);
2229   if (pc != values.sals[0].pc)
2230     values.sals[0] = find_pc_sect_line (pc, NULL, 0);
2231
2232   if (funfirstline)
2233     skip_prologue_sal (&values.sals[0]);
2234
2235   values.nelts = 1;
2236   return values;
2237 }
2238
2239 void
2240 init_linespec_result (struct linespec_result *lr)
2241 {
2242   memset (lr, 0, sizeof (*lr));
2243 }