gdb/linespec.c

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