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