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