2002-09-12 David Carlton <carlton@math.stanford.edu>

	* symtab.h: Run through gdb_indent.h.
	Add 2002 to Copyright year list.

2 files changed, 519 insertions, 514 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index cb2e45d..41d025e 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+2002-09-12  David Carlton  <carlton@math.stanford.edu>
+
+	* symtab.h: Run through gdb_indent.h.
+	Add 2002 to Copyright year list.
+
 2002-09-12  Alan Modra  <amodra@bigpond.net.au>
 
 	* x86-64-tdep.c (_initialize_x86_64_tdep): Don't use hard-coded
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 7f511f0..ba04a98 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -1,6 +1,6 @@
 /* Symbol table definitions for GDB.
    Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
-   1997, 1998, 1999, 2000, 2001
+   1997, 1998, 1999, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
    This file is part of GDB.
@@ -46,78 +46,78 @@ struct obstack;
    have tens or hundreds of thousands of these.  */
 
 struct general_symbol_info
-  {
-    /* Name of the symbol.  This is a required field.  Storage for the name is
-       allocated on the psymbol_obstack or symbol_obstack for the associated
-       objfile. */
+{
+  /* Name of the symbol.  This is a required field.  Storage for the name is
+     allocated on the psymbol_obstack or symbol_obstack for the associated
+     objfile. */
 
-    char *name;
+  char *name;
 
-    /* Value of the symbol.  Which member of this union to use, and what
-       it means, depends on what kind of symbol this is and its
-       SYMBOL_CLASS.  See comments there for more details.  All of these
-       are in host byte order (though what they point to might be in
-       target byte order, e.g. LOC_CONST_BYTES).  */
+  /* Value of the symbol.  Which member of this union to use, and what
+     it means, depends on what kind of symbol this is and its
+     SYMBOL_CLASS.  See comments there for more details.  All of these
+     are in host byte order (though what they point to might be in
+     target byte order, e.g. LOC_CONST_BYTES).  */
 
-    union
-      {
-	/* The fact that this is a long not a LONGEST mainly limits the
-	   range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
-	   sure that is a big deal.  */
-	long ivalue;
+  union
+  {
+    /* The fact that this is a long not a LONGEST mainly limits the
+       range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
+       sure that is a big deal.  */
+    long ivalue;
 
-	struct block *block;
+    struct block *block;
 
-	char *bytes;
+    char *bytes;
 
-	CORE_ADDR address;
+    CORE_ADDR address;
 
-	/* for opaque typedef struct chain */
+    /* for opaque typedef struct chain */
 
-	struct symbol *chain;
-      }
-    value;
+    struct symbol *chain;
+  }
+  value;
 
-    /* Since one and only one language can apply, wrap the language specific
-       information inside a union. */
+  /* Since one and only one language can apply, wrap the language specific
+     information inside a union. */
 
-    union
-      {
-	struct cplus_specific	/* For C++ */
-	/*  and Java */
-	  {
-	    char *demangled_name;
-	  }
-	cplus_specific;
+  union
+  {
+    struct cplus_specific	/* For C++ */
+      /*  and Java */
+    {
+      char *demangled_name;
+    }
+    cplus_specific;
 #if 0
-	/* OBSOLETE struct chill_specific	 *//* For Chill */
-	/* OBSOLETE   { */
-	/* OBSOLETE     char *demangled_name; */
-	/* OBSOLETE   } */
-	/* OBSOLETE chill_specific; */
+/* OBSOLETE struct chill_specific        *//* For Chill */
+    /* OBSOLETE   { */
+    /* OBSOLETE     char *demangled_name; */
+    /* OBSOLETE   } */
+    /* OBSOLETE chill_specific; */
 #endif
-      }
-    language_specific;
+  }
+  language_specific;
 
-    /* Record the source code language that applies to this symbol.
-       This is used to select one of the fields from the language specific
-       union above. */
+  /* Record the source code language that applies to this symbol.
+     This is used to select one of the fields from the language specific
+     union above. */
 
-    enum language language BYTE_BITFIELD;
+  enum language language BYTE_BITFIELD;
 
-    /* Which section is this symbol in?  This is an index into
-       section_offsets for this objfile.  Negative means that the symbol
-       does not get relocated relative to a section.
-       Disclaimer: currently this is just used for xcoff, so don't
-       expect all symbol-reading code to set it correctly (the ELF code
-       also tries to set it correctly).  */
+  /* Which section is this symbol in?  This is an index into
+     section_offsets for this objfile.  Negative means that the symbol
+     does not get relocated relative to a section.
+     Disclaimer: currently this is just used for xcoff, so don't
+     expect all symbol-reading code to set it correctly (the ELF code
+     also tries to set it correctly).  */
 
-    short section;
+  short section;
 
-    /* The bfd section associated with this symbol. */
+  /* The bfd section associated with this symbol. */
 
-    asection *bfd_section;
-  };
+  asection *bfd_section;
+};
 
 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, asection *);
 
@@ -160,9 +160,9 @@ extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, asection *);
 #define SYMBOL_INIT_DEMANGLED_NAME(symbol,obstack) \
   (symbol_init_demangled_name (&symbol->ginfo, (obstack)))
 extern void symbol_init_demangled_name (struct general_symbol_info *symbol,
-                                        struct obstack *obstack);
+					struct obstack *obstack);
+
 
-  
 /* Macro that returns the demangled name for a symbol based on the language
    for that symbol.  If no demangled name exists, returns NULL. */
 
