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