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   while (isspace (*p))
 719     ++p;
 720   if (*p == '<')
 721     ptr = p = find_template_name_end (ptr);
 722
 723   if (name_end (ptr))
 724     return remove_trailing_whitespace (start, ptr);
 725
 726   /* Keep method overload information.  */
 727   if (*p == '(')
 728     ptr = p = find_method_overload_end (p);
 729
 730   if (name_end (ptr))
 731     return remove_trailing_whitespace (start, ptr);
 732
 733   /* Keep important keywords.  */
 734   while (isspace (*p))
 735     ++p;
 736   if (strncmp (p, "const", 5) == 0
 737       && (isspace (p[5]) || p[5] == '\0'
 738           || strchr (get_gdb_completer_quote_characters (), p[5]) != NULL))
 739     ptr = p = p + 5;
 740
 741   return remove_trailing_whitespace (start, ptr);
 742 }
 743
 744 \f
 745 /* The parser of linespec itself.  */
 746
 747 /* Parse a string that specifies a line number.
 748    Pass the address of a char * variable; that variable will be
 749    advanced over the characters actually parsed.
 750
 751    The string can be:
 752
 753    LINENUM -- that line number in current file.  PC returned is 0.
 754    FILE:LINENUM -- that line in that file.  PC returned is 0.
 755    FUNCTION -- line number of openbrace of that function.
 756    PC returned is the start of the function.
 757    LABEL -- a label in the current scope
 758    VARIABLE -- line number of definition of that variable.
 759    PC returned is 0.
 760    FILE:FUNCTION -- likewise, but prefer functions in that file.
 761    *EXPR -- line in which address EXPR appears.
 762
 763    This may all be followed by an "if EXPR", which we ignore.
 764
 765    FUNCTION may be an undebuggable function found in minimal symbol table.
 766
 767    If the argument FUNFIRSTLINE is nonzero, we want the first line
 768    of real code inside a function when a function is specified, and it is
 769    not OK to specify a variable or type to get its line number.
 770
 771    DEFAULT_SYMTAB specifies the file to use if none is specified.
 772    It defaults to current_source_symtab.
 773    DEFAULT_LINE specifies the line number to use for relative
 774    line numbers (that start with signs).  Defaults to current_source_line.
 775    If CANONICAL is non-NULL, store an array of strings containing the canonical
 776    line specs there if necessary.  Currently overloaded member functions and
 777    line numbers or static functions without a filename yield a canonical
 778    line spec.  The array and the line spec strings are allocated on the heap,
 779    it is the callers responsibility to free them.
 780
 781    Note that it is possible to return zero for the symtab
 782    if no file is validly specified.  Callers must check that.
 783    Also, the line number returned may be invalid.  */
 784
 785 /* We allow single quotes in various places.  This is a hideous
 786    kludge, which exists because the completer can't yet deal with the
 787    lack of single quotes.  FIXME: write a linespec_completer which we
 788    can use as appropriate instead of make_symbol_completion_list.  */
 789
 790 struct symtabs_and_lines
 791 decode_line_1 (char **argptr, int funfirstline, struct symtab *default_symtab,
 792                int default_line, struct linespec_result *canonical)
 793 {
 794   char *p;
 795   char *q;
 796   /* If a file name is specified, this is its symtab.  */
 797   struct symtab *file_symtab = NULL;
 798
 799   char *copy;
 800   /* This says whether or not something in *ARGPTR is quoted with
 801      completer_quotes (i.e. with single quotes).  */
 802   int is_quoted;
 803   /* Is *ARGPTR is enclosed in double quotes?  */
 804   int is_quote_enclosed;
 805   int is_objc_method = 0;
 806   char *saved_arg = *argptr;
 807   /* If IS_QUOTED, the end of the quoted bit.  */
 808   char *end_quote = NULL;
 809   /* The "first half" of the linespec.  */
 810   char *first_half;
 811
 812   /* If we are parsing `function:label', this holds the symbol for the
 813      function.  */
 814   struct symbol *function_symbol = NULL;
 815   /* If FUNCTION_SYMBOL is not NULL, then this is the exception that
 816      was thrown when trying to parse a filename.  */
 817   volatile struct gdb_exception file_exception;
 818
 819   /* Defaults have defaults.  */
 820
 821   initialize_defaults (&default_symtab, &default_line);
 822
 823   /* See if arg is *PC.  */
 824
 825   if (**argptr == '*')
 826     return decode_indirect (argptr);
 827
 828   is_quoted = (strchr (get_gdb_completer_quote_characters (),
 829                        **argptr) != NULL);
 830
 831   if (is_quoted)
 832     end_quote = skip_quoted (*argptr);
 833
 834   /* Check to see if it's a multipart linespec (with colons or
 835      periods).  */
 836
 837   /* Locate the end of the first half of the linespec.
 838      After the call, for instance, if the argptr string is "foo.c:123"
 839      p will point at "123".  If there is only one part, like "foo", p
 840      will point to "".  If this is a C++ name, like "A::B::foo", p will
 841      point to "::B::foo".  Argptr is not changed by this call.  */
 842
 843   first_half = p = locate_first_half (argptr, &is_quote_enclosed);
 844
 845   /* Check if this is an Objective-C method (anything that starts with
 846      a '+' or '-' and a '[').  */
 847   if (is_objc_method_format (p))
 848     is_objc_method = 1;
 849
 850   /* Check if the symbol could be an Objective-C selector.  */
 851
 852   {
 853     struct symtabs_and_lines values;
 854
 855     values = decode_objc (argptr, funfirstline, NULL,
 856                           canonical, saved_arg);
 857     if (values.sals != NULL)
 858       return values;
 859   }
 860
 861   /* Does it look like there actually were two parts?  */
 862
 863   if (p[0] == ':' || p[0] == '.')
 864     {
 865       /* Is it a C++ or Java compound data structure?
 866          The check on p[1] == ':' is capturing the case of "::",
 867          since p[0]==':' was checked above.
 868          Note that the call to decode_compound does everything
 869          for us, including the lookup on the symbol table, so we
 870          can return now.  */
 871
 872       if (p[0] == '.' || p[1] == ':')
 873         {
 874           struct symtabs_and_lines values;
 875
 876           if (is_quote_enclosed)
 877             ++saved_arg;
 878           values = decode_compound (argptr, funfirstline, canonical,
 879                                     saved_arg, p);
 880           if (is_quoted && **argptr == '\'')
 881             *argptr = *argptr + 1;
 882           return values;
 883         }
 884
 885       /* No, the first part is a filename; set file_symtab to be that file's
 886          symtab.  Also, move argptr past the filename.  */
 887
 888       TRY_CATCH (file_exception, RETURN_MASK_ERROR)
 889         {
 890           file_symtab = symtab_from_filename (argptr, p, is_quote_enclosed);
 891         }
 892       /* If that failed, maybe we have `function:label'.  */
 893       if (file_exception.reason < 0)
 894         {
 895           function_symbol = find_function_symbol (argptr, p, is_quote_enclosed);
 896           /* If we did not find a function, re-throw the original
 897              exception.  */
 898           if (!function_symbol)
 899             throw_exception (file_exception);
 900         }
 901
 902       /* Check for single quotes on the non-filename part.  */
 903       if (!is_quoted)
 904         {
 905           is_quoted = (**argptr
 906                        && strchr (get_gdb_completer_quote_characters (),
 907                                   **argptr) != NULL);
 908           if (is_quoted)
 909             end_quote = skip_quoted (*argptr);
 910         }
 911     }
 912
 913   /* file_symtab is specified file's symtab, or 0 if no file specified.
 914      If we are parsing `function:symbol', then FUNCTION_SYMBOL is the
 915      function before the `:'.
 916      arg no longer contains the file name.  */
 917
 918   /* If the filename was quoted, we must re-check the quotation.  */
 919
 920   if (end_quote == first_half && *end_quote!= '\0')
 921     {
 922       is_quoted = (**argptr
 923                    && strchr (get_gdb_completer_quote_characters (),
 924                               **argptr) != NULL);
 925       if (is_quoted)
 926         end_quote = skip_quoted (*argptr);
 927     }
 928
 929   /* Check whether arg is all digits (and sign).  */
 930
 931   q = *argptr;
 932   if (*q == '-' || *q == '+')
 933     q++;
 934   while (*q >= '0' && *q <= '9')
 935     q++;
 936
 937   if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ',')
 938       && function_symbol == NULL)
 939     /* We found a token consisting of all digits -- at least one digit.  */
 940     return decode_all_digits (argptr, default_symtab, default_line,
 941                               canonical, file_symtab, q);
 942
 943   /* Arg token is not digits => try it as a variable name
 944      Find the next token (everything up to end or next whitespace).  */
 945
 946   if (**argptr == '$')          /* May be a convenience variable.  */
 947     /* One or two $ chars possible.  */
 948     p = skip_quoted (*argptr + (((*argptr)[1] == '$') ? 2 : 1));
 949   else if (is_quoted)
 950     {
 951       p = end_quote;
 952       if (p[-1] != '\'')
 953         error (_("Unmatched single quote."));
 954     }
 955   else if (is_objc_method)
 956     {
 957       /* allow word separators in method names for Obj-C.  */
 958       p = skip_quoted_chars (*argptr, NULL, "");
 959     }
 960   else
 961     {
 962       p = skip_quoted (*argptr);
 963     }
 964
 965   /* Keep any important naming information.  */
 966   p = keep_name_info (p);
 967
 968   copy = (char *) alloca (p - *argptr + 1);
 969   memcpy (copy, *argptr, p - *argptr);
 970   copy[p - *argptr] = '\0';
 971   if (p != *argptr
 972       && copy[0]
 973       && copy[0] == copy[p - *argptr - 1]
 974       && strchr (get_gdb_completer_quote_characters (), copy[0]) != NULL)
 975     {
 976       copy[p - *argptr - 1] = '\0';
 977       copy++;
 978     }
 979   else if (is_quoted)
 980     copy[p - *argptr - 1] = '\0';
 981   while (*p == ' ' || *p == '\t')
 982     p++;
 983   *argptr = p;
 984
 985   /* If it starts with $: may be a legitimate variable or routine name
 986      (e.g. HP-UX millicode routines such as $$dyncall), or it may
 987      be history value, or it may be a convenience variable.  */
 988
 989   if (*copy == '$' && function_symbol == NULL)
 990     return decode_dollar (copy, funfirstline, default_symtab,
 991                           canonical, file_symtab);
 992
 993   /* Try the token as a label, but only if no file was specified,
 994      because we can only really find labels in the current scope.  */
 995
 996   if (!file_symtab)
 997     {
 998       struct symtabs_and_lines label_result;
 999       if (decode_label (function_symbol, copy, canonical, &label_result))
1000         return label_result;
1001     }
1002
1003   if (function_symbol)
1004     throw_exception (file_exception);
1005
1006   /* Look up that token as a variable.
1007      If file specified, use that file's per-file block to start with.  */
1008
1009   return decode_variable (copy, funfirstline, canonical, file_symtab);
1010 }
1011
1012 \f
1013
1014 /* Now, more helper functions for decode_line_1.  Some conventions
1015    that these functions follow:
1016
1017    Decode_line_1 typically passes along some of its arguments or local
1018    variables to the subfunctions.  It passes the variables by
1019    reference if they are modified by the subfunction, and by value
1020    otherwise.
1021
1022    Some of the functions have side effects that don't arise from
1023    variables that are passed by reference.  In particular, if a
1024    function is passed ARGPTR as an argument, it modifies what ARGPTR
1025    points to; typically, it advances *ARGPTR past whatever substring
1026    it has just looked at.  (If it doesn't modify *ARGPTR, then the
1027    function gets passed *ARGPTR instead, which is then called ARG.)
1028    Also, functions that return a struct symtabs_and_lines may modify
1029    CANONICAL, as in the description of decode_line_1.
1030
1031    If a function returns a struct symtabs_and_lines, then that struct
1032    will immediately make its way up the call chain to be returned by
1033    decode_line_1.  In particular, all of the functions decode_XXX
1034    calculate the appropriate struct symtabs_and_lines, under the
1035    assumption that their argument is of the form XXX.  */
1036
1037 /* First, some functions to initialize stuff at the beggining of the
1038    function.  */
1039
1040 static void
1041 initialize_defaults (struct symtab **default_symtab, int *default_line)
1042 {
1043   if (*default_symtab == 0)
1044     {
1045       /* Use whatever we have for the default source line.  We don't use
1046          get_current_or_default_symtab_and_line as it can recurse and call
1047          us back!  */
1048       struct symtab_and_line cursal =
1049         get_current_source_symtab_and_line ();
1050
1051       *default_symtab = cursal.symtab;
1052       *default_line = cursal.line;
1053     }
1054 }
1055
1056 \f
1057
1058 /* Decode arg of the form *PC.  */
1059
1060 static struct symtabs_and_lines
1061 decode_indirect (char **argptr)
1062 {
1063   struct symtabs_and_lines values;
1064   CORE_ADDR pc;
1065
1066   (*argptr)++;
1067   pc = value_as_address (parse_to_comma_and_eval (argptr));
1068
1069   values.sals = (struct symtab_and_line *)
1070     xmalloc (sizeof (struct symtab_and_line));
1071
1072   values.nelts = 1;
1073   values.sals[0] = find_pc_line (pc, 0);
1074   values.sals[0].pc = pc;
1075   values.sals[0].section = find_pc_overlay (pc);
1076   values.sals[0].explicit_pc = 1;
1077
1078   return values;
1079 }
1080
1081 \f
1082
1083 /* Locate the first half of the linespec, ending in a colon, period,
1084    or whitespace.  (More or less.)  Also, check to see if *ARGPTR is
1085    enclosed in double quotes; if so, set is_quote_enclosed, advance
1086    ARGPTR past that and zero out the trailing double quote.
1087    If ARGPTR is just a simple name like "main", p will point to ""
1088    at the end.  */
1089
1090 static char *
1091 locate_first_half (char **argptr, int *is_quote_enclosed)
1092 {
1093   char *ii;
1094   char *p, *p1;
1095   int has_comma;
1096
1097   /* Maybe we were called with a line range FILENAME:LINENUM,FILENAME:LINENUM
1098      and we must isolate the first half.  Outer layers will call again later
1099      for the second half.
1100
1101      Don't count commas that appear in argument lists of overloaded
1102      functions, or in quoted strings.  It's stupid to go to this much
1103      trouble when the rest of the function is such an obvious roach hotel.  */
1104   ii = find_toplevel_char (*argptr, ',');
1105   has_comma = (ii != 0);
1106
1107   /* Temporarily zap out second half to not confuse the code below.
1108      This is undone below.  Do not change ii!!  */
1109   if (has_comma)
1110     {
1111       *ii = '\0';
1112     }
1113
1114   /* Maybe arg is FILE : LINENUM or FILE : FUNCTION.  May also be
1115      CLASS::MEMBER, or NAMESPACE::NAME.  Look for ':', but ignore
1116      inside of <>.  */
1117
1118   p = *argptr;
1119   if (p[0] == '"')
1120     {
1121       *is_quote_enclosed = 1;
1122       (*argptr)++;
1123       p++;
1124     }
1125   else
1126     {
1127       *is_quote_enclosed = 0;
1128       if (strchr (get_gdb_completer_quote_characters (), *p))
1129         {
1130           ++(*argptr);
1131           ++p;
1132         }
1133     }
1134   for (; *p; p++)
1135     {
1136       if (p[0] == '<')
1137         {
1138           char *temp_end = find_template_name_end (p);
1139
1140           if (!temp_end)
1141             error (_("malformed template specification in command"));
1142           p = temp_end;
1143         }
1144
1145       if (p[0] == '(')
1146         p = find_method_overload_end (p);
1147
1148       /* Check for a colon and a plus or minus and a [ (which
1149          indicates an Objective-C method).  */
1150       if (is_objc_method_format (p))
1151         {
1152           break;
1153         }
1154       /* Check for the end of the first half of the linespec.  End of
1155          line, a tab, a double colon or the last single colon, or a
1156          space.  But if enclosed in double quotes we do not break on
1157          enclosed spaces.  */
1158       if (!*p
1159           || p[0] == '\t'
1160           || ((p[0] == ':')
1161               && ((p[1] == ':') || (strchr (p + 1, ':') == NULL)))
1162           || ((p[0] == ' ') && !*is_quote_enclosed))
1163         break;
1164       if (p[0] == '.' && strchr (p, ':') == NULL)
1165         {
1166           /* Java qualified method.  Find the *last* '.', since the
1167              others are package qualifiers.  Stop at any open parenthesis
1168              which might provide overload information.  */
1169           for (p1 = p; *p1 && *p1 != '('; p1++)
1170             {
1171               if (*p1 == '.')
1172                 p = p1;
1173             }
1174           break;
1175         }
1176     }
1177   while (p[0] == ' ' || p[0] == '\t')
1178     p++;
1179
1180   /* If the closing double quote was left at the end, remove it.  */
1181   if (*is_quote_enclosed)
1182     {
1183       char *closing_quote = strchr (p - 1, '"');
1184
1185       if (closing_quote && closing_quote[1] == '\0')
1186         *closing_quote = '\0';
1187     }
1188
1189   /* Now that we've safely parsed the first half, put back ',' so
1190      outer layers can see it.  */
1191   if (has_comma)
1192     *ii = ',';
1193
1194   return p;
1195 }
1196
1197 \f
1198
1199 /* Here's where we recognise an Objective-C Selector.  An Objective C
1200    selector may be implemented by more than one class, therefore it
1201    may represent more than one method/function.  This gives us a
1202    situation somewhat analogous to C++ overloading.  If there's more
1203    than one method that could represent the selector, then use some of
1204    the existing C++ code to let the user choose one.  */
1205
1206 struct symtabs_and_lines
1207 decode_objc (char **argptr, int funfirstline, struct symtab *file_symtab,
1208              struct linespec_result *canonical, char *saved_arg)
1209 {
1210   struct symtabs_and_lines values;
1211   struct symbol **sym_arr = NULL;
1212   struct symbol *sym = NULL;
1213   struct block *block = NULL;
1214   unsigned i1 = 0;
1215   unsigned i2 = 0;
1216
1217   values.sals = NULL;
1218   values.nelts = 0;
1219
1220   if (file_symtab != NULL)
1221     block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab), STATIC_BLOCK);
1222   else
1223     {
1224       enum language save_language;
1225
1226       /* get_selected_block can change the current language when there is
1227          no selected frame yet.  */
1228       save_language = current_language->la_language;
1229       block = get_selected_block (0);
1230       set_language (save_language);
1231     }
1232
1233   find_imps (file_symtab, block, *argptr, NULL, &i1, &i2);
1234
1235   if (i1 > 0)
1236     {
1237       sym_arr = (struct symbol **)
1238         alloca ((i1 + 1) * sizeof (struct symbol *));
1239       sym_arr[i1] = NULL;
1240
1241       *argptr = find_imps (file_symtab, block, *argptr, sym_arr, &i1, &i2);
1242     }
1243
1244   /* i1 now represents the TOTAL number of matches found.
1245      i2 represents how many HIGH-LEVEL (struct symbol) matches,
1246      which will come first in the sym_arr array.  Any low-level
1247      (minimal_symbol) matches will follow those.  */
1248
1249   if (i1 == 1)
1250     {
1251       if (i2 > 0)
1252         {
1253           /* Already a struct symbol.  */
1254           sym = sym_arr[0];
1255         }
1256       else
1257         {
1258           sym = find_pc_function (SYMBOL_VALUE_ADDRESS (sym_arr[0]));
1259           if ((sym != NULL) && strcmp (SYMBOL_LINKAGE_NAME (sym_arr[0]),
1260                                        SYMBOL_LINKAGE_NAME (sym)) != 0)
1261             {
1262               warning (_("debugging symbol \"%s\" does "
1263                          "not match selector; ignoring"),
1264                        SYMBOL_LINKAGE_NAME (sym));
1265               sym = NULL;
1266             }
1267         }
1268
1269       values.sals = (struct symtab_and_line *)
1270         xmalloc (sizeof (struct symtab_and_line));
1271       values.nelts = 1;
1272
1273       if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1274         {
1275           /* Canonicalize this, so it remains resolved for dylib loads.  */
1276           values.sals[0] = find_function_start_sal (sym, funfirstline);
1277           build_canonical_line_spec (values.sals,
1278                                      SYMBOL_NATURAL_NAME (sym), canonical);
1279         }
1280       else
1281         {
1282           /* The only match was a non-debuggable symbol, which might point
1283              to a function descriptor; resolve it to the actual code address
1284              instead.  */
1285           struct minimal_symbol *msymbol = (struct minimal_symbol *)sym_arr[0];
1286           struct objfile *objfile = msymbol_objfile (msymbol);
1287           struct gdbarch *gdbarch = get_objfile_arch (objfile);
1288           CORE_ADDR pc = SYMBOL_VALUE_ADDRESS (msymbol);
1289
1290           pc = gdbarch_convert_from_func_ptr_addr (gdbarch, pc,
1291                                                    &current_target);
1292
1293           init_sal (&values.sals[0]);
1294           values.sals[0].pc = pc;
1295         }
1296       return values;
1297     }
1298
1299   if (i1 > 1)
1300     {
1301       /* More than one match.  The user must choose one or more.  */
1302       return decode_line_2 (sym_arr, i2, funfirstline, canonical);
1303     }
1304
1305   return values;
1306 }
1307
1308 /* This handles C++ and Java compound data structures.  P should point
1309    at the first component separator, i.e. double-colon or period.  As
1310    an example, on entrance to this function we could have ARGPTR
1311    pointing to "AAA::inA::fun" and P pointing to "::inA::fun".  */
1312
1313 static struct symtabs_and_lines
1314 decode_compound (char **argptr, int funfirstline,
1315                  struct linespec_result *canonical,
1316                  char *the_real_saved_arg, char *p)
1317 {
1318   struct symtabs_and_lines values;
1319   char *p2;
1320   char *saved_arg2 = *argptr;
1321   char *temp_end;
1322   struct symbol *sym;
1323   char *copy;
1324   struct symbol *sym_class;
1325   struct type *t;
1326   char *saved_java_argptr = NULL;
1327   char *saved_arg;
1328
1329   /* If the user specified any completer quote characters in the input,
1330      strip them.  They are superfluous.  */
1331   saved_arg = alloca (strlen (the_real_saved_arg) + 1);
1332   {
1333     char *dst = saved_arg;
1334     char *src = the_real_saved_arg;
1335     char *quotes = get_gdb_completer_quote_characters ();
1336     while (*src != '\0')
1337       {
1338         if (strchr (quotes, *src) == NULL)
1339           *dst++ = *src;
1340         ++src;
1341       }
1342     *dst = '\0';
1343   }
1344
1345   /* First check for "global" namespace specification, of the form
1346      "::foo".  If found, skip over the colons and jump to normal
1347      symbol processing.  I.e. the whole line specification starts with
1348      "::" (note the condition that *argptr == p).  */
1349   if (p[0] == ':'
1350       && ((*argptr == p) || (p[-1] == ' ') || (p[-1] == '\t')))
1351     saved_arg2 += 2;
1352
1353   /* Given our example "AAA::inA::fun", we have two cases to consider:
1354
1355      1) AAA::inA is the name of a class.  In that case, presumably it
1356         has a method called "fun"; we then look up that method using
1357         find_method.
1358
1359      2) AAA::inA isn't the name of a class.  In that case, either the
1360         user made a typo, AAA::inA is the name of a namespace, or it is
1361         the name of a minimal symbol.
1362         We just look up AAA::inA::fun with lookup_symbol.  If that fails,
1363         try lookup_minimal_symbol.
1364
1365      Thus, our first task is to find everything before the last set of
1366      double-colons and figure out if it's the name of a class.  So we
1367      first loop through all of the double-colons.  */
1368
1369   p2 = p;               /* Save for restart.  */
1370
1371   /* This is very messy.  Following the example above we have now the
1372      following pointers:
1373      p -> "::inA::fun"
1374      argptr -> "AAA::inA::fun
1375      saved_arg -> "AAA::inA::fun
1376      saved_arg2 -> "AAA::inA::fun
1377      p2 -> "::inA::fun".  */
1378
1379   /* In the loop below, with these strings, we'll make 2 passes, each
1380      is marked in comments.  */
1381
1382   while (1)
1383     {
1384       static char *break_characters = " \t(";
1385
1386       /* Move pointer up to next possible class/namespace token.  */
1387
1388       p = p2 + 1;       /* Restart with old value +1.  */
1389
1390       /* PASS1: at this point p2->"::inA::fun", so p->":inA::fun",
1391          i.e. if there is a double-colon, p will now point to the
1392          second colon.  */
1393       /* PASS2: p2->"::fun", p->":fun" */
1394
1395       /* Move pointer ahead to next double-colon.  */
1396       while (*p
1397              && strchr (break_characters, *p) == NULL
1398              && strchr (get_gdb_completer_quote_characters (), *p) == NULL)
1399         {
1400           if (current_language->la_language == language_cplus)
1401             p += cp_validate_operator (p);
1402
1403           if (p[0] == '<')
1404             {
1405               temp_end = find_template_name_end (p);
1406               if (!temp_end)
1407                 error (_("malformed template specification in command"));
1408               p = temp_end;
1409             }
1410           /* Note that, since, at the start of this loop, p would be
1411              pointing to the second colon in a double-colon, we only
1412              satisfy the condition below if there is another
1413              double-colon to the right (after).  I.e. there is another
1414              component that can be a class or a namespace.  I.e, if at
1415              the beginning of this loop (PASS1), we had
1416              p->":inA::fun", we'll trigger this when p has been
1417              advanced to point to "::fun".  */
1418           /* PASS2: we will not trigger this.  */
1419           else if ((p[0] == ':') && (p[1] == ':'))
1420             break;      /* Found double-colon.  */
1421           else
1422             {
1423               /* PASS2: We'll keep getting here, until P points to one of the
1424                  break characters, at which point we exit this loop.  */
1425               if (*p && strchr (break_characters, *p) == NULL)
1426                 p++;
1427             }
1428         }
1429
1430       if (*p != ':')
1431         break;          /* Out of the while (1).  This would happen
1432                            for instance if we have looked up
1433                            unsuccessfully all the components of the
1434                            string, and p->""(PASS2).  */
1435
1436       /* We get here if p points to one of the break characters or "" (i.e.,
1437          string ended).  */
1438       /* Save restart for next time around.  */
1439       p2 = p;
1440       /* Restore argptr as it was on entry to this function.  */
1441       *argptr = saved_arg2;
1442       /* PASS1: at this point p->"::fun" argptr->"AAA::inA::fun",
1443          p2->"::fun".  */
1444
1445       /* All ready for next pass through the loop.  */
1446     }                   /* while (1) */
1447
1448
1449   /* Start of lookup in the symbol tables.  */
1450
1451   /* Lookup in the symbol table the substring between argptr and
1452      p.  Note, this call changes the value of argptr.  */
1453   /* Before the call, argptr->"AAA::inA::fun",
1454      p->"", p2->"::fun".  After the call: argptr->"fun", p, p2
1455      unchanged.  */
1456   sym_class = lookup_prefix_sym (argptr, p2);
1457
1458   /* If sym_class has been found, and if "AAA::inA" is a class, then
1459      we're in case 1 above.  So we look up "fun" as a method of that
1460      class.  */
1461   if (sym_class &&
1462       (t = check_typedef (SYMBOL_TYPE (sym_class)),
1463        (TYPE_CODE (t) == TYPE_CODE_STRUCT
1464         || TYPE_CODE (t) == TYPE_CODE_UNION)))
1465     {
1466       /* Arg token is not digits => try it as a function name.
1467          Find the next token (everything up to end or next
1468          blank).  */
1469       if (**argptr
1470           && strchr (get_gdb_completer_quote_characters (),
1471                      **argptr) != NULL)
1472         {
1473           p = skip_quoted (*argptr);
1474           *argptr = *argptr + 1;
1475         }
1476       else
1477         {
1478           /* At this point argptr->"fun".  */
1479           char *a;
1480
1481           p = *argptr;
1482           while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p != ':'
1483                  && *p != '(')
1484             p++;
1485           /* At this point p->"".  String ended.  */
1486           /* Nope, C++ operators could have spaces in them
1487              ("foo::operator <" or "foo::operator delete []").
1488              I apologize, this is a bit hacky...  */
1489           if (current_language->la_language == language_cplus
1490               && *p == ' ' && p - 8 - *argptr + 1 > 0)
1491             {
1492               /* The above loop has already swallowed "operator".  */
1493               p += cp_validate_operator (p - 8) - 8;
1494             }
1495
1496           /* Keep any important naming information.  */
1497           p = keep_name_info (p);
1498
1499           /* Java may append typenames,  so assume that if there is
1500              anything else left in *argptr, it must be a typename.  */
1501           if (*p && current_language->la_language == language_java)
1502             {
1503               struct type *type;
1504
1505               p2 = p;
1506               while (*p2)
1507                 ++p2;
1508               copy = (char *) alloca (p2 - p + 1);
1509               memcpy (copy, p, p2 - p);
1510               copy[p2 - p] = '\0';
1511               type = lookup_typename (current_language, get_current_arch (),
1512                                       copy, NULL, 1);
1513               if (type != NULL)
1514                 {
1515                   /* Save the location of this just in case this
1516                      method/type combination isn't actually defined.
1517                      It will be checked later.  */
1518                   saved_java_argptr = p;
1519                   p = p2;
1520                 }
1521             }
1522         }
1523
1524       /* Allocate our own copy of the substring between argptr and
1525          p.  */
1526       copy = (char *) alloca (p - *argptr + 1);
1527       memcpy (copy, *argptr, p - *argptr);
1528       copy[p - *argptr] = '\0';
1529       if (p != *argptr
1530           && copy[p - *argptr - 1]
1531           && strchr (get_gdb_completer_quote_characters (),
1532                      copy[p - *argptr - 1]) != NULL)
1533         copy[p - *argptr - 1] = '\0';
1534
1535       /* At this point copy->"fun", p->"".  */
1536
1537       /* No line number may be specified.  */
1538       while (*p == ' ' || *p == '\t')
1539         p++;
1540       *argptr = p;
1541       /* At this point arptr->"".  */
1542
1543       /* Look for copy as a method of sym_class.  */
1544       /* At this point copy->"fun", sym_class is "AAA:inA",
1545          saved_arg->"AAA::inA::fun".  This concludes the scanning of
1546          the string for possible components matches.  If we find it
1547          here, we return.  If not, and we are at the and of the string,
1548          we'll lookup the whole string in the symbol tables.  */
1549
1550       values = find_method (funfirstline, canonical, saved_arg,
1551                             copy, t, sym_class);
1552       if (saved_java_argptr != NULL && values.nelts == 1)
1553         {
1554           /* The user specified a specific return type for a java method.
1555              Double-check that it really is the one the user specified.
1556              [This is a necessary evil because strcmp_iw_ordered stops
1557              comparisons too prematurely.]  */
1558           sym = find_pc_sect_function (values.sals[0].pc,
1559                                        values.sals[0].section);
1560           /* We just found a SAL, we had better be able to go backwards!  */
1561           gdb_assert (sym != NULL);
1562           if (strcmp_iw (SYMBOL_LINKAGE_NAME (sym), saved_arg) != 0)
1563             {
1564               xfree (values.sals);
1565               error (_("the class `%s' does not have "
1566                        "any method instance named %s"),
1567                      SYMBOL_PRINT_NAME (sym_class), copy);
1568             }
1569         }
1570       return values;
1571     } /* End if symbol found.  */
1572
1573
1574   /* We couldn't find a class, so we're in case 2 above.  We check the
1575      entire name as a symbol instead.  */
1576
1577   if (current_language->la_language == language_cplus
1578       || current_language->la_language == language_java)
1579     p = keep_name_info (p);
1580
1581   copy = (char *) alloca (p - saved_arg2 + 1);
1582   memcpy (copy, saved_arg2, p - saved_arg2);
1583   /* Note: if is_quoted should be true, we snuff out quote here
1584      anyway.  */
1585   copy[p - saved_arg2] = '\000';
1586   /* Set argptr to skip over the name.  */
1587   *argptr = (*p == '\'') ? p + 1 : p;
1588
1589   /* Look up entire name.  */
1590   sym = lookup_symbol (copy, get_selected_block (0), VAR_DOMAIN, 0);
1591   if (sym)
1592     return symbol_found (funfirstline, canonical, copy, sym, NULL, NULL);
1593   else
1594     {
1595       struct minimal_symbol *msym;
1596
1597       /* Couldn't find any interpretation as classes/namespaces.  As a last
1598          resort, try the minimal symbol tables.  */
1599       msym = lookup_minimal_symbol (copy, NULL, NULL);
1600       if (msym != NULL)
1601         return minsym_found (funfirstline, msym);
1602     }
1603
1604   /* Couldn't find a minimal symbol, either, so give up.  */
1605   cplusplus_error (the_real_saved_arg,
1606                    "Can't find member of namespace, "
1607                    "class, struct, or union named \"%s\"\n",
1608                    copy);
1609 }
1610
1611 /* Next come some helper functions for decode_compound.  */
1612
1613 /* Return the symbol corresponding to the substring of *ARGPTR ending
1614    at P, allowing whitespace.  Also, advance *ARGPTR past the symbol
1615    name in question, the compound object separator ("::" or "."), and
1616    whitespace.  Note that *ARGPTR is changed whether or not the
1617    lookup_symbol call finds anything (i.e we return NULL).  As an
1618    example, say ARGPTR is "AAA::inA::fun" and P is "::inA::fun".  */
1619
1620 static struct symbol *
1621 lookup_prefix_sym (char **argptr, char *p)
1622 {
1623   char *p1;
1624   char *copy;
1625   struct symbol *sym;
1626
1627   /* Extract the class name.  */
1628   p1 = p;
1629   while (p != *argptr && p[-1] == ' ')
1630     --p;
1631   copy = (char *) alloca (p - *argptr + 1);
1632   memcpy (copy, *argptr, p - *argptr);
1633   copy[p - *argptr] = 0;
1634
1635   /* Discard the class name from the argptr.  */
1636   p = p1 + (p1[0] == ':' ? 2 : 1);
1637   while (*p == ' ' || *p == '\t')
1638     p++;
1639   *argptr = p;
1640
1641   /* At this point p1->"::inA::fun", p->"inA::fun" copy->"AAA",
1642      argptr->"inA::fun".  */
1643
1644   sym = lookup_symbol (copy, get_selected_block (0), STRUCT_DOMAIN, 0);
1645   if (sym == NULL)
1646     {
1647       /* Typedefs are in VAR_DOMAIN so the above symbol lookup will
1648          fail when the user attempts to lookup a method of a class
1649          via a typedef'd name (NOT via the class's name, which is already
1650          handled in symbol_matches_domain).  So try the lookup again
1651          using VAR_DOMAIN (where typedefs live) and double-check that we
1652          found a struct/class type.  */
1653       struct symbol *s = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
1654
1655       if (s != NULL)
1656         {
1657           struct type *t = SYMBOL_TYPE (s);
1658
1659           CHECK_TYPEDEF (t);
1660           if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
1661             return s;
1662         }
1663     }
1664
1665   return sym;
1666 }
1667
1668 /* This finds the method COPY in the class whose type is T and whose
1669    symbol is SYM_CLASS.  */
1670
1671 static struct symtabs_and_lines
1672 find_method (int funfirstline, struct linespec_result *canonical,
1673              char *saved_arg,
1674              char *copy, struct type *t, struct symbol *sym_class)
1675 {
1676   struct symtabs_and_lines values;
1677   struct symbol *sym = NULL;
1678   int i1;       /*  Counter for the symbol array.  */
1679   struct symbol **sym_arr =  alloca (total_number_of_methods (t)
1680                                      * sizeof (struct symbol *));
1681
1682   /* Find all methods with a matching name, and put them in
1683      sym_arr.  */
1684
1685   i1 = find_methods (t, copy, SYMBOL_LANGUAGE (sym_class), sym_arr);
1686
1687   if (i1 == 1)
1688     {
1689       /* There is exactly one field with that name.  */
1690       sym = sym_arr[0];
1691
1692       if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1693         {
1694           values.sals = (struct symtab_and_line *)
1695             xmalloc (sizeof (struct symtab_and_line));
1696           values.nelts = 1;
1697           values.sals[0] = find_function_start_sal (sym,
1698                                                     funfirstline);
1699         }
1700       else
1701         {
1702           values.sals = NULL;
1703           values.nelts = 0;
1704         }
1705       return values;
1706     }
1707   if (i1 > 0)
1708     {
1709       /* If we were given a specific overload instance, use that
1710          (or error if no matches were found).  Otherwise ask the user
1711          which one to use.  */
1712       if (strchr (copy, '('))
1713         {
1714           int i;
1715           char *name;
1716           char *canon;
1717           struct cleanup *cleanup;
1718
1719           /* Construct the proper search name based on SYM_CLASS and COPY.
1720              SAVED_ARG may contain a valid name, but that name might not be
1721              what is actually stored in the symbol table.  For example,
1722              if SAVED_ARG (and SYM_CLASS) were found via an import
1723              ("using namespace" in C++), then the physname of
1724              SYM_CLASS ("A::myclass") may not be the same as SAVED_ARG
1725              ("myclass").  */
1726           name = xmalloc (strlen (SYMBOL_NATURAL_NAME (sym_class))
1727                           + 2 /* "::" */ + strlen (copy) + 1);
1728           strcpy (name, SYMBOL_NATURAL_NAME (sym_class));
1729           strcat (name, "::");
1730           strcat (name, copy);
1731           canon = cp_canonicalize_string (name);
1732           if (canon != NULL)
1733             {
1734               xfree (name);
1735               name = canon;
1736             }
1737           cleanup = make_cleanup (xfree, name);
1738
1739           for (i = 0; i < i1; ++i)
1740             {
1741               if (strcmp_iw (name, SYMBOL_LINKAGE_NAME (sym_arr[i])) == 0)
1742                 {
1743                   values.sals = (struct symtab_and_line *)
1744                     xmalloc (sizeof (struct symtab_and_line));
1745                   values.nelts = 1;
1746                   values.sals[0] = find_function_start_sal (sym_arr[i],
1747                                                             funfirstline);
1748                   do_cleanups (cleanup);
1749                   return values;
1750                 }
1751             }
1752
1753           error (_("the class `%s' does not have "
1754                    "any method instance named %s"),
1755                  SYMBOL_PRINT_NAME (sym_class), copy);
1756         }
1757
1758       return decode_line_2 (sym_arr, i1, funfirstline, canonical);
1759     }
1760   else
1761     {
1762       if (copy[0] == '~')
1763         cplusplus_error (saved_arg,
1764                          "the class `%s' does not have destructor defined\n",
1765                          SYMBOL_PRINT_NAME (sym_class));
1766       else
1767         cplusplus_error (saved_arg,
1768                          "the class %s does not have any method named %s\n",
1769                          SYMBOL_PRINT_NAME (sym_class), copy);
1770     }
1771 }
1772
1773 \f
1774
1775 /* Return the symtab associated to the filename given by the substring
1776    of *ARGPTR ending at P, and advance ARGPTR past that filename.  */
1777
1778 static struct symtab *
1779 symtab_from_filename (char **argptr, char *p, int is_quote_enclosed)
1780 {
1781   char *p1;
1782   char *copy;
1783   struct symtab *file_symtab;
1784
1785   p1 = p;
1786   while (p != *argptr && p[-1] == ' ')
1787     --p;
1788   if ((*p == '"') && is_quote_enclosed)
1789     --p;
1790   copy = (char *) alloca (p - *argptr + 1);
1791   memcpy (copy, *argptr, p - *argptr);
1792   /* It may have the ending quote right after the file name.  */
1793   if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
1794       || copy[p - *argptr - 1] == '\'')
1795     copy[p - *argptr - 1] = 0;
1796   else
1797     copy[p - *argptr] = 0;
1798
1799   /* Find that file's data.  */
1800   file_symtab = lookup_symtab (copy);
1801   if (file_symtab == 0)
1802     {
1803       if (!have_full_symbols () && !have_partial_symbols ())
1804         throw_error (NOT_FOUND_ERROR,
1805                      _("No symbol table is loaded.  "
1806                        "Use the \"file\" command."));
1807       throw_error (NOT_FOUND_ERROR, _("No source file named %s."), copy);
1808     }
1809
1810   /* Discard the file name from the arg.  */
1811   p = p1 + 1;
1812   while (*p == ' ' || *p == '\t')
1813     p++;
1814   *argptr = p;
1815
1816   return file_symtab;
1817 }
1818
1819 /* Look up a function symbol in *ARGPTR.  If found, advance *ARGPTR
1820    and return the symbol.  If not found, return NULL.  */
1821
1822 static struct symbol *
1823 find_function_symbol (char **argptr, char *p, int is_quote_enclosed)
1824 {
1825   char *p1;
1826   char *copy;
1827   struct symbol *function_symbol;
1828
1829   p1 = p;
1830   while (p != *argptr && p[-1] == ' ')
1831     --p;
1832   if ((*p == '"') && is_quote_enclosed)
1833     --p;
1834   copy = (char *) alloca (p - *argptr + 1);
1835   memcpy (copy, *argptr, p - *argptr);
1836   /* It may have the ending quote right after the file name.  */
1837   if ((is_quote_enclosed && copy[p - *argptr - 1] == '"')
1838       || copy[p - *argptr - 1] == '\'')
1839     copy[p - *argptr - 1] = 0;
1840   else
1841     copy[p - *argptr] = 0;
1842
1843   function_symbol = lookup_symbol (copy, get_selected_block (0),
1844                                    VAR_DOMAIN, 0);
1845   if (!function_symbol || SYMBOL_CLASS (function_symbol) != LOC_BLOCK)
1846     return NULL;
1847
1848   /* Discard the file name from the arg.  */
1849   p = p1 + 1;
1850   while (*p == ' ' || *p == '\t')
1851     p++;
1852   *argptr = p;
1853
1854   return function_symbol;
1855 }
1856
1857 \f
1858
1859 /* This decodes a line where the argument is all digits (possibly
1860    preceded by a sign).  Q should point to the end of those digits;
1861    the other arguments are as usual.  */
1862
1863 static struct symtabs_and_lines
1864 decode_all_digits (char **argptr, struct symtab *default_symtab,
1865                    int default_line, struct linespec_result *canonical,
1866                    struct symtab *file_symtab, char *q)
1867
1868 {
1869   struct symtabs_and_lines values;
1870   struct symtab_and_line val;
1871
1872   enum sign
1873     {
1874       none, plus, minus
1875     }
1876   sign = none;
1877
1878   /* We might need a canonical line spec if no file was specified.  */
1879   int need_canonical = (file_symtab == NULL) ? 1 : 0;
1880
1881   init_sal (&val);
1882
1883   val.pspace = current_program_space;
1884
1885   /* This is where we need to make sure that we have good defaults.
1886      We must guarantee that this section of code is never executed
1887      when we are called with just a function name, since
1888      set_default_source_symtab_and_line uses
1889      select_source_symtab that calls us with such an argument.  */
1890
1891   if (file_symtab == 0 && default_symtab == 0)
1892     {
1893       /* Make sure we have at least a default source file.  */
1894       set_default_source_symtab_and_line ();
1895       initialize_defaults (&default_symtab, &default_line);
1896     }
1897
1898   if (**argptr == '+')
1899     sign = plus, (*argptr)++;
1900   else if (**argptr == '-')
1901     sign = minus, (*argptr)++;
1902   val.line = atoi (*argptr);
1903   switch (sign)
1904     {
1905     case plus:
1906       if (q == *argptr)
1907         val.line = 5;
1908       if (file_symtab == 0)
1909         val.line = default_line + val.line;
1910       break;
1911     case minus:
1912       if (q == *argptr)
1913         val.line = 15;
1914       if (file_symtab == 0)
1915         val.line = default_line - val.line;
1916       else
1917         val.line = 1;
1918       break;
1919     case none:
1920       break;            /* No need to adjust val.line.  */
1921     }
1922
1923   while (*q == ' ' || *q == '\t')
1924     q++;
1925   *argptr = q;
1926   if (file_symtab == 0)
1927     file_symtab = default_symtab;
1928
1929   /* It is possible that this source file has more than one symtab,
1930      and that the new line number specification has moved us from the
1931      default (in file_symtab) to a new one.  */
1932   val.symtab = find_line_symtab (file_symtab, val.line, NULL, NULL);
1933   if (val.symtab == 0)
1934     val.symtab = file_symtab;
1935
1936   val.pspace = SYMTAB_PSPACE (val.symtab);
1937   val.pc = 0;
1938   values.sals = (struct symtab_and_line *)
1939     xmalloc (sizeof (struct symtab_and_line));
1940   values.sals[0] = val;
1941   values.nelts = 1;
1942   if (need_canonical)
1943     build_canonical_line_spec (values.sals, NULL, canonical);
1944   values.sals[0].explicit_line = 1;
1945   return values;
1946 }
1947
1948 \f
1949
1950 /* Decode a linespec starting with a dollar sign.  */
1951
1952 static struct symtabs_and_lines
1953 decode_dollar (char *copy, int funfirstline, struct symtab *default_symtab,
1954                struct linespec_result *canonical, struct symtab *file_symtab)
1955 {
1956   LONGEST valx;
1957   int index = 0;
1958   int need_canonical = 0;
1959   struct symtabs_and_lines values;
1960   struct symtab_and_line val;
1961   char *p;
1962   struct symbol *sym;
1963   struct minimal_symbol *msymbol;
1964
1965   p = (copy[1] == '$') ? copy + 2 : copy + 1;
1966   while (*p >= '0' && *p <= '9')
1967     p++;
1968   if (!*p)              /* Reached end of token without hitting non-digit.  */
1969     {
1970       /* We have a value history reference.  */
1971       struct value *val_history;
1972
1973       sscanf ((copy[1] == '$') ? copy + 2 : copy + 1, "%d", &index);
1974       val_history = access_value_history ((copy[1] == '$') ? -index : index);
1975       if (TYPE_CODE (value_type (val_history)) != TYPE_CODE_INT)
1976         error (_("History values used in line "
1977                  "specs must have integer values."));
1978       valx = value_as_long (val_history);
1979     }
1980   else
1981     {
1982       /* Not all digits -- may be user variable/function or a
1983          convenience variable.  */
1984
1985       /* Look up entire name as a symbol first.  */
1986       sym = lookup_symbol (copy, 0, VAR_DOMAIN, 0);
1987       file_symtab = (struct symtab *) NULL;
1988       need_canonical = 1;
1989       /* Symbol was found --> jump to normal symbol processing.  */
1990       if (sym)
1991         return symbol_found (funfirstline, canonical, copy, sym, NULL, NULL);
1992
1993       /* If symbol was not found, look in minimal symbol tables.  */
1994       msymbol = lookup_minimal_symbol (copy, NULL, NULL);
1995       /* Min symbol was found --> jump to minsym processing.  */
1996       if (msymbol)
1997         return minsym_found (funfirstline, msymbol);
1998
1999       /* Not a user variable or function -- must be convenience variable.  */
2000       if (!get_internalvar_integer (lookup_internalvar (copy + 1), &valx))
2001         error (_("Convenience variables used in line "
2002                  "specs must have integer values."));
2003     }
2004
2005   init_sal (&val);
2006
2007   /* Either history value or convenience value from above, in valx.  */
2008   val.symtab = file_symtab ? file_symtab : default_symtab;
2009   val.line = valx;
2010   val.pc = 0;
2011   val.pspace = current_program_space;
2012
2013   values.sals = (struct symtab_and_line *) xmalloc (sizeof val);
2014   values.sals[0] = val;
2015   values.nelts = 1;
2016
2017   if (need_canonical)
2018     build_canonical_line_spec (values.sals, NULL, canonical);
2019
2020   return values;
2021 }
2022
2023 \f
2024
2025 /* A helper for decode_line_1 that tries to find a label.  The label
2026    is searched for in the current block.
2027    FUNCTION_SYMBOL is the enclosing function; or NULL if none
2028    specified.
2029    COPY is the name of the label to find.
2030    CANONICAL is the same as the "canonical" argument to decode_line_1.
2031    RESULT is a pointer to a symtabs_and_lines structure which will be
2032    filled in on success.
2033    This function returns 1 if a label was found, 0 otherwise.  */
2034
2035 static int
2036 decode_label (struct symbol *function_symbol, char *copy,
2037               struct linespec_result *canonical,
2038               struct symtabs_and_lines *result)
2039 {
2040   struct symbol *sym;
2041   struct block *block;
2042
2043   if (function_symbol)
2044     block = SYMBOL_BLOCK_VALUE (function_symbol);
2045   else
2046     {
2047       block = get_selected_block (0);
2048       for (;
2049            block && !BLOCK_FUNCTION (block);
2050            block = BLOCK_SUPERBLOCK (block))
2051         ;
2052       if (!block)
2053         return 0;
2054       function_symbol = BLOCK_FUNCTION (block);
2055     }
2056
2057   sym = lookup_symbol (copy, block, LABEL_DOMAIN, 0);
2058
2059   if (sym != NULL)
2060     *result = symbol_found (0, canonical, copy, sym, NULL, function_symbol);
2061
2062   return sym != NULL;
2063 }
2064
2065 /* Decode a linespec that's a variable.  If FILE_SYMTAB is non-NULL,
2066    look in that symtab's static variables first.  */
2067
2068 static struct symtabs_and_lines
2069 decode_variable (char *copy, int funfirstline,
2070                  struct linespec_result *canonical,
2071                  struct symtab *file_symtab)
2072 {
2073   struct symbol *sym;
2074   struct minimal_symbol *msymbol;
2075
2076   sym = lookup_symbol (copy,
2077                        (file_symtab
2078                         ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (file_symtab),
2079                                              STATIC_BLOCK)
2080                         : get_selected_block (0)),
2081                        VAR_DOMAIN, 0);
2082
2083   if (sym != NULL)
2084     return symbol_found (funfirstline, canonical, copy, sym, file_symtab, NULL);
2085
2086   msymbol = lookup_minimal_symbol (copy, NULL, NULL);
2087
2088   if (msymbol != NULL)
2089     return minsym_found (funfirstline, msymbol);
2090
2091   if (!have_full_symbols ()
2092       && !have_partial_symbols ()
2093       && !have_minimal_symbols ())
2094     throw_error (NOT_FOUND_ERROR,
2095                  _("No symbol table is loaded.  Use the \"file\" command."));
2096   throw_error (NOT_FOUND_ERROR, _("Function \"%s\" not defined."), copy);
2097 }
2098
2099
2100 \f
2101
2102 /* Now come some functions that are called from multiple places within
2103    decode_line_1.  */
2104
2105 /* We've found a symbol SYM to associate with our linespec; build a
2106    corresponding struct symtabs_and_lines.  */
2107
2108 static struct symtabs_and_lines
2109 symbol_found (int funfirstline, struct linespec_result *canonical, char *copy,
2110               struct symbol *sym, struct symtab *file_symtab,
2111               struct symbol *function_symbol)
2112 {
2113   struct symtabs_and_lines values;
2114
2115   if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2116     {
2117       /* Arg is the name of a function.  */
2118       values.sals = (struct symtab_and_line *)
2119         xmalloc (sizeof (struct symtab_and_line));
2120       values.sals[0] = find_function_start_sal (sym, funfirstline);
2121       values.nelts = 1;
2122
2123       /* Don't use the SYMBOL_LINE; if used at all it points to
2124          the line containing the parameters or thereabouts, not
2125          the first line of code.  */
2126
2127       /* We might need a canonical line spec if it is a static
2128          function.  */
2129       if (file_symtab == 0)
2130         {
2131           struct blockvector *bv = BLOCKVECTOR (SYMBOL_SYMTAB (sym));
2132           struct block *b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2133
2134           if (lookup_block_symbol (b, copy, VAR_DOMAIN) != NULL)
2135             build_canonical_line_spec (values.sals, copy, canonical);
2136         }
2137       return values;
2138     }
2139   else
2140     {
2141       if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
2142         {
2143           /* We know its line number.  */
2144           values.sals = (struct symtab_and_line *)
2145             xmalloc (sizeof (struct symtab_and_line));
2146           values.nelts = 1;
2147           init_sal (&values.sals[0]);
2148           values.sals[0].symtab = SYMBOL_SYMTAB (sym);
2149           values.sals[0].line = SYMBOL_LINE (sym);
2150           values.sals[0].pc = SYMBOL_VALUE_ADDRESS (sym);
2151           values.sals[0].pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2152           values.sals[0].explicit_pc = 1;
2153
2154           if (canonical)
2155             {
2156               canonical->special_display = 1;
2157               canonical->canonical = xmalloc (sizeof (char *));
2158               canonical->canonical[0]
2159                 = xstrprintf ("%s:%s",
2160                               SYMBOL_NATURAL_NAME (function_symbol),
2161                               SYMBOL_NATURAL_NAME (sym));
2162             }
2163
2164           return values;
2165         }
2166       else if (funfirstline)
2167         error (_("\"%s\" is not a function"), copy);
2168       else if (SYMBOL_LINE (sym) != 0)
2169         {
2170           /* We know its line number.  */
2171           values.sals = (struct symtab_and_line *)
2172             xmalloc (sizeof (struct symtab_and_line));
2173           values.nelts = 1;
2174           memset (&values.sals[0], 0, sizeof (values.sals[0]));
2175           values.sals[0].symtab = SYMBOL_SYMTAB (sym);
2176           values.sals[0].line = SYMBOL_LINE (sym);
2177           values.sals[0].pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
2178           return values;
2179         }
2180       else
2181         /* This can happen if it is compiled with a compiler which doesn't
2182            put out line numbers for variables.  */
2183         /* FIXME: Shouldn't we just set .line and .symtab to zero
2184            and return?  For example, "info line foo" could print
2185            the address.  */
2186         error (_("Line number not known for symbol \"%s\""), copy);
2187     }
2188 }
2189
2190 /* We've found a minimal symbol MSYMBOL to associate with our
2191    linespec; build a corresponding struct symtabs_and_lines.  */
2192
2193 static struct symtabs_and_lines
2194 minsym_found (int funfirstline, struct minimal_symbol *msymbol)
2195 {
2196   struct objfile *objfile = msymbol_objfile (msymbol);
2197   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2198   struct symtabs_and_lines values;
2199   CORE_ADDR pc;
2200
2201   values.sals = (struct symtab_and_line *)
2202     xmalloc (sizeof (struct symtab_and_line));
2203   values.sals[0] = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
2204                                       (struct obj_section *) 0, 0);
2205   values.sals[0].section = SYMBOL_OBJ_SECTION (msymbol);
2206
2207   /* The minimal symbol might point to a function descriptor;
2208      resolve it to the actual code address instead.  */
2209   pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
2210                                            values.sals[0].pc,
2211                                            &current_target);
2212   if (pc != values.sals[0].pc)
2213     values.sals[0] = find_pc_sect_line (pc, NULL, 0);
2214
2215   if (funfirstline)
2216     skip_prologue_sal (&values.sals[0]);
2217
2218   values.nelts = 1;
2219   return values;
2220 }
2221
2222 void
2223 init_linespec_result (struct linespec_result *lr)
2224 {
2225   memset (lr, 0, sizeof (*lr));
2226 }