@@ -233,82 +233,82 @@ extern void symbol_init_demangled_name (struct general_symbol_info *symbol,
    used to figure out what full symbol table entries need to be read in. */
 
 struct minimal_symbol
-  {
+{
 
-    /* The general symbol info required for all types of symbols.
+  /* The general symbol info required for all types of symbols.
 
-       The SYMBOL_VALUE_ADDRESS contains the address that this symbol
-       corresponds to.  */
+     The SYMBOL_VALUE_ADDRESS contains the address that this symbol
+     corresponds to.  */
 
-    struct general_symbol_info ginfo;
+  struct general_symbol_info ginfo;
 
-    /* The info field is available for caching machine-specific information
-       so it doesn't have to rederive the info constantly (over a serial line).
-       It is initialized to zero and stays that way until target-dependent code
-       sets it.  Storage for any data pointed to by this field should be allo-
-       cated on the symbol_obstack for the associated objfile.  
-       The type would be "void *" except for reasons of compatibility with older
-       compilers.  This field is optional.
+  /* The info field is available for caching machine-specific information
+     so it doesn't have to rederive the info constantly (over a serial line).
+     It is initialized to zero and stays that way until target-dependent code
+     sets it.  Storage for any data pointed to by this field should be allo-
+     cated on the symbol_obstack for the associated objfile.  
+     The type would be "void *" except for reasons of compatibility with older
+     compilers.  This field is optional.
 
-       Currently, the AMD 29000 tdep.c uses it to remember things it has decoded
-       from the instructions in the function header, and the MIPS-16 code uses
-       it to identify 16-bit procedures.  */
+     Currently, the AMD 29000 tdep.c uses it to remember things it has decoded
+     from the instructions in the function header, and the MIPS-16 code uses
+     it to identify 16-bit procedures.  */
 
-    char *info;
+  char *info;
 
 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
-    /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
-    char *filename;
+  /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
+  char *filename;
 #endif
 
-    /* Classification types for this symbol.  These should be taken as "advisory
-       only", since if gdb can't easily figure out a classification it simply
-       selects mst_unknown.  It may also have to guess when it can't figure out
-       which is a better match between two types (mst_data versus mst_bss) for
-       example.  Since the minimal symbol info is sometimes derived from the
-       BFD library's view of a file, we need to live with what information bfd
-       supplies. */
-
-    enum minimal_symbol_type
-      {
-	mst_unknown = 0,	/* Unknown type, the default */
-	mst_text,		/* Generally executable instructions */
-	mst_data,		/* Generally initialized data */
-	mst_bss,		/* Generally uninitialized data */
-	mst_abs,		/* Generally absolute (nonrelocatable) */
-	/* GDB uses mst_solib_trampoline for the start address of a shared
-	   library trampoline entry.  Breakpoints for shared library functions
-	   are put there if the shared library is not yet loaded.
-	   After the shared library is loaded, lookup_minimal_symbol will
-	   prefer the minimal symbol from the shared library (usually
-	   a mst_text symbol) over the mst_solib_trampoline symbol, and the
-	   breakpoints will be moved to their true address in the shared
-	   library via breakpoint_re_set.  */
-	mst_solib_trampoline,	/* Shared library trampoline code */
-	/* For the mst_file* types, the names are only guaranteed to be unique
-	   within a given .o file.  */
-	mst_file_text,		/* Static version of mst_text */
-	mst_file_data,		/* Static version of mst_data */
-	mst_file_bss		/* Static version of mst_bss */
-      }
-    type BYTE_BITFIELD;
-
-    /* Minimal symbols with the same hash key are kept on a linked
-       list.  This is the link.  */
-
-    struct minimal_symbol *hash_next;
-
-    /* Minimal symbols are stored in two different hash tables.  This is
-       the `next' pointer for the demangled hash table.  */
-
-    struct minimal_symbol *demangled_hash_next;
-  };
+  /* Classification types for this symbol.  These should be taken as "advisory
+     only", since if gdb can't easily figure out a classification it simply
+     selects mst_unknown.  It may also have to guess when it can't figure out
+     which is a better match between two types (mst_data versus mst_bss) for
+     example.  Since the minimal symbol info is sometimes derived from the
+     BFD library's view of a file, we need to live with what information bfd
+     supplies. */
+
+  enum minimal_symbol_type
+  {
+    mst_unknown = 0,		/* Unknown type, the default */
+    mst_text,			/* Generally executable instructions */
+    mst_data,			/* Generally initialized data */
+    mst_bss,			/* Generally uninitialized data */
+    mst_abs,			/* Generally absolute (nonrelocatable) */
+    /* GDB uses mst_solib_trampoline for the start address of a shared
+       library trampoline entry.  Breakpoints for shared library functions
+       are put there if the shared library is not yet loaded.
+       After the shared library is loaded, lookup_minimal_symbol will
+       prefer the minimal symbol from the shared library (usually
+       a mst_text symbol) over the mst_solib_trampoline symbol, and the
+       breakpoints will be moved to their true address in the shared
+       library via breakpoint_re_set.  */
+    mst_solib_trampoline,	/* Shared library trampoline code */
+    /* For the mst_file* types, the names are only guaranteed to be unique
+       within a given .o file.  */
+    mst_file_text,		/* Static version of mst_text */
+    mst_file_data,		/* Static version of mst_data */
+    mst_file_bss		/* Static version of mst_bss */
+  }
+  type BYTE_BITFIELD;
+
+  /* Minimal symbols with the same hash key are kept on a linked
+     list.  This is the link.  */
+
+  struct minimal_symbol *hash_next;
+
+  /* Minimal symbols are stored in two different hash tables.  This is
+     the `next' pointer for the demangled hash table.  */
+
+  struct minimal_symbol *demangled_hash_next;
+};
 
 #define MSYMBOL_INFO(msymbol)		(msymbol)->info
 #define MSYMBOL_TYPE(msymbol)		(msymbol)->type
-
 
 
+
 /* All of the name-scope contours of the program
    are represented by `struct block' objects.
    All of these objects are pointed to by the blockvector.
@@ -336,12 +336,12 @@ struct minimal_symbol
    the blocks appear in the order of a depth-first tree walk.  */
 
 struct blockvector
-  {
-    /* Number of blocks in the list.  */
-    int nblocks;
-    /* The blocks themselves.  */
-    struct block *block[1];
-  };
+{
+  /* Number of blocks in the list.  */
+  int nblocks;
+  /* The blocks themselves.  */
+  struct block *block[1];
+};
 
 #define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
 #define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
@@ -353,66 +353,66 @@ struct blockvector
 #define	FIRST_LOCAL_BLOCK	2
 
 struct block
-  {
+{
 
-    /* Addresses in the executable code that are in this block.  */
+  /* Addresses in the executable code that are in this block.  */
 
-    CORE_ADDR startaddr;
-    CORE_ADDR endaddr;
+  CORE_ADDR startaddr;
+  CORE_ADDR endaddr;
 
-    /* The symbol that names this block, if the block is the body of a
-       function; otherwise, zero.  */
+  /* The symbol that names this block, if the block is the body of a
+     function; otherwise, zero.  */
 
-    struct symbol *function;
+  struct symbol *function;
 
-    /* The `struct block' for the containing block, or 0 if none.
+  /* The `struct block' for the containing block, or 0 if none.
 
-       The superblock of a top-level local block (i.e. a function in the
-       case of C) is the STATIC_BLOCK.  The superblock of the
-       STATIC_BLOCK is the GLOBAL_BLOCK.  */
+     The superblock of a top-level local block (i.e. a function in the
+     case of C) is the STATIC_BLOCK.  The superblock of the
+     STATIC_BLOCK is the GLOBAL_BLOCK.  */
 
-    struct block *superblock;
+  struct block *superblock;
 
-    /* Version of GCC used to compile the function corresponding
-       to this block, or 0 if not compiled with GCC.  When possible,
-       GCC should be compatible with the native compiler, or if that
-       is not feasible, the differences should be fixed during symbol
-       reading.  As of 16 Apr 93, this flag is never used to distinguish
-       between gcc2 and the native compiler.
+  /* Version of GCC used to compile the function corresponding
+     to this block, or 0 if not compiled with GCC.  When possible,
+     GCC should be compatible with the native compiler, or if that
+     is not feasible, the differences should be fixed during symbol
+     reading.  As of 16 Apr 93, this flag is never used to distinguish
+     between gcc2 and the native compiler.
 
-       If there is no function corresponding to this block, this meaning
-       of this flag is undefined.  */
+     If there is no function corresponding to this block, this meaning
+     of this flag is undefined.  */
 
-    unsigned char gcc_compile_flag;
+  unsigned char gcc_compile_flag;
 
-    /* The symbols for this block are either in a simple linear list or
-       in a simple hashtable.  Blocks which correspond to a function
-       (which have a list of symbols corresponding to arguments) use
-       a linear list, as do some older symbol readers (currently only
-       mdebugread and dstread).  Other blocks are hashed.
+  /* The symbols for this block are either in a simple linear list or
+     in a simple hashtable.  Blocks which correspond to a function
+     (which have a list of symbols corresponding to arguments) use
+     a linear list, as do some older symbol readers (currently only
+     mdebugread and dstread).  Other blocks are hashed.
 
-       The hashtable uses the same hash function as the minsym hashtables,
-       found in minsyms.c:minsym_hash_iw.  Symbols are hashed based on
-       their demangled name if appropriate, and on their name otherwise.
-       The hash function ignores space, and stops at the beginning of the
-       argument list if any.
+     The hashtable uses the same hash function as the minsym hashtables,
+     found in minsyms.c:minsym_hash_iw.  Symbols are hashed based on
+     their demangled name if appropriate, and on their name otherwise.
+     The hash function ignores space, and stops at the beginning of the
+     argument list if any.
 
-       The table is laid out in NSYMS/5 buckets and symbols are chained via
-       their hash_next field.  */
+     The table is laid out in NSYMS/5 buckets and symbols are chained via
+     their hash_next field.  */
 
-    /* If this is really a hashtable of the symbols, this flag is 1.  */
+  /* If this is really a hashtable of the symbols, this flag is 1.  */
 
-    unsigned char hashtable;
+  unsigned char hashtable;
 
-    /* Number of local symbols.  */
+  /* Number of local symbols.  */
 
-    int nsyms;
+  int nsyms;
 
-    /* The symbols.  If some of them are arguments, then they must be
-       in the order in which we would like to print them.  */
+  /* The symbols.  If some of them are arguments, then they must be
+     in the order in which we would like to print them.  */
 
-    struct symbol *sym[1];
-  };
+  struct symbol *sym[1];
+};
 
 #define BLOCK_START(bl)		(bl)->startaddr
 #define BLOCK_END(bl)		(bl)->endaddr
@@ -456,250 +456,248 @@ struct block
    namespace and ignores symbol definitions in other name spaces. */
 
 typedef enum
-  {
-    /* UNDEF_NAMESPACE is used when a namespace has not been discovered or
-       none of the following apply.  This usually indicates an error either
-       in the symbol information or in gdb's handling of symbols. */
-
-    UNDEF_NAMESPACE,
+{
+  /* UNDEF_NAMESPACE is used when a namespace has not been discovered or
+     none of the following apply.  This usually indicates an error either
+     in the symbol information or in gdb's handling of symbols. */
 
-    /* VAR_NAMESPACE is the usual namespace.  In C, this contains variables,
-       function names, typedef names and enum type values. */
+  UNDEF_NAMESPACE,
 
-    VAR_NAMESPACE,
+  /* VAR_NAMESPACE is the usual namespace.  In C, this contains variables,
+     function names, typedef names and enum type values. */
 
-    /* STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
-       Thus, if `struct foo' is used in a C program, it produces a symbol named
-       `foo' in the STRUCT_NAMESPACE. */
+  VAR_NAMESPACE,
 
-    STRUCT_NAMESPACE,
+  /* STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
+     Thus, if `struct foo' is used in a C program, it produces a symbol named
+     `foo' in the STRUCT_NAMESPACE. */
 
-    /* LABEL_NAMESPACE may be used for names of labels (for gotos);
-       currently it is not used and labels are not recorded at all.  */
+  STRUCT_NAMESPACE,
 
-    LABEL_NAMESPACE,
+  /* LABEL_NAMESPACE may be used for names of labels (for gotos);
+     currently it is not used and labels are not recorded at all.  */
 
-    /* Searching namespaces. These overlap with VAR_NAMESPACE, providing
-       some granularity with the search_symbols function. */
+  LABEL_NAMESPACE,
 
-    /* Everything in VAR_NAMESPACE minus FUNCTIONS_-, TYPES_-, and
-       METHODS_NAMESPACE */
-    VARIABLES_NAMESPACE,
+  /* Searching namespaces. These overlap with VAR_NAMESPACE, providing
+     some granularity with the search_symbols function. */
 
-    /* All functions -- for some reason not methods, though. */
-    FUNCTIONS_NAMESPACE,
+  /* Everything in VAR_NAMESPACE minus FUNCTIONS_-, TYPES_-, and
+     METHODS_NAMESPACE */
+  VARIABLES_NAMESPACE,
 
-    /* All defined types */
-    TYPES_NAMESPACE,
+  /* All functions -- for some reason not methods, though. */
+  FUNCTIONS_NAMESPACE,
 
-    /* All class methods -- why is this separated out? */
-    METHODS_NAMESPACE
+  /* All defined types */
+  TYPES_NAMESPACE,
 
-  }
+  /* All class methods -- why is this separated out? */
+  METHODS_NAMESPACE
+}
 namespace_enum;
 
 /* An address-class says where to find the value of a symbol.  */
 
 enum address_class
-  {
-    /* Not used; catches errors */
+{
+  /* Not used; catches errors */
 
-    LOC_UNDEF,
+  LOC_UNDEF,
 
-    /* Value is constant int SYMBOL_VALUE, host byteorder */
+  /* Value is constant int SYMBOL_VALUE, host byteorder */
 
-    LOC_CONST,
+  LOC_CONST,
 
-    /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
+  /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
 
-    LOC_STATIC,
+  LOC_STATIC,
 
-    /* Value is in register.  SYMBOL_VALUE is the register number.  */
+  /* Value is in register.  SYMBOL_VALUE is the register number.  */
 
-    LOC_REGISTER,
+  LOC_REGISTER,
 
-    /* It's an argument; the value is at SYMBOL_VALUE offset in arglist.  */
+  /* It's an argument; the value is at SYMBOL_VALUE offset in arglist.  */
 
-    LOC_ARG,
+  LOC_ARG,
 
-    /* Value address is at SYMBOL_VALUE offset in arglist.  */
+  /* Value address is at SYMBOL_VALUE offset in arglist.  */
 
-    LOC_REF_ARG,
+  LOC_REF_ARG,
 
-    /* Value is in register number SYMBOL_VALUE.  Just like LOC_REGISTER
-       except this is an argument.  Probably the cleaner way to handle
-       this would be to separate address_class (which would include
-       separate ARG and LOCAL to deal with FRAME_ARGS_ADDRESS versus
-       FRAME_LOCALS_ADDRESS), and an is_argument flag.
+  /* Value is in register number SYMBOL_VALUE.  Just like LOC_REGISTER
+     except this is an argument.  Probably the cleaner way to handle
+     this would be to separate address_class (which would include
+     separate ARG and LOCAL to deal with FRAME_ARGS_ADDRESS versus
+     FRAME_LOCALS_ADDRESS), and an is_argument flag.
 
-       For some symbol formats (stabs, for some compilers at least),
-       the compiler generates two symbols, an argument and a register.
-       In some cases we combine them to a single LOC_REGPARM in symbol
-       reading, but currently not for all cases (e.g. it's passed on the
-       stack and then loaded into a register).  */
+     For some symbol formats (stabs, for some compilers at least),
+     the compiler generates two symbols, an argument and a register.
+     In some cases we combine them to a single LOC_REGPARM in symbol
+     reading, but currently not for all cases (e.g. it's passed on the
+     stack and then loaded into a register).  */
 
-    LOC_REGPARM,
+  LOC_REGPARM,
 
-    /* Value is in specified register.  Just like LOC_REGPARM except the
-       register holds the address of the argument instead of the argument
-       itself. This is currently used for the passing of structs and unions
-       on sparc and hppa.  It is also used for call by reference where the
-       address is in a register, at least by mipsread.c.  */
+  /* Value is in specified register.  Just like LOC_REGPARM except the
+     register holds the address of the argument instead of the argument
+     itself. This is currently used for the passing of structs and unions
+     on sparc and hppa.  It is also used for call by reference where the
+     address is in a register, at least by mipsread.c.  */
 
-    LOC_REGPARM_ADDR,
+  LOC_REGPARM_ADDR,
 
-    /* Value is a local variable at SYMBOL_VALUE offset in stack frame.  */
+  /* Value is a local variable at SYMBOL_VALUE offset in stack frame.  */
 
-    LOC_LOCAL,
+  LOC_LOCAL,
 
-    /* Value not used; definition in SYMBOL_TYPE.  Symbols in the namespace
-       STRUCT_NAMESPACE all have this class.  */
+  /* Value not used; definition in SYMBOL_TYPE.  Symbols in the namespace
+     STRUCT_NAMESPACE all have this class.  */
 
-    LOC_TYPEDEF,
+  LOC_TYPEDEF,
 
-    /* Value is address SYMBOL_VALUE_ADDRESS in the code */
+  /* Value is address SYMBOL_VALUE_ADDRESS in the code */
 
-    LOC_LABEL,
+  LOC_LABEL,
 
-    /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
-       In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
-       of the block.  Function names have this class. */
+  /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
+     In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
+     of the block.  Function names have this class. */
 
-    LOC_BLOCK,
+  LOC_BLOCK,
 
-    /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
-       target byte order.  */
+  /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
+     target byte order.  */
 
-    LOC_CONST_BYTES,
+  LOC_CONST_BYTES,
 
-    /* Value is arg at SYMBOL_VALUE offset in stack frame. Differs from
-       LOC_LOCAL in that symbol is an argument; differs from LOC_ARG in
-       that we find it in the frame (FRAME_LOCALS_ADDRESS), not in the
-       arglist (FRAME_ARGS_ADDRESS).  Added for i960, which passes args
-       in regs then copies to frame.  */
+  /* Value is arg at SYMBOL_VALUE offset in stack frame. Differs from
+     LOC_LOCAL in that symbol is an argument; differs from LOC_ARG in
+     that we find it in the frame (FRAME_LOCALS_ADDRESS), not in the
+     arglist (FRAME_ARGS_ADDRESS).  Added for i960, which passes args
+     in regs then copies to frame.  */
 
-    LOC_LOCAL_ARG,
+  LOC_LOCAL_ARG,
 
-    /* Value is at SYMBOL_VALUE offset from the current value of
-       register number SYMBOL_BASEREG.  This exists mainly for the same
-       things that LOC_LOCAL and LOC_ARG do; but we need to do this
-       instead because on 88k DWARF gives us the offset from the
-       frame/stack pointer, rather than the offset from the "canonical
-       frame address" used by COFF, stabs, etc., and we don't know how
-       to convert between these until we start examining prologues.
+  /* Value is at SYMBOL_VALUE offset from the current value of
+     register number SYMBOL_BASEREG.  This exists mainly for the same
+     things that LOC_LOCAL and LOC_ARG do; but we need to do this
+     instead because on 88k DWARF gives us the offset from the
+     frame/stack pointer, rather than the offset from the "canonical
+     frame address" used by COFF, stabs, etc., and we don't know how
+     to convert between these until we start examining prologues.
 
-       Note that LOC_BASEREG is much less general than a DWARF expression.
-       We don't need the generality (at least not yet), and storing a general
-       DWARF expression would presumably take up more space than the existing
-       scheme.  */
+     Note that LOC_BASEREG is much less general than a DWARF expression.
+     We don't need the generality (at least not yet), and storing a general
+     DWARF expression would presumably take up more space than the existing
+     scheme.  */
 
-    LOC_BASEREG,
+  LOC_BASEREG,
 
-    /* Same as LOC_BASEREG but it is an argument.  */
+  /* Same as LOC_BASEREG but it is an argument.  */
 
-    LOC_BASEREG_ARG,
+  LOC_BASEREG_ARG,
 
-    /* Value is at fixed address, but the address of the variable has
-       to be determined from the minimal symbol table whenever the
-       variable is referenced.
-       This happens if debugging information for a global symbol is
-       emitted and the corresponding minimal symbol is defined
-       in another object file or runtime common storage.
-       The linker might even remove the minimal symbol if the global
-       symbol is never referenced, in which case the symbol remains
-       unresolved.  */
+  /* Value is at fixed address, but the address of the variable has
+     to be determined from the minimal symbol table whenever the
+     variable is referenced.
+     This happens if debugging information for a global symbol is
+     emitted and the corresponding minimal symbol is defined
+     in another object file or runtime common storage.
+     The linker might even remove the minimal symbol if the global
+     symbol is never referenced, in which case the symbol remains
+     unresolved.  */
 
-    LOC_UNRESOLVED,
+  LOC_UNRESOLVED,
 
-    /* Value is at a thread-specific location calculated by a
-       target-specific method. */
+  /* Value is at a thread-specific location calculated by a
+     target-specific method. */
 
-    LOC_THREAD_LOCAL_STATIC,
+  LOC_THREAD_LOCAL_STATIC,
 
-    /* The variable does not actually exist in the program.
-       The value is ignored.  */
+  /* The variable does not actually exist in the program.
+     The value is ignored.  */
 
-    LOC_OPTIMIZED_OUT,
+  LOC_OPTIMIZED_OUT,
 
-    /* The variable is static, but actually lives at * (address).
-     * I.e. do an extra indirection to get to it.
-     * This is used on HP-UX to get at globals that are allocated
-     * in shared libraries, where references from images other
-     * than the one where the global was allocated are done
-     * with a level of indirection.
-     */
+  /* The variable is static, but actually lives at * (address).
+   * I.e. do an extra indirection to get to it.
+   * This is used on HP-UX to get at globals that are allocated
+   * in shared libraries, where references from images other
+   * than the one where the global was allocated are done
+   * with a level of indirection.
+   */
 
-    LOC_INDIRECT
-
-  };
+  LOC_INDIRECT
+};
 
 /* Linked list of symbol's live ranges. */
 
 struct range_list
-  {
-    CORE_ADDR start;
-    CORE_ADDR end;
-    struct range_list *next;
-  };
+{
+  CORE_ADDR start;
+  CORE_ADDR end;
+  struct range_list *next;
+};
 
 /* Linked list of aliases for a particular main/primary symbol.  */
 struct alias_list
-  {
-    struct symbol *sym;
-    struct alias_list *next;
-  };
+{
+  struct symbol *sym;
+  struct alias_list *next;
+};
 
 struct symbol
-  {
+{
 
-    /* The general symbol info required for all types of symbols. */
+  /* The general symbol info required for all types of symbols. */
 
-    struct general_symbol_info ginfo;
+  struct general_symbol_info ginfo;
 
-    /* Data type of value */
+  /* Data type of value */
 
-    struct type *type;
+  struct type *type;
 
-    /* Name space code.  */
+  /* Name space code.  */
 
 #ifdef __MFC4__
-    /* FIXME: don't conflict with C++'s namespace */
-    /* would be safer to do a global change for all namespace identifiers. */
+  /* FIXME: don't conflict with C++'s namespace */
+  /* would be safer to do a global change for all namespace identifiers. */
 #define namespace _namespace
 #endif
-    namespace_enum namespace BYTE_BITFIELD;
+  namespace_enum namespace BYTE_BITFIELD;
 
-    /* Address class */
+  /* Address class */
 
-    enum address_class aclass BYTE_BITFIELD;
+  enum address_class aclass BYTE_BITFIELD;
 
-    /* Line number of definition.  FIXME:  Should we really make the assumption
-       that nobody will try to debug files longer than 64K lines?  What about
-       machine generated programs? */
+  /* Line number of definition.  FIXME:  Should we really make the assumption
+     that nobody will try to debug files longer than 64K lines?  What about
+     machine generated programs? */
 
-    unsigned short line;
+  unsigned short line;
 
-    /* Some symbols require an additional value to be recorded on a per-
-       symbol basis.  Stash those values here. */
+  /* Some symbols require an additional value to be recorded on a per-
+     symbol basis.  Stash those values here. */
 
-    union
-      {
-	/* Used by LOC_BASEREG and LOC_BASEREG_ARG.  */
-	short basereg;
-      }
-    aux_value;
+  union
+  {
+    /* Used by LOC_BASEREG and LOC_BASEREG_ARG.  */
+    short basereg;
+  }
+  aux_value;
 
 
-    /* Link to a list of aliases for this symbol.
-       Only a "primary/main symbol may have aliases.  */
-    struct alias_list *aliases;
+  /* Link to a list of aliases for this symbol.
+     Only a "primary/main symbol may have aliases.  */
+  struct alias_list *aliases;
 
-    /* List of ranges where this symbol is active.  This is only
-       used by alias symbols at the current time.  */
-    struct range_list *ranges;
+  /* List of ranges where this symbol is active.  This is only
+     used by alias symbols at the current time.  */
+  struct range_list *ranges;
 
-    struct symbol *hash_next;
-  };
+  struct symbol *hash_next;
+};
 
 
 #define SYMBOL_NAMESPACE(symbol)	(symbol)->namespace
@@ -718,21 +716,21 @@ struct symbol
    normal symtab once the partial_symtab has been referenced.  */
 
 struct partial_symbol
-  {
+{
 
-    /* The general symbol info required for all types of symbols. */
+  /* The general symbol info required for all types of symbols. */
 
-    struct general_symbol_info ginfo;
+  struct general_symbol_info ginfo;
 
-    /* Name space code.  */
+  /* Name space code.  */
 
-    namespace_enum namespace BYTE_BITFIELD;
+  namespace_enum namespace BYTE_BITFIELD;
 
-    /* Address class (for info_symbols) */
+  /* Address class (for info_symbols) */
 
-    enum address_class aclass BYTE_BITFIELD;
+  enum address_class aclass BYTE_BITFIELD;
 
-  };
+};
 
 #define PSYMBOL_NAMESPACE(psymbol)	(psymbol)->namespace
 #define PSYMBOL_CLASS(psymbol)		(psymbol)->aclass
@@ -742,10 +740,10 @@ struct partial_symbol
    line numbers and addresses in the program text.  */
 
 struct sourcevector
-  {
-    int length;			/* Number of source files described */
-    struct source *source[1];	/* Descriptions of the files */
-  };
+{
+  int length;			/* Number of source files described */
+  struct source *source[1];	/* Descriptions of the files */
+};
 
 /* Each item represents a line-->pc (or the reverse) mapping.  This is
    somewhat more wasteful of space than one might wish, but since only
@@ -753,10 +751,10 @@ struct sourcevector
    waste much space.  */
 
 struct linetable_entry
-  {
-    int line;
-    CORE_ADDR pc;
-  };
+{
+  int line;
+  CORE_ADDR pc;
+};
 
 /* The order of entries in the linetable is significant.  They should
    be sorted by increasing values of the pc field.  If there is more than
@@ -776,22 +774,22 @@ struct linetable_entry
    zero length.  */
 
 struct linetable
-  {
-    int nitems;
+{
+  int nitems;
 
-    /* Actually NITEMS elements.  If you don't like this use of the
-       `struct hack', you can shove it up your ANSI (seriously, if the
-       committee tells us how to do it, we can probably go along).  */
-    struct linetable_entry item[1];
-  };
+  /* Actually NITEMS elements.  If you don't like this use of the
+     `struct hack', you can shove it up your ANSI (seriously, if the
+     committee tells us how to do it, we can probably go along).  */
+  struct linetable_entry item[1];
+};
 
 /* All the information on one source file.  */
 
 struct source
-  {
-    char *name;			/* Name of file */
-    struct linetable contents;
-  };
+{
+  char *name;			/* Name of file */
+  struct linetable contents;
+};
 
 /* How to relocate the symbols from each section in a symbol file.
    Each struct contains an array of offsets.
@@ -804,9 +802,9 @@ struct source
    extract offset values in the struct.  */
 
 struct section_offsets
-  {
-    CORE_ADDR offsets[1];	/* As many as needed. */
-  };
+{
+  CORE_ADDR offsets[1];		/* As many as needed. */
+};
 
 #define	ANOFFSET(secoff, whichone) \
    ((whichone == -1) \
@@ -823,100 +821,100 @@ struct section_offsets
    These objects are chained through the `next' field.  */
 
 struct symtab
-  {
+{
 
-    /* Chain of all existing symtabs.  */
+  /* Chain of all existing symtabs.  */
 
-    struct symtab *next;
+  struct symtab *next;
 
-    /* List of all symbol scope blocks for this symtab.  May be shared
-       between different symtabs (and normally is for all the symtabs
-       in a given compilation unit).  */
+  /* List of all symbol scope blocks for this symtab.  May be shared
+     between different symtabs (and normally is for all the symtabs
+     in a given compilation unit).  */
 
-    struct blockvector *blockvector;
+  struct blockvector *blockvector;
 
-    /* Table mapping core addresses to line numbers for this file.
-       Can be NULL if none.  Never shared between different symtabs.  */
+  /* Table mapping core addresses to line numbers for this file.
+     Can be NULL if none.  Never shared between different symtabs.  */
 
-    struct linetable *linetable;
+  struct linetable *linetable;
 
-    /* Section in objfile->section_offsets for the blockvector and
-       the linetable.  Probably always SECT_OFF_TEXT.  */
+  /* Section in objfile->section_offsets for the blockvector and
+     the linetable.  Probably always SECT_OFF_TEXT.  */
 
-    int block_line_section;
+  int block_line_section;
 
-    /* If several symtabs share a blockvector, exactly one of them
-       should be designated the primary, so that the blockvector
-       is relocated exactly once by objfile_relocate.  */
+  /* If several symtabs share a blockvector, exactly one of them
+     should be designated the primary, so that the blockvector
+     is relocated exactly once by objfile_relocate.  */
 
-    int primary;
+  int primary;
 
-    /* The macro table for this symtab.  Like the blockvector, this
-       may be shared between different symtabs --- and normally is for
-       all the symtabs in a given compilation unit.  */
-    struct macro_table *macro_table;
+  /* The macro table for this symtab.  Like the blockvector, this
+     may be shared between different symtabs --- and normally is for
+     all the symtabs in a given compilation unit.  */
+  struct macro_table *macro_table;
 
-    /* Name of this source file.  */
+  /* Name of this source file.  */
 
-    char *filename;
+  char *filename;
 
-    /* Directory in which it was compiled, or NULL if we don't know.  */
+  /* Directory in which it was compiled, or NULL if we don't know.  */
 
-    char *dirname;
+  char *dirname;
 
-    /* This component says how to free the data we point to:
-       free_contents => do a tree walk and free each object.
-       free_nothing => do nothing; some other symtab will free
-       the data this one uses.
-       free_linetable => free just the linetable.  FIXME: Is this redundant
-       with the primary field?  */
+  /* This component says how to free the data we point to:
+     free_contents => do a tree walk and free each object.
+     free_nothing => do nothing; some other symtab will free
+     the data this one uses.
+     free_linetable => free just the linetable.  FIXME: Is this redundant
+     with the primary field?  */
 
-    enum free_code
-      {
-	free_nothing, free_contents, free_linetable
-      }
-    free_code;
+  enum free_code
+  {
+    free_nothing, free_contents, free_linetable
+  }
+  free_code;
 
-    /* Pointer to one block of storage to be freed, if nonzero.  */
-    /* This is IN ADDITION to the action indicated by free_code.  */
+  /* Pointer to one block of storage to be freed, if nonzero.  */
+  /* This is IN ADDITION to the action indicated by free_code.  */
 
-    char *free_ptr;
+  char *free_ptr;
 
-    /* Total number of lines found in source file.  */
+  /* Total number of lines found in source file.  */
 
-    int nlines;
+  int nlines;
 
-    /* line_charpos[N] is the position of the (N-1)th line of the
-       source file.  "position" means something we can lseek() to; it
-       is not guaranteed to be useful any other way.  */
+  /* line_charpos[N] is the position of the (N-1)th line of the
+     source file.  "position" means something we can lseek() to; it
+     is not guaranteed to be useful any other way.  */
 
-    int *line_charpos;
+  int *line_charpos;
 
-    /* Language of this source file.  */
+  /* Language of this source file.  */
 
-    enum language language;
+  enum language language;
 
-    /* String that identifies the format of the debugging information, such
-       as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
-       for automated testing of gdb but may also be information that is
-       useful to the user. */
+  /* String that identifies the format of the debugging information, such
+     as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
+     for automated testing of gdb but may also be information that is
+     useful to the user. */
 
-    char *debugformat;
+  char *debugformat;
 
-    /* String of version information.  May be zero.  */
+  /* String of version information.  May be zero.  */
 
-    char *version;
+  char *version;
 
-    /* Full name of file as found by searching the source path.
-       NULL if not yet known.  */
+  /* Full name of file as found by searching the source path.
+     NULL if not yet known.  */
 
-    char *fullname;
+  char *fullname;
 
-    /* Object file from which this symbol information was read.  */
+  /* Object file from which this symbol information was read.  */
 
-    struct objfile *objfile;
+  struct objfile *objfile;
 
-  };
+};
 
 #define BLOCKVECTOR(symtab)	(symtab)->blockvector
 #define LINETABLE(symtab)	(symtab)->linetable
@@ -934,88 +932,88 @@ struct symtab
    style execution of a bunch of .o's.  */
 
 struct partial_symtab
-  {
+{
 
-    /* Chain of all existing partial symtabs.  */
+  /* Chain of all existing partial symtabs.  */
 
-    struct partial_symtab *next;
+  struct partial_symtab *next;
 
-    /* Name of the source file which this partial_symtab defines */
+  /* Name of the source file which this partial_symtab defines */
 
-    char *filename;
+  char *filename;
 
-    /* Full path of the source file.  NULL if not known.  */
+  /* Full path of the source file.  NULL if not known.  */
 
-    char *fullname;
+  char *fullname;
 
-    /* Information about the object file from which symbols should be read.  */
+  /* Information about the object file from which symbols should be read.  */
 
-    struct objfile *objfile;
+  struct objfile *objfile;
 
-    /* Set of relocation offsets to apply to each section.  */
+  /* Set of relocation offsets to apply to each section.  */
 
-    struct section_offsets *section_offsets;
+  struct section_offsets *section_offsets;
 
-    /* Range of text addresses covered by this file; texthigh is the
-       beginning of the next section. */
+  /* Range of text addresses covered by this file; texthigh is the
+     beginning of the next section. */
 
-    CORE_ADDR textlow;
-    CORE_ADDR texthigh;
+  CORE_ADDR textlow;
+  CORE_ADDR texthigh;
 
-    /* Array of pointers to all of the partial_symtab's which this one
-       depends on.  Since this array can only be set to previous or
-       the current (?) psymtab, this dependency tree is guaranteed not
-       to have any loops.  "depends on" means that symbols must be read
-       for the dependencies before being read for this psymtab; this is
-       for type references in stabs, where if foo.c includes foo.h, declarations
-       in foo.h may use type numbers defined in foo.c.  For other debugging
-       formats there may be no need to use dependencies.  */
+  /* Array of pointers to all of the partial_symtab's which this one
+     depends on.  Since this array can only be set to previous or
+     the current (?) psymtab, this dependency tree is guaranteed not
+     to have any loops.  "depends on" means that symbols must be read
+     for the dependencies before being read for this psymtab; this is
+     for type references in stabs, where if foo.c includes foo.h, declarations
+     in foo.h may use type numbers defined in foo.c.  For other debugging
+     formats there may be no need to use dependencies.  */
 
-    struct partial_symtab **dependencies;
+  struct partial_symtab **dependencies;
 
-    int number_of_dependencies;
+  int number_of_dependencies;
 
-    /* Global symbol list.  This list will be sorted after readin to
-       improve access.  Binary search will be the usual method of
-       finding a symbol within it. globals_offset is an integer offset
-       within global_psymbols[].  */
+  /* Global symbol list.  This list will be sorted after readin to
+     improve access.  Binary search will be the usual method of
+     finding a symbol within it. globals_offset is an integer offset
+     within global_psymbols[].  */
 
-    int globals_offset;
-    int n_global_syms;
+  int globals_offset;
+  int n_global_syms;
 
-    /* Static symbol list.  This list will *not* be sorted after readin;
-       to find a symbol in it, exhaustive search must be used.  This is
-       reasonable because searches through this list will eventually
-       lead to either the read in of a files symbols for real (assumed
-       to take a *lot* of time; check) or an error (and we don't care
-       how long errors take).  This is an offset and size within
-       static_psymbols[].  */
+  /* Static symbol list.  This list will *not* be sorted after readin;
+     to find a symbol in it, exhaustive search must be used.  This is
+     reasonable because searches through this list will eventually
+     lead to either the read in of a files symbols for real (assumed
+     to take a *lot* of time; check) or an error (and we don't care
+     how long errors take).  This is an offset and size within
+     static_psymbols[].  */
 
-    int statics_offset;
-    int n_static_syms;
+  int statics_offset;
+  int n_static_syms;
 
-    /* Pointer to symtab eventually allocated for this source file, 0 if
-       !readin or if we haven't looked for the symtab after it was readin.  */
+  /* Pointer to symtab eventually allocated for this source file, 0 if
+     !readin or if we haven't looked for the symtab after it was readin.  */
 
-    struct symtab *symtab;
+  struct symtab *symtab;
 
-    /* Pointer to function which will read in the symtab corresponding to
-       this psymtab.  */
+  /* Pointer to function which will read in the symtab corresponding to
+     this psymtab.  */
 
-    void (*read_symtab) (struct partial_symtab *);
+  void (*read_symtab) (struct partial_symtab *);
 
-    /* Information that lets read_symtab() locate the part of the symbol table
-       that this psymtab corresponds to.  This information is private to the
-       format-dependent symbol reading routines.  For further detail examine
-       the various symbol reading modules.  Should really be (void *) but is
-       (char *) as with other such gdb variables.  (FIXME) */
+  /* Information that lets read_symtab() locate the part of the symbol table
+     that this psymtab corresponds to.  This information is private to the
+     format-dependent symbol reading routines.  For further detail examine
+     the various symbol reading modules.  Should really be (void *) but is
+     (char *) as with other such gdb variables.  (FIXME) */
 
-    char *read_symtab_private;
+  char *read_symtab_private;
 
-    /* Non-zero if the symtab corresponding to this psymtab has been readin */
+  /* Non-zero if the symtab corresponding to this psymtab has been readin */
 
-    unsigned char readin;
-  };
+  unsigned char readin;
+};
 
 /* A fast way to get from a psymtab to its symtab (after the first time).  */
 #define	PSYMTAB_TO_SYMTAB(pst)  \
@@ -1213,17 +1211,17 @@ extern void install_minimal_symbols (struct objfile *);
 extern void msymbols_sort (struct objfile *objfile);
 
 struct symtab_and_line
-  {
-    struct symtab *symtab;
-    asection *section;
-    /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
-       0 is never a valid line number; it is used to indicate that line number
-       information is not available.  */
-    int line;
-
-    CORE_ADDR pc;
-    CORE_ADDR end;
-  };
+{
+  struct symtab *symtab;
+  asection *section;
+  /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
+     0 is never a valid line number; it is used to indicate that line number
+     information is not available.  */
+  int line;
+
+  CORE_ADDR pc;
+  CORE_ADDR end;
+};
 
 #define INIT_SAL(sal) { \
   (sal)->symtab  = 0;   \
@@ -1234,10 +1232,10 @@ struct symtab_and_line
 }
 
 struct symtabs_and_lines
-  {
-    struct symtab_and_line *sals;
-    int nelts;
-  };
+{
+  struct symtab_and_line *sals;
+  int nelts;
+};
 
 
 
@@ -1248,22 +1246,22 @@ struct symtabs_and_lines
 
 /* Enums for exception-handling support */
 enum exception_event_kind
-  {
-    EX_EVENT_THROW,
-    EX_EVENT_CATCH
-  };
+{
+  EX_EVENT_THROW,
+  EX_EVENT_CATCH
+};
 
 /* Type for returning info about an exception */
 struct exception_event_record
-  {
-    enum exception_event_kind kind;
-    struct symtab_and_line throw_sal;
-    struct symtab_and_line catch_sal;
-    /* This may need to be extended in the future, if
-       some platforms allow reporting more information,
-       such as point of rethrow, type of exception object,
-       type expected by catch clause, etc. */
-  };
+{
+  enum exception_event_kind kind;
+  struct symtab_and_line throw_sal;
+  struct symtab_and_line catch_sal;
+  /* This may need to be extended in the future, if
+     some platforms allow reporting more information,
+     such as point of rethrow, type of exception object,
+     type expected by catch clause, etc. */
+};
 
 #define CURRENT_EXCEPTION_KIND       (current_exception_event->kind)
 #define CURRENT_EXCEPTION_CATCH_SAL  (current_exception_event->catch_sal)
@@ -1356,7 +1354,8 @@ extern struct partial_symtab *find_main_psymtab (void);
 
 extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
 
-extern struct symtab_and_line find_function_start_sal (struct symbol *sym, int);
+extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
+						       int);
 
 /* blockframe.c */
 
@@ -1387,36 +1386,37 @@ extern struct partial_symbol *fixup_psymbol_section (struct partial_symbol
 /* When using search_symbols, a list of the following structs is returned.
    Callers must free the search list using free_search_symbols! */
 struct symbol_search
-  {
-    /* The block in which the match was found. Could be, for example,
-       STATIC_BLOCK or GLOBAL_BLOCK. */
-    int block;
+{
+  /* The block in which the match was found. Could be, for example,
+     STATIC_BLOCK or GLOBAL_BLOCK. */
+  int block;
 
-    /* Information describing what was found.
+  /* Information describing what was found.
 
-       If symtab abd symbol are NOT NULL, then information was found
-       for this match. */
-    struct symtab *symtab;
-    struct symbol *symbol;
+     If symtab abd symbol are NOT NULL, then information was found
+     for this match. */
+  struct symtab *symtab;
+  struct symbol *symbol;
 
-    /* If msymbol is non-null, then a match was made on something for
-       which only minimal_symbols exist. */
-    struct minimal_symbol *msymbol;
+  /* If msymbol is non-null, then a match was made on something for
+     which only minimal_symbols exist. */
+  struct minimal_symbol *msymbol;
 
-    /* A link to the next match, or NULL for the end. */
-    struct symbol_search *next;
-  };
+  /* A link to the next match, or NULL for the end. */
+  struct symbol_search *next;
+};
 
 extern void search_symbols (char *, namespace_enum, int, char **,
 			    struct symbol_search **);
 extern void free_search_symbols (struct symbol_search *);
-extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search *);
+extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
+							 *);
 
 /* The name of the ``main'' function.
    FIXME: cagney/2001-03-20: Can't make main_name() const since some
    of the calling code currently assumes that the string isn't
    const. */
 extern void set_main_name (const char *name);
-extern /*const*/ char *main_name (void);
+extern /*const */ char *main_name (void);
 
 #endif /* !defined(SYMTAB_H) */