gdb/symtab.c

   1 /* Symbol table lookup for the GNU debugger, GDB.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "gdbcore.h"
  25 #include "frame.h"
  26 #include "target.h"
  27 #include "value.h"
  28 #include "symfile.h"
  29 #include "objfiles.h"
  30 #include "gdbcmd.h"
  31 #include "call-cmds.h"
  32 #include "regex.h"
  33 #include "expression.h"
  34 #include "language.h"
  35 #include "demangle.h"
  36
  37 #include <obstack.h>
  38 #include <assert.h>
  39
  40 #include <sys/types.h>
  41 #include <fcntl.h>
  42 #include <string.h>
  43 #include <sys/stat.h>
  44 #include <ctype.h>
  45
  46 /* Prototypes for local functions */
  47
  48 extern int
  49 find_methods PARAMS ((struct type *, char *, struct symbol **));
  50
  51 static void
  52 completion_list_add_name PARAMS ((char *, char *, int, char *, char *));
  53
  54 static void
  55 build_canonical_line_spec PARAMS ((struct symtab_and_line *, char *, char ***));
  56
  57 static struct symtabs_and_lines
  58 decode_line_2 PARAMS ((struct symbol *[], int, int, char ***));
  59
  60 static void
  61 rbreak_command PARAMS ((char *, int));
  62
  63 static void
  64 types_info PARAMS ((char *, int));
  65
  66 static void
  67 functions_info PARAMS ((char *, int));
  68
  69 static void
  70 variables_info PARAMS ((char *, int));
  71
  72 static void
  73 sources_info PARAMS ((char *, int));
  74
  75 static void
  76 list_symbols PARAMS ((char *, int, int));
  77
  78 static void
  79 output_source_filename PARAMS ((char *, int *));
  80
  81 static char *
  82 operator_chars PARAMS ((char *, char **));
  83
  84 static int find_line_common PARAMS ((struct linetable *, int, int *));
  85
  86 static struct partial_symbol *
  87 lookup_partial_symbol PARAMS ((struct partial_symtab *, const char *,
  88                                int, enum namespace));
  89
  90 static struct symtab *
  91 lookup_symtab_1 PARAMS ((char *));
  92
  93 /* */
  94
  95 /* The single non-language-specific builtin type */
  96 struct type *builtin_type_error;
  97
  98 /* Block in which the most recently searched-for symbol was found.
  99    Might be better to make this a parameter to lookup_symbol and
 100    value_of_this. */
 101
 102 const struct block *block_found;
 103
 104 char no_symtab_msg[] = "No symbol table is loaded.  Use the \"file\" command.";
 105
 106 /* While the C++ support is still in flux, issue a possibly helpful hint on
 107    using the new command completion feature on single quoted demangled C++
 108    symbols.  Remove when loose ends are cleaned up.   FIXME -fnf */
 109
 110 void
 111 cplusplus_hint (name)
 112      char *name;
 113 {
 114   printf_unfiltered ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name, name);
 115   printf_unfiltered ("(Note leading single quote.)\n");
 116 }
 117
 118 /* Check for a symtab of a specific name; first in symtabs, then in
 119    psymtabs.  *If* there is no '/' in the name, a match after a '/'
 120    in the symtab filename will also work.  */
 121
 122 static struct symtab *
 123 lookup_symtab_1 (name)
 124      char *name;
 125 {
 126   register struct symtab *s;
 127   register struct partial_symtab *ps;
 128   register char *slash;
 129   register struct objfile *objfile;
 130
 131  got_symtab:
 132
 133   /* First, search for an exact match */
 134
 135   ALL_SYMTABS (objfile, s)
 136     if (STREQ (name, s->filename))
 137       return s;
 138
 139   slash = strchr (name, '/');
 140
 141   /* Now, search for a matching tail (only if name doesn't have any dirs) */
 142
 143   if (!slash)
 144     ALL_SYMTABS (objfile, s)
 145       {
 146         char *p = s -> filename;
 147         char *tail = strrchr (p, '/');
 148
 149         if (tail)
 150           p = tail + 1;
 151
 152         if (STREQ (p, name))
 153           return s;
 154       }
 155
 156   /* Same search rules as above apply here, but now we look thru the
 157      psymtabs.  */
 158
 159   ps = lookup_partial_symtab (name);
 160   if (!ps)
 161     return (NULL);
 162
 163   if (ps -> readin)
 164     error ("Internal: readin %s pst for `%s' found when no symtab found.",
 165            ps -> filename, name);
 166
 167   s = PSYMTAB_TO_SYMTAB (ps);
 168
 169   if (s)
 170     return s;
 171
 172   /* At this point, we have located the psymtab for this file, but
 173      the conversion to a symtab has failed.  This usually happens
 174      when we are looking up an include file.  In this case,
 175      PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has
 176      been created.  So, we need to run through the symtabs again in
 177      order to find the file.
 178      XXX - This is a crock, and should be fixed inside of the the
 179      symbol parsing routines. */
 180   goto got_symtab;
 181 }
 182
 183 /* Lookup the symbol table of a source file named NAME.  Try a couple
 184    of variations if the first lookup doesn't work.  */
 185
 186 struct symtab *
 187 lookup_symtab (name)
 188      char *name;
 189 {
 190   register struct symtab *s;
 191   register char *copy;
 192
 193   s = lookup_symtab_1 (name);
 194   if (s) return s;
 195
 196 #if 0
 197   /* This screws c-exp.y:yylex if there is both a type "tree" and a symtab
 198      "tree.c".  */
 199
 200   /* If name not found as specified, see if adding ".c" helps.  */
 201   /* Why is this?  Is it just a user convenience?  (If so, it's pretty
 202      questionable in the presence of C++, FORTRAN, etc.).  It's not in
 203      the GDB manual.  */
 204
 205   copy = (char *) alloca (strlen (name) + 3);
 206   strcpy (copy, name);
 207   strcat (copy, ".c");
 208   s = lookup_symtab_1 (copy);
 209   if (s) return s;
 210 #endif /* 0 */
 211
 212   /* We didn't find anything; die.  */
 213   return 0;
 214 }
 215
 216 /* Lookup the partial symbol table of a source file named NAME.
 217    *If* there is no '/' in the name, a match after a '/'
 218    in the psymtab filename will also work.  */
 219
 220 struct partial_symtab *
 221 lookup_partial_symtab (name)
 222 char *name;
 223 {
 224   register struct partial_symtab *pst;
 225   register struct objfile *objfile;
 226
 227   ALL_PSYMTABS (objfile, pst)
 228     {
 229       if (STREQ (name, pst -> filename))
 230         {
 231           return (pst);
 232         }
 233     }
 234
 235   /* Now, search for a matching tail (only if name doesn't have any dirs) */
 236
 237   if (!strchr (name, '/'))
 238     ALL_PSYMTABS (objfile, pst)
 239       {
 240         char *p = pst -> filename;
 241         char *tail = strrchr (p, '/');
 242
 243         if (tail)
 244           p = tail + 1;
 245
 246         if (STREQ (p, name))
 247           return (pst);
 248       }
 249
 250   return (NULL);
 251 }
 252 \f
 253 /* Demangle a GDB method stub type.
 254    Note that this function is g++ specific. */
 255
 256 char *
 257 gdb_mangle_name (type, i, j)
 258      struct type *type;
 259      int i, j;
 260 {
 261   int mangled_name_len;
 262   char *mangled_name;
 263   struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 264   struct fn_field *method = &f[j];
 265   char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);
 266   char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 267   char *newname = type_name_no_tag (type);
 268
 269   /* Does the form of physname indicate that it is the full mangled name
 270      of a constructor (not just the args)?  */
 271   int is_full_physname_constructor;
 272
 273   int is_constructor;
 274   int is_destructor = DESTRUCTOR_PREFIX_P (physname);
 275   /* Need a new type prefix.  */
 276   char *const_prefix = method->is_const ? "C" : "";
 277   char *volatile_prefix = method->is_volatile ? "V" : "";
 278   char buf[20];
 279   int len = (newname == NULL ? 0 : strlen (newname));
 280
 281   is_full_physname_constructor =
 282     ((physname[0]=='_' && physname[1]=='_' &&
 283       (isdigit(physname[2]) || physname[2]=='Q' || physname[2]=='t'))
 284      || (strncmp(physname, "__ct", 4) == 0));
 285
 286   is_constructor =
 287     is_full_physname_constructor || (newname && STREQ(field_name, newname));
 288
 289   if (!is_destructor)
 290     is_destructor = (strncmp(physname, "__dt", 4) == 0);
 291
 292 #ifndef GCC_MANGLE_BUG
 293   if (is_destructor || is_full_physname_constructor)
 294     {
 295       mangled_name = (char*) xmalloc(strlen(physname)+1);
 296       strcpy(mangled_name, physname);
 297       return mangled_name;
 298     }
 299
 300   if (len == 0)
 301     {
 302       sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
 303       if (strcmp(buf, "__") == 0)
 304         buf[0] = '\0';
 305     }
 306   else
 307     {
 308       sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
 309     }
 310   mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
 311                           + strlen (buf) + len
 312                           + strlen (physname)
 313                           + 1);
 314
 315   /* Only needed for GNU-mangled names.  ANSI-mangled names
 316      work with the normal mechanisms.  */
 317   if (OPNAME_PREFIX_P (field_name))
 318     {
 319       char *opname = cplus_mangle_opname (field_name + 3, 0);
 320       if (opname == NULL)
 321         error ("No mangling for \"%s\"", field_name);
 322       mangled_name_len += strlen (opname);
 323       mangled_name = (char *)xmalloc (mangled_name_len);
 324
 325       strncpy (mangled_name, field_name, 3);
 326       mangled_name[3] = '\0';
 327       strcat (mangled_name, opname);
 328     }
 329   else
 330     {
 331       mangled_name = (char *)xmalloc (mangled_name_len);
 332       if (is_constructor)
 333         mangled_name[0] = '\0';
 334       else
 335         strcpy (mangled_name, field_name);
 336     }
 337   strcat (mangled_name, buf);
 338   /* If the class doesn't have a name, i.e. newname NULL, then we just
 339      mangle it using 0 for the length of the class.  Thus it gets mangled
 340      as something starting with `::' rather than `classname::'. */
 341   if (newname != NULL)
 342     strcat (mangled_name, newname);
 343
 344 #else
 345
 346   if (is_constructor)
 347     {
 348       buf[0] = '\0';
 349     }
 350   else
 351     {
 352       sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
 353     }
 354
 355   mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
 356                       + strlen (buf) + strlen (physname) + 1);
 357
 358   /* Only needed for GNU-mangled names.  ANSI-mangled names
 359      work with the normal mechanisms.  */
 360   if (OPNAME_PREFIX_P (field_name))
 361     {
 362       char *opname;
 363       opname = cplus_mangle_opname (field_name + 3, 0);
 364       if (opname == NULL)
 365         {
 366           error ("No mangling for \"%s\"", field_name);
 367         }
 368       mangled_name_len += strlen (opname);
 369       mangled_name = (char *) xmalloc (mangled_name_len);
 370
 371       strncpy (mangled_name, field_name, 3);
 372       strcpy (mangled_name + 3, opname);
 373     }
 374   else
 375     {
 376       mangled_name = (char *) xmalloc (mangled_name_len);
 377       if (is_constructor)
 378         {
 379           mangled_name[0] = '\0';
 380         }
 381       else
 382         {
 383           strcpy (mangled_name, field_name);
 384         }
 385     }
 386   strcat (mangled_name, buf);
 387
 388 #endif
 389   strcat (mangled_name, physname);
 390   return (mangled_name);
 391 }
 392
 393 \f
 394 /* Find which partial symtab on contains PC.  Return 0 if none.  */
 395
 396 struct partial_symtab *
 397 find_pc_psymtab (pc)
 398      register CORE_ADDR pc;
 399 {
 400   register struct partial_symtab *pst;
 401   register struct objfile *objfile;
 402
 403   ALL_PSYMTABS (objfile, pst)
 404     {
 405       if (pc >= pst->textlow && pc < pst->texthigh)
 406         return (pst);
 407     }
 408   return (NULL);
 409 }
 410
 411 /* Find which partial symbol within a psymtab contains PC.  Return 0
 412    if none.  Check all psymtabs if PSYMTAB is 0.  */
 413 struct partial_symbol *
 414 find_pc_psymbol (psymtab, pc)
 415      struct partial_symtab *psymtab;
 416      CORE_ADDR pc;
 417 {
 418   struct partial_symbol *best = NULL, *p;
 419   CORE_ADDR best_pc;
 420
 421   if (!psymtab)
 422     psymtab = find_pc_psymtab (pc);
 423   if (!psymtab)
 424     return 0;
 425
 426   best_pc = psymtab->textlow - 1;
 427
 428   /* Search the global symbols as well as the static symbols, so that
 429      find_pc_partial_function doesn't use a minimal symbol and thus
 430      cache a bad endaddr.  */
 431   for (p = psymtab->objfile->global_psymbols.list + psymtab->globals_offset;
 432        (p - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset)
 433         < psymtab->n_global_syms);
 434        p++)
 435     if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
 436         && SYMBOL_CLASS (p) == LOC_BLOCK
 437         && pc >= SYMBOL_VALUE_ADDRESS (p)
 438         && SYMBOL_VALUE_ADDRESS (p) > best_pc)
 439       {
 440         best_pc = SYMBOL_VALUE_ADDRESS (p);
 441         best = p;
 442       }
 443   for (p = psymtab->objfile->static_psymbols.list + psymtab->statics_offset;
 444        (p - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset)
 445         < psymtab->n_static_syms);
 446        p++)
 447     if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
 448         && SYMBOL_CLASS (p) == LOC_BLOCK
 449         && pc >= SYMBOL_VALUE_ADDRESS (p)
 450         && SYMBOL_VALUE_ADDRESS (p) > best_pc)
 451       {
 452         best_pc = SYMBOL_VALUE_ADDRESS (p);
 453         best = p;
 454       }
 455   if (best_pc == psymtab->textlow - 1)
 456     return 0;
 457   return best;
 458 }
 459
 460 \f
 461 /* Find the definition for a specified symbol name NAME
 462    in namespace NAMESPACE, visible from lexical block BLOCK.
 463    Returns the struct symbol pointer, or zero if no symbol is found.
 464    If SYMTAB is non-NULL, store the symbol table in which the
 465    symbol was found there, or NULL if not found.
 466    C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
 467    NAME is a field of the current implied argument `this'.  If so set
 468    *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
 469    BLOCK_FOUND is set to the block in which NAME is found (in the case of
 470    a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
 471
 472 struct symbol *
 473 lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
 474      const char *name;
 475      register const struct block *block;
 476      const enum namespace namespace;
 477      int *is_a_field_of_this;
 478      struct symtab **symtab;
 479 {
 480   register struct symbol *sym;
 481   register struct symtab *s = NULL;
 482   register struct partial_symtab *ps;
 483   struct blockvector *bv;
 484   register struct objfile *objfile;
 485   register struct block *b;
 486   register struct minimal_symbol *msymbol;
 487
 488   /* Search specified block and its superiors.  */
 489
 490   while (block != 0)
 491     {
 492       sym = lookup_block_symbol (block, name, namespace);
 493       if (sym)
 494         {
 495           block_found = block;
 496           if (symtab != NULL)
 497             {
 498               /* Search the list of symtabs for one which contains the
 499                  address of the start of this block.  */
 500               ALL_SYMTABS (objfile, s)
 501                 {
 502                   bv = BLOCKVECTOR (s);
 503                   b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 504                   if (BLOCK_START (b) <= BLOCK_START (block)
 505                       && BLOCK_END (b) > BLOCK_START (block))
 506                     goto found;
 507                 }
 508 found:
 509               *symtab = s;
 510             }
 511
 512           return (sym);
 513         }
 514       block = BLOCK_SUPERBLOCK (block);
 515     }
 516
 517   /* FIXME: this code is never executed--block is always NULL at this
 518      point.  What is it trying to do, anyway?  We already should have
 519      checked the STATIC_BLOCK above (it is the superblock of top-level
 520      blocks).  Why is VAR_NAMESPACE special-cased?  */
 521   /* Don't need to mess with the psymtabs; if we have a block,
 522      that file is read in.  If we don't, then we deal later with
 523      all the psymtab stuff that needs checking.  */
 524   if (namespace == VAR_NAMESPACE && block != NULL)
 525     {
 526       struct block *b;
 527       /* Find the right symtab.  */
 528       ALL_SYMTABS (objfile, s)
 529         {
 530           bv = BLOCKVECTOR (s);
 531           b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
 532           if (BLOCK_START (b) <= BLOCK_START (block)
 533               && BLOCK_END (b) > BLOCK_START (block))
 534             {
 535               sym = lookup_block_symbol (b, name, VAR_NAMESPACE);
 536               if (sym)
 537                 {
 538                   block_found = b;
 539                   if (symtab != NULL)
 540                     *symtab = s;
 541                   return sym;
 542                 }
 543             }
 544         }
 545     }
 546
 547
 548   /* C++: If requested to do so by the caller,
 549      check to see if NAME is a field of `this'. */
 550   if (is_a_field_of_this)
 551     {
 552       struct value *v = value_of_this (0);
 553
 554       *is_a_field_of_this = 0;
 555       if (v && check_field (v, name))
 556         {
 557           *is_a_field_of_this = 1;
 558           if (symtab != NULL)
 559             *symtab = NULL;
 560           return 0;
 561         }
 562     }
 563
 564   /* Now search all global blocks.  Do the symtab's first, then
 565      check the psymtab's */
 566
 567   ALL_SYMTABS (objfile, s)
 568     {
 569       bv = BLOCKVECTOR (s);
 570       block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 571       sym = lookup_block_symbol (block, name, namespace);
 572       if (sym)
 573         {
 574           block_found = block;
 575           if (symtab != NULL)
 576             *symtab = s;
 577           return sym;
 578         }
 579     }
 580
 581   /* Check for the possibility of the symbol being a global function
 582      that is stored in one of the minimal symbol tables.  Eventually, all
 583      global symbols might be resolved in this way.  */
 584
 585   if (namespace == VAR_NAMESPACE)
 586     {
 587       msymbol = lookup_minimal_symbol (name, (struct objfile *) NULL);
 588       if (msymbol != NULL)
 589         {
 590           s = find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol));
 591           /* If S is NULL, there are no debug symbols for this file.
 592              Skip this stuff and check for matching static symbols below. */
 593           if (s != NULL)
 594             {
 595               bv = BLOCKVECTOR (s);
 596               block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 597               sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
 598                                          namespace);
 599               /* We kept static functions in minimal symbol table as well as
 600                  in static scope. We want to find them in the symbol table. */
 601                 if (!sym) {
 602                   block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
 603                   sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
 604                                              namespace);
 605                 }
 606
 607               /* sym == 0 if symbol was found in the minimal symbol table
 608                  but not in the symtab.
 609                  Return 0 to use the msymbol definition of "foo_".
 610
 611                  This happens for Fortran  "foo_" symbols,
 612                  which are "foo" in the symtab.
 613
 614                  This can also happen if "asm" is used to make a
 615                  regular symbol but not a debugging symbol, e.g.
 616                  asm(".globl _main");
 617                  asm("_main:");
 618                  */
 619
 620               if (symtab != NULL)
 621                 *symtab = s;
 622               return sym;
 623             }
 624         }
 625     }
 626
 627   ALL_PSYMTABS (objfile, ps)
 628     {
 629       if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace))
 630         {
 631           s = PSYMTAB_TO_SYMTAB(ps);
 632           bv = BLOCKVECTOR (s);
 633           block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 634           sym = lookup_block_symbol (block, name, namespace);
 635           if (!sym)
 636             error ("Internal: global symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
 637           if (symtab != NULL)
 638             *symtab = s;
 639           return sym;
 640         }
 641     }
 642
 643   /* Now search all per-file blocks.
 644      Not strictly correct, but more useful than an error.
 645      Do the symtabs first, then check the psymtabs */
 646
 647   ALL_SYMTABS (objfile, s)
 648     {
 649       bv = BLOCKVECTOR (s);
 650       block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
 651       sym = lookup_block_symbol (block, name, namespace);
 652       if (sym)
 653         {
 654           block_found = block;
 655           if (symtab != NULL)
 656             *symtab = s;
 657           return sym;
 658         }
 659     }
 660
 661   ALL_PSYMTABS (objfile, ps)
 662     {
 663       if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace))
 664         {
 665           s = PSYMTAB_TO_SYMTAB(ps);
 666           bv = BLOCKVECTOR (s);
 667           block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
 668           sym = lookup_block_symbol (block, name, namespace);
 669           if (!sym)
 670             error ("Internal: static symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
 671           if (symtab != NULL)
 672             *symtab = s;
 673           return sym;
 674         }
 675     }
 676
 677   /* Now search all per-file blocks for static mangled symbols.
 678      Do the symtabs first, then check the psymtabs.  */
 679
 680   if (namespace == VAR_NAMESPACE)
 681     {
 682       ALL_SYMTABS (objfile, s)
 683         {
 684           bv = BLOCKVECTOR (s);
 685           block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
 686           sym = lookup_block_symbol (block, name, VAR_NAMESPACE);
 687           if (sym)
 688             {
 689               block_found = block;
 690               if (symtab != NULL)
 691                 *symtab = s;
 692               return sym;
 693             }
 694         }
 695
 696       ALL_PSYMTABS (objfile, ps)
 697         {
 698           if (!ps->readin && lookup_partial_symbol (ps, name, 0, VAR_NAMESPACE))
 699             {
 700               s = PSYMTAB_TO_SYMTAB(ps);
 701               bv = BLOCKVECTOR (s);
 702               block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
 703               sym = lookup_block_symbol (block, name, VAR_NAMESPACE);
 704               if (!sym)
 705                 error ("Internal: mangled static symbol `%s' found in %s psymtab but not in symtab", name, ps->filename);
 706               if (symtab != NULL)
 707                 *symtab = s;
 708               return sym;
 709             }
 710         }
 711     }
 712
 713   if (symtab != NULL)
 714     *symtab = NULL;
 715   return 0;
 716 }
 717
 718 /* Look, in partial_symtab PST, for symbol NAME.  Check the global
 719    symbols if GLOBAL, the static symbols if not */
 720
 721 static struct partial_symbol *
 722 lookup_partial_symbol (pst, name, global, namespace)
 723      struct partial_symtab *pst;
 724      const char *name;
 725      int global;
 726      enum namespace namespace;
 727 {
 728   struct partial_symbol *start, *psym;
 729   struct partial_symbol *top, *bottom, *center;
 730   int length = (global ? pst->n_global_syms : pst->n_static_syms);
 731   int do_linear_search = 1;
 732
 733   if (length == 0)
 734     {
 735       return (NULL);
 736     }
 737
 738   start = (global ?
 739            pst->objfile->global_psymbols.list + pst->globals_offset :
 740            pst->objfile->static_psymbols.list + pst->statics_offset  );
 741
 742   if (global)           /* This means we can use a binary search. */
 743     {
 744       do_linear_search = 0;
 745
 746       /* Binary search.  This search is guaranteed to end with center
 747          pointing at the earliest partial symbol with the correct
 748          name.  At that point *all* partial symbols with that name
 749          will be checked against the correct namespace. */
 750
 751       bottom = start;
 752       top = start + length - 1;
 753       while (top > bottom)
 754         {
 755           center = bottom + (top - bottom) / 2;
 756           assert (center < top);
 757           if (!do_linear_search && SYMBOL_LANGUAGE (center) == language_cplus)
 758             {
 759               do_linear_search = 1;
 760             }
 761           if (STRCMP (SYMBOL_NAME (center), name) >= 0)
 762             {
 763               top = center;
 764             }
 765           else
 766             {
 767               bottom = center + 1;
 768             }
 769         }
 770       assert (top == bottom);
 771       while (STREQ (SYMBOL_NAME (top), name))
 772         {
 773           if (SYMBOL_NAMESPACE (top) == namespace)
 774             {
 775               return top;
 776             }
 777           top ++;
 778         }
 779     }
 780
 781   /* Can't use a binary search or else we found during the binary search that
 782      we should also do a linear search. */
 783
 784   if (do_linear_search)
 785     {
 786       for (psym = start; psym < start + length; psym++)
 787         {
 788           if (namespace == SYMBOL_NAMESPACE (psym))
 789             {
 790               if (SYMBOL_MATCHES_NAME (psym, name))
 791                 {
 792                   return (psym);
 793                 }
 794             }
 795         }
 796     }
 797
 798   return (NULL);
 799 }
 800
 801 /* Find the psymtab containing main(). */
 802 /* FIXME:  What about languages without main() or specially linked
 803    executables that have no main() ? */
 804
 805 struct partial_symtab *
 806 find_main_psymtab ()
 807 {
 808   register struct partial_symtab *pst;
 809   register struct objfile *objfile;
 810
 811   ALL_PSYMTABS (objfile, pst)
 812     {
 813       if (lookup_partial_symbol (pst, "main", 1, VAR_NAMESPACE))
 814         {
 815           return (pst);
 816         }
 817     }
 818   return (NULL);
 819 }
 820
 821 /* Search BLOCK for symbol NAME in NAMESPACE.
 822
 823    Note that if NAME is the demangled form of a C++ symbol, we will fail
 824    to find a match during the binary search of the non-encoded names, but
 825    for now we don't worry about the slight inefficiency of looking for
 826    a match we'll never find, since it will go pretty quick.  Once the
 827    binary search terminates, we drop through and do a straight linear
 828    search on the symbols.  Each symbol which is marked as being a C++
 829    symbol (language_cplus set) has both the encoded and non-encoded names
 830    tested for a match. */
 831
 832 struct symbol *
 833 lookup_block_symbol (block, name, namespace)
 834      register const struct block *block;
 835      const char *name;
 836      const enum namespace namespace;
 837 {
 838   register int bot, top, inc;
 839   register struct symbol *sym;
 840   register struct symbol *sym_found = NULL;
 841   register int do_linear_search = 1;
 842
 843   /* If the blocks's symbols were sorted, start with a binary search.  */
 844
 845   if (BLOCK_SHOULD_SORT (block))
 846     {
 847       /* Reset the linear search flag so if the binary search fails, we
 848          won't do the linear search once unless we find some reason to
 849          do so, such as finding a C++ symbol during the binary search.
 850          Note that for C++ modules, ALL the symbols in a block should
 851          end up marked as C++ symbols. */
 852
 853       do_linear_search = 0;
 854       top = BLOCK_NSYMS (block);
 855       bot = 0;
 856
 857       /* Advance BOT to not far before the first symbol whose name is NAME. */
 858
 859       while (1)
 860         {
 861           inc = (top - bot + 1);
 862           /* No need to keep binary searching for the last few bits worth.  */
 863           if (inc < 4)
 864             {
 865               break;
 866             }
 867           inc = (inc >> 1) + bot;
 868           sym = BLOCK_SYM (block, inc);
 869           if (!do_linear_search && SYMBOL_LANGUAGE (sym) == language_cplus)
 870             {
 871               do_linear_search = 1;
 872             }
 873           if (SYMBOL_NAME (sym)[0] < name[0])
 874             {
 875               bot = inc;
 876             }
 877           else if (SYMBOL_NAME (sym)[0] > name[0])
 878             {
 879               top = inc;
 880             }
 881           else if (STRCMP (SYMBOL_NAME (sym), name) < 0)
 882             {
 883               bot = inc;
 884             }
 885           else
 886             {
 887               top = inc;
 888             }
 889         }
 890
 891       /* Now scan forward until we run out of symbols, find one whose
 892          name is greater than NAME, or find one we want.  If there is
 893          more than one symbol with the right name and namespace, we
 894          return the first one; I believe it is now impossible for us
 895          to encounter two symbols with the same name and namespace
 896          here, because blocks containing argument symbols are no
 897          longer sorted.  */
 898
 899       top = BLOCK_NSYMS (block);
 900       while (bot < top)
 901         {
 902           sym = BLOCK_SYM (block, bot);
 903           inc = SYMBOL_NAME (sym)[0] - name[0];
 904           if (inc == 0)
 905             {
 906               inc = STRCMP (SYMBOL_NAME (sym), name);
 907             }
 908           if (inc == 0 && SYMBOL_NAMESPACE (sym) == namespace)
 909             {
 910               return (sym);
 911             }
 912           if (inc > 0)
 913             {
 914               break;
 915             }
 916           bot++;
 917         }
 918     }
 919
 920   /* Here if block isn't sorted, or we fail to find a match during the
 921      binary search above.  If during the binary search above, we find a
 922      symbol which is a C++ symbol, then we have re-enabled the linear
 923      search flag which was reset when starting the binary search.
 924
 925      This loop is equivalent to the loop above, but hacked greatly for speed.
 926
 927      Note that parameter symbols do not always show up last in the
 928      list; this loop makes sure to take anything else other than
 929      parameter symbols first; it only uses parameter symbols as a
 930      last resort.  Note that this only takes up extra computation
 931      time on a match.  */
 932
 933   if (do_linear_search)
 934     {
 935       top = BLOCK_NSYMS (block);
 936       bot = 0;
 937       while (bot < top)
 938         {
 939           sym = BLOCK_SYM (block, bot);
 940           if (SYMBOL_NAMESPACE (sym) == namespace &&
 941               SYMBOL_MATCHES_NAME (sym, name))
 942             {
 943               sym_found = sym;
 944               if (SYMBOL_CLASS (sym) != LOC_ARG &&
 945                   SYMBOL_CLASS (sym) != LOC_LOCAL_ARG &&
 946                   SYMBOL_CLASS (sym) != LOC_REF_ARG &&
 947                   SYMBOL_CLASS (sym) != LOC_REGPARM &&
 948                   SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR &&
 949                   SYMBOL_CLASS (sym) != LOC_BASEREG_ARG)
 950                 {
 951                   break;
 952                 }
 953             }
 954           bot++;
 955         }
 956     }
 957   return (sym_found);           /* Will be NULL if not found. */
 958 }
 959
 960 \f
 961 /* Return the symbol for the function which contains a specified
 962    lexical block, described by a struct block BL.  */
 963
 964 struct symbol *
 965 block_function (bl)
 966      struct block *bl;
 967 {
 968   while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
 969     bl = BLOCK_SUPERBLOCK (bl);
 970
 971   return BLOCK_FUNCTION (bl);
 972 }
 973
 974 /* Find the symtab associated with PC.  Look through the psymtabs and read in
 975    another symtab if necessary. */
 976
 977 struct symtab *
 978 find_pc_symtab (pc)
 979      register CORE_ADDR pc;
 980 {
 981   register struct block *b;
 982   struct blockvector *bv;
 983   register struct symtab *s = NULL;
 984   register struct symtab *best_s = NULL;
 985   register struct partial_symtab *ps;
 986   register struct objfile *objfile;
 987   int distance = 0;
 988
 989   /* Search all symtabs for the one whose file contains our address, and which
 990      is the smallest of all the ones containing the address.  This is designed
 991      to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000
 992      and symtab b is at 0x2000-0x3000.  So the GLOBAL_BLOCK for a is from
 993      0x1000-0x4000, but for address 0x2345 we want to return symtab b.
 994      This is said to happen for the mips; it might be swifter to create
 995      several symtabs with the same name like xcoff does (I'm not sure).  */
 996
 997   ALL_SYMTABS (objfile, s)
 998     {
 999       bv = BLOCKVECTOR (s);
1000       b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1001       if (BLOCK_START (b) <= pc
1002           && BLOCK_END (b) > pc
1003           && (distance == 0
1004               || BLOCK_END (b) - BLOCK_START (b) < distance))
1005         {
1006           distance = BLOCK_END (b) - BLOCK_START (b);
1007           best_s = s;
1008         }
1009     }
1010
1011   if (best_s != NULL)
1012     return(best_s);
1013
1014   s = NULL;
1015   ps = find_pc_psymtab (pc);
1016   if (ps)
1017     {
1018       if (ps->readin)
1019         /* Might want to error() here (in case symtab is corrupt and
1020            will cause a core dump), but maybe we can successfully
1021            continue, so let's not.  */
1022         warning ("\
1023 (Internal error: pc 0x%lx in read in psymtab, but not in symtab.)\n",
1024                  (unsigned long) pc);
1025       s = PSYMTAB_TO_SYMTAB (ps);
1026     }
1027   return (s);
1028 }
1029 \f
1030 /* Find the closest symbol value (of any sort -- function or variable)
1031    for a given address value.  Slow but complete.  */
1032
1033 struct symbol *
1034 find_addr_symbol (addr)
1035      CORE_ADDR addr;
1036 {
1037   struct symtab *symtab;
1038   struct objfile *objfile;
1039   register int bot, top;
1040   register struct symbol *sym;
1041   register CORE_ADDR sym_addr;
1042   struct block *block;
1043   int blocknum;
1044
1045   /* Info on best symbol seen so far */
1046
1047   register CORE_ADDR best_sym_addr = 0;
1048   struct symbol *best_sym = 0;
1049
1050   /* FIXME -- we should pull in all the psymtabs, too!  */
1051   ALL_SYMTABS (objfile, symtab)
1052     {
1053       /* Search the global and static blocks in this symtab for
1054          the closest symbol-address to the desired address.  */
1055
1056       for (blocknum = GLOBAL_BLOCK; blocknum <= STATIC_BLOCK; blocknum++)
1057         {
1058           QUIT;
1059           block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), blocknum);
1060           top = BLOCK_NSYMS (block);
1061           for (bot = 0; bot < top; bot++)
1062             {
1063               sym = BLOCK_SYM (block, bot);
1064               switch (SYMBOL_CLASS (sym))
1065                 {
1066                 case LOC_STATIC:
1067                 case LOC_LABEL:
1068                   sym_addr = SYMBOL_VALUE_ADDRESS (sym);
1069                   break;
1070
1071                 case LOC_BLOCK:
1072                   sym_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1073                   break;
1074
1075                 default:
1076                   continue;
1077                 }
1078
1079                 if (sym_addr <= addr)
1080                   if (sym_addr > best_sym_addr)
1081                     {
1082                       /* Quit if we found an exact match.  */
1083                       if (sym_addr == addr)
1084                         return sym;
1085                       best_sym = sym;
1086                       best_sym_addr = sym_addr;
1087                     }
1088             }
1089         }
1090     }
1091   return best_sym;
1092 }
1093
1094
1095 /* Find the source file and line number for a given PC value.
1096    Return a structure containing a symtab pointer, a line number,
1097    and a pc range for the entire source line.
1098    The value's .pc field is NOT the specified pc.
1099    NOTCURRENT nonzero means, if specified pc is on a line boundary,
1100    use the line that ends there.  Otherwise, in that case, the line
1101    that begins there is used.  */
1102
1103 /* The big complication here is that a line may start in one file, and end just
1104    before the start of another file.  This usually occurs when you #include
1105    code in the middle of a subroutine.  To properly find the end of a line's PC
1106    range, we must search all symtabs associated with this compilation unit, and
1107    find the one whose first PC is closer than that of the next line in this
1108    symtab.  */
1109
1110 /* If it's worth the effort, we could be using a binary search.  */
1111
1112 struct symtab_and_line
1113 find_pc_line (pc, notcurrent)
1114      CORE_ADDR pc;
1115      int notcurrent;
1116 {
1117   struct symtab *s;
1118   register struct linetable *l;
1119   register int len;
1120   register int i;
1121   register struct linetable_entry *item;
1122   struct symtab_and_line val;
1123   struct blockvector *bv;
1124
1125   /* Info on best line seen so far, and where it starts, and its file.  */
1126
1127   struct linetable_entry *best = NULL;
1128   CORE_ADDR best_end = 0;
1129   struct symtab *best_symtab = 0;
1130
1131   /* Store here the first line number
1132      of a file which contains the line at the smallest pc after PC.
1133      If we don't find a line whose range contains PC,
1134      we will use a line one less than this,
1135      with a range from the start of that file to the first line's pc.  */
1136   struct linetable_entry *alt = NULL;
1137   struct symtab *alt_symtab = 0;
1138
1139   /* Info on best line seen in this file.  */
1140
1141   struct linetable_entry *prev;
1142
1143   /* If this pc is not from the current frame,
1144      it is the address of the end of a call instruction.
1145      Quite likely that is the start of the following statement.
1146      But what we want is the statement containing the instruction.
1147      Fudge the pc to make sure we get that.  */
1148
1149   if (notcurrent) pc -= 1;
1150
1151   s = find_pc_symtab (pc);
1152   if (!s)
1153     {
1154       val.symtab = 0;
1155       val.line = 0;
1156       val.pc = pc;
1157       val.end = 0;
1158       return val;
1159     }
1160
1161   bv = BLOCKVECTOR (s);
1162
1163   /* Look at all the symtabs that share this blockvector.
1164      They all have the same apriori range, that we found was right;
1165      but they have different line tables.  */
1166
1167   for (; s && BLOCKVECTOR (s) == bv; s = s->next)
1168     {
1169       /* Find the best line in this symtab.  */
1170       l = LINETABLE (s);
1171       if (!l)
1172         continue;
1173       len = l->nitems;
1174       if (len <= 0)
1175         {
1176           /* I think len can be zero if the symtab lacks line numbers
1177              (e.g. gcc -g1).  (Either that or the LINETABLE is NULL;
1178              I'm not sure which, and maybe it depends on the symbol
1179              reader).  */
1180           continue;
1181         }
1182
1183       prev = NULL;
1184       item = l->item;           /* Get first line info */
1185
1186       /* Is this file's first line closer than the first lines of other files?
1187          If so, record this file, and its first line, as best alternate.  */
1188       if (item->pc > pc && (!alt || item->pc < alt->pc))
1189         {
1190           alt = item;
1191           alt_symtab = s;
1192         }
1193
1194       for (i = 0; i < len; i++, item++)
1195         {
1196           /* Return the last line that did not start after PC.  */
1197           if (item->pc > pc)
1198             break;
1199
1200           prev = item;
1201         }
1202
1203       /* At this point, prev points at the line whose start addr is <= pc, and
1204          item points at the next line.  If we ran off the end of the linetable
1205          (pc >= start of the last line), then prev == item.  If pc < start of
1206          the first line, prev will not be set.  */
1207
1208       /* Is this file's best line closer than the best in the other files?
1209          If so, record this file, and its best line, as best so far.  */
1210
1211       if (prev && (!best || prev->pc > best->pc))
1212         {
1213           best = prev;
1214           best_symtab = s;
1215           /* If another line is in the linetable, and its PC is closer
1216              than the best_end we currently have, take it as best_end.  */
1217           if (i < len && (best_end == 0 || best_end > item->pc))
1218             best_end = item->pc;
1219         }
1220     }
1221
1222   if (!best_symtab)
1223     {
1224       if (!alt_symtab)
1225         {                       /* If we didn't find any line # info, just
1226                                  return zeros.  */
1227           val.symtab = 0;
1228           val.line = 0;
1229           val.pc = pc;
1230           val.end = 0;
1231         }
1232       else
1233         {
1234           val.symtab = alt_symtab;
1235           val.line = alt->line - 1;
1236           val.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
1237           val.end = alt->pc;
1238         }
1239     }
1240   else
1241     {
1242       val.symtab = best_symtab;
1243       val.line = best->line;
1244       val.pc = best->pc;
1245       if (best_end && (!alt || best_end < alt->pc))
1246         val.end = best_end;
1247       else if (alt)
1248         val.end = alt->pc;
1249       else
1250         val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
1251     }
1252   return val;
1253 }
1254 \f
1255 static int find_line_symtab PARAMS ((struct symtab *, int, struct linetable **,
1256                                      int *, int *));
1257
1258 /* Find line number LINE in any symtab whose name is the same as
1259    SYMTAB.
1260
1261    If found, return 1, set *LINETABLE to the linetable in which it was
1262    found, set *INDEX to the index in the linetable of the best entry
1263    found, and set *EXACT_MATCH nonzero if the value returned is an
1264    exact match.
1265
1266    If not found, return 0.  */
1267
1268 static int
1269 find_line_symtab (symtab, line, linetable, index, exact_match)
1270      struct symtab *symtab;
1271      int line;
1272      struct linetable **linetable;
1273      int *index;
1274      int *exact_match;
1275 {
1276   int exact;
1277
1278   /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE
1279      so far seen.  */
1280
1281   int best_index;
1282   struct linetable *best_linetable;
1283
1284   /* First try looking it up in the given symtab.  */
1285   best_linetable = LINETABLE (symtab);
1286   best_index = find_line_common (best_linetable, line, &exact);
1287   if (best_index < 0 || !exact)
1288     {
1289       /* Didn't find an exact match.  So we better keep looking for
1290          another symtab with the same name.  In the case of xcoff,
1291          multiple csects for one source file (produced by IBM's FORTRAN
1292          compiler) produce multiple symtabs (this is unavoidable
1293          assuming csects can be at arbitrary places in memory and that
1294          the GLOBAL_BLOCK of a symtab has a begin and end address).  */
1295
1296       /* BEST is the smallest linenumber > LINE so far seen,
1297          or 0 if none has been seen so far.
1298          BEST_INDEX and BEST_LINETABLE identify the item for it.  */
1299       int best;
1300
1301       struct objfile *objfile;
1302       struct symtab *s;
1303
1304       if (best_index >= 0)
1305         best = best_linetable->item[best_index].line;
1306       else
1307         best = 0;
1308
1309       ALL_SYMTABS (objfile, s)
1310         {
1311           struct linetable *l;
1312           int ind;
1313
1314           if (!STREQ (symtab->filename, s->filename))
1315             continue;
1316           l = LINETABLE (s);
1317           ind = find_line_common (l, line, &exact);
1318           if (ind >= 0)
1319             {
1320               if (exact)
1321                 {
1322                   best_index = ind;
1323                   best_linetable = l;
1324                   goto done;
1325                 }
1326               if (best == 0 || l->item[ind].line < best)
1327                 {
1328                   best = l->item[ind].line;
1329                   best_index = ind;
1330                   best_linetable = l;
1331                 }
1332             }
1333         }
1334     }
1335  done:
1336   if (best_index < 0)
1337     return 0;
1338
1339   if (index)
1340     *index = best_index;
1341   if (linetable)
1342     *linetable = best_linetable;
1343   if (exact_match)
1344     *exact_match = exact;
1345   return 1;
1346 }
1347 \f
1348 /* Find the PC value for a given source file and line number.
1349    Returns zero for invalid line number.
1350    The source file is specified with a struct symtab.  */
1351
1352 CORE_ADDR
1353 find_line_pc (symtab, line)
1354      struct symtab *symtab;
1355      int line;
1356 {
1357   struct linetable *l;
1358   int ind;
1359
1360   if (symtab == 0)
1361     return 0;
1362   if (find_line_symtab (symtab, line, &l, &ind, NULL))
1363     return l->item[ind].pc;
1364   else
1365     return 0;
1366 }
1367
1368 /* Find the range of pc values in a line.
1369    Store the starting pc of the line into *STARTPTR
1370    and the ending pc (start of next line) into *ENDPTR.
1371    Returns 1 to indicate success.
1372    Returns 0 if could not find the specified line.  */
1373
1374 int
1375 find_line_pc_range (sal, startptr, endptr)
1376      struct symtab_and_line sal;
1377      CORE_ADDR *startptr, *endptr;
1378 {
1379   CORE_ADDR startaddr;
1380   struct symtab_and_line found_sal;
1381
1382   startaddr = sal.pc;
1383   if (startaddr == 0)
1384     {
1385       startaddr = find_line_pc (sal.symtab, sal.line);
1386     }
1387   if (startaddr == 0)
1388     return 0;
1389
1390   /* This whole function is based on address.  For example, if line 10 has
1391      two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then
1392      "info line *0x123" should say the line goes from 0x100 to 0x200
1393      and "info line *0x355" should say the line goes from 0x300 to 0x400.
1394      This also insures that we never give a range like "starts at 0x134
1395      and ends at 0x12c".  */
1396
1397   found_sal = find_pc_line (startaddr, 0);
1398   if (found_sal.line != sal.line)
1399     {
1400       /* The specified line (sal) has zero bytes.  */
1401       *startptr = found_sal.pc;
1402       *endptr = found_sal.pc;
1403     }
1404   else
1405     {
1406       *startptr = found_sal.pc;
1407       *endptr = found_sal.end;
1408     }
1409   return 1;
1410 }
1411
1412 /* Given a line table and a line number, return the index into the line
1413    table for the pc of the nearest line whose number is >= the specified one.
1414    Return -1 if none is found.  The value is >= 0 if it is an index.
1415
1416    Set *EXACT_MATCH nonzero if the value returned is an exact match.  */
1417
1418 static int
1419 find_line_common (l, lineno, exact_match)
1420      register struct linetable *l;
1421      register int lineno;
1422      int *exact_match;
1423 {
1424   register int i;
1425   register int len;
1426
1427   /* BEST is the smallest linenumber > LINENO so far seen,
1428      or 0 if none has been seen so far.
1429      BEST_INDEX identifies the item for it.  */
1430
1431   int best_index = -1;
1432   int best = 0;
1433
1434   if (lineno <= 0)
1435     return -1;
1436   if (l == 0)
1437     return -1;
1438
1439   len = l->nitems;
1440   for (i = 0; i < len; i++)
1441     {
1442       register struct linetable_entry *item = &(l->item[i]);
1443
1444       if (item->line == lineno)
1445         {
1446           /* Return the first (lowest address) entry which matches.  */
1447           *exact_match = 1;
1448           return i;
1449         }
1450
1451       if (item->line > lineno && (best == 0 || item->line < best))
1452         {
1453           best = item->line;
1454           best_index = i;
1455         }
1456     }
1457
1458   /* If we got here, we didn't get an exact match.  */
1459
1460   *exact_match = 0;
1461   return best_index;
1462 }
1463
1464 int
1465 find_pc_line_pc_range (pc, startptr, endptr)
1466      CORE_ADDR pc;
1467      CORE_ADDR *startptr, *endptr;
1468 {
1469   struct symtab_and_line sal;
1470   sal = find_pc_line (pc, 0);
1471   *startptr = sal.pc;
1472   *endptr = sal.end;
1473   return sal.symtab != 0;
1474 }
1475 \f
1476 /* If P is of the form "operator[ \t]+..." where `...' is
1477    some legitimate operator text, return a pointer to the
1478    beginning of the substring of the operator text.
1479    Otherwise, return "".  */
1480 static char *
1481 operator_chars (p, end)
1482      char *p;
1483      char **end;
1484 {
1485   *end = "";
1486   if (strncmp (p, "operator", 8))
1487     return *end;
1488   p += 8;
1489
1490   /* Don't get faked out by `operator' being part of a longer
1491      identifier.  */
1492   if (isalpha(*p) || *p == '_' || *p == '$' || *p == '\0')
1493     return *end;
1494
1495   /* Allow some whitespace between `operator' and the operator symbol.  */
1496   while (*p == ' ' || *p == '\t')
1497     p++;
1498
1499   /* Recognize 'operator TYPENAME'. */
1500
1501   if (isalpha(*p) || *p == '_' || *p == '$')
1502     {
1503       register char *q = p+1;
1504       while (isalnum(*q) || *q == '_' || *q == '$')
1505         q++;
1506       *end = q;
1507       return p;
1508     }
1509
1510   switch (*p)
1511     {
1512     case '!':
1513     case '=':
1514     case '*':
1515     case '/':
1516     case '%':
1517     case '^':
1518       if (p[1] == '=')
1519         *end = p+2;
1520       else
1521         *end = p+1;
1522       return p;
1523     case '<':
1524     case '>':
1525     case '+':
1526     case '-':
1527     case '&':
1528     case '|':
1529       if (p[1] == '=' || p[1] == p[0])
1530         *end = p+2;
1531       else
1532         *end = p+1;
1533       return p;
1534     case '~':
1535     case ',':
1536       *end = p+1;
1537       return p;
1538     case '(':
1539       if (p[1] != ')')
1540         error ("`operator ()' must be specified without whitespace in `()'");
1541       *end = p+2;
1542       return p;
1543     case '?':
1544       if (p[1] != ':')
1545         error ("`operator ?:' must be specified without whitespace in `?:'");
1546       *end = p+2;
1547       return p;
1548     case '[':
1549       if (p[1] != ']')
1550         error ("`operator []' must be specified without whitespace in `[]'");
1551       *end = p+2;
1552       return p;
1553     default:
1554       error ("`operator %s' not supported", p);
1555       break;
1556     }
1557   *end = "";
1558   return *end;
1559 }
1560
1561 /* Recursive helper function for decode_line_1.
1562  * Look for methods named NAME in type T.
1563  * Return number of matches.
1564  * Put matches in SYM_ARR (which better be big enough!).
1565  * These allocations seem to define "big enough":
1566  * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1567  * Note that this function is g++ specific.
1568  */
1569
1570 int
1571 find_methods (t, name, sym_arr)
1572      struct type *t;
1573      char *name;
1574      struct symbol **sym_arr;
1575 {
1576   int i1 = 0;
1577   int ibase;
1578   struct symbol *sym_class;
1579   char *class_name = type_name_no_tag (t);
1580   /* Ignore this class if it doesn't have a name.  This is ugly, but
1581      unless we figure out how to get the physname without the name of
1582      the class, then the loop can't do any good.  */
1583   if (class_name
1584       && (sym_class = lookup_symbol (class_name,
1585                                      (struct block *)NULL,
1586                                      STRUCT_NAMESPACE,
1587                                      (int *)NULL,
1588                                      (struct symtab **)NULL)))
1589     {
1590       int method_counter;
1591       /* FIXME: Shouldn't this just be check_stub_type (t)?  */
1592       t = SYMBOL_TYPE (sym_class);
1593       for (method_counter = TYPE_NFN_FIELDS (t) - 1;
1594            method_counter >= 0;
1595            --method_counter)
1596         {
1597           int field_counter;
1598           struct fn_field *f = TYPE_FN_FIELDLIST1 (t, method_counter);
1599           char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
1600           char dem_opname[64];
1601
1602           if (strncmp(method_name, "__", 2)==0 ||
1603             strncmp(method_name, "op", 2)==0 ||
1604             strncmp(method_name, "type", 4)==0 )
1605             {
1606               if (cplus_demangle_opname(method_name, dem_opname, DMGL_ANSI))
1607                 method_name = dem_opname;
1608               else if (cplus_demangle_opname(method_name, dem_opname, 0))
1609                 method_name = dem_opname;
1610             }
1611           if (STREQ (name, method_name))
1612             /* Find all the fields with that name.  */
1613             for (field_counter = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1;
1614                  field_counter >= 0;
1615                  --field_counter)
1616               {
1617                 char *phys_name;
1618                 if (TYPE_FN_FIELD_STUB (f, field_counter))
1619                   check_stub_method (t, method_counter, field_counter);
1620                 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
1621                 /* Destructor is handled by caller, dont add it to the list */
1622                 if (DESTRUCTOR_PREFIX_P (phys_name))
1623                   continue;
1624
1625                 /* FIXME: Why are we looking this up in the
1626                    SYMBOL_BLOCK_VALUE (sym_class)?  It is intended as a hook
1627                    for nested types?  If so, it should probably hook to the
1628                    type, not the symbol.  mipsread.c is the only symbol
1629                    reader which sets the SYMBOL_BLOCK_VALUE for types, and
1630                    this is not documented in symtab.h.  -26Aug93.  */
1631
1632                 sym_arr[i1] = lookup_symbol (phys_name,
1633                                              SYMBOL_BLOCK_VALUE (sym_class),
1634                                              VAR_NAMESPACE,
1635                                              (int *) NULL,
1636                                              (struct symtab **) NULL);
1637                 if (sym_arr[i1]) i1++;
1638                 else
1639                   {
1640                     fputs_filtered("(Cannot find method ", gdb_stdout);
1641                     fprintf_symbol_filtered (gdb_stdout, phys_name,
1642                                              language_cplus,
1643                                              DMGL_PARAMS | DMGL_ANSI);
1644                     fputs_filtered(" - possibly inlined.)\n", gdb_stdout);
1645                   }
1646               }
1647         }
1648     }
1649
1650   /* Only search baseclasses if there is no match yet, since names in
1651      derived classes override those in baseclasses.
1652
1653      FIXME: The above is not true; it is only true of member functions
1654      if they have the same number of arguments (??? - section 13.1 of the
1655      ARM says the function members are not in the same scope but doesn't
1656      really spell out the rules in a way I understand.  In any case, if
1657      the number of arguments differ this is a case in which we can overload
1658      rather than hiding without any problem, and gcc 2.4.5 does overload
1659      rather than hiding in this case).  */
1660
1661   if (i1)
1662     return i1;
1663   for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
1664     i1 += find_methods(TYPE_BASECLASS(t, ibase), name,
1665                        sym_arr + i1);
1666   return i1;
1667 }
1668
1669 /* Helper function for decode_line_1.
1670    Build a canonical line spec in CANONICAL if it is non-NULL and if
1671    the SAL has a symtab.
1672    If SYMNAME is non-NULL the canonical line spec is `filename:symname'.
1673    If SYMNAME is NULL the line number from SAL is used and the canonical
1674    line spec is `filename:linenum'.  */
1675
1676 static void
1677 build_canonical_line_spec (sal, symname, canonical)
1678      struct symtab_and_line *sal;
1679      char *symname;
1680      char ***canonical;
1681 {
1682   char **canonical_arr;
1683   char *canonical_name;
1684   char *filename;
1685   struct symtab *s = sal->symtab;
1686
1687   if (s == (struct symtab *)NULL
1688       || s->filename == (char *)NULL
1689       || canonical == (char ***)NULL)
1690     return;
1691
1692   canonical_arr = (char **) xmalloc (sizeof (char *));
1693   *canonical = canonical_arr;
1694
1695   filename = s->filename;
1696   if (symname != NULL)
1697     {
1698       canonical_name = xmalloc (strlen (filename) + strlen (symname) + 2);
1699       sprintf (canonical_name, "%s:%s", filename, symname);
1700     }
1701   else
1702     {
1703       canonical_name = xmalloc (strlen (filename) + 30);
1704       sprintf (canonical_name, "%s:%d", filename, sal->line);
1705     }
1706   canonical_arr[0] = canonical_name;
1707 }
1708
1709 /* Parse a string that specifies a line number.
1710    Pass the address of a char * variable; that variable will be
1711    advanced over the characters actually parsed.
1712
1713    The string can be:
1714
1715    LINENUM -- that line number in current file.  PC returned is 0.
1716    FILE:LINENUM -- that line in that file.  PC returned is 0.
1717    FUNCTION -- line number of openbrace of that function.
1718       PC returned is the start of the function.
1719    VARIABLE -- line number of definition of that variable.
1720       PC returned is 0.
1721    FILE:FUNCTION -- likewise, but prefer functions in that file.
1722    *EXPR -- line in which address EXPR appears.
1723
1724    FUNCTION may be an undebuggable function found in minimal symbol table.
1725
1726    If the argument FUNFIRSTLINE is nonzero, we want the first line
1727    of real code inside a function when a function is specified.
1728
1729    DEFAULT_SYMTAB specifies the file to use if none is specified.
1730    It defaults to current_source_symtab.
1731    DEFAULT_LINE specifies the line number to use for relative
1732    line numbers (that start with signs).  Defaults to current_source_line.
1733    If CANONICAL is non-NULL, store an array of strings containing the canonical
1734    line specs there if necessary. Currently overloaded member functions and
1735    line numbers or static functions without a filename yield a canonical
1736    line spec. The array and the line spec strings are allocated on the heap,
1737    it is the callers responsibility to free them.
1738
1739    Note that it is possible to return zero for the symtab
1740    if no file is validly specified.  Callers must check that.
1741    Also, the line number returned may be invalid.  */
1742
1743 /* We allow single quotes in various places.  This is a hideous
1744    kludge, which exists because the completer can't yet deal with the
1745    lack of single quotes.  FIXME: write a linespec_completer which we
1746    can use as appropriate instead of make_symbol_completion_list.  */
1747
1748 struct symtabs_and_lines
1749 decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
1750      char **argptr;
1751      int funfirstline;
1752      struct symtab *default_symtab;
1753      int default_line;
1754      char ***canonical;
1755 {
1756   struct symtabs_and_lines values;
1757 #ifdef HPPA_COMPILER_BUG
1758   /* FIXME: The native HP 9000/700 compiler has a bug which appears
1759      when optimizing this file with target i960-vxworks.  I haven't
1760      been able to construct a simple test case.  The problem is that
1761      in the second call to SKIP_PROLOGUE below, the compiler somehow
1762      does not realize that the statement val = find_pc_line (...) will
1763      change the values of the fields of val.  It extracts the elements
1764      into registers at the top of the block, and does not update the
1765      registers after the call to find_pc_line.  You can check this by
1766      inserting a printf at the end of find_pc_line to show what values
1767      it is returning for val.pc and val.end and another printf after
1768      the call to see what values the function actually got (remember,
1769      this is compiling with cc -O, with this patch removed).  You can
1770      also examine the assembly listing: search for the second call to
1771      skip_prologue; the LDO statement before the next call to
1772      find_pc_line loads the address of the structure which
1773      find_pc_line will return; if there is a LDW just before the LDO,
1774      which fetches an element of the structure, then the compiler
1775      still has the bug.
1776
1777      Setting val to volatile avoids the problem.  We must undef
1778      volatile, because the HPPA native compiler does not define
1779      __STDC__, although it does understand volatile, and so volatile
1780      will have been defined away in defs.h.  */
1781 #undef volatile
1782   volatile struct symtab_and_line val;
1783 #define volatile /*nothing*/
1784 #else
1785   struct symtab_and_line val;
1786 #endif
1787   register char *p, *p1;
1788   char *q, *q1, *pp;
1789   register struct symtab *s;
1790
1791   register struct symbol *sym;
1792   /* The symtab that SYM was found in.  */
1793   struct symtab *sym_symtab;
1794
1795   register CORE_ADDR pc;
1796   register struct minimal_symbol *msymbol;
1797   char *copy;
1798   struct symbol *sym_class;
1799   int i1;
1800   int is_quoted, has_parens;
1801   struct symbol **sym_arr;
1802   struct type *t;
1803   char *saved_arg = *argptr;
1804   extern char *gdb_completer_quote_characters;
1805
1806   /* Defaults have defaults.  */
1807
1808   if (default_symtab == 0)
1809     {
1810       default_symtab = current_source_symtab;
1811       default_line = current_source_line;
1812     }
1813
1814   /* See if arg is *PC */
1815
1816   if (**argptr == '*')
1817     {
1818       if (**argptr == '*')
1819         {
1820           (*argptr)++;
1821         }
1822       pc = parse_and_eval_address_1 (argptr);
1823       values.sals = (struct symtab_and_line *)
1824         xmalloc (sizeof (struct symtab_and_line));
1825       values.nelts = 1;
1826       values.sals[0] = find_pc_line (pc, 0);
1827       values.sals[0].pc = pc;
1828       build_canonical_line_spec (values.sals, NULL, canonical);
1829       return values;
1830     }
1831
1832   /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1833
1834   s = NULL;
1835   is_quoted = (strchr(gdb_completer_quote_characters, **argptr) != NULL);
1836   has_parens = (( pp = strchr(*argptr, '(')) != NULL  &&
1837                  (pp = strchr(pp, ')')) != NULL);
1838
1839   for (p = *argptr; *p; p++)
1840     {
1841       if (p[0] == '<')
1842         {
1843           while(!++p && *p != '>');
1844           if (!p)
1845             {
1846               /* FIXME: Why warning() and then return_to_top_level?
1847                  What's wrong with error()?  */
1848               warning("non-matching '<' and '>' in command");
1849               return_to_top_level (RETURN_ERROR);
1850             }
1851         }
1852       if (p[0] == ':' || p[0] == ' ' || p[0] == '\t')
1853         break;
1854     }
1855   while (p[0] == ' ' || p[0] == '\t') p++;
1856
1857   if ((p[0] == ':') && !has_parens)
1858     {
1859
1860       /*  C++  */
1861       if (is_quoted) *argptr = *argptr+1;
1862       if (p[1] ==':')
1863         {
1864           /* Extract the class name.  */
1865           p1 = p;
1866           while (p != *argptr && p[-1] == ' ') --p;
1867           copy = (char *) alloca (p - *argptr + 1);
1868           memcpy (copy, *argptr, p - *argptr);
1869           copy[p - *argptr] = 0;
1870
1871           /* Discard the class name from the arg.  */
1872           p = p1 + 2;
1873           while (*p == ' ' || *p == '\t') p++;
1874           *argptr = p;
1875
1876           sym_class = lookup_symbol (copy, 0, STRUCT_NAMESPACE, 0,
1877                                      (struct symtab **)NULL);
1878
1879           if (sym_class &&
1880               (   TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_STRUCT
1881                || TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_UNION))
1882             {
1883               /* Arg token is not digits => try it as a function name
1884                  Find the next token(everything up to end or next blank). */
1885               if (strchr(gdb_completer_quote_characters, **argptr) != NULL)
1886                 {
1887                   p = skip_quoted(*argptr);
1888                   *argptr = *argptr + 1;
1889                 }
1890               else
1891                 {
1892                   p = *argptr;
1893                   while (*p && *p!=' ' && *p!='\t' && *p!=',' && *p!=':') p++;
1894                 }
1895 /*
1896               q = operator_chars (*argptr, &q1);
1897               if (q1 - q)
1898                 {
1899                   char *opname;
1900                   char *tmp = alloca (q1 - q + 1);
1901                   memcpy (tmp, q, q1 - q);
1902                   tmp[q1 - q] = '\0';
1903                   opname = cplus_mangle_opname (tmp, DMGL_ANSI);
1904                   if (opname == NULL)
1905                     {
1906                       warning ("no mangling for \"%s\"", tmp);
1907                       cplusplus_hint (saved_arg);
1908                       return_to_top_level (RETURN_ERROR);
1909                     }
1910                   copy = (char*) alloca (3 + strlen(opname));
1911                   sprintf (copy, "__%s", opname);
1912                   p = q1;
1913                 }
1914               else
1915 */
1916                 {
1917                   copy = (char *) alloca (p - *argptr + 1 );
1918                   memcpy (copy, *argptr, p - *argptr);
1919                   copy[p - *argptr] = '\0';
1920                   if (strchr(gdb_completer_quote_characters, copy[p-*argptr-1]) != NULL)
1921                     copy[p - *argptr -1] = '\0';
1922                 }
1923
1924               /* no line number may be specified */
1925               while (*p == ' ' || *p == '\t') p++;
1926               *argptr = p;
1927
1928               sym = 0;
1929               i1 = 0;           /*  counter for the symbol array */
1930               t = SYMBOL_TYPE (sym_class);
1931               sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1932
1933               /* Cfront objects don't have fieldlists.  */
1934               if (destructor_name_p (copy, t) && TYPE_FN_FIELDLISTS (t) != NULL)
1935                 {
1936                   /* destructors are a special case.  */
1937                   struct fn_field *f = TYPE_FN_FIELDLIST1 (t, 0);
1938                   int len = TYPE_FN_FIELDLIST_LENGTH (t, 0) - 1;
1939                   /* gcc 1.x puts destructor in last field,
1940                      gcc 2.x puts destructor in first field.  */
1941                   char *phys_name = TYPE_FN_FIELD_PHYSNAME (f, len);
1942                   if (!DESTRUCTOR_PREFIX_P (phys_name))
1943                     {
1944                       phys_name = TYPE_FN_FIELD_PHYSNAME (f, 0);
1945                       if (!DESTRUCTOR_PREFIX_P (phys_name))
1946                         phys_name = "";
1947                     }
1948                   sym_arr[i1] =
1949                     lookup_symbol (phys_name, SYMBOL_BLOCK_VALUE (sym_class),
1950                                    VAR_NAMESPACE, 0, (struct symtab **)NULL);
1951                   if (sym_arr[i1]) i1++;
1952                 }
1953               else
1954                 i1 = find_methods (t, copy, sym_arr);
1955               if (i1 == 1)
1956                 {
1957                   /* There is exactly one field with that name.  */
1958                   sym = sym_arr[0];
1959
1960                   if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1961                     {
1962                       /* Arg is the name of a function */
1963                       pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1964                       if (funfirstline)
1965                         {
1966                           pc += FUNCTION_START_OFFSET;
1967                           SKIP_PROLOGUE (pc);
1968                         }
1969                       values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1970                       values.nelts = 1;
1971                       values.sals[0] = find_pc_line (pc, 0);
1972                       values.sals[0].pc = (values.sals[0].end && values.sals[0].pc != pc) ? values.sals[0].end : pc;
1973                     }
1974                   else
1975                     {
1976                       values.nelts = 0;
1977                     }
1978                   return values;
1979                 }
1980               if (i1 > 0)
1981                 {
1982                   /* There is more than one field with that name
1983                      (overloaded).  Ask the user which one to use.  */
1984                   return decode_line_2 (sym_arr, i1, funfirstline, canonical);
1985                 }
1986               else
1987                 {
1988                   char *tmp;
1989
1990                   if (OPNAME_PREFIX_P (copy))
1991                     {
1992                       tmp = (char *)alloca (strlen (copy+3) + 9);
1993                       strcpy (tmp, "operator ");
1994                       strcat (tmp, copy+3);
1995                     }
1996                   else
1997                     tmp = copy;
1998                   if (tmp[0] == '~')
1999                     warning ("the class `%s' does not have destructor defined",
2000                              SYMBOL_SOURCE_NAME(sym_class));
2001                   else
2002                     warning ("the class %s does not have any method named %s",
2003                              SYMBOL_SOURCE_NAME(sym_class), tmp);
2004                   cplusplus_hint (saved_arg);
2005                   return_to_top_level (RETURN_ERROR);
2006                 }
2007             }
2008           else
2009             {
2010               /* The quotes are important if copy is empty.  */
2011               warning ("can't find class, struct, or union named \"%s\"",
2012                        copy);
2013               cplusplus_hint (saved_arg);
2014               return_to_top_level (RETURN_ERROR);
2015             }
2016         }
2017       /*  end of C++  */
2018
2019
2020       /* Extract the file name.  */
2021       p1 = p;
2022       while (p != *argptr && p[-1] == ' ') --p;
2023       copy = (char *) alloca (p - *argptr + 1);
2024       memcpy (copy, *argptr, p - *argptr);
2025       copy[p - *argptr] = 0;
2026
2027       /* Find that file's data.  */
2028       s = lookup_symtab (copy);
2029       if (s == 0)
2030         {
2031           if (!have_full_symbols () && !have_partial_symbols ())
2032             error (no_symtab_msg);
2033           error ("No source file named %s.", copy);
2034         }
2035
2036       /* Discard the file name from the arg.  */
2037       p = p1 + 1;
2038       while (*p == ' ' || *p == '\t') p++;
2039       *argptr = p;
2040     }
2041
2042   /* S is specified file's symtab, or 0 if no file specified.
2043      arg no longer contains the file name.  */
2044
2045   /* Check whether arg is all digits (and sign) */
2046
2047   q = *argptr;
2048   if (*q == '-' || *q == '+') q++;
2049   while (*q >= '0' && *q <= '9')
2050     q++;
2051
2052   if (q != *argptr && (*q == 0 || *q == ' ' || *q == '\t' || *q == ','))
2053     {
2054       /* We found a token consisting of all digits -- at least one digit.  */
2055       enum sign {none, plus, minus} sign = none;
2056
2057       /* We might need a canonical line spec if no file was specified.  */
2058       int need_canonical = (s == 0) ? 1 : 0;
2059
2060       /* This is where we need to make sure that we have good defaults.
2061          We must guarantee that this section of code is never executed
2062          when we are called with just a function name, since
2063          select_source_symtab calls us with such an argument  */
2064
2065       if (s == 0 && default_symtab == 0)
2066         {
2067           select_source_symtab (0);
2068           default_symtab = current_source_symtab;
2069           default_line = current_source_line;
2070         }
2071
2072       if (**argptr == '+')
2073         sign = plus, (*argptr)++;
2074       else if (**argptr == '-')
2075         sign = minus, (*argptr)++;
2076       val.line = atoi (*argptr);
2077       switch (sign)
2078         {
2079         case plus:
2080           if (q == *argptr)
2081             val.line = 5;
2082           if (s == 0)
2083             val.line = default_line + val.line;
2084           break;
2085         case minus:
2086           if (q == *argptr)
2087             val.line = 15;
2088           if (s == 0)
2089             val.line = default_line - val.line;
2090           else
2091             val.line = 1;
2092           break;
2093         case none:
2094           break;        /* No need to adjust val.line.  */
2095         }
2096
2097       while (*q == ' ' || *q == '\t') q++;
2098       *argptr = q;
2099       if (s == 0)
2100         s = default_symtab;
2101       val.symtab = s;
2102       val.pc = 0;
2103       values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
2104       values.sals[0] = val;
2105       values.nelts = 1;
2106       if (need_canonical)
2107         build_canonical_line_spec (values.sals, NULL, canonical);
2108       return values;
2109     }
2110
2111   /* Arg token is not digits => try it as a variable name
2112      Find the next token (everything up to end or next whitespace).  */
2113
2114   if (is_quoted)
2115     {
2116       p = skip_quoted (*argptr);
2117       if (p[-1] != '\'')
2118         error ("Unmatched single quote.");
2119     }
2120   else if (has_parens)
2121     {
2122       p = pp+1;
2123     }
2124   else
2125     {
2126       p = skip_quoted(*argptr);
2127     }
2128
2129   copy = (char *) alloca (p - *argptr + 1);
2130   memcpy (copy, *argptr, p - *argptr);
2131   copy[p - *argptr] = '\0';
2132   if ((copy[0] == copy [p - *argptr - 1])
2133       && strchr (gdb_completer_quote_characters, copy[0]) != NULL)
2134     {
2135       copy [p - *argptr - 1] = '\0';
2136       copy++;
2137     }
2138   while (*p == ' ' || *p == '\t') p++;
2139   *argptr = p;
2140
2141   /* Look up that token as a variable.
2142      If file specified, use that file's per-file block to start with.  */
2143
2144   sym = lookup_symbol (copy,
2145                        (s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
2146                         : get_selected_block ()),
2147                        VAR_NAMESPACE, 0, &sym_symtab);
2148
2149   if (sym != NULL)
2150     {
2151       if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2152         {
2153           /* Arg is the name of a function */
2154           pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
2155           if (funfirstline)
2156             {
2157               pc += FUNCTION_START_OFFSET;
2158               SKIP_PROLOGUE (pc);
2159             }
2160           val = find_pc_line (pc, 0);
2161 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2162           /* Convex: no need to suppress code on first line, if any */
2163           val.pc = pc;
2164 #else
2165           /* Check if SKIP_PROLOGUE left us in mid-line, and the next
2166              line is still part of the same function.  */
2167           if (val.pc != pc
2168               && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= val.end
2169               && val.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
2170             {
2171               /* First pc of next line */
2172               pc = val.end;
2173               /* Recalculate the line number (might not be N+1).  */
2174               val = find_pc_line (pc, 0);
2175             }
2176           val.pc = pc;
2177 #endif
2178           values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
2179           values.sals[0] = val;
2180           values.nelts = 1;
2181
2182           /* Don't use the SYMBOL_LINE; if used at all it points to
2183              the line containing the parameters or thereabouts, not
2184              the first line of code.  */
2185
2186           /* We might need a canonical line spec if it is a static
2187              function.  */
2188           if (s == 0)
2189             {
2190               struct blockvector *bv = BLOCKVECTOR (sym_symtab);
2191               struct block *b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
2192               if (lookup_block_symbol (b, copy, VAR_NAMESPACE) != NULL)
2193                 build_canonical_line_spec (values.sals, copy, canonical);
2194             }
2195           return values;
2196         }
2197       else if (SYMBOL_LINE (sym) != 0)
2198         {
2199           /* We know its line number.  */
2200           values.sals = (struct symtab_and_line *)
2201             xmalloc (sizeof (struct symtab_and_line));
2202           values.nelts = 1;
2203           memset (&values.sals[0], 0, sizeof (values.sals[0]));
2204           values.sals[0].symtab = sym_symtab;
2205           values.sals[0].line = SYMBOL_LINE (sym);
2206           return values;
2207         }
2208       else
2209         /* This can happen if it is compiled with a compiler which doesn't
2210            put out line numbers for variables.  */
2211         /* FIXME: Shouldn't we just set .line and .symtab to zero and
2212            return?  For example, "info line foo" could print the address.  */
2213         error ("Line number not known for symbol \"%s\"", copy);
2214     }
2215
2216   msymbol = lookup_minimal_symbol (copy, (struct objfile *) NULL);
2217   if (msymbol != NULL)
2218     {
2219       val.symtab = 0;
2220       val.line = 0;
2221       val.pc = SYMBOL_VALUE_ADDRESS (msymbol);
2222       if (funfirstline)
2223         {
2224           val.pc += FUNCTION_START_OFFSET;
2225           SKIP_PROLOGUE (val.pc);
2226         }
2227       values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
2228       values.sals[0] = val;
2229       values.nelts = 1;
2230       return values;
2231     }
2232
2233   if (!have_full_symbols () &&
2234       !have_partial_symbols () && !have_minimal_symbols ())
2235     error (no_symtab_msg);
2236
2237   error ("Function \"%s\" not defined.", copy);
2238   return values;        /* for lint */
2239 }
2240
2241 struct symtabs_and_lines
2242 decode_line_spec (string, funfirstline)
2243      char *string;
2244      int funfirstline;
2245 {
2246   struct symtabs_and_lines sals;
2247   if (string == 0)
2248     error ("Empty line specification.");
2249   sals = decode_line_1 (&string, funfirstline,
2250                         current_source_symtab, current_source_line,
2251                         (char ***)NULL);
2252   if (*string)
2253     error ("Junk at end of line specification: %s", string);
2254   return sals;
2255 }
2256
2257 /* Given a list of NELTS symbols in SYM_ARR, return a list of lines to
2258    operate on (ask user if necessary).
2259    If CANONICAL is non-NULL return a corresponding array of mangled names
2260    as canonical line specs there.  */
2261
2262 static struct symtabs_and_lines
2263 decode_line_2 (sym_arr, nelts, funfirstline, canonical)
2264      struct symbol *sym_arr[];
2265      int nelts;
2266      int funfirstline;
2267      char ***canonical;
2268 {
2269   struct symtabs_and_lines values, return_values;
2270   register CORE_ADDR pc;
2271   char *args, *arg1;
2272   int i;
2273   char *prompt;
2274   char *symname;
2275   struct cleanup *old_chain;
2276   char **canonical_arr = (char **)NULL;
2277
2278   values.sals = (struct symtab_and_line *) alloca (nelts * sizeof(struct symtab_and_line));
2279   return_values.sals = (struct symtab_and_line *) xmalloc (nelts * sizeof(struct symtab_and_line));
2280   old_chain = make_cleanup (free, return_values.sals);
2281
2282   if (canonical)
2283     {
2284       canonical_arr = (char **) xmalloc (nelts * sizeof (char *));
2285       make_cleanup (free, canonical_arr);
2286       memset (canonical_arr, 0, nelts * sizeof (char *));
2287       *canonical = canonical_arr;
2288     }
2289
2290   i = 0;
2291   printf_unfiltered("[0] cancel\n[1] all\n");
2292   while (i < nelts)
2293     {
2294       if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
2295         {
2296           /* Arg is the name of a function */
2297           pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr[i]));
2298           if (funfirstline)
2299             {
2300               pc += FUNCTION_START_OFFSET;
2301               SKIP_PROLOGUE (pc);
2302             }
2303           values.sals[i] = find_pc_line (pc, 0);
2304           values.sals[i].pc = (values.sals[i].end && values.sals[i].pc != pc) ?
2305                                values.sals[i].end                      :  pc;
2306           printf_unfiltered("[%d] %s at %s:%d\n", (i+2), SYMBOL_SOURCE_NAME (sym_arr[i]),
2307                  values.sals[i].symtab->filename, values.sals[i].line);
2308         }
2309       else printf_unfiltered ("?HERE\n");
2310       i++;
2311     }
2312
2313   if ((prompt = getenv ("PS2")) == NULL)
2314     {
2315       prompt = ">";
2316     }
2317   printf_unfiltered("%s ",prompt);
2318   gdb_flush(gdb_stdout);
2319
2320   args = command_line_input ((char *) NULL, 0);
2321
2322   if (args == 0 || *args == 0)
2323     error_no_arg ("one or more choice numbers");
2324
2325   i = 0;
2326   while (*args)
2327     {
2328       int num;
2329
2330       arg1 = args;
2331       while (*arg1 >= '0' && *arg1 <= '9') arg1++;
2332       if (*arg1 && *arg1 != ' ' && *arg1 != '\t')
2333         error ("Arguments must be choice numbers.");
2334
2335       num = atoi (args);
2336
2337       if (num == 0)
2338         error ("cancelled");
2339       else if (num == 1)
2340         {
2341           if (canonical_arr)
2342             {
2343               for (i = 0; i < nelts; i++)
2344                 {
2345                   if (canonical_arr[i] == NULL)
2346                     {
2347                       symname = SYMBOL_NAME (sym_arr[i]);
2348                       canonical_arr[i] = savestring (symname, strlen (symname));
2349                     }
2350                 }
2351             }
2352           memcpy (return_values.sals, values.sals,
2353                   (nelts * sizeof(struct symtab_and_line)));
2354           return_values.nelts = nelts;
2355           discard_cleanups (old_chain);
2356           return return_values;
2357         }
2358
2359       if (num > nelts + 2)
2360         {
2361           printf_unfiltered ("No choice number %d.\n", num);
2362         }
2363       else
2364         {
2365           num -= 2;
2366           if (values.sals[num].pc)
2367             {
2368               if (canonical_arr)
2369                 {
2370                   symname = SYMBOL_NAME (sym_arr[num]);
2371                   make_cleanup (free, symname);
2372                   canonical_arr[i] = savestring (symname, strlen (symname));
2373                 }
2374               return_values.sals[i++] = values.sals[num];
2375               values.sals[num].pc = 0;
2376             }
2377           else
2378             {
2379               printf_unfiltered ("duplicate request for %d ignored.\n", num);
2380             }
2381         }
2382
2383       args = arg1;
2384       while (*args == ' ' || *args == '\t') args++;
2385     }
2386   return_values.nelts = i;
2387   discard_cleanups (old_chain);
2388   return return_values;
2389 }
2390
2391 \f
2392 /* Slave routine for sources_info.  Force line breaks at ,'s.
2393    NAME is the name to print and *FIRST is nonzero if this is the first
2394    name printed.  Set *FIRST to zero.  */
2395 static void
2396 output_source_filename (name, first)
2397      char *name;
2398      int *first;
2399 {
2400   /* Table of files printed so far.  Since a single source file can
2401      result in several partial symbol tables, we need to avoid printing
2402      it more than once.  Note: if some of the psymtabs are read in and
2403      some are not, it gets printed both under "Source files for which
2404      symbols have been read" and "Source files for which symbols will
2405      be read in on demand".  I consider this a reasonable way to deal
2406      with the situation.  I'm not sure whether this can also happen for
2407      symtabs; it doesn't hurt to check.  */
2408   static char **tab = NULL;
2409   /* Allocated size of tab in elements.
2410      Start with one 256-byte block (when using GNU malloc.c).
2411      24 is the malloc overhead when range checking is in effect.  */
2412   static int tab_alloc_size = (256 - 24) / sizeof (char *);
2413   /* Current size of tab in elements.  */
2414   static int tab_cur_size;
2415
2416   char **p;
2417
2418   if (*first)
2419     {
2420       if (tab == NULL)
2421         tab = (char **) xmalloc (tab_alloc_size * sizeof (*tab));
2422       tab_cur_size = 0;
2423     }
2424
2425   /* Is NAME in tab?  */
2426   for (p = tab; p < tab + tab_cur_size; p++)
2427     if (STREQ (*p, name))
2428       /* Yes; don't print it again.  */
2429       return;
2430   /* No; add it to tab.  */
2431   if (tab_cur_size == tab_alloc_size)
2432     {
2433       tab_alloc_size *= 2;
2434       tab = (char **) xrealloc ((char *) tab, tab_alloc_size * sizeof (*tab));
2435     }
2436   tab[tab_cur_size++] = name;
2437
2438   if (*first)
2439     {
2440       *first = 0;
2441     }
2442   else
2443     {
2444       printf_filtered (", ");
2445     }
2446
2447   wrap_here ("");
2448   fputs_filtered (name, gdb_stdout);
2449 }
2450
2451 static void
2452 sources_info (ignore, from_tty)
2453      char *ignore;
2454      int from_tty;
2455 {
2456   register struct symtab *s;
2457   register struct partial_symtab *ps;
2458   register struct objfile *objfile;
2459   int first;
2460
2461   if (!have_full_symbols () && !have_partial_symbols ())
2462     {
2463       error (no_symtab_msg);
2464     }
2465
2466   printf_filtered ("Source files for which symbols have been read in:\n\n");
2467
2468   first = 1;
2469   ALL_SYMTABS (objfile, s)
2470     {
2471       output_source_filename (s -> filename, &first);
2472     }
2473   printf_filtered ("\n\n");
2474
2475   printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2476
2477   first = 1;
2478   ALL_PSYMTABS (objfile, ps)
2479     {
2480       if (!ps->readin)
2481         {
2482           output_source_filename (ps -> filename, &first);
2483         }
2484     }
2485   printf_filtered ("\n");
2486 }
2487
2488 /* List all symbols (if REGEXP is NULL) or all symbols matching REGEXP.
2489    If CLASS is zero, list all symbols except functions, type names, and
2490                      constants (enums).
2491    If CLASS is 1, list only functions.
2492    If CLASS is 2, list only type names.
2493    If CLASS is 3, list only method names.
2494
2495    BPT is non-zero if we should set a breakpoint at the functions
2496    we find.  */
2497
2498 static void
2499 list_symbols (regexp, class, bpt)
2500      char *regexp;
2501      int class;
2502      int bpt;
2503 {
2504   register struct symtab *s;
2505   register struct partial_symtab *ps;
2506   register struct blockvector *bv;
2507   struct blockvector *prev_bv = 0;
2508   register struct block *b;
2509   register int i, j;
2510   register struct symbol *sym;
2511   struct partial_symbol *psym;
2512   struct objfile *objfile;
2513   struct minimal_symbol *msymbol;
2514   char *val;
2515   static char *classnames[]
2516     = {"variable", "function", "type", "method"};
2517   int found_in_file = 0;
2518   int found_misc = 0;
2519   static enum minimal_symbol_type types[]
2520     = {mst_data, mst_text, mst_abs, mst_unknown};
2521   static enum minimal_symbol_type types2[]
2522     = {mst_bss,  mst_text, mst_abs, mst_unknown};
2523   enum minimal_symbol_type ourtype = types[class];
2524   enum minimal_symbol_type ourtype2 = types2[class];
2525
2526   if (regexp != NULL)
2527     {
2528       /* Make sure spacing is right for C++ operators.
2529          This is just a courtesy to make the matching less sensitive
2530          to how many spaces the user leaves between 'operator'
2531          and <TYPENAME> or <OPERATOR>. */
2532       char *opend;
2533       char *opname = operator_chars (regexp, &opend);
2534       if (*opname)
2535         {
2536           int fix = -1; /* -1 means ok; otherwise number of spaces needed. */
2537           if (isalpha(*opname) || *opname == '_' || *opname == '$')
2538             {
2539               /* There should 1 space between 'operator' and 'TYPENAME'. */
2540               if (opname[-1] != ' ' || opname[-2] == ' ')
2541                 fix = 1;
2542             }
2543           else
2544             {
2545               /* There should 0 spaces between 'operator' and 'OPERATOR'. */
2546               if (opname[-1] == ' ')
2547                 fix = 0;
2548             }
2549           /* If wrong number of spaces, fix it. */
2550           if (fix >= 0)
2551             {
2552               char *tmp = (char*) alloca(opend-opname+10);
2553               sprintf(tmp, "operator%.*s%s", fix, " ", opname);
2554               regexp = tmp;
2555             }
2556         }
2557
2558       if (0 != (val = re_comp (regexp)))
2559         error ("Invalid regexp (%s): %s", val, regexp);
2560     }
2561
2562   /* Search through the partial symtabs *first* for all symbols
2563      matching the regexp.  That way we don't have to reproduce all of
2564      the machinery below. */
2565
2566   ALL_PSYMTABS (objfile, ps)
2567     {
2568       struct partial_symbol *bound, *gbound, *sbound;
2569       int keep_going = 1;
2570
2571       if (ps->readin) continue;
2572
2573       gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms;
2574       sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms;
2575       bound = gbound;
2576
2577       /* Go through all of the symbols stored in a partial
2578          symtab in one loop. */
2579       psym = objfile->global_psymbols.list + ps->globals_offset;
2580       while (keep_going)
2581         {
2582           if (psym >= bound)
2583             {
2584               if (bound == gbound && ps->n_static_syms != 0)
2585                 {
2586                   psym = objfile->static_psymbols.list + ps->statics_offset;
2587                   bound = sbound;
2588                 }
2589               else
2590                 keep_going = 0;
2591               continue;
2592             }
2593           else
2594             {
2595               QUIT;
2596
2597               /* If it would match (logic taken from loop below)
2598                  load the file and go on to the next one */
2599               if ((regexp == NULL || SYMBOL_MATCHES_REGEXP (psym))
2600                   && ((class == 0 && SYMBOL_CLASS (psym) != LOC_TYPEDEF
2601                        && SYMBOL_CLASS (psym) != LOC_BLOCK)
2602                       || (class == 1 && SYMBOL_CLASS (psym) == LOC_BLOCK)
2603                       || (class == 2 && SYMBOL_CLASS (psym) == LOC_TYPEDEF)
2604                       || (class == 3 && SYMBOL_CLASS (psym) == LOC_BLOCK)))
2605                 {
2606                   PSYMTAB_TO_SYMTAB(ps);
2607                   keep_going = 0;
2608                 }
2609             }
2610           psym++;
2611         }
2612     }
2613
2614   /* Here, we search through the minimal symbol tables for functions that
2615      match, and call find_pc_symtab on them to force their symbols to
2616      be read.  The symbol will then be found during the scan of symtabs
2617      below.  If find_pc_symtab fails, set found_misc so that we will
2618      rescan to print any matching symbols without debug info.  */
2619
2620   if (class == 1)
2621     {
2622       ALL_MSYMBOLS (objfile, msymbol)
2623         {
2624           if (MSYMBOL_TYPE (msymbol) == ourtype ||
2625               MSYMBOL_TYPE (msymbol) == ourtype2)
2626             {
2627               if (regexp == NULL || SYMBOL_MATCHES_REGEXP (msymbol))
2628                 {
2629                   if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
2630                     {
2631                       found_misc = 1;
2632                     }
2633                 }
2634             }
2635         }
2636     }
2637
2638   /* Printout here so as to get after the "Reading in symbols"
2639      messages which will be generated above.  */
2640   if (!bpt)
2641     printf_filtered (regexp
2642           ? "All %ss matching regular expression \"%s\":\n"
2643           : "All defined %ss:\n",
2644           classnames[class],
2645           regexp);
2646
2647   ALL_SYMTABS (objfile, s)
2648     {
2649       found_in_file = 0;
2650       bv = BLOCKVECTOR (s);
2651       /* Often many files share a blockvector.
2652          Scan each blockvector only once so that
2653          we don't get every symbol many times.
2654          It happens that the first symtab in the list
2655          for any given blockvector is the main file.  */
2656       if (bv != prev_bv)
2657         for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
2658           {
2659             b = BLOCKVECTOR_BLOCK (bv, i);
2660             /* Skip the sort if this block is always sorted.  */
2661             if (!BLOCK_SHOULD_SORT (b))
2662               sort_block_syms (b);
2663             for (j = 0; j < BLOCK_NSYMS (b); j++)
2664               {
2665                 QUIT;
2666                 sym = BLOCK_SYM (b, j);
2667                 if ((regexp == NULL || SYMBOL_MATCHES_REGEXP (sym))
2668                     && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
2669                          && SYMBOL_CLASS (sym) != LOC_BLOCK
2670                          && SYMBOL_CLASS (sym) != LOC_CONST)
2671                         || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
2672                         || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2673                         || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK)))
2674                   {
2675                     if (bpt)
2676                       {
2677                         /* Set a breakpoint here, if it's a function */
2678                         if (class == 1)
2679                           {
2680                             /* There may be more than one function with the
2681                                same name but in different files.  In order to
2682                                set breakpoints on all of them, we must give
2683                                both the file name and the function name to
2684                                break_command.  */
2685                             char *string =
2686                               (char *) alloca (strlen (s->filename)
2687                                                + strlen (SYMBOL_NAME(sym))
2688                                                + 2);
2689                             strcpy (string, s->filename);
2690                             strcat (string, ":");
2691                             strcat (string, SYMBOL_NAME(sym));
2692                             break_command (string, 0);
2693                           }
2694                       }
2695                     else if (!found_in_file)
2696                       {
2697                         fputs_filtered ("\nFile ", gdb_stdout);
2698                         fputs_filtered (s->filename, gdb_stdout);
2699                         fputs_filtered (":\n", gdb_stdout);
2700                       }
2701                     found_in_file = 1;
2702
2703                     if (class != 2 && i == STATIC_BLOCK)
2704                       printf_filtered ("static ");
2705
2706                     /* Typedef that is not a C++ class */
2707                     if (class == 2
2708                         && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
2709                       c_typedef_print (SYMBOL_TYPE(sym), sym, gdb_stdout);
2710                     /* variable, func, or typedef-that-is-c++-class */
2711                     else if (class < 2 ||
2712                              (class == 2 &&
2713                               SYMBOL_NAMESPACE(sym) == STRUCT_NAMESPACE))
2714                       {
2715                         type_print (SYMBOL_TYPE (sym),
2716                                     (SYMBOL_CLASS (sym) == LOC_TYPEDEF
2717                                      ? "" : SYMBOL_SOURCE_NAME (sym)),
2718                                     gdb_stdout, 0);
2719
2720                         printf_filtered (";\n");
2721                       }
2722                     else
2723                       {
2724 # if 0  /* FIXME, why is this zapped out? */
2725                         char buf[1024];
2726                         c_type_print_base (TYPE_FN_FIELD_TYPE(t, i),
2727                                            gdb_stdout, 0, 0);
2728                         c_type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t, i),
2729                                                      gdb_stdout, 0);
2730                         sprintf (buf, " %s::", type_name_no_tag (t));
2731                         cp_type_print_method_args (TYPE_FN_FIELD_ARGS (t, i),
2732                                                    buf, name, gdb_stdout);
2733 # endif
2734                       }
2735                   }
2736               }
2737           }
2738       prev_bv = bv;
2739     }
2740
2741   /* If there are no eyes, avoid all contact.  I mean, if there are
2742      no debug symbols, then print directly from the msymbol_vector.  */
2743
2744   if (found_misc || class != 1)
2745     {
2746       found_in_file = 0;
2747       ALL_MSYMBOLS (objfile, msymbol)
2748         {
2749           if (MSYMBOL_TYPE (msymbol) == ourtype ||
2750               MSYMBOL_TYPE (msymbol) == ourtype2)
2751             {
2752               if (regexp == NULL || SYMBOL_MATCHES_REGEXP (msymbol))
2753                 {
2754                   /* Functions:  Look up by address. */
2755                   if (class != 1 ||
2756                       (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
2757                     {
2758                       /* Variables/Absolutes:  Look up by name */
2759                       if (lookup_symbol (SYMBOL_NAME (msymbol),
2760                                          (struct block *) NULL, VAR_NAMESPACE,
2761                                          0, (struct symtab **) NULL) == NULL)
2762                         {
2763                           if (!found_in_file)
2764                             {
2765                               printf_filtered ("\nNon-debugging symbols:\n");
2766                               found_in_file = 1;
2767                             }
2768                           printf_filtered ("    %08lx  %s\n",
2769                                            (unsigned long) SYMBOL_VALUE_ADDRESS (msymbol),
2770                                            SYMBOL_SOURCE_NAME (msymbol));
2771                         }
2772                     }
2773                 }
2774             }
2775         }
2776     }
2777 }
2778
2779 static void
2780 variables_info (regexp, from_tty)
2781      char *regexp;
2782      int from_tty;
2783 {
2784   list_symbols (regexp, 0, 0);
2785 }
2786
2787 static void
2788 functions_info (regexp, from_tty)
2789      char *regexp;
2790      int from_tty;
2791 {
2792   list_symbols (regexp, 1, 0);
2793 }
2794
2795 static void
2796 types_info (regexp, from_tty)
2797      char *regexp;
2798      int from_tty;
2799 {
2800   list_symbols (regexp, 2, 0);
2801 }
2802
2803 #if 0
2804 /* Tiemann says: "info methods was never implemented."  */
2805 static void
2806 methods_info (regexp)
2807      char *regexp;
2808 {
2809   list_symbols (regexp, 3, 0);
2810 }
2811 #endif /* 0 */
2812
2813 /* Breakpoint all functions matching regular expression. */
2814 static void
2815 rbreak_command (regexp, from_tty)
2816      char *regexp;
2817      int from_tty;
2818 {
2819   list_symbols (regexp, 1, 1);
2820 }
2821 \f
2822
2823 /* Return Nonzero if block a is lexically nested within block b,
2824    or if a and b have the same pc range.
2825    Return zero otherwise. */
2826 int
2827 contained_in (a, b)
2828      struct block *a, *b;
2829 {
2830   if (!a || !b)
2831     return 0;
2832   return BLOCK_START (a) >= BLOCK_START (b)
2833       && BLOCK_END (a)   <= BLOCK_END (b);
2834 }
2835
2836 \f
2837 /* Helper routine for make_symbol_completion_list.  */
2838
2839 static int return_val_size;
2840 static int return_val_index;
2841 static char **return_val;
2842
2843 #define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
2844   do { \
2845     if (SYMBOL_DEMANGLED_NAME (symbol) != NULL) \
2846       /* Put only the mangled name on the list.  */ \
2847       /* Advantage:  "b foo<TAB>" completes to "b foo(int, int)" */ \
2848       /* Disadvantage:  "b foo__i<TAB>" doesn't complete.  */ \
2849       completion_list_add_name \
2850         (SYMBOL_DEMANGLED_NAME (symbol), (sym_text), (len), (text), (word)); \
2851     else \
2852       completion_list_add_name \
2853         (SYMBOL_NAME (symbol), (sym_text), (len), (text), (word)); \
2854   } while (0)
2855
2856 /*  Test to see if the symbol specified by SYMNAME (which is already
2857     demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
2858     characters.  If so, add it to the current completion list. */
2859
2860 static void
2861 completion_list_add_name (symname, sym_text, sym_text_len, text, word)
2862      char *symname;
2863      char *sym_text;
2864      int sym_text_len;
2865      char *text;
2866      char *word;
2867 {
2868   int newsize;
2869   int i;
2870
2871   /* clip symbols that cannot match */
2872
2873   if (strncmp (symname, sym_text, sym_text_len) != 0)
2874     {
2875       return;
2876     }
2877
2878   /* Clip any symbol names that we've already considered.  (This is a
2879      time optimization)  */
2880
2881   for (i = 0; i < return_val_index; ++i)
2882     {
2883       if (STREQ (symname, return_val[i]))
2884         {
2885           return;
2886         }
2887     }
2888
2889   /* We have a match for a completion, so add SYMNAME to the current list
2890      of matches. Note that the name is moved to freshly malloc'd space. */
2891
2892   {
2893     char *new;
2894     if (word == sym_text)
2895       {
2896         new = xmalloc (strlen (symname) + 5);
2897         strcpy (new, symname);
2898       }
2899     else if (word > sym_text)
2900       {
2901         /* Return some portion of symname.  */
2902         new = xmalloc (strlen (symname) + 5);
2903         strcpy (new, symname + (word - sym_text));
2904       }
2905     else
2906       {
2907         /* Return some of SYM_TEXT plus symname.  */
2908         new = xmalloc (strlen (symname) + (sym_text - word) + 5);
2909         strncpy (new, word, sym_text - word);
2910         new[sym_text - word] = '\0';
2911         strcat (new, symname);
2912       }
2913
2914     if (return_val_index + 3 > return_val_size)
2915       {
2916         newsize = (return_val_size *= 2) * sizeof (char *);
2917         return_val = (char **) xrealloc ((char *) return_val, newsize);
2918       }
2919     return_val[return_val_index++] = new;
2920     return_val[return_val_index] = NULL;
2921   }
2922 }
2923
2924 /* Return a NULL terminated array of all symbols (regardless of class) which
2925    begin by matching TEXT.  If the answer is no symbols, then the return value
2926    is an array which contains only a NULL pointer.
2927
2928    Problem: All of the symbols have to be copied because readline frees them.
2929    I'm not going to worry about this; hopefully there won't be that many.  */
2930
2931 char **
2932 make_symbol_completion_list (text, word)
2933      char *text;
2934      char *word;
2935 {
2936   register struct symbol *sym;
2937   register struct symtab *s;
2938   register struct partial_symtab *ps;
2939   register struct minimal_symbol *msymbol;
2940   register struct objfile *objfile;
2941   register struct block *b, *surrounding_static_block = 0;
2942   register int i, j;
2943   struct partial_symbol *psym;
2944   /* The symbol we are completing on.  Points in same buffer as text.  */
2945   char *sym_text;
2946   /* Length of sym_text.  */
2947   int sym_text_len;
2948
2949   /* Now look for the symbol we are supposed to complete on.
2950      FIXME: This should be language-specific.  */
2951   {
2952     char *p;
2953     char quote_found;
2954     char *quote_pos = NULL;
2955
2956     /* First see if this is a quoted string.  */
2957     quote_found = '\0';
2958     for (p = text; *p != '\0'; ++p)
2959       {
2960         if (quote_found != '\0')
2961           {
2962             if (*p == quote_found)
2963               /* Found close quote.  */
2964               quote_found = '\0';
2965             else if (*p == '\\' && p[1] == quote_found)
2966               /* A backslash followed by the quote character
2967                  doesn't end the string.  */
2968               ++p;
2969           }
2970         else if (*p == '\'' || *p == '"')
2971           {
2972             quote_found = *p;
2973             quote_pos = p;
2974           }
2975       }
2976     if (quote_found == '\'')
2977       /* A string within single quotes can be a symbol, so complete on it.  */
2978       sym_text = quote_pos + 1;
2979     else if (quote_found == '"')
2980       /* A double-quoted string is never a symbol, nor does it make sense
2981          to complete it any other way.  */
2982       return NULL;
2983     else
2984       {
2985         /* It is not a quoted string.  Break it based on the characters
2986            which are in symbols.  */
2987         while (p > text)
2988           {
2989             if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0')
2990               --p;
2991             else
2992               break;
2993           }
2994         sym_text = p;
2995       }
2996   }
2997
2998   sym_text_len = strlen (sym_text);
2999
3000   return_val_size = 100;
3001   return_val_index = 0;
3002   return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
3003   return_val[0] = NULL;
3004
3005   /* Look through the partial symtabs for all symbols which begin
3006      by matching SYM_TEXT.  Add each one that you find to the list.  */
3007
3008   ALL_PSYMTABS (objfile, ps)
3009     {
3010       /* If the psymtab's been read in we'll get it when we search
3011          through the blockvector.  */
3012       if (ps->readin) continue;
3013
3014       for (psym = objfile->global_psymbols.list + ps->globals_offset;
3015            psym < (objfile->global_psymbols.list + ps->globals_offset
3016                    + ps->n_global_syms);
3017            psym++)
3018         {
3019           /* If interrupted, then quit. */
3020           QUIT;
3021           COMPLETION_LIST_ADD_SYMBOL (psym, sym_text, sym_text_len, text, word);
3022         }
3023
3024       for (psym = objfile->static_psymbols.list + ps->statics_offset;
3025            psym < (objfile->static_psymbols.list + ps->statics_offset
3026                    + ps->n_static_syms);
3027            psym++)
3028         {
3029           QUIT;
3030           COMPLETION_LIST_ADD_SYMBOL (psym, sym_text, sym_text_len, text, word);
3031         }
3032     }
3033
3034   /* At this point scan through the misc symbol vectors and add each
3035      symbol you find to the list.  Eventually we want to ignore
3036      anything that isn't a text symbol (everything else will be
3037      handled by the psymtab code above).  */
3038
3039   ALL_MSYMBOLS (objfile, msymbol)
3040     {
3041       QUIT;
3042       COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word);
3043     }
3044
3045   /* Search upwards from currently selected frame (so that we can
3046      complete on local vars.  */
3047
3048   for (b = get_selected_block (); b != NULL; b = BLOCK_SUPERBLOCK (b))
3049     {
3050       if (!BLOCK_SUPERBLOCK (b))
3051         {
3052           surrounding_static_block = b;         /* For elmin of dups */
3053         }
3054
3055       /* Also catch fields of types defined in this places which match our
3056          text string.  Only complete on types visible from current context. */
3057
3058       for (i = 0; i < BLOCK_NSYMS (b); i++)
3059         {
3060           sym = BLOCK_SYM (b, i);
3061           COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3062           if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
3063             {
3064               struct type *t = SYMBOL_TYPE (sym);
3065               enum type_code c = TYPE_CODE (t);
3066
3067               if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
3068                 {
3069                   for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
3070                     {
3071                       if (TYPE_FIELD_NAME (t, j))
3072                         {
3073                           completion_list_add_name (TYPE_FIELD_NAME (t, j),
3074                                                       sym_text, sym_text_len, text, word);
3075                         }
3076                     }
3077                 }
3078             }
3079         }
3080     }
3081
3082   /* Go through the symtabs and check the externs and statics for
3083      symbols which match.  */
3084
3085   ALL_SYMTABS (objfile, s)
3086     {
3087       QUIT;
3088       b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
3089       for (i = 0; i < BLOCK_NSYMS (b); i++)
3090         {
3091           sym = BLOCK_SYM (b, i);
3092           COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3093         }
3094     }
3095
3096   ALL_SYMTABS (objfile, s)
3097     {
3098       QUIT;
3099       b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
3100       /* Don't do this block twice.  */
3101       if (b == surrounding_static_block) continue;
3102       for (i = 0; i < BLOCK_NSYMS (b); i++)
3103         {
3104           sym = BLOCK_SYM (b, i);
3105           COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word);
3106         }
3107     }
3108
3109   return (return_val);
3110 }
3111
3112 \f
3113 #if 0
3114 /* Add the type of the symbol sym to the type of the current
3115    function whose block we are in (assumed).  The type of
3116    this current function is contained in *TYPE.
3117
3118    This basically works as follows:  When we find a function
3119    symbol (N_FUNC with a 'f' or 'F' in the symbol name), we record
3120    a pointer to its type in the global in_function_type.  Every
3121    time we come across a parameter symbol ('p' in its name), then
3122    this procedure adds the name and type of that parameter
3123    to the function type pointed to by *TYPE.  (Which should correspond
3124    to in_function_type if it was called correctly).
3125
3126    Note that since we are modifying a type, the result of
3127    lookup_function_type() should be memcpy()ed before calling
3128    this.  When not in strict typing mode, the expression
3129    evaluator can choose to ignore this.
3130
3131    Assumption:  All of a function's parameter symbols will
3132    appear before another function symbol is found.  The parameters
3133    appear in the same order in the argument list as they do in the
3134    symbol table. */
3135
3136 void
3137 add_param_to_type (type,sym)
3138    struct type **type;
3139    struct symbol *sym;
3140 {
3141    int num = ++(TYPE_NFIELDS(*type));
3142
3143    if(TYPE_NFIELDS(*type)-1)
3144       TYPE_FIELDS(*type) = (struct field *)
3145           (*current_objfile->xrealloc) ((char *)(TYPE_FIELDS(*type)),
3146                                         num*sizeof(struct field));
3147    else
3148       TYPE_FIELDS(*type) = (struct field *)
3149           (*current_objfile->xmalloc) (num*sizeof(struct field));
3150
3151    TYPE_FIELD_BITPOS(*type,num-1) = num-1;
3152    TYPE_FIELD_BITSIZE(*type,num-1) = 0;
3153    TYPE_FIELD_TYPE(*type,num-1) = SYMBOL_TYPE(sym);
3154    TYPE_FIELD_NAME(*type,num-1) = SYMBOL_NAME(sym);
3155 }
3156 #endif
3157 \f
3158 void
3159 _initialize_symtab ()
3160 {
3161   add_info ("variables", variables_info,
3162             "All global and static variable names, or those matching REGEXP.");
3163   add_info ("functions", functions_info,
3164             "All function names, or those matching REGEXP.");
3165
3166   /* FIXME:  This command has at least the following problems:
3167      1.  It prints builtin types (in a very strange and confusing fashion).
3168      2.  It doesn't print right, e.g. with
3169          typedef struct foo *FOO
3170          type_print prints "FOO" when we want to make it (in this situation)
3171          print "struct foo *".
3172      I also think "ptype" or "whatis" is more likely to be useful (but if
3173      there is much disagreement "info types" can be fixed).  */
3174   add_info ("types", types_info,
3175             "All type names, or those matching REGEXP.");
3176
3177 #if 0
3178   add_info ("methods", methods_info,
3179             "All method names, or those matching REGEXP::REGEXP.\n\
3180 If the class qualifier is omitted, it is assumed to be the current scope.\n\
3181 If the first REGEXP is omitted, then all methods matching the second REGEXP\n\
3182 are listed.");
3183 #endif
3184   add_info ("sources", sources_info,
3185             "Source files in the program.");
3186
3187   add_com ("rbreak", no_class, rbreak_command,
3188             "Set a breakpoint for all functions matching REGEXP.");
3189
3190   /* Initialize the one built-in type that isn't language dependent... */
3191   builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0,
3192                                   "<unknown type>", (struct objfile *) NULL);
3193 }