gdb/symtab.c

   1 /* Symbol table lookup for the GNU debugger, GDB.
   2    Copyright (C) 1986, 1987, 1988, 1989, 1990 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 GDB is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 1, or (at your option)
   9 any later version.
  10
  11 GDB is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GDB; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <stdio.h>
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "param.h"
  24 #include "gdbcore.h"
  25 #include "frame.h"
  26 #include "target.h"
  27 #include "value.h"
  28 #include "symfile.h"
  29 #include "gdbcmd.h"
  30
  31 #include <obstack.h>
  32 #include <assert.h>
  33
  34 #include <sys/types.h>
  35 #include <fcntl.h>
  36 #include <string.h>
  37 #include <sys/stat.h>
  38
  39 extern int close ();
  40 extern void qsort ();
  41 extern char *getenv ();
  42
  43 extern char *cplus_demangle ();
  44 extern struct value *value_of_this ();
  45 extern void break_command ();
  46 extern void select_source_symtab ();
  47
  48 /* Functions this file defines */
  49 static int find_line_common ();
  50 struct partial_symtab *lookup_partial_symtab ();
  51 static struct partial_symbol *lookup_partial_symbol ();
  52 static struct partial_symbol *lookup_demangled_partial_symbol ();
  53 static struct symbol *lookup_demangled_block_symbol ();
  54
  55 /* These variables point to the objects
  56    representing the predefined C data types.  */
  57
  58 struct type *builtin_type_void;
  59 struct type *builtin_type_char;
  60 struct type *builtin_type_short;
  61 struct type *builtin_type_int;
  62 struct type *builtin_type_long;
  63 struct type *builtin_type_long_long;
  64 struct type *builtin_type_unsigned_char;
  65 struct type *builtin_type_unsigned_short;
  66 struct type *builtin_type_unsigned_int;
  67 struct type *builtin_type_unsigned_long;
  68 struct type *builtin_type_unsigned_long_long;
  69 struct type *builtin_type_float;
  70 struct type *builtin_type_double;
  71 struct type *builtin_type_error;
  72
  73 /* Block in which the most recently searched-for symbol was found.
  74    Might be better to make this a parameter to lookup_symbol and
  75    value_of_this. */
  76 struct block *block_found;
  77
  78 char no_symtab_msg[] = "No symbol table is loaded.  Use the \"file\" command.";
  79
  80 /* Check for a symtab of a specific name; first in symtabs, then in
  81    psymtabs.  *If* there is no '/' in the name, a match after a '/'
  82    in the symtab filename will also work.  */
  83
  84 static struct symtab *
  85 lookup_symtab_1 (name)
  86      char *name;
  87 {
  88   register struct symtab *s;
  89   register struct partial_symtab *ps;
  90   register char *slash = strchr (name, '/');
  91   register int len = strlen (name);
  92
  93   for (s = symtab_list; s; s = s->next)
  94     if (!strcmp (name, s->filename))
  95       return s;
  96
  97   for (ps = partial_symtab_list; ps; ps = ps->next)
  98     if (!strcmp (name, ps->filename))
  99       {
 100         if (ps->readin)
 101           fatal ("Internal: readin pst found when no symtab found.");
 102         return PSYMTAB_TO_SYMTAB (ps);
 103       }
 104
 105   if (!slash)
 106     {
 107       for (s = symtab_list; s; s = s->next)
 108         {
 109           int l = strlen (s->filename);
 110
 111           if (s->filename[l - len -1] == '/'
 112               && !strcmp (s->filename + l - len, name))
 113             return s;
 114         }
 115
 116       for (ps = partial_symtab_list; ps; ps = ps->next)
 117         {
 118           int l = strlen (ps->filename);
 119
 120           if (ps->filename[l - len - 1] == '/'
 121               && !strcmp (ps->filename + l - len, name))
 122             {
 123               if (ps->readin)
 124                 fatal ("Internal: readin pst found when no symtab found.");
 125               return PSYMTAB_TO_SYMTAB (ps);
 126             }
 127         }
 128     }
 129   return 0;
 130 }
 131
 132 /* Lookup the symbol table of a source file named NAME.  Try a couple
 133    of variations if the first lookup doesn't work.  */
 134
 135 struct symtab *
 136 lookup_symtab (name)
 137      char *name;
 138 {
 139   register struct symtab *s;
 140   register char *copy;
 141
 142   s = lookup_symtab_1 (name);
 143   if (s) return s;
 144
 145   /* If name not found as specified, see if adding ".c" helps.  */
 146
 147   copy = (char *) alloca (strlen (name) + 3);
 148   strcpy (copy, name);
 149   strcat (copy, ".c");
 150   s = lookup_symtab_1 (copy);
 151   if (s) return s;
 152
 153   /* We didn't find anything; die.  */
 154   return 0;
 155 }
 156
 157 /* Lookup the partial symbol table of a source file named NAME.  This
 158    only returns true on an exact match (ie. this semantics are
 159    different from lookup_symtab.  */
 160
 161 struct partial_symtab *
 162 lookup_partial_symtab (name)
 163 char *name;
 164 {
 165   register struct partial_symtab *s;
 166
 167   for (s = partial_symtab_list; s; s = s->next)
 168     if (!strcmp (name, s->filename))
 169       return s;
 170
 171   return 0;
 172 }
 173 \f
 174 /* Return a typename for a struct/union/enum type
 175    without the tag qualifier.  If the type has a NULL name,
 176    NULL is returned.  */
 177 char *
 178 type_name_no_tag (type)
 179      register struct type *type;
 180 {
 181   register char *name = TYPE_NAME (type);
 182   char *strchr ();
 183   if (name == 0)
 184     return 0;
 185
 186 #if 0
 187   switch (TYPE_CODE (type))
 188     {
 189     case TYPE_CODE_STRUCT:
 190       return name + 7;
 191     case TYPE_CODE_UNION:
 192       return name + 6;
 193     case TYPE_CODE_ENUM:
 194       return name + 5;
 195     }
 196 #endif
 197
 198   name = strchr (name, ' ');
 199   if (name)
 200     return name + 1;
 201
 202   return TYPE_NAME (type);
 203 }
 204
 205 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
 206
 207    If this is a stubbed struct (i.e. declared as struct foo *), see if
 208    we can find a full definition in some other file. If so, copy this
 209    definition, so we can use it in future.  If not, set a flag so we
 210    don't waste too much time in future.
 211
 212    This used to be coded as a macro, but I don't think it is called
 213    often enough to merit such treatment.
 214 */
 215
 216 struct complaint stub_noname_complaint =
 217   {"stub type has NULL name", 0, 0};
 218
 219 void
 220 check_stub_type(type)
 221      struct type *type;
 222 {
 223   if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
 224     {
 225       char* name= type_name_no_tag (type);
 226       struct symbol *sym;
 227       if (name == 0)
 228         {
 229           complain (&stub_noname_complaint, 0, 0);
 230           return;
 231         }
 232       if (sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
 233                                (struct symtab **)NULL) )
 234         bcopy (SYMBOL_TYPE(sym), type, sizeof (struct type));
 235     }
 236 }
 237
 238 /* Demangle a GDB method stub type.  */
 239 char *
 240 gdb_mangle_typename (type)
 241      struct type *type;
 242 {
 243   static struct type *last_type;
 244   static char *mangled_typename;
 245
 246   if (type != last_type)
 247     {
 248       /* Need a new type prefix.  */
 249       char *strchr ();
 250       char *newname = type_name_no_tag (type);
 251       char buf[20];
 252       int len;
 253
 254       if (mangled_typename)
 255         free (mangled_typename);
 256
 257       len = strlen (newname);
 258       sprintf (buf, "__%d", len);
 259       mangled_typename = (char *)xmalloc (strlen (buf) + len + 1);
 260       strcpy (mangled_typename, buf);
 261       strcat (mangled_typename, newname);
 262       /* Now we have built "__#newname".  */
 263     }
 264   return mangled_typename;
 265 }
 266
 267 /* Lookup a primitive type named NAME.
 268    Return zero if NAME is not a primitive type.*/
 269
 270 struct type *
 271 lookup_primitive_typename (name)
 272      char *name;
 273 {
 274   if (!strcmp (name, "int"))
 275     return builtin_type_int;
 276   if (!strcmp (name, "long"))
 277     return builtin_type_long;
 278   if (!strcmp (name, "short"))
 279     return builtin_type_short;
 280   if (!strcmp (name, "char"))
 281     return builtin_type_char;
 282   if (!strcmp (name, "float"))
 283     return builtin_type_float;
 284   if (!strcmp (name, "double"))
 285     return builtin_type_double;
 286   if (!strcmp (name, "void"))
 287     return builtin_type_void;
 288   return 0;
 289 }
 290
 291 /* Lookup a typedef or primitive type named NAME,
 292    visible in lexical block BLOCK.
 293    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
 294
 295 struct type *
 296 lookup_typename (name, block, noerr)
 297      char *name;
 298      struct block *block;
 299      int noerr;
 300 {
 301   register struct symbol *sym =
 302     lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **)NULL);
 303   if (sym == 0 || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
 304     {
 305       struct type *tmp;
 306       tmp = lookup_primitive_typename (name);
 307       if (!tmp && noerr)
 308         return 0;
 309       error ("No type named %s.", name);
 310     }
 311   return SYMBOL_TYPE (sym);
 312 }
 313
 314 struct type *
 315 lookup_unsigned_typename (name)
 316      char *name;
 317 {
 318   if (!strcmp (name, "int"))
 319     return builtin_type_unsigned_int;
 320   if (!strcmp (name, "long"))
 321     return builtin_type_unsigned_long;
 322   if (!strcmp (name, "short"))
 323     return builtin_type_unsigned_short;
 324   if (!strcmp (name, "char"))
 325     return builtin_type_unsigned_char;
 326   error ("No type named unsigned %s.", name);
 327   return (struct type *)-1;  /* for lint */
 328 }
 329
 330 /* Lookup a structure type named "struct NAME",
 331    visible in lexical block BLOCK.  */
 332
 333 struct type *
 334 lookup_struct (name, block)
 335      char *name;
 336      struct block *block;
 337 {
 338   register struct symbol *sym
 339     = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **)NULL);
 340
 341   if (sym == 0)
 342     error ("No struct type named %s.", name);
 343   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
 344     error ("This context has class, union or enum %s, not a struct.", name);
 345   return SYMBOL_TYPE (sym);
 346 }
 347
 348 /* Lookup a union type named "union NAME",
 349    visible in lexical block BLOCK.  */
 350
 351 struct type *
 352 lookup_union (name, block)
 353      char *name;
 354      struct block *block;
 355 {
 356   register struct symbol *sym
 357     = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **)NULL);
 358
 359   if (sym == 0)
 360     error ("No union type named %s.", name);
 361   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
 362     error ("This context has class, struct or enum %s, not a union.", name);
 363   return SYMBOL_TYPE (sym);
 364 }
 365
 366 /* Lookup an enum type named "enum NAME",
 367    visible in lexical block BLOCK.  */
 368
 369 struct type *
 370 lookup_enum (name, block)
 371      char *name;
 372      struct block *block;
 373 {
 374   register struct symbol *sym
 375     = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, (struct symtab **)NULL);
 376   if (sym == 0)
 377     error ("No enum type named %s.", name);
 378   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
 379     error ("This context has class, struct or union %s, not an enum.", name);
 380   return SYMBOL_TYPE (sym);
 381 }
 382
 383 /* Given a type TYPE, lookup the type of the component of type named
 384    NAME.
 385    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
 386
 387 struct type *
 388 lookup_struct_elt_type (type, name, noerr)
 389      struct type *type;
 390      char *name;
 391      int noerr;
 392 {
 393   int i;
 394
 395   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
 396       && TYPE_CODE (type) != TYPE_CODE_UNION)
 397     {
 398       target_terminal_ours ();
 399       fflush (stdout);
 400       fprintf (stderr, "Type ");
 401       type_print (type, "", stderr, -1);
 402       error (" is not a structure or union type.");
 403     }
 404
 405   check_stub_type (type);
 406
 407   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
 408     {
 409       char *t_field_name = TYPE_FIELD_NAME (type, i);
 410
 411       if (t_field_name && !strcmp (t_field_name, name))
 412         return TYPE_FIELD_TYPE (type, i);
 413     }
 414   /* OK, it's not in this class.  Recursively check the baseclasses.  */
 415   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
 416     {
 417       struct type *t = lookup_struct_elt_type (TYPE_BASECLASS (type, i),
 418                                                name, 0);
 419       if (t != NULL)
 420         return t;
 421     }
 422
 423   if (noerr)
 424     return NULL;
 425
 426   target_terminal_ours ();
 427   fflush (stdout);
 428   fprintf (stderr, "Type ");
 429   type_print (type, "", stderr, -1);
 430   fprintf (stderr, " has no component named ");
 431   fputs_filtered (name, stderr);
 432   error (".");
 433   return (struct type *)-1;     /* For lint */
 434 }
 435
 436 /* Given a type TYPE, return a type of pointers to that type.
 437    May need to construct such a type if this is the first use.
 438
 439    C++: use TYPE_MAIN_VARIANT and TYPE_CHAIN to keep pointer
 440    to member types under control.  */
 441
 442 struct type *
 443 lookup_pointer_type (type)
 444      struct type *type;
 445 {
 446   register struct type *ptype = TYPE_POINTER_TYPE (type);
 447   if (ptype) return TYPE_MAIN_VARIANT (ptype);
 448
 449   /* This is the first time anyone wanted a pointer to a TYPE.  */
 450   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 451     ptype  = (struct type *) xmalloc (sizeof (struct type));
 452   else
 453     ptype  = (struct type *) obstack_alloc (symbol_obstack,
 454                                             sizeof (struct type));
 455
 456   bzero (ptype, sizeof (struct type));
 457   TYPE_MAIN_VARIANT (ptype) = ptype;
 458   TYPE_TARGET_TYPE (ptype) = type;
 459   TYPE_POINTER_TYPE (type) = ptype;
 460   /* New type is permanent if type pointed to is permanent.  */
 461   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 462     TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
 463   /* We assume the machine has only one representation for pointers!  */
 464   TYPE_LENGTH (ptype) = sizeof (char *);
 465   TYPE_CODE (ptype) = TYPE_CODE_PTR;
 466   return ptype;
 467 }
 468
 469 struct type *
 470 lookup_reference_type (type)
 471      struct type *type;
 472 {
 473   register struct type *rtype = TYPE_REFERENCE_TYPE (type);
 474   if (rtype) return TYPE_MAIN_VARIANT (rtype);
 475
 476   /* This is the first time anyone wanted a pointer to a TYPE.  */
 477   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 478     rtype  = (struct type *) xmalloc (sizeof (struct type));
 479   else
 480     rtype  = (struct type *) obstack_alloc (symbol_obstack,
 481                                             sizeof (struct type));
 482
 483   bzero (rtype, sizeof (struct type));
 484   TYPE_MAIN_VARIANT (rtype) = rtype;
 485   TYPE_TARGET_TYPE (rtype) = type;
 486   TYPE_REFERENCE_TYPE (type) = rtype;
 487   /* New type is permanent if type pointed to is permanent.  */
 488   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 489     TYPE_FLAGS (rtype) |= TYPE_FLAG_PERM;
 490   /* We assume the machine has only one representation for pointers!  */
 491   TYPE_LENGTH (rtype) = sizeof (char *);
 492   TYPE_CODE (rtype) = TYPE_CODE_REF;
 493   return rtype;
 494 }
 495
 496
 497 /* Implement direct support for MEMBER_TYPE in GNU C++.
 498    May need to construct such a type if this is the first use.
 499    The TYPE is the type of the member.  The DOMAIN is the type
 500    of the aggregate that the member belongs to.  */
 501
 502 struct type *
 503 lookup_member_type (type, domain)
 504      struct type *type, *domain;
 505 {
 506   register struct type *mtype = TYPE_MAIN_VARIANT (type);
 507   struct type *main_type;
 508
 509   main_type = mtype;
 510   while (mtype)
 511     {
 512       if (TYPE_DOMAIN_TYPE (mtype) == domain)
 513         return mtype;
 514       mtype = TYPE_NEXT_VARIANT (mtype);
 515     }
 516
 517   /* This is the first time anyone wanted this member type.  */
 518   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 519     mtype  = (struct type *) xmalloc (sizeof (struct type));
 520   else
 521     mtype  = (struct type *) obstack_alloc (symbol_obstack,
 522                                             sizeof (struct type));
 523
 524   bzero (mtype, sizeof (struct type));
 525   if (main_type == 0)
 526     main_type = mtype;
 527   else
 528     {
 529       TYPE_NEXT_VARIANT (mtype) = TYPE_NEXT_VARIANT (main_type);
 530       TYPE_NEXT_VARIANT (main_type) = mtype;
 531     }
 532   TYPE_MAIN_VARIANT (mtype) = main_type;
 533   TYPE_TARGET_TYPE (mtype) = type;
 534   TYPE_DOMAIN_TYPE (mtype) = domain;
 535   /* New type is permanent if type pointed to is permanent.  */
 536   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 537     TYPE_FLAGS (mtype) |= TYPE_FLAG_PERM;
 538
 539   /* In practice, this is never used.  */
 540   TYPE_LENGTH (mtype) = 1;
 541   TYPE_CODE (mtype) = TYPE_CODE_MEMBER;
 542
 543 #if 0
 544   /* Now splice in the new member pointer type.  */
 545   if (main_type)
 546     {
 547       /* This type was not "smashed".  */
 548       TYPE_CHAIN (mtype) = TYPE_CHAIN (main_type);
 549       TYPE_CHAIN (main_type) = mtype;
 550     }
 551 #endif
 552
 553   return mtype;
 554 }
 555
 556 /* Allocate a stub method whose return type is
 557    TYPE.  We will fill in arguments later.  This always
 558    returns a fresh type.  If we unify this type with
 559    an existing type later, the storage allocated
 560    here can be freed.  */
 561 struct type *
 562 allocate_stub_method (type)
 563      struct type *type;
 564 {
 565   struct type *mtype = (struct type *)xmalloc (sizeof (struct type));
 566   bzero (mtype, sizeof (struct type));
 567   TYPE_MAIN_VARIANT (mtype) = mtype;
 568   TYPE_TARGET_TYPE (mtype) = type;
 569   TYPE_FLAGS (mtype) = TYPE_FLAG_STUB;
 570   TYPE_CODE (mtype) = TYPE_CODE_METHOD;
 571   TYPE_LENGTH (mtype) = 1;
 572   return mtype;
 573 }
 574
 575 /* Lookup a method type returning type TYPE, belonging
 576    to class DOMAIN, and taking a list of arguments ARGS.
 577    If one is not found, allocate a new one.  */
 578
 579 struct type *
 580 lookup_method_type (type, domain, args)
 581      struct type *type, *domain, **args;
 582 {
 583   register struct type *mtype = TYPE_MAIN_VARIANT (type);
 584   struct type *main_type;
 585
 586   main_type = mtype;
 587   while (mtype)
 588     {
 589       if (TYPE_DOMAIN_TYPE (mtype) == domain)
 590         {
 591           struct type **t1 = args;
 592           struct type **t2 = TYPE_ARG_TYPES (mtype);
 593           if (t2)
 594             {
 595               int i;
 596               for (i = 0; t1[i] != 0 && t1[i]->code != TYPE_CODE_VOID; i++)
 597                 if (t1[i] != t2[i])
 598                   break;
 599               if (t1[i] == t2[i])
 600                 return mtype;
 601             }
 602         }
 603       mtype = TYPE_NEXT_VARIANT (mtype);
 604     }
 605
 606   /* This is the first time anyone wanted this member type.  */
 607   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 608     mtype  = (struct type *) xmalloc (sizeof (struct type));
 609   else
 610     mtype  = (struct type *) obstack_alloc (symbol_obstack,
 611                                             sizeof (struct type));
 612
 613   bzero (mtype, sizeof (struct type));
 614   if (main_type == 0)
 615     main_type = mtype;
 616   else
 617     {
 618       TYPE_NEXT_VARIANT (mtype) = TYPE_NEXT_VARIANT (main_type);
 619       TYPE_NEXT_VARIANT (main_type) = mtype;
 620     }
 621   TYPE_MAIN_VARIANT (mtype) = main_type;
 622   TYPE_TARGET_TYPE (mtype) = type;
 623   TYPE_DOMAIN_TYPE (mtype) = domain;
 624   TYPE_ARG_TYPES (mtype) = args;
 625   /* New type is permanent if type pointed to is permanent.  */
 626   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 627     TYPE_FLAGS (mtype) |= TYPE_FLAG_PERM;
 628
 629   /* In practice, this is never used.  */
 630   TYPE_LENGTH (mtype) = 1;
 631   TYPE_CODE (mtype) = TYPE_CODE_METHOD;
 632
 633 #if 0
 634   /* Now splice in the new member pointer type.  */
 635   if (main_type)
 636     {
 637       /* This type was not "smashed".  */
 638       TYPE_CHAIN (mtype) = TYPE_CHAIN (main_type);
 639       TYPE_CHAIN (main_type) = mtype;
 640     }
 641 #endif
 642
 643   return mtype;
 644 }
 645
 646 #if 0
 647 /* Given a type TYPE, return a type which has offset OFFSET,
 648    via_virtual VIA_VIRTUAL, and via_public VIA_PUBLIC.
 649    May need to construct such a type if none exists.  */
 650 struct type *
 651 lookup_basetype_type (type, offset, via_virtual, via_public)
 652      struct type *type;
 653      int offset;
 654      int via_virtual, via_public;
 655 {
 656   register struct type *btype = TYPE_MAIN_VARIANT (type);
 657   struct type *main_type;
 658
 659   if (offset != 0)
 660     {
 661       printf ("Internal error: type offset non-zero in lookup_basetype_type");
 662       offset = 0;
 663     }
 664
 665   main_type = btype;
 666   while (btype)
 667     {
 668       if (/* TYPE_OFFSET (btype) == offset
 669           && */ TYPE_VIA_PUBLIC (btype) == via_public
 670           && TYPE_VIA_VIRTUAL (btype) == via_virtual)
 671         return btype;
 672       btype = TYPE_NEXT_VARIANT (btype);
 673     }
 674
 675   /* This is the first time anyone wanted this member type.  */
 676   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 677     btype  = (struct type *) xmalloc (sizeof (struct type));
 678   else
 679     btype  = (struct type *) obstack_alloc (symbol_obstack,
 680                                             sizeof (struct type));
 681
 682   if (main_type == 0)
 683     {
 684       main_type = btype;
 685       bzero (btype, sizeof (struct type));
 686       TYPE_MAIN_VARIANT (btype) = main_type;
 687     }
 688   else
 689     {
 690       bcopy (main_type, btype, sizeof (struct type));
 691       TYPE_NEXT_VARIANT (main_type) = btype;
 692     }
 693 /* TYPE_OFFSET (btype) = offset; */
 694   if (via_public)
 695     TYPE_FLAGS (btype) |= TYPE_FLAG_VIA_PUBLIC;
 696   if (via_virtual)
 697     TYPE_FLAGS (btype) |= TYPE_FLAG_VIA_VIRTUAL;
 698   /* New type is permanent if type pointed to is permanent.  */
 699   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 700     TYPE_FLAGS (btype) |= TYPE_FLAG_PERM;
 701
 702   /* In practice, this is never used.  */
 703   TYPE_LENGTH (btype) = 1;
 704   TYPE_CODE (btype) = TYPE_CODE_STRUCT;
 705
 706   return btype;
 707 }
 708 #endif
 709
 710 /* Given a type TYPE, return a type of functions that return that type.
 711    May need to construct such a type if this is the first use.  */
 712
 713 struct type *
 714 lookup_function_type (type)
 715      struct type *type;
 716 {
 717   register struct type *ptype = TYPE_FUNCTION_TYPE (type);
 718   if (ptype) return ptype;
 719
 720   /* This is the first time anyone wanted a function returning a TYPE.  */
 721   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 722     ptype  = (struct type *) xmalloc (sizeof (struct type));
 723   else
 724     ptype  = (struct type *) obstack_alloc (symbol_obstack,
 725                                             sizeof (struct type));
 726
 727   bzero (ptype, sizeof (struct type));
 728   TYPE_TARGET_TYPE (ptype) = type;
 729   TYPE_FUNCTION_TYPE (type) = ptype;
 730   /* New type is permanent if type returned is permanent.  */
 731   if (TYPE_FLAGS (type) & TYPE_FLAG_PERM)
 732     TYPE_FLAGS (ptype) |= TYPE_FLAG_PERM;
 733   TYPE_LENGTH (ptype) = 1;
 734   TYPE_CODE (ptype) = TYPE_CODE_FUNC;
 735   TYPE_NFIELDS (ptype) = 0;
 736   return ptype;
 737 }
 738 \f
 739 /* Create an array type.  Elements will be of type TYPE, and there will
 740    be NUM of them.
 741
 742    Eventually this should be extended to take two more arguments which
 743    specify the bounds of the array and the type of the index.
 744    It should also be changed to be a "lookup" function, with the
 745    appropriate data structures added to the type field.
 746    Then read array type should call here.  */
 747
 748 struct type *
 749 create_array_type (element_type, number)
 750      struct type *element_type;
 751      int number;
 752 {
 753   struct type *result_type = (struct type *)
 754     obstack_alloc (symbol_obstack, sizeof (struct type));
 755
 756   bzero (result_type, sizeof (struct type));
 757
 758   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
 759   TYPE_TARGET_TYPE (result_type) = element_type;
 760   TYPE_LENGTH (result_type) = number * TYPE_LENGTH (element_type);
 761   TYPE_NFIELDS (result_type) = 1;
 762   TYPE_FIELDS (result_type) =
 763     (struct field *) obstack_alloc (symbol_obstack, sizeof (struct field));
 764   TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int;
 765   TYPE_VPTR_FIELDNO (result_type) = -1;
 766
 767   return result_type;
 768 }
 769
 770 \f
 771 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.  */
 772
 773 void
 774 smash_to_member_type (type, domain, to_type)
 775      struct type *type, *domain, *to_type;
 776 {
 777   bzero (type, sizeof (struct type));
 778   TYPE_TARGET_TYPE (type) = to_type;
 779   TYPE_DOMAIN_TYPE (type) = domain;
 780
 781   /* In practice, this is never needed.  */
 782   TYPE_LENGTH (type) = 1;
 783   TYPE_CODE (type) = TYPE_CODE_MEMBER;
 784
 785   TYPE_MAIN_VARIANT (type) = lookup_member_type (domain, to_type);
 786 }
 787
 788 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.  */
 789
 790 void
 791 smash_to_method_type (type, domain, to_type, args)
 792      struct type *type, *domain, *to_type, **args;
 793 {
 794   bzero (type, sizeof (struct type));
 795   TYPE_TARGET_TYPE (type) = to_type;
 796   TYPE_DOMAIN_TYPE (type) = domain;
 797   TYPE_ARG_TYPES (type) = args;
 798
 799   /* In practice, this is never needed.  */
 800   TYPE_LENGTH (type) = 1;
 801   TYPE_CODE (type) = TYPE_CODE_METHOD;
 802
 803   TYPE_MAIN_VARIANT (type) = lookup_method_type (domain, to_type, args);
 804 }
 805 \f
 806 /* Find which partial symtab on the partial_symtab_list contains
 807    PC.  Return 0 if none.  */
 808
 809 struct partial_symtab *
 810 find_pc_psymtab (pc)
 811      register CORE_ADDR pc;
 812 {
 813   register struct partial_symtab *ps;
 814
 815   for (ps = partial_symtab_list; ps; ps = ps->next)
 816     if (pc >= ps->textlow && pc < ps->texthigh)
 817       return ps;
 818
 819   return 0;
 820 }
 821
 822 /* Find which partial symbol within a psymtab contains PC.  Return 0
 823    if none.  Check all psymtabs if PSYMTAB is 0.  */
 824 struct partial_symbol *
 825 find_pc_psymbol (psymtab, pc)
 826      struct partial_symtab *psymtab;
 827      CORE_ADDR pc;
 828 {
 829   struct partial_symbol *best, *p;
 830   CORE_ADDR best_pc;
 831
 832   if (!psymtab)
 833     psymtab = find_pc_psymtab (pc);
 834   if (!psymtab)
 835     return 0;
 836
 837   best_pc = psymtab->textlow - 1;
 838
 839   for (p = static_psymbols.list + psymtab->statics_offset;
 840        (p - (static_psymbols.list + psymtab->statics_offset)
 841         < psymtab->n_static_syms);
 842        p++)
 843     if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
 844         && SYMBOL_CLASS (p) == LOC_BLOCK
 845         && pc >= SYMBOL_VALUE_ADDRESS (p)
 846         && SYMBOL_VALUE_ADDRESS (p) > best_pc)
 847       {
 848         best_pc = SYMBOL_VALUE_ADDRESS (p);
 849         best = p;
 850       }
 851   if (best_pc == psymtab->textlow - 1)
 852     return 0;
 853   return best;
 854 }
 855
 856 \f
 857 /* Find the definition for a specified symbol name NAME
 858    in namespace NAMESPACE, visible from lexical block BLOCK.
 859    Returns the struct symbol pointer, or zero if no symbol is found.
 860    If SYMTAB is non-NULL, store the symbol table in which the
 861    symbol was found there, or NULL if not found.
 862    C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if
 863    NAME is a field of the current implied argument `this'.  If so set
 864    *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero.
 865    BLOCK_FOUND is set to the block in which NAME is found (in the case of
 866    a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */
 867
 868 struct symbol *
 869 lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
 870      char *name;
 871      register struct block *block;
 872      enum namespace namespace;
 873      int *is_a_field_of_this;
 874      struct symtab **symtab;
 875 {
 876   register struct symbol *sym;
 877   register struct symtab *s;
 878   register struct partial_symtab *ps;
 879   struct blockvector *bv;
 880
 881   /* Search specified block and its superiors.  */
 882
 883   while (block != 0)
 884     {
 885       sym = lookup_block_symbol (block, name, namespace);
 886       if (sym)
 887         {
 888           block_found = block;
 889           if (symtab != NULL)
 890             {
 891               /* Search the list of symtabs for one which contains the
 892                  address of the start of this block.  */
 893               struct block *b;
 894               for (s = symtab_list; s; s = s->next)
 895                 {
 896                   bv = BLOCKVECTOR (s);
 897                   b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 898                   if (BLOCK_START (b) <= BLOCK_START (block)
 899                       && BLOCK_END (b) > BLOCK_START (block))
 900                     break;
 901                 }
 902               *symtab = s;
 903             }
 904
 905           return sym;
 906         }
 907       block = BLOCK_SUPERBLOCK (block);
 908     }
 909
 910   /* But that doesn't do any demangling for the STATIC_BLOCK.
 911      I'm not sure whether demangling is needed in the case of
 912      nested function in inner blocks; if so this needs to be changed.
 913
 914      Don't need to mess with the psymtabs; if we have a block,
 915      that file is read in.  If we don't, then we deal later with
 916      all the psymtab stuff that needs checking.  */
 917   if (namespace == VAR_NAMESPACE && block != NULL)
 918     {
 919       struct block *b;
 920       /* Find the right symtab.  */
 921       for (s = symtab_list; s; s = s->next)
 922         {
 923           bv = BLOCKVECTOR (s);
 924           b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
 925           if (BLOCK_START (b) <= BLOCK_START (block)
 926               && BLOCK_END (b) > BLOCK_START (block))
 927             {
 928               sym = lookup_demangled_block_symbol (b, name);
 929               if (sym)
 930                 {
 931                   block_found = b;
 932                   if (symtab != NULL)
 933                     *symtab = s;
 934                   return sym;
 935                 }
 936             }
 937         }
 938     }
 939
 940
 941   /* C++: If requested to do so by the caller,
 942      check to see if NAME is a field of `this'. */
 943   if (is_a_field_of_this)
 944     {
 945       struct value *v = value_of_this (0);
 946
 947       *is_a_field_of_this = 0;
 948       if (v && check_field (v, name))
 949         {
 950           *is_a_field_of_this = 1;
 951           if (symtab != NULL)
 952             *symtab = NULL;
 953           return 0;
 954         }
 955     }
 956
 957   /* Now search all global blocks.  Do the symtab's first, then
 958      check the psymtab's */
 959
 960   for (s = symtab_list; s; s = s->next)
 961     {
 962       bv = BLOCKVECTOR (s);
 963       block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 964       sym = lookup_block_symbol (block, name, namespace);
 965       if (sym)
 966         {
 967           block_found = block;
 968           if (symtab != NULL)
 969             *symtab = s;
 970           return sym;
 971         }
 972     }
 973
 974   /* Check for the possibility of the symbol being a global function
 975      that is stored on the misc function vector.  Eventually, all
 976      global symbols might be resolved in this way.  */
 977
 978   if (namespace == VAR_NAMESPACE)
 979     {
 980       int ind = lookup_misc_func (name);
 981
 982       /* Look for a mangled C++ name for NAME. */
 983       if (ind == -1)
 984         {
 985           int name_len = strlen (name);
 986
 987           for (ind = misc_function_count; --ind >= 0; )
 988               /* Assume orginal name is prefix of mangled name. */
 989               if (!strncmp (misc_function_vector[ind].name, name, name_len))
 990                 {
 991                   char *demangled =
 992                       cplus_demangle(misc_function_vector[ind].name, -1);
 993                   if (demangled != NULL)
 994                     {
 995                       int cond = strcmp (demangled, name);
 996                       free (demangled);
 997                       if (!cond)
 998                           break;
 999                     }
1000                 }
1001           /* Loop terminates on no match with ind == -1. */
1002         }
1003
1004       if (ind != -1)
1005         {
1006           s = find_pc_symtab (misc_function_vector[ind].address);
1007           if (s)
1008             {
1009               bv = BLOCKVECTOR (s);
1010               block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1011               sym = lookup_block_symbol (block, misc_function_vector[ind].name,
1012                                          namespace);
1013               /* sym == 0 if symbol was found in the misc_function_vector
1014                  but not in the symtab.
1015                  Return 0 to use the misc_function definition of "foo_".
1016
1017                  This happens for Fortran  "foo_" symbols,
1018                  which are "foo" in the symtab.
1019
1020                  This can also happen if "asm" is used to make a
1021                  regular symbol but not a debugging symbol, e.g.
1022                  asm(".globl _main");
1023                  asm("_main:");
1024                  */
1025
1026               if (symtab != NULL)
1027                 *symtab = s;
1028               return sym;
1029             }
1030         }
1031     }
1032
1033   for (ps = partial_symtab_list; ps; ps = ps->next)
1034     if (!ps->readin && lookup_partial_symbol (ps, name, 1, namespace))
1035       {
1036         s = PSYMTAB_TO_SYMTAB(ps);
1037         bv = BLOCKVECTOR (s);
1038         block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1039         sym = lookup_block_symbol (block, name, namespace);
1040         if (!sym)
1041           fatal ("Internal: global symbol found in psymtab but not in symtab");
1042         if (symtab != NULL)
1043           *symtab = s;
1044         return sym;
1045       }
1046
1047   /* Now search all per-file blocks.
1048      Not strictly correct, but more useful than an error.
1049      Do the symtabs first, then check the psymtabs */
1050
1051   for (s = symtab_list; s; s = s->next)
1052     {
1053       bv = BLOCKVECTOR (s);
1054       block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1055       sym = lookup_block_symbol (block, name, namespace);
1056       if (sym)
1057         {
1058           block_found = block;
1059           if (symtab != NULL)
1060             *symtab = s;
1061           return sym;
1062         }
1063     }
1064
1065   for (ps = partial_symtab_list; ps; ps = ps->next)
1066     if (!ps->readin && lookup_partial_symbol (ps, name, 0, namespace))
1067       {
1068         s = PSYMTAB_TO_SYMTAB(ps);
1069         bv = BLOCKVECTOR (s);
1070         block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1071         sym = lookup_block_symbol (block, name, namespace);
1072         if (!sym)
1073           fatal ("Internal: static symbol found in psymtab but not in symtab");
1074         if (symtab != NULL)
1075           *symtab = s;
1076         return sym;
1077       }
1078
1079   /* Now search all per-file blocks for static mangled symbols.
1080      Do the symtabs first, then check the psymtabs.  */
1081
1082   if (namespace ==  VAR_NAMESPACE)
1083     {
1084       for (s = symtab_list; s; s = s->next)
1085         {
1086           bv = BLOCKVECTOR (s);
1087           block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1088           sym = lookup_demangled_block_symbol (block, name);
1089           if (sym)
1090             {
1091               block_found = block;
1092               if (symtab != NULL)
1093                 *symtab = s;
1094               return sym;
1095             }
1096         }
1097
1098       for (ps = partial_symtab_list; ps; ps = ps->next)
1099         if (!ps->readin && lookup_demangled_partial_symbol (ps, name))
1100           {
1101             s = PSYMTAB_TO_SYMTAB(ps);
1102             bv = BLOCKVECTOR (s);
1103             block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1104             sym = lookup_demangled_block_symbol (block, name);
1105             if (!sym)
1106               fatal ("Internal: static symbol found in psymtab but not in symtab");
1107             if (symtab != NULL)
1108               *symtab = s;
1109             return sym;
1110           }
1111     }
1112
1113   if (symtab != NULL)
1114     *symtab = NULL;
1115   return 0;
1116 }
1117
1118 /* Look for a static demangled symbol in block BLOCK.  */
1119
1120 static struct symbol *
1121 lookup_demangled_block_symbol (block, name)
1122      register struct block *block;
1123      char *name;
1124 {
1125   register int bot, top, inc;
1126   register struct symbol *sym;
1127
1128   bot = 0;
1129   top = BLOCK_NSYMS (block);
1130   inc = name[0];
1131
1132   while (bot < top)
1133     {
1134       sym = BLOCK_SYM (block, bot);
1135       if (SYMBOL_NAME (sym)[0] == inc
1136           && SYMBOL_NAMESPACE (sym) == VAR_NAMESPACE)
1137         {
1138           char *demangled = cplus_demangle(SYMBOL_NAME (sym), -1);
1139           if (demangled != NULL)
1140             {
1141               int cond = strcmp (demangled, name);
1142               free (demangled);
1143               if (!cond)
1144                 return sym;
1145             }
1146         }
1147       bot++;
1148     }
1149
1150   return 0;
1151 }
1152
1153 /* Look, in partial_symtab PST, for static mangled symbol NAME. */
1154
1155 static struct partial_symbol *
1156 lookup_demangled_partial_symbol (pst, name)
1157      struct partial_symtab *pst;
1158      char *name;
1159 {
1160   struct partial_symbol *start, *psym;
1161   int length = pst->n_static_syms;
1162   register int inc = name[0];
1163
1164   if (!length)
1165     return (struct partial_symbol *) 0;
1166
1167   start = static_psymbols.list + pst->statics_offset;
1168   for (psym = start; psym < start + length; psym++)
1169     {
1170       if (SYMBOL_NAME (psym)[0] == inc
1171           && SYMBOL_NAMESPACE (psym) == VAR_NAMESPACE)
1172         {
1173           char *demangled = cplus_demangle(SYMBOL_NAME (psym), -1);
1174           if (demangled != NULL)
1175             {
1176               int cond = strcmp (demangled, name);
1177               free (demangled);
1178               if (!cond)
1179                 return psym;
1180             }
1181         }
1182     }
1183
1184   return (struct partial_symbol *) 0;
1185 }
1186
1187 /* Look, in partial_symtab PST, for symbol NAME.  Check the global
1188    symbols if GLOBAL, the static symbols if not */
1189
1190 static struct partial_symbol *
1191 lookup_partial_symbol (pst, name, global, namespace)
1192      struct partial_symtab *pst;
1193      char *name;
1194      int global;
1195      enum namespace namespace;
1196 {
1197   struct partial_symbol *start, *psym;
1198   int length = (global ? pst->n_global_syms : pst->n_static_syms);
1199
1200   if (!length)
1201     return (struct partial_symbol *) 0;
1202
1203   start = (global ?
1204            global_psymbols.list + pst->globals_offset :
1205            static_psymbols.list + pst->statics_offset  );
1206
1207   if (global)                   /* This means we can use a binary */
1208                                 /* search.  */
1209     {
1210       struct partial_symbol *top, *bottom, *center;
1211
1212       /* Binary search.  This search is guaranteed to end with center
1213          pointing at the earliest partial symbol with the correct
1214          name.  At that point *all* partial symbols with that name
1215          will be checked against the correct namespace. */
1216       bottom = start;
1217       top = start + length - 1;
1218       while (top > bottom)
1219         {
1220           center = bottom + (top - bottom) / 2;
1221
1222           assert (center < top);
1223
1224           if (strcmp (SYMBOL_NAME (center), name) >= 0)
1225             top = center;
1226           else
1227             bottom = center + 1;
1228         }
1229       assert (top == bottom);
1230
1231       while (!strcmp (SYMBOL_NAME (top), name))
1232         {
1233           if (SYMBOL_NAMESPACE (top) == namespace)
1234             return top;
1235           top ++;
1236         }
1237     }
1238   else
1239     {
1240       /* Can't use a binary search */
1241       for (psym = start; psym < start + length; psym++)
1242         if (namespace == SYMBOL_NAMESPACE (psym)
1243             && !strcmp (name, SYMBOL_NAME (psym)))
1244           return psym;
1245     }
1246
1247   return (struct partial_symbol *) 0;
1248 }
1249
1250 /* Look for a symbol in block BLOCK.  */
1251
1252 struct symbol *
1253 lookup_block_symbol (block, name, namespace)
1254      register struct block *block;
1255      char *name;
1256      enum namespace namespace;
1257 {
1258   register int bot, top, inc;
1259   register struct symbol *sym, *parameter_sym;
1260
1261   top = BLOCK_NSYMS (block);
1262   bot = 0;
1263
1264   /* If the blocks's symbols were sorted, start with a binary search.  */
1265
1266   if (BLOCK_SHOULD_SORT (block))
1267     {
1268       /* First, advance BOT to not far before
1269          the first symbol whose name is NAME.  */
1270
1271       while (1)
1272         {
1273           inc = (top - bot + 1);
1274           /* No need to keep binary searching for the last few bits worth.  */
1275           if (inc < 4)
1276             break;
1277           inc = (inc >> 1) + bot;
1278           sym = BLOCK_SYM (block, inc);
1279           if (SYMBOL_NAME (sym)[0] < name[0])
1280             bot = inc;
1281           else if (SYMBOL_NAME (sym)[0] > name[0])
1282             top = inc;
1283           else if (strcmp (SYMBOL_NAME (sym), name) < 0)
1284             bot = inc;
1285           else
1286             top = inc;
1287         }
1288
1289       /* Now scan forward until we run out of symbols,
1290          find one whose name is greater than NAME,
1291          or find one we want.
1292          If there is more than one symbol with the right name and namespace,
1293          we return the first one.  dbxread.c is careful to make sure
1294          that if one is a register then it comes first.  */
1295
1296       top = BLOCK_NSYMS (block);
1297       while (bot < top)
1298         {
1299           sym = BLOCK_SYM (block, bot);
1300           inc = SYMBOL_NAME (sym)[0] - name[0];
1301           if (inc == 0)
1302             inc = strcmp (SYMBOL_NAME (sym), name);
1303           if (inc == 0 && SYMBOL_NAMESPACE (sym) == namespace)
1304             return sym;
1305           if (inc > 0)
1306             return 0;
1307           bot++;
1308         }
1309       return 0;
1310     }
1311
1312   /* Here if block isn't sorted.
1313      This loop is equivalent to the loop above,
1314      but hacked greatly for speed.
1315
1316      Note that parameter symbols do not always show up last in the
1317      list; this loop makes sure to take anything else other than
1318      parameter symbols first; it only uses parameter symbols as a
1319      last resort.  Note that this only takes up extra computation
1320      time on a match.  */
1321
1322   parameter_sym = (struct symbol *) 0;
1323   top = BLOCK_NSYMS (block);
1324   inc = name[0];
1325   while (bot < top)
1326     {
1327       sym = BLOCK_SYM (block, bot);
1328       if (SYMBOL_NAME (sym)[0] == inc
1329           && !strcmp (SYMBOL_NAME (sym), name)
1330           && SYMBOL_NAMESPACE (sym) == namespace)
1331         {
1332           if (SYMBOL_CLASS (sym) == LOC_ARG
1333               || SYMBOL_CLASS (sym) == LOC_LOCAL_ARG
1334               || SYMBOL_CLASS (sym) == LOC_REF_ARG
1335               || SYMBOL_CLASS (sym) == LOC_REGPARM)
1336             parameter_sym = sym;
1337           else
1338             return sym;
1339         }
1340       bot++;
1341     }
1342   return parameter_sym;         /* Will be 0 if not found. */
1343 }
1344 \f
1345 /* Return the symbol for the function which contains a specified
1346    lexical block, described by a struct block BL.  */
1347
1348 struct symbol *
1349 block_function (bl)
1350      struct block *bl;
1351 {
1352   while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
1353     bl = BLOCK_SUPERBLOCK (bl);
1354
1355   return BLOCK_FUNCTION (bl);
1356 }
1357
1358 /* Subroutine of find_pc_line */
1359
1360 struct symtab *
1361 find_pc_symtab (pc)
1362      register CORE_ADDR pc;
1363 {
1364   register struct block *b;
1365   struct blockvector *bv;
1366   register struct symtab *s;
1367   register struct partial_symtab *ps;
1368
1369   /* Search all symtabs for one whose file contains our pc */
1370
1371   for (s = symtab_list; s; s = s->next)
1372     {
1373       bv = BLOCKVECTOR (s);
1374       b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1375       if (BLOCK_START (b) <= pc
1376           && BLOCK_END (b) > pc)
1377         break;
1378     }
1379
1380   if (!s)
1381     {
1382       ps = find_pc_psymtab (pc);
1383       if (ps && ps->readin)
1384         fatal ("Internal error: pc in read in psymtab, but not in symtab.");
1385
1386       if (ps)
1387         s = PSYMTAB_TO_SYMTAB (ps);
1388     }
1389
1390   return s;
1391 }
1392
1393 /* Find the source file and line number for a given PC value.
1394    Return a structure containing a symtab pointer, a line number,
1395    and a pc range for the entire source line.
1396    The value's .pc field is NOT the specified pc.
1397    NOTCURRENT nonzero means, if specified pc is on a line boundary,
1398    use the line that ends there.  Otherwise, in that case, the line
1399    that begins there is used.  */
1400
1401 struct symtab_and_line
1402 find_pc_line (pc, notcurrent)
1403      CORE_ADDR pc;
1404      int notcurrent;
1405 {
1406   struct symtab *s;
1407   register struct linetable *l;
1408   register int len;
1409   register int i;
1410   register struct linetable_entry *item;
1411   struct symtab_and_line val;
1412   struct blockvector *bv;
1413
1414   /* Info on best line seen so far, and where it starts, and its file.  */
1415
1416   int best_line = 0;
1417   CORE_ADDR best_pc = 0;
1418   CORE_ADDR best_end = 0;
1419   struct symtab *best_symtab = 0;
1420
1421   /* Store here the first line number
1422      of a file which contains the line at the smallest pc after PC.
1423      If we don't find a line whose range contains PC,
1424      we will use a line one less than this,
1425      with a range from the start of that file to the first line's pc.  */
1426   int alt_line = 0;
1427   CORE_ADDR alt_pc = 0;
1428   struct symtab *alt_symtab = 0;
1429
1430   /* Info on best line seen in this file.  */
1431
1432   int prev_line;
1433   CORE_ADDR prev_pc;
1434
1435   /* Info on first line of this file.  */
1436
1437   int first_line;
1438   CORE_ADDR first_pc;
1439
1440   /* If this pc is not from the current frame,
1441      it is the address of the end of a call instruction.
1442      Quite likely that is the start of the following statement.
1443      But what we want is the statement containing the instruction.
1444      Fudge the pc to make sure we get that.  */
1445
1446   if (notcurrent) pc -= 1;
1447
1448   s = find_pc_symtab (pc);
1449   if (s == 0)
1450     {
1451       val.symtab = 0;
1452       val.line = 0;
1453       val.pc = pc;
1454       val.end = 0;
1455       return val;
1456     }
1457
1458   bv = BLOCKVECTOR (s);
1459
1460   /* Look at all the symtabs that share this blockvector.
1461      They all have the same apriori range, that we found was right;
1462      but they have different line tables.  */
1463
1464   for (; s && BLOCKVECTOR (s) == bv; s = s->next)
1465     {
1466       /* Find the best line in this symtab.  */
1467       l = LINETABLE (s);
1468       len = l->nitems;
1469       prev_line = -1;
1470       first_line = -1;
1471       for (i = 0; i < len; i++)
1472         {
1473           item = &(l->item[i]);
1474
1475           if (first_line < 0)
1476             {
1477               first_line = item->line;
1478               first_pc = item->pc;
1479             }
1480           /* Return the last line that did not start after PC.  */
1481           if (pc >= item->pc)
1482             {
1483               prev_line = item->line;
1484               prev_pc = item->pc;
1485             }
1486           else
1487             break;
1488         }
1489
1490       /* Is this file's best line closer than the best in the other files?
1491          If so, record this file, and its best line, as best so far.  */
1492       if (prev_line >= 0 && prev_pc > best_pc)
1493         {
1494           best_pc = prev_pc;
1495           best_line = prev_line;
1496           best_symtab = s;
1497           if (i < len)
1498             best_end = item->pc;
1499           else
1500             best_end = 0;
1501         }
1502       /* Is this file's first line closer than the first lines of other files?
1503          If so, record this file, and its first line, as best alternate.  */
1504       if (first_line >= 0 && first_pc > pc
1505           && (alt_pc == 0 || first_pc < alt_pc))
1506         {
1507           alt_pc = first_pc;
1508           alt_line = first_line;
1509           alt_symtab = s;
1510         }
1511     }
1512   if (best_symtab == 0)
1513     {
1514       val.symtab = alt_symtab;
1515       val.line = alt_line - 1;
1516       val.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
1517       val.end = alt_pc;
1518     }
1519   else
1520     {
1521       val.symtab = best_symtab;
1522       val.line = best_line;
1523       val.pc = best_pc;
1524       val.end = (best_end ? best_end
1525                    : (alt_pc ? alt_pc
1526                       : BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))));
1527     }
1528   return val;
1529 }
1530 \f
1531 /* Find the PC value for a given source file and line number.
1532    Returns zero for invalid line number.
1533    The source file is specified with a struct symtab.  */
1534
1535 CORE_ADDR
1536 find_line_pc (symtab, line)
1537      struct symtab *symtab;
1538      int line;
1539 {
1540   register struct linetable *l;
1541   register int ind;
1542   int dummy;
1543
1544   if (symtab == 0)
1545     return 0;
1546   l = LINETABLE (symtab);
1547   ind = find_line_common(l, line, &dummy);
1548   return (ind >= 0) ? l->item[ind].pc : 0;
1549 }
1550
1551 /* Find the range of pc values in a line.
1552    Store the starting pc of the line into *STARTPTR
1553    and the ending pc (start of next line) into *ENDPTR.
1554    Returns 1 to indicate success.
1555    Returns 0 if could not find the specified line.  */
1556
1557 int
1558 find_line_pc_range (symtab, thisline, startptr, endptr)
1559      struct symtab *symtab;
1560      int thisline;
1561      CORE_ADDR *startptr, *endptr;
1562 {
1563   register struct linetable *l;
1564   register int ind;
1565   int exact_match;              /* did we get an exact linenumber match */
1566
1567   if (symtab == 0)
1568     return 0;
1569
1570   l = LINETABLE (symtab);
1571   ind = find_line_common (l, thisline, &exact_match);
1572   if (ind >= 0)
1573     {
1574       *startptr = l->item[ind].pc;
1575       /* If we have not seen an entry for the specified line,
1576          assume that means the specified line has zero bytes.  */
1577       if (!exact_match || ind == l->nitems-1)
1578         *endptr = *startptr;
1579       else
1580         /* Perhaps the following entry is for the following line.
1581            It's worth a try.  */
1582         if (ind+1 < l->nitems
1583          && l->item[ind+1].line == thisline + 1)
1584           *endptr = l->item[ind+1].pc;
1585         else
1586           *endptr = find_line_pc (symtab, thisline+1);
1587       return 1;
1588     }
1589
1590   return 0;
1591 }
1592
1593 /* Given a line table and a line number, return the index into the line
1594    table for the pc of the nearest line whose number is >= the specified one.
1595    Return -1 if none is found.  The value is >= 0 if it is an index.
1596
1597    Set *EXACT_MATCH nonzero if the value returned is an exact match.  */
1598
1599 static int
1600 find_line_common (l, lineno, exact_match)
1601      register struct linetable *l;
1602      register int lineno;
1603      int *exact_match;
1604 {
1605   register int i;
1606   register int len;
1607
1608   /* BEST is the smallest linenumber > LINENO so far seen,
1609      or 0 if none has been seen so far.
1610      BEST_INDEX identifies the item for it.  */
1611
1612   int best_index = -1;
1613   int best = 0;
1614
1615   if (lineno <= 0)
1616     return -1;
1617
1618   len = l->nitems;
1619   for (i = 0; i < len; i++)
1620     {
1621       register struct linetable_entry *item = &(l->item[i]);
1622
1623       if (item->line == lineno)
1624         {
1625           *exact_match = 1;
1626           return i;
1627         }
1628
1629       if (item->line > lineno && (best == 0 || item->line < best))
1630         {
1631           best = item->line;
1632           best_index = i;
1633         }
1634     }
1635
1636   /* If we got here, we didn't get an exact match.  */
1637
1638   *exact_match = 0;
1639   return best_index;
1640 }
1641
1642 int
1643 find_pc_line_pc_range (pc, startptr, endptr)
1644      CORE_ADDR pc;
1645      CORE_ADDR *startptr, *endptr;
1646 {
1647   struct symtab_and_line sal;
1648   sal = find_pc_line (pc, 0);
1649   *startptr = sal.pc;
1650   *endptr = sal.end;
1651   return sal.symtab != 0;
1652 }
1653 \f
1654 /* If P is of the form "operator[ \t]+..." where `...' is
1655    some legitimate operator text, return a pointer to the
1656    beginning of the substring of the operator text.
1657    Otherwise, return "".  */
1658 static char *
1659 operator_chars (p, end)
1660      char *p;
1661      char **end;
1662 {
1663   *end = "";
1664   if (strncmp (p, "operator", 8))
1665     return *end;
1666   p += 8;
1667
1668   /* Don't get faked out by `operator' being part of a longer
1669      identifier.  */
1670   if ((*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z')
1671       || *p == '_' || *p == '$' || *p == '\0')
1672     return *end;
1673
1674   /* Allow some whitespace between `operator' and the operator symbol.  */
1675   while (*p == ' ' || *p == '\t')
1676     p++;
1677
1678   switch (*p)
1679     {
1680     case '!':
1681     case '=':
1682     case '*':
1683     case '/':
1684     case '%':
1685     case '^':
1686       if (p[1] == '=')
1687         *end = p+2;
1688       else
1689         *end = p+1;
1690       return p;
1691     case '<':
1692     case '>':
1693     case '+':
1694     case '-':
1695     case '&':
1696     case '|':
1697       if (p[1] == '=' || p[1] == p[0])
1698         *end = p+2;
1699       else
1700         *end = p+1;
1701       return p;
1702     case '~':
1703     case ',':
1704       *end = p+1;
1705       return p;
1706     case '(':
1707       if (p[1] != ')')
1708         error ("`operator ()' must be specified without whitespace in `()'");
1709       *end = p+2;
1710       return p;
1711     case '?':
1712       if (p[1] != ':')
1713         error ("`operator ?:' must be specified without whitespace in `?:'");
1714       *end = p+2;
1715       return p;
1716     case '[':
1717       if (p[1] != ']')
1718         error ("`operator []' must be specified without whitespace in `[]'");
1719       *end = p+2;
1720       return p;
1721     default:
1722       error ("`operator %s' not supported", p);
1723       break;
1724     }
1725   *end = "";
1726   return *end;
1727 }
1728
1729 /* Recursive helper function for decode_line_1.
1730  * Look for methods named NAME in type T.
1731  * Return number of matches.
1732  * Put matches in PHYSNAMES and SYM_ARR (which better be big enough!).
1733  * These allocations seem to define "big enough":
1734  * sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1735  * physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
1736  */
1737
1738 int
1739 find_methods(t, name, physnames, sym_arr)
1740      struct type *t;
1741      char *name;
1742      char **physnames;
1743      struct symbol **sym_arr;
1744 {
1745   int i1 = 0;
1746   int ibase;
1747   struct symbol *sym_class;
1748   char *class_name = type_name_no_tag (t);
1749   /* Ignore this class if it doesn't have a name.
1750      This prevents core dumps, but is just a workaround
1751      because we might not find the function in
1752      certain cases, such as
1753      struct D {virtual int f();}
1754      struct C : D {virtual int g();}
1755      (in this case g++ 1.35.1- does not put out a name
1756      for D as such, it defines type 19 (for example) in
1757      the same stab as C, and then does a
1758      .stabs "D:T19" and a .stabs "D:t19".
1759      Thus
1760      "break C::f" should not be looking for field f in
1761      the class named D,
1762      but just for the field f in the baseclasses of C
1763      (no matter what their names).
1764
1765      However, I don't know how to replace the code below
1766      that depends on knowing the name of D.  */
1767   if (class_name
1768       && (sym_class = lookup_symbol (class_name,
1769                                      (struct block *)NULL,
1770                                      STRUCT_NAMESPACE,
1771                                      (int *)NULL,
1772                                      (struct symtab **)NULL)))
1773     {
1774       int method_counter;
1775       t = SYMBOL_TYPE (sym_class);
1776       for (method_counter = TYPE_NFN_FIELDS (t) - 1;
1777            method_counter >= 0;
1778            --method_counter)
1779         {
1780           int field_counter;
1781           struct fn_field *f = TYPE_FN_FIELDLIST1 (t, method_counter);
1782
1783           char *method_name = TYPE_FN_FIELDLIST_NAME (t, method_counter);
1784           if (!strcmp (name, method_name))
1785             /* Find all the fields with that name.  */
1786             for (field_counter = TYPE_FN_FIELDLIST_LENGTH (t, method_counter) - 1;
1787                  field_counter >= 0;
1788                  --field_counter)
1789               {
1790                 char *phys_name;
1791                 if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f, field_counter)) & TYPE_FLAG_STUB)
1792                   check_stub_method (t, method_counter, field_counter);
1793                 phys_name = TYPE_FN_FIELD_PHYSNAME (f, field_counter);
1794                 physnames[i1] = (char*) alloca (strlen (phys_name) + 1);
1795                 strcpy (physnames[i1], phys_name);
1796                 sym_arr[i1] = lookup_symbol (phys_name,
1797                                              SYMBOL_BLOCK_VALUE (sym_class),
1798                                              VAR_NAMESPACE,
1799                                              (int *) NULL,
1800                                              (struct symtab **) NULL);
1801                 if (sym_arr[i1]) i1++;
1802               }
1803         }
1804     }
1805   /* Only search baseclasses if there is no match yet,
1806    * since names in derived classes override those in baseclasses.
1807    */
1808   if (i1)
1809     return i1;
1810   for (ibase = 0; ibase < TYPE_N_BASECLASSES (t); ibase++)
1811     i1 += find_methods(TYPE_BASECLASS(t, ibase), name,
1812                        physnames + i1, sym_arr + i1);
1813   return i1;
1814 }
1815
1816 /* Parse a string that specifies a line number.
1817    Pass the address of a char * variable; that variable will be
1818    advanced over the characters actually parsed.
1819
1820    The string can be:
1821
1822    LINENUM -- that line number in current file.  PC returned is 0.
1823    FILE:LINENUM -- that line in that file.  PC returned is 0.
1824    FUNCTION -- line number of openbrace of that function.
1825       PC returned is the start of the function.
1826    VARIABLE -- line number of definition of that variable.
1827       PC returned is 0.
1828    FILE:FUNCTION -- likewise, but prefer functions in that file.
1829    *EXPR -- line in which address EXPR appears.
1830
1831    FUNCTION may be an undebuggable function found in misc_function_vector.
1832
1833    If the argument FUNFIRSTLINE is nonzero, we want the first line
1834    of real code inside a function when a function is specified.
1835
1836    DEFAULT_SYMTAB specifies the file to use if none is specified.
1837    It defaults to current_source_symtab.
1838    DEFAULT_LINE specifies the line number to use for relative
1839    line numbers (that start with signs).  Defaults to current_source_line.
1840
1841    Note that it is possible to return zero for the symtab
1842    if no file is validly specified.  Callers must check that.
1843    Also, the line number returned may be invalid.  */
1844
1845 struct symtabs_and_lines
1846 decode_line_1 (argptr, funfirstline, default_symtab, default_line)
1847      char **argptr;
1848      int funfirstline;
1849      struct symtab *default_symtab;
1850      int default_line;
1851 {
1852   struct symtabs_and_lines decode_line_2 ();
1853   struct symtabs_and_lines values;
1854   struct symtab_and_line val;
1855   register char *p, *p1;
1856   char *q, *q1;
1857   register struct symtab *s;
1858
1859   register struct symbol *sym;
1860   /* The symtab that SYM was found in.  */
1861   struct symtab *sym_symtab;
1862
1863   register CORE_ADDR pc;
1864   register int i;
1865   char *copy;
1866   struct symbol *sym_class;
1867   int i1;
1868   struct symbol **sym_arr;
1869   struct type *t;
1870   char **physnames;
1871
1872   /* Defaults have defaults.  */
1873
1874   if (default_symtab == 0)
1875     {
1876       default_symtab = current_source_symtab;
1877       default_line = current_source_line;
1878     }
1879
1880   /* See if arg is *PC */
1881
1882   if (**argptr == '*')
1883     {
1884       (*argptr)++;
1885       pc = parse_and_eval_address_1 (argptr);
1886       values.sals = (struct symtab_and_line *)
1887         xmalloc (sizeof (struct symtab_and_line));
1888       values.nelts = 1;
1889       values.sals[0] = find_pc_line (pc, 0);
1890       values.sals[0].pc = pc;
1891       return values;
1892     }
1893
1894   /* Maybe arg is FILE : LINENUM or FILE : FUNCTION */
1895
1896   s = 0;
1897
1898   for (p = *argptr; *p; p++)
1899     {
1900       if (p[0] == ':' || p[0] == ' ' || p[0] == '\t')
1901         break;
1902     }
1903   while (p[0] == ' ' || p[0] == '\t') p++;
1904
1905   q = operator_chars (*argptr, &q1);
1906   if (p[0] == ':')
1907     {
1908
1909       /*  C++  */
1910       if (p[1] ==':')
1911         {
1912           /* Extract the class name.  */
1913           p1 = p;
1914           while (p != *argptr && p[-1] == ' ') --p;
1915           copy = (char *) alloca (p - *argptr + 1);
1916           bcopy (*argptr, copy, p - *argptr);
1917           copy[p - *argptr] = 0;
1918
1919           /* Discard the class name from the arg.  */
1920           p = p1 + 2;
1921           while (*p == ' ' || *p == '\t') p++;
1922           *argptr = p;
1923
1924           sym_class = lookup_symbol (copy, 0, STRUCT_NAMESPACE, 0,
1925                                      (struct symtab **)NULL);
1926
1927           if (sym_class &&
1928               (TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_STRUCT
1929                || TYPE_CODE (SYMBOL_TYPE (sym_class)) == TYPE_CODE_UNION))
1930             {
1931               /* Arg token is not digits => try it as a function name
1932                  Find the next token (everything up to end or next whitespace). */
1933               p = *argptr;
1934               while (*p && *p != ' ' && *p != '\t' && *p != ',' && *p !=':') p++;
1935               q = operator_chars (*argptr, &q1);
1936
1937               copy = (char *) alloca (p - *argptr + 1 + (q1 - q));
1938               if (q1 - q)
1939                 {
1940                   copy[0] = 'o';
1941                   copy[1] = 'p';
1942                   copy[2] = CPLUS_MARKER;
1943                   bcopy (q, copy + 3, q1 - q);
1944                   copy[3 + (q1 - q)] = '\0';
1945                   p = q1;
1946                 }
1947               else
1948                 {
1949                   bcopy (*argptr, copy, p - *argptr);
1950                   copy[p - *argptr] = '\0';
1951                 }
1952
1953               /* no line number may be specified */
1954               while (*p == ' ' || *p == '\t') p++;
1955               *argptr = p;
1956
1957               sym = 0;
1958               i1 = 0;           /*  counter for the symbol array */
1959               t = SYMBOL_TYPE (sym_class);
1960               sym_arr = (struct symbol **) alloca(TYPE_NFN_FIELDS_TOTAL (t) * sizeof(struct symbol*));
1961               physnames = (char **) alloca (TYPE_NFN_FIELDS_TOTAL (t) * sizeof(char*));
1962
1963               if (destructor_name_p (copy, t))
1964                 {
1965                   /* destructors are a special case.  */
1966                   struct fn_field *f = TYPE_FN_FIELDLIST1 (t, 0);
1967                   int len = TYPE_FN_FIELDLIST_LENGTH (t, 0) - 1;
1968                   char *phys_name = TYPE_FN_FIELD_PHYSNAME (f, len);
1969                   physnames[i1] = (char *)alloca (strlen (phys_name) + 1);
1970                   strcpy (physnames[i1], phys_name);
1971                   sym_arr[i1] =
1972                     lookup_symbol (phys_name, SYMBOL_BLOCK_VALUE (sym_class),
1973                                    VAR_NAMESPACE, 0, (struct symtab **)NULL);
1974                   if (sym_arr[i1]) i1++;
1975                 }
1976               else
1977                 i1 = find_methods (t, copy, physnames, sym_arr);
1978               if (i1 == 1)
1979                 {
1980                   /* There is exactly one field with that name.  */
1981                   sym = sym_arr[0];
1982
1983                   if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1984                     {
1985                       /* Arg is the name of a function */
1986                       pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
1987                       if (funfirstline)
1988                         SKIP_PROLOGUE (pc);
1989                       values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
1990                       values.nelts = 1;
1991                       values.sals[0] = find_pc_line (pc, 0);
1992                       values.sals[0].pc = (values.sals[0].end && values.sals[0].pc != pc) ? values.sals[0].end : pc;
1993                     }
1994                   else
1995                     {
1996                       values.nelts = 0;
1997                     }
1998                   return values;
1999                 }
2000               if (i1 > 0)
2001                 {
2002                   /* There is more than one field with that name
2003                      (overloaded).  Ask the user which one to use.  */
2004                   return decode_line_2 (sym_arr, i1, funfirstline);
2005                 }
2006               else
2007                 {
2008                   char *tmp;
2009
2010                   if (OPNAME_PREFIX_P (copy))
2011                     {
2012                       tmp = (char *)alloca (strlen (copy+3) + 9);
2013                       strcpy (tmp, "operator ");
2014                       strcat (tmp, copy+3);
2015                     }
2016                   else
2017                     tmp = copy;
2018                   error ("that class does not have any method named %s", tmp);
2019                 }
2020             }
2021           else
2022             /* The quotes are important if copy is empty.  */
2023             error("No class, struct, or union named \"%s\"", copy );
2024         }
2025       /*  end of C++  */
2026
2027
2028       /* Extract the file name.  */
2029       p1 = p;
2030       while (p != *argptr && p[-1] == ' ') --p;
2031       copy = (char *) alloca (p - *argptr + 1 + (q1 - q));
2032       if (q1 - q)
2033         {
2034           copy[0] = 'o';
2035           copy[1] = 'p';
2036           copy[2] = CPLUS_MARKER;
2037           bcopy (q, copy + 3, q1-q);
2038           copy[3 + (q1-q)] = 0;
2039           p = q1;
2040         }
2041       else
2042         {
2043           bcopy (*argptr, copy, p - *argptr);
2044           copy[p - *argptr] = 0;
2045         }
2046
2047       /* Find that file's data.  */
2048       s = lookup_symtab (copy);
2049       if (s == 0)
2050         {
2051           if (symtab_list == 0 && partial_symtab_list == 0)
2052             error (no_symtab_msg);
2053           error ("No source file named %s.", copy);
2054         }
2055
2056       /* Discard the file name from the arg.  */
2057       p = p1 + 1;
2058       while (*p == ' ' || *p == '\t') p++;
2059       *argptr = p;
2060     }
2061
2062   /* S is specified file's symtab, or 0 if no file specified.
2063      arg no longer contains the file name.  */
2064
2065   /* Check whether arg is all digits (and sign) */
2066
2067   p = *argptr;
2068   if (*p == '-' || *p == '+') p++;
2069   while (*p >= '0' && *p <= '9')
2070     p++;
2071
2072   if (p != *argptr && (*p == 0 || *p == ' ' || *p == '\t' || *p == ','))
2073     {
2074       /* We found a token consisting of all digits -- at least one digit.  */
2075       enum sign {none, plus, minus} sign = none;
2076
2077       /* This is where we need to make sure that we have good defaults.
2078          We must guarantee that this section of code is never executed
2079          when we are called with just a function name, since
2080          select_source_symtab calls us with such an argument  */
2081
2082       if (s == 0 && default_symtab == 0)
2083         {
2084           if (symtab_list == 0 && partial_symtab_list == 0)
2085             error (no_symtab_msg);
2086           select_source_symtab (0);
2087           default_symtab = current_source_symtab;
2088           default_line = current_source_line;
2089         }
2090
2091       if (**argptr == '+')
2092         sign = plus, (*argptr)++;
2093       else if (**argptr == '-')
2094         sign = minus, (*argptr)++;
2095       val.line = atoi (*argptr);
2096       switch (sign)
2097         {
2098         case plus:
2099           if (p == *argptr)
2100             val.line = 5;
2101           if (s == 0)
2102             val.line = default_line + val.line;
2103           break;
2104         case minus:
2105           if (p == *argptr)
2106             val.line = 15;
2107           if (s == 0)
2108             val.line = default_line - val.line;
2109           else
2110             val.line = 1;
2111           break;
2112         case none:
2113           break;        /* No need to adjust val.line.  */
2114         }
2115
2116       while (*p == ' ' || *p == '\t') p++;
2117       *argptr = p;
2118       if (s == 0)
2119         s = default_symtab;
2120       val.symtab = s;
2121       val.pc = 0;
2122       values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
2123       values.sals[0] = val;
2124       values.nelts = 1;
2125       return values;
2126     }
2127
2128   /* Arg token is not digits => try it as a variable name
2129      Find the next token (everything up to end or next whitespace).  */
2130   p = *argptr;
2131   while (*p && *p != ' ' && *p != '\t' && *p != ',') p++;
2132   copy = (char *) alloca (p - *argptr + 1);
2133   bcopy (*argptr, copy, p - *argptr);
2134   copy[p - *argptr] = 0;
2135   while (*p == ' ' || *p == '\t') p++;
2136   *argptr = p;
2137
2138   /* Look up that token as a variable.
2139      If file specified, use that file's per-file block to start with.  */
2140
2141   sym = lookup_symbol (copy,
2142                        (s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
2143                         : get_selected_block ()),
2144                        VAR_NAMESPACE, 0, &sym_symtab);
2145
2146   if (sym != NULL)
2147     {
2148       if (SYMBOL_CLASS (sym) == LOC_BLOCK)
2149         {
2150           /* Arg is the name of a function */
2151           pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) + FUNCTION_START_OFFSET;
2152           if (funfirstline)
2153             SKIP_PROLOGUE (pc);
2154           val = find_pc_line (pc, 0);
2155 #ifdef PROLOGUE_FIRSTLINE_OVERLAP
2156           /* Convex: no need to suppress code on first line, if any */
2157           val.pc = pc;
2158 #else
2159           val.pc = (val.end && val.pc != pc) ? val.end : pc;
2160 #endif
2161           values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
2162           values.sals[0] = val;
2163           values.nelts = 1;
2164
2165           /* I think this is always the same as the line that
2166              we calculate above, but the general principle is
2167              "trust the symbols more than stuff like
2168              SKIP_PROLOGUE".  */
2169           if (SYMBOL_LINE (sym) != 0)
2170             values.sals[0].line = SYMBOL_LINE (sym);
2171
2172           return values;
2173         }
2174       else if (SYMBOL_LINE (sym) != 0)
2175         {
2176           /* We know its line number.  */
2177           values.sals = (struct symtab_and_line *)
2178             xmalloc (sizeof (struct symtab_and_line));
2179           values.nelts = 1;
2180           bzero (&values.sals[0], sizeof (values.sals[0]));
2181           values.sals[0].symtab = sym_symtab;
2182           values.sals[0].line = SYMBOL_LINE (sym);
2183           return values;
2184         }
2185       else
2186         /* This can happen if it is compiled with a compiler which doesn't
2187            put out line numbers for variables.  */
2188         error ("Line number not known for symbol \"%s\"", copy);
2189     }
2190
2191   if (symtab_list == 0 && partial_symtab_list == 0)
2192     error (no_symtab_msg);
2193
2194   if ((i = lookup_misc_func (copy)) >= 0)
2195     {
2196       val.symtab = 0;
2197       val.line = 0;
2198       val.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
2199       if (funfirstline)
2200         SKIP_PROLOGUE (val.pc);
2201       values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
2202       values.sals[0] = val;
2203       values.nelts = 1;
2204       return values;
2205     }
2206
2207   error ("Function %s not defined.", copy);
2208   return values;        /* for lint */
2209 }
2210
2211 struct symtabs_and_lines
2212 decode_line_spec (string, funfirstline)
2213      char *string;
2214      int funfirstline;
2215 {
2216   struct symtabs_and_lines sals;
2217   if (string == 0)
2218     error ("Empty line specification.");
2219   sals = decode_line_1 (&string, funfirstline,
2220                         current_source_symtab, current_source_line);
2221   if (*string)
2222     error ("Junk at end of line specification: %s", string);
2223   return sals;
2224 }
2225
2226 /* Given a list of NELTS symbols in sym_arr (with corresponding
2227    mangled names in physnames), return a list of lines to operate on
2228    (ask user if necessary).  */
2229 struct symtabs_and_lines
2230 decode_line_2 (sym_arr, nelts, funfirstline)
2231      struct symbol *sym_arr[];
2232      int nelts;
2233      int funfirstline;
2234 {
2235   char *getenv();
2236   struct symtabs_and_lines values, return_values;
2237   register CORE_ADDR pc;
2238   char *args, *arg1, *command_line_input ();
2239   int i;
2240   char *prompt;
2241
2242   values.sals = (struct symtab_and_line *) alloca (nelts * sizeof(struct symtab_and_line));
2243   return_values.sals = (struct symtab_and_line *) xmalloc (nelts * sizeof(struct symtab_and_line));
2244
2245   i = 0;
2246   printf("[0] cancel\n[1] all\n");
2247   while (i < nelts)
2248     {
2249       if (sym_arr[i] && SYMBOL_CLASS (sym_arr[i]) == LOC_BLOCK)
2250         {
2251           /* Arg is the name of a function */
2252           pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym_arr[i]))
2253                + FUNCTION_START_OFFSET;
2254           if (funfirstline)
2255             SKIP_PROLOGUE (pc);
2256           values.sals[i] = find_pc_line (pc, 0);
2257           values.sals[i].pc = (values.sals[i].end && values.sals[i].pc != pc) ?
2258                                values.sals[i].end                      :  pc;
2259           printf("[%d] file:%s; line number:%d\n",
2260                  (i+2), values.sals[i].symtab->filename, values.sals[i].line);
2261         }
2262       else printf ("?HERE\n");
2263       i++;
2264     }
2265
2266   if ((prompt = getenv ("PS2")) == NULL)
2267     {
2268       prompt = ">";
2269     }
2270   printf("%s ",prompt);
2271   fflush(stdout);
2272
2273   args = command_line_input (0, 0);
2274
2275   if (args == 0)
2276     error_no_arg ("one or more choice numbers");
2277
2278   i = 0;
2279   while (*args)
2280     {
2281       int num;
2282
2283       arg1 = args;
2284       while (*arg1 >= '0' && *arg1 <= '9') arg1++;
2285       if (*arg1 && *arg1 != ' ' && *arg1 != '\t')
2286         error ("Arguments must be choice numbers.");
2287
2288       num = atoi (args);
2289
2290       if (num == 0)
2291         error ("cancelled");
2292       else if (num == 1)
2293         {
2294           bcopy (values.sals, return_values.sals, (nelts * sizeof(struct symtab_and_line)));
2295           return_values.nelts = nelts;
2296           return return_values;
2297         }
2298
2299       if (num > nelts + 2)
2300         {
2301           printf ("No choice number %d.\n", num);
2302         }
2303       else
2304         {
2305           num -= 2;
2306           if (values.sals[num].pc)
2307             {
2308               return_values.sals[i++] = values.sals[num];
2309               values.sals[num].pc = 0;
2310             }
2311           else
2312             {
2313               printf ("duplicate request for %d ignored.\n", num);
2314             }
2315         }
2316
2317       args = arg1;
2318       while (*args == ' ' || *args == '\t') args++;
2319     }
2320   return_values.nelts = i;
2321   return return_values;
2322 }
2323
2324 /* Return the index of misc function named NAME.  */
2325
2326 int
2327 lookup_misc_func (name)
2328      register char *name;
2329 {
2330   register int i;
2331
2332   for (i = 0; i < misc_function_count; i++)
2333     if (!strcmp (misc_function_vector[i].name, name))
2334       return i;
2335   return -1;            /* not found */
2336 }
2337 \f
2338 /* Slave routine for sources_info.  Force line breaks at ,'s.
2339    NAME is the name to print and *FIRST is nonzero if this is the first
2340    name printed.  Set *FIRST to zero.  */
2341 static void
2342 output_source_filename (name, first)
2343      char *name;
2344      int *first;
2345 {
2346   static int column;
2347   /* Table of files printed so far.  Since a single source file can
2348      result in several partial symbol tables, we need to avoid printing
2349      it more than once.  Note: if some of the psymtabs are read in and
2350      some are not, it gets printed both under "Source files for which
2351      symbols have been read" and "Source files for which symbols will
2352      be read in on demand".  I consider this a reasonable way to deal
2353      with the situation.  I'm not sure whether this can also happen for
2354      symtabs; it doesn't hurt to check.  */
2355   static char **tab = NULL;
2356   /* Allocated size of tab in elements.
2357      Start with one 256-byte block (when using GNU malloc.c).
2358      24 is the malloc overhead when range checking is in effect.  */
2359   static int tab_alloc_size = (256 - 24) / sizeof (char *);
2360   /* Current size of tab in elements.  */
2361   static int tab_cur_size;
2362
2363   char **p;
2364
2365   if (*first)
2366     {
2367       if (tab == NULL)
2368         tab = (char **) xmalloc (tab_alloc_size * sizeof (*tab));
2369       tab_cur_size = 0;
2370     }
2371
2372   /* Is NAME in tab?  */
2373   for (p = tab; p < tab + tab_cur_size; p++)
2374     if (strcmp (*p, name) == 0)
2375       /* Yes; don't print it again.  */
2376       return;
2377   /* No; add it to tab.  */
2378   if (tab_cur_size == tab_alloc_size)
2379     {
2380       tab_alloc_size *= 2;
2381       tab = (char **) xrealloc (tab, tab_alloc_size * sizeof (*tab));
2382     }
2383   tab[tab_cur_size++] = name;
2384
2385   if (*first)
2386     {
2387       column = 0;
2388       *first = 0;
2389     }
2390   else
2391     {
2392       printf_filtered (",");
2393       column++;
2394     }
2395
2396   if (column != 0 && column + strlen (name) >= 70)
2397     {
2398       printf_filtered ("\n");
2399       column = 0;
2400     }
2401   else if (column != 0)
2402     {
2403       printf_filtered (" ");
2404       column++;
2405     }
2406   fputs_filtered (name, stdout);
2407   column += strlen (name);
2408 }
2409
2410 static void
2411 sources_info ()
2412 {
2413   register struct symtab *s;
2414   register struct partial_symtab *ps;
2415   int first;
2416
2417   if (symtab_list == 0 && partial_symtab_list == 0)
2418     {
2419       printf (no_symtab_msg);
2420       return;
2421     }
2422
2423   printf_filtered ("Source files for which symbols have been read in:\n\n");
2424
2425   first = 1;
2426   for (s = symtab_list; s; s = s->next)
2427     output_source_filename (s->filename, &first);
2428   printf_filtered ("\n\n");
2429
2430   printf_filtered ("Source files for which symbols will be read in on demand:\n\n");
2431
2432   first = 1;
2433   for (ps = partial_symtab_list; ps; ps = ps->next)
2434     if (!ps->readin)
2435       output_source_filename (ps->filename, &first);
2436   printf_filtered ("\n");
2437 }
2438
2439 /* List all symbols (if REGEXP is 0) or all symbols matching REGEXP.
2440    If CLASS is zero, list all symbols except functions and type names.
2441    If CLASS is 1, list only functions.
2442    If CLASS is 2, list only type names.
2443
2444    BPT is non-zero if we should set a breakpoint at the functions
2445    we find.  */
2446
2447 static void
2448 list_symbols (regexp, class, bpt)
2449      char *regexp;
2450      int class;
2451      int bpt;
2452 {
2453   register struct symtab *s;
2454   register struct partial_symtab *ps;
2455   register struct blockvector *bv;
2456   struct blockvector *prev_bv = 0;
2457   register struct block *b;
2458   register int i, j;
2459   register struct symbol *sym;
2460   struct partial_symbol *psym;
2461   char *val;
2462   static char *classnames[]
2463     = {"variable", "function", "type", "method"};
2464   int found_in_file = 0;
2465
2466   if (regexp)
2467     if (0 != (val = (char *) re_comp (regexp)))
2468       error ("Invalid regexp (%s): %s", val, regexp);
2469
2470   /* Search through the partial_symtab_list *first* for all symbols
2471      matching the regexp.  That way we don't have to reproduce all of
2472      the machinery below. */
2473   for (ps = partial_symtab_list; ps; ps = ps->next)
2474     {
2475       struct partial_symbol *bound, *gbound, *sbound;
2476       int keep_going = 1;
2477
2478       if (ps->readin) continue;
2479
2480       gbound = global_psymbols.list + ps->globals_offset + ps->n_global_syms;
2481       sbound = static_psymbols.list + ps->statics_offset + ps->n_static_syms;
2482       bound = gbound;
2483
2484       /* Go through all of the symbols stored in a partial
2485          symtab in one loop. */
2486       psym = global_psymbols.list + ps->globals_offset;
2487       while (keep_going)
2488         {
2489           if (psym >= bound)
2490             {
2491               if (bound == gbound && ps->n_static_syms != 0)
2492                 {
2493                   psym = static_psymbols.list + ps->statics_offset;
2494                   bound = sbound;
2495                 }
2496               else
2497                 keep_going = 0;
2498               continue;
2499             }
2500           else
2501             {
2502               QUIT;
2503
2504               /* If it would match (logic taken from loop below)
2505                  load the file and go on to the next one */
2506               if ((regexp == 0 || re_exec (SYMBOL_NAME (psym)))
2507                   && ((class == 0 && SYMBOL_CLASS (psym) != LOC_TYPEDEF
2508                        && SYMBOL_CLASS (psym) != LOC_BLOCK)
2509                       || (class == 1 && SYMBOL_CLASS (psym) == LOC_BLOCK)
2510                       || (class == 2 && SYMBOL_CLASS (psym) == LOC_TYPEDEF)
2511                       || (class == 3 && SYMBOL_CLASS (psym) == LOC_BLOCK)))
2512                 {
2513                   (void) PSYMTAB_TO_SYMTAB(ps);
2514                   keep_going = 0;
2515                 }
2516             }
2517           psym++;
2518         }
2519     }
2520
2521   /* Here, *if* the class is correct (function only, right now), we
2522      search through the misc function vector for symbols that
2523      match, and call find_pc_symtab on them to force their symbols to
2524      be read.  The symbol will then be found during the scan of symtabs
2525      below.  */
2526
2527   if (class == 1)
2528     {
2529       for (i = 0; i < misc_function_count; i++)
2530         if (regexp == 0 || re_exec (misc_function_vector[i].name))
2531           {
2532             (void) find_pc_symtab (misc_function_vector[i].address);
2533           }
2534     }
2535
2536   /* Printout here so as to get after the "Reading in symbols"
2537      messages which will be generated above.  */
2538   if (!bpt)
2539     printf_filtered (regexp
2540           ? "All %ss matching regular expression \"%s\":\n"
2541           : "All defined %ss:\n",
2542           classnames[class],
2543           regexp);
2544
2545   for (s = symtab_list; s; s = s->next)
2546     {
2547       found_in_file = 0;
2548       bv = BLOCKVECTOR (s);
2549       /* Often many files share a blockvector.
2550          Scan each blockvector only once so that
2551          we don't get every symbol many times.
2552          It happens that the first symtab in the list
2553          for any given blockvector is the main file.  */
2554       if (bv != prev_bv)
2555         for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
2556           {
2557             b = BLOCKVECTOR_BLOCK (bv, i);
2558             /* Skip the sort if this block is always sorted.  */
2559             if (!BLOCK_SHOULD_SORT (b))
2560               sort_block_syms (b);
2561             for (j = 0; j < BLOCK_NSYMS (b); j++)
2562               {
2563                 QUIT;
2564                 sym = BLOCK_SYM (b, j);
2565                 if ((regexp == 0 || re_exec (SYMBOL_NAME (sym)))
2566                     && ((class == 0 && SYMBOL_CLASS (sym) != LOC_TYPEDEF
2567                          && SYMBOL_CLASS (sym) != LOC_BLOCK)
2568                         || (class == 1 && SYMBOL_CLASS (sym) == LOC_BLOCK)
2569                         || (class == 2 && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2570                         || (class == 3 && SYMBOL_CLASS (sym) == LOC_BLOCK)))
2571                   {
2572                     if (bpt)
2573                       {
2574                         /* Set a breakpoint here, if it's a function */
2575                         if (class == 1)
2576                           break_command (SYMBOL_NAME(sym), 0);
2577                       }
2578                     else if (!found_in_file)
2579                       {
2580                         fputs_filtered ("\nFile ", stdout);
2581                         fputs_filtered (s->filename, stdout);
2582                         fputs_filtered (":\n", stdout);
2583                       }
2584                     found_in_file = 1;
2585
2586                     if (class != 2 && i == STATIC_BLOCK)
2587                       printf_filtered ("static ");
2588                     if (class == 2
2589                         && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
2590                       printf_filtered ("typedef ");
2591
2592                     if (class < 3)
2593                       {
2594                         type_print (SYMBOL_TYPE (sym),
2595                                     (SYMBOL_CLASS (sym) == LOC_TYPEDEF
2596                                      ? "" : SYMBOL_NAME (sym)),
2597                                     stdout, 0);
2598
2599                         if (class == 2
2600                             && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE
2601                             && (TYPE_NAME ((SYMBOL_TYPE (sym))) == 0
2602                                 || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (sym))),
2603                                                 SYMBOL_NAME (sym))))
2604                           {
2605                             fputs_filtered (" ", stdout);
2606                             fprint_symbol (stdout, SYMBOL_NAME (sym));
2607                           }
2608
2609                         printf_filtered (";\n");
2610                       }
2611                     else
2612                       {
2613 # if 0
2614                         char buf[1024];
2615                         type_print_base (TYPE_FN_FIELD_TYPE(t, i), stdout, 0, 0);
2616                         type_print_varspec_prefix (TYPE_FN_FIELD_TYPE(t, i), stdout, 0);
2617                         sprintf (buf, " %s::", type_name_no_tag (t));
2618                         type_print_method_args (TYPE_FN_FIELD_ARGS (t, i), buf, name, stdout);
2619 # endif
2620                       }
2621                   }
2622               }
2623           }
2624       prev_bv = bv;
2625     }
2626 }
2627
2628 static void
2629 variables_info (regexp)
2630      char *regexp;
2631 {
2632   list_symbols (regexp, 0, 0);
2633 }
2634
2635 static void
2636 functions_info (regexp)
2637      char *regexp;
2638 {
2639   list_symbols (regexp, 1, 0);
2640 }
2641
2642 static void
2643 types_info (regexp)
2644      char *regexp;
2645 {
2646   list_symbols (regexp, 2, 0);
2647 }
2648
2649 #if 0
2650 /* Tiemann says: "info methods was never implemented."  */
2651 static void
2652 methods_info (regexp)
2653      char *regexp;
2654 {
2655   list_symbols (regexp, 3, 0);
2656 }
2657 #endif /* 0 */
2658
2659 /* Breakpoint all functions matching regular expression. */
2660 static void
2661 rbreak_command (regexp)
2662      char *regexp;
2663 {
2664   list_symbols (regexp, 1, 1);
2665 }
2666 \f
2667 /* Initialize the standard C scalar types.  */
2668
2669 static
2670 struct type *
2671 init_type (code, length, uns, name)
2672      enum type_code code;
2673      int length, uns;
2674      char *name;
2675 {
2676   register struct type *type;
2677
2678   type = (struct type *) xmalloc (sizeof (struct type));
2679   bzero (type, sizeof *type);
2680   TYPE_MAIN_VARIANT (type) = type;
2681   TYPE_CODE (type) = code;
2682   TYPE_LENGTH (type) = length;
2683   TYPE_FLAGS (type) = uns ? TYPE_FLAG_UNSIGNED : 0;
2684   TYPE_FLAGS (type) |= TYPE_FLAG_PERM;
2685   TYPE_NFIELDS (type) = 0;
2686   TYPE_NAME (type) = name;
2687
2688   /* C++ fancies.  */
2689   TYPE_NFN_FIELDS (type) = 0;
2690   TYPE_N_BASECLASSES (type) = 0;
2691   return type;
2692 }
2693
2694 /* Return Nonzero if block a is lexically nested within block b,
2695    or if a and b have the same pc range.
2696    Return zero otherwise. */
2697 int
2698 contained_in (a, b)
2699      struct block *a, *b;
2700 {
2701   if (!a || !b)
2702     return 0;
2703   return BLOCK_START (a) >= BLOCK_START (b)
2704       && BLOCK_END (a)   <= BLOCK_END (b);
2705 }
2706
2707 \f
2708 /* Helper routine for make_symbol_completion_list.  */
2709
2710 int return_val_size, return_val_index;
2711 char **return_val;
2712
2713 void
2714 completion_list_add_symbol (symname)
2715      char *symname;
2716 {
2717   if (return_val_index + 3 > return_val_size)
2718     return_val =
2719       (char **)xrealloc (return_val,
2720                          (return_val_size *= 2) * sizeof (char *));
2721
2722   return_val[return_val_index] =
2723     (char *)xmalloc (1 + strlen (symname));
2724
2725   strcpy (return_val[return_val_index], symname);
2726
2727   return_val[++return_val_index] = (char *)NULL;
2728 }
2729
2730 /* Return a NULL terminated array of all symbols (regardless of class) which
2731    begin by matching TEXT.  If the answer is no symbols, then the return value
2732    is an array which contains only a NULL pointer.
2733
2734    Problem: All of the symbols have to be copied because readline
2735    frees them.  I'm not going to worry about this; hopefully there
2736    won't be that many.  */
2737
2738 char **
2739 make_symbol_completion_list (text)
2740   char *text;
2741 {
2742   register struct symtab *s;
2743   register struct partial_symtab *ps;
2744   register struct block *b, *surrounding_static_block = 0;
2745   extern struct block *get_selected_block ();
2746   register int i, j;
2747   struct partial_symbol *psym;
2748
2749   int text_len = strlen (text);
2750   return_val_size = 100;
2751   return_val_index = 0;
2752   return_val =
2753     (char **)xmalloc ((1 + return_val_size) *sizeof (char *));
2754   return_val[0] = (char *)NULL;
2755
2756   /* Look through the partial symtabs for all symbols which begin
2757      by matching TEXT.  Add each one that you find to the list.  */
2758
2759   for (ps = partial_symtab_list; ps; ps = ps->next)
2760     {
2761       /* If the psymtab's been read in we'll get it when we search
2762          through the blockvector.  */
2763       if (ps->readin) continue;
2764
2765       for (psym = global_psymbols.list + ps->globals_offset;
2766            psym < (global_psymbols.list + ps->globals_offset
2767                    + ps->n_global_syms);
2768            psym++)
2769         {
2770           QUIT;                 /* If interrupted, then quit. */
2771           if ((strncmp (SYMBOL_NAME (psym), text, text_len) == 0))
2772             completion_list_add_symbol (SYMBOL_NAME (psym));
2773         }
2774
2775       for (psym = static_psymbols.list + ps->statics_offset;
2776            psym < (static_psymbols.list + ps->statics_offset
2777                    + ps->n_static_syms);
2778            psym++)
2779         {
2780           QUIT;
2781           if ((strncmp (SYMBOL_NAME (psym), text, text_len) == 0))
2782             completion_list_add_symbol (SYMBOL_NAME (psym));
2783         }
2784     }
2785
2786   /* At this point scan through the misc function vector and add each
2787      symbol you find to the list.  Eventually we want to ignore
2788      anything that isn't a text symbol (everything else will be
2789      handled by the psymtab code above).  */
2790
2791   for (i = 0; i < misc_function_count; i++)
2792     if (!strncmp (text, misc_function_vector[i].name, text_len))
2793       completion_list_add_symbol (misc_function_vector[i].name);
2794
2795   /* Search upwards from currently selected frame (so that we can
2796      complete on local vars.  */
2797   for (b = get_selected_block (); b; b = BLOCK_SUPERBLOCK (b))
2798     {
2799       if (!BLOCK_SUPERBLOCK (b))
2800         surrounding_static_block = b; /* For elmin of dups */
2801
2802       /* Also catch fields of types defined in this places which
2803          match our text string.  Only complete on types visible
2804          from current context.  */
2805       for (i = 0; i < BLOCK_NSYMS (b); i++)
2806         {
2807           register struct symbol *sym = BLOCK_SYM (b, i);
2808
2809           if (!strncmp (SYMBOL_NAME (sym), text, text_len))
2810             completion_list_add_symbol (SYMBOL_NAME (sym));
2811
2812           if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2813             {
2814               struct type *t = SYMBOL_TYPE (sym);
2815               enum type_code c = TYPE_CODE (t);
2816
2817               if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
2818                 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
2819                   if (TYPE_FIELD_NAME (t, j) &&
2820                       !strncmp (TYPE_FIELD_NAME (t, j), text, text_len))
2821                     completion_list_add_symbol (TYPE_FIELD_NAME (t, j));
2822             }
2823         }
2824     }
2825
2826   /* Go through the symtabs and check the externs and statics for
2827      symbols which match.  */
2828
2829   for (s = symtab_list; s; s = s->next)
2830     {
2831       b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
2832
2833       for (i = 0; i < BLOCK_NSYMS (b); i++)
2834         if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b, i)), text, text_len))
2835           completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b, i)));
2836     }
2837
2838   for (s = symtab_list; s; s = s->next)
2839     {
2840       b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
2841
2842       /* Don't do this block twice.  */
2843       if (b == surrounding_static_block) continue;
2844
2845       for (i = 0; i < BLOCK_NSYMS (b); i++)
2846         if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b, i)), text, text_len))
2847           completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b, i)));
2848     }
2849
2850   return (return_val);
2851 }
2852 \f
2853 void
2854 _initialize_symtab ()
2855 {
2856   add_info ("variables", variables_info,
2857             "All global and static variable names, or those matching REGEXP.");
2858   add_info ("functions", functions_info,
2859             "All function names, or those matching REGEXP.");
2860
2861   /* FIXME:  This command has at least the following problems:
2862      1.  It prints builtin types (in a very strange and confusing fashion).
2863      2.  It doesn't print right, e.g. with
2864          typedef struct foo *FOO
2865          type_print prints "FOO" when we want to make it (in this situation)
2866          print "struct foo *".
2867      I also think "ptype" or "whatis" is more likely to be useful (but if
2868      there is much disagreement "info types" can be fixed).  */
2869   add_info ("types", types_info,
2870             "All types names, or those matching REGEXP.");
2871
2872 #if 0
2873   add_info ("methods", methods_info,
2874             "All method names, or those matching REGEXP::REGEXP.\n\
2875 If the class qualifier is ommited, it is assumed to be the current scope.\n\
2876 If the first REGEXP is ommited, then all methods matching the second REGEXP\n\
2877 are listed.");
2878 #endif
2879   add_info ("sources", sources_info,
2880             "Source files in the program.");
2881
2882   add_com ("rbreak", no_class, rbreak_command,
2883             "Set a breakpoint for all functions matching REGEXP.");
2884
2885   /* FIXME:  The code below assumes that the sizes of the basic data
2886      types are the same on the host and target machines!!!  */
2887
2888   builtin_type_void = init_type (TYPE_CODE_VOID, 1, 0, "void");
2889
2890   builtin_type_float = init_type (TYPE_CODE_FLT, sizeof (float), 0, "float");
2891   builtin_type_double = init_type (TYPE_CODE_FLT, sizeof (double), 0, "double");
2892
2893   builtin_type_char = init_type (TYPE_CODE_INT, sizeof (char), 0, "char");
2894   builtin_type_short = init_type (TYPE_CODE_INT, sizeof (short), 0, "short");
2895   builtin_type_long = init_type (TYPE_CODE_INT, sizeof (long), 0, "long");
2896   builtin_type_int = init_type (TYPE_CODE_INT, sizeof (int), 0, "int");
2897
2898   builtin_type_unsigned_char = init_type (TYPE_CODE_INT, sizeof (char), 1, "unsigned char");
2899   builtin_type_unsigned_short = init_type (TYPE_CODE_INT, sizeof (short), 1, "unsigned short");
2900   builtin_type_unsigned_long = init_type (TYPE_CODE_INT, sizeof (long), 1, "unsigned long");
2901   builtin_type_unsigned_int = init_type (TYPE_CODE_INT, sizeof (int), 1, "unsigned int");
2902
2903   builtin_type_long_long =
2904     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
2905                0, "long long");
2906   builtin_type_unsigned_long_long =
2907     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
2908                1, "unsigned long long");
2909
2910   builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>");
2911 }
2912