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