Convert to ISO C90 formatting.

1 files changed, 248 insertions, 355 deletions

diff --git a/bfd/coffgen.c b/bfd/coffgen.c
index 426721a..d303bec 100644
--- a/bfd/coffgen.c
+++ b/bfd/coffgen.c
@@ -4,21 +4,21 @@
    Free Software Foundation, Inc.
    Written by Cygnus Support.
 
-This file is part of BFD, the Binary File Descriptor library.
+   This file is part of BFD, the Binary File Descriptor library.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* Most of this hacked by  Steve Chamberlain, sac@cygnus.com.
    Split out of coffcode.h by Ian Taylor, ian@cygnus.com.  */
@@ -43,42 +43,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "coff/internal.h"
 #include "libcoff.h"
 
-static void coff_fix_symbol_name
-  PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *,
-	   asection **, bfd_size_type *));
-static bfd_boolean coff_write_symbol
-  PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_vma *,
-	   bfd_size_type *, asection **, bfd_size_type *));
-static bfd_boolean coff_write_alien_symbol
-  PARAMS ((bfd *, asymbol *, bfd_vma *, bfd_size_type *,
-	   asection **, bfd_size_type *));
-static bfd_boolean coff_write_native_symbol
-  PARAMS ((bfd *, coff_symbol_type *, bfd_vma *, bfd_size_type *,
-	   asection **, bfd_size_type *));
-static void coff_pointerize_aux
-  PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
-	   unsigned int, combined_entry_type *));
-static bfd_boolean make_a_section_from_file
-  PARAMS ((bfd *, struct internal_scnhdr *, unsigned int));
-static const bfd_target *coff_real_object_p
-  PARAMS ((bfd *, unsigned, struct internal_filehdr *,
-	   struct internal_aouthdr *));
-static void fixup_symbol_value
-  PARAMS ((bfd *, coff_symbol_type *, struct internal_syment *));
-static char *build_debug_section
-  PARAMS ((bfd *));
-static char *copy_name
-  PARAMS ((bfd *, char *, size_t));
-
-#define STRING_SIZE_SIZE (4)
-
 /* Take a section header read from a coff file (in HOST byte order),
    and make a BFD "section" out of it.  This is used by ECOFF.  */
+
 static bfd_boolean
-make_a_section_from_file (abfd, hdr, target_index)
-     bfd *abfd;
-     struct internal_scnhdr *hdr;
-     unsigned int target_index;
+make_a_section_from_file (bfd *abfd,
+			  struct internal_scnhdr *hdr,
+			  unsigned int target_index)
 {
   asection *return_section;
   char *name;
@@ -142,7 +113,7 @@ make_a_section_from_file (abfd, hdr, target_index)
 
   return_section->lineno_count = hdr->s_nlnno;
   return_section->userdata = NULL;
-  return_section->next = (asection *) NULL;
+  return_section->next = NULL;
   return_section->target_index = target_index;
 
   if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
@@ -158,7 +129,7 @@ make_a_section_from_file (abfd, hdr, target_index)
 
   if (hdr->s_nreloc != 0)
     return_section->flags |= SEC_RELOC;
-  /* FIXME: should this check 'hdr->s_size > 0' */
+  /* FIXME: should this check 'hdr->s_size > 0'.  */
   if (hdr->s_scnptr != 0)
     return_section->flags |= SEC_HAS_CONTENTS;
 
@@ -169,17 +140,16 @@ make_a_section_from_file (abfd, hdr, target_index)
    ECOFF as well.  */
 
 static const bfd_target *
-coff_real_object_p (abfd, nscns, internal_f, internal_a)
-     bfd *abfd;
-     unsigned nscns;
-     struct internal_filehdr *internal_f;
-     struct internal_aouthdr *internal_a;
+coff_real_object_p (bfd *abfd,
+		    unsigned nscns,
+		    struct internal_filehdr *internal_f,
+		    struct internal_aouthdr *internal_a)
 {
   flagword oflags = abfd->flags;
   bfd_vma ostart = bfd_get_start_address (abfd);
-  PTR tdata;
-  PTR tdata_save;
-  bfd_size_type readsize;	/* length of file_info */
+  void * tdata;
+  void * tdata_save;
+  bfd_size_type readsize;	/* Length of file_info.  */
   unsigned int scnhsz;
   char *external_sections;
 
@@ -208,22 +178,22 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
   /* Set up the tdata area.  ECOFF uses its own routine, and overrides
      abfd->flags.  */
   tdata_save = abfd->tdata.any;
-  tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a);
+  tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a);
   if (tdata == NULL)
     goto fail2;
 
   scnhsz = bfd_coff_scnhsz (abfd);
   readsize = (bfd_size_type) nscns * scnhsz;
-  external_sections = (char *) bfd_alloc (abfd, readsize);
+  external_sections = bfd_alloc (abfd, readsize);
   if (!external_sections)
     goto fail;
 
-  if (bfd_bread ((PTR) external_sections, readsize, abfd) != readsize)
+  if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize)
     goto fail;
 
   /* Set the arch/mach *before* swapping in sections; section header swapping
      may depend on arch/mach info.  */
-  if (! bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f))
+  if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f))
     goto fail;
 
   /* Now copy data as required; construct all asections etc.  */
@@ -234,8 +204,8 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
 	{
 	  struct internal_scnhdr tmp;
 	  bfd_coff_swap_scnhdr_in (abfd,
-				   (PTR) (external_sections + i * scnhsz),
-				   (PTR) & tmp);
+				   (void *) (external_sections + i * scnhsz),
+				   (void *) & tmp);
 	  if (! make_a_section_from_file (abfd, &tmp, i + 1))
 	    goto fail;
 	}
@@ -256,17 +226,16 @@ coff_real_object_p (abfd, nscns, internal_f, internal_a)
    not a COFF file.  This is also used by ECOFF.  */
 
 const bfd_target *
-coff_object_p (abfd)
-     bfd *abfd;
+coff_object_p (bfd *abfd)
 {
   bfd_size_type filhsz;
   bfd_size_type aoutsz;
   unsigned int nscns;
-  PTR filehdr;
+  void * filehdr;
   struct internal_filehdr internal_f;
   struct internal_aouthdr internal_a;
 
-  /* figure out how much to read */
+  /* Figure out how much to read.  */
   filhsz = bfd_coff_filhsz (abfd);
   aoutsz = bfd_coff_aoutsz (abfd);
 
@@ -301,7 +270,7 @@ coff_object_p (abfd)
 
   if (internal_f.f_opthdr)
     {
-      PTR opthdr;
+      void * opthdr;
 
       opthdr = bfd_alloc (abfd, aoutsz);
       if (opthdr == NULL)
@@ -312,7 +281,7 @@ coff_object_p (abfd)
 	  bfd_release (abfd, opthdr);
 	  return NULL;
 	}
-      bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a);
+      bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);
       bfd_release (abfd, opthdr);
     }
 
@@ -325,9 +294,7 @@ coff_object_p (abfd)
 /* Get the BFD section from a COFF symbol section number.  */
 
 asection *
-coff_section_from_bfd_index (abfd, index)
-     bfd *abfd;
-     int index;
+coff_section_from_bfd_index (bfd *abfd, int index)
 {
   struct bfd_section *answer = abfd->sections;
 
@@ -353,8 +320,7 @@ coff_section_from_bfd_index (abfd, index)
 /* Get the upper bound of a COFF symbol table.  */
 
 long
-coff_get_symtab_upper_bound (abfd)
-     bfd *abfd;
+coff_get_symtab_upper_bound (bfd *abfd)
 {
   if (!bfd_coff_slurp_symbol_table (abfd))
     return -1;
@@ -365,9 +331,7 @@ coff_get_symtab_upper_bound (abfd)
 /* Canonicalize a COFF symbol table.  */
 
 long
-coff_canonicalize_symtab (abfd, alocation)
-     bfd *abfd;
-     asymbol **alocation;
+coff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 {
   unsigned int counter;
   coff_symbol_type *symbase;
@@ -390,10 +354,9 @@ coff_canonicalize_symtab (abfd, alocation)
    >= SYMNMLEN + 1.  */
 
 const char *
-_bfd_coff_internal_syment_name (abfd, sym, buf)
-     bfd *abfd;
-     const struct internal_syment *sym;
-     char *buf;
+_bfd_coff_internal_syment_name (bfd *abfd,
+				const struct internal_syment *sym,
+				char *buf)
 {
   /* FIXME: It's not clear this will work correctly if sizeof
      (_n_zeroes) != 4.  */
@@ -430,14 +393,12 @@ _bfd_coff_internal_syment_name (abfd, sym, buf)
    value must be INTERNAL_RELOCS.  The function returns NULL on error.  */
 
 struct internal_reloc *
-_bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
-				require_internal, internal_relocs)
-     bfd *abfd;
-     asection *sec;
-     bfd_boolean cache;
-     bfd_byte *external_relocs;
-     bfd_boolean require_internal;
-     struct internal_reloc *internal_relocs;
+_bfd_coff_read_internal_relocs (bfd *abfd,
+				asection *sec,
+				bfd_boolean cache,
+				bfd_byte *external_relocs,
+				bfd_boolean require_internal,
+				struct internal_reloc *internal_relocs)
 {
   bfd_size_type relsz;
   bfd_byte *free_external = NULL;
@@ -462,7 +423,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
   amt = sec->reloc_count * relsz;
   if (external_relocs == NULL)
     {
-      free_external = (bfd_byte *) bfd_malloc (amt);
+      free_external = bfd_malloc (amt);
       if (free_external == NULL && sec->reloc_count > 0)
 	goto error_return;
       external_relocs = free_external;
@@ -476,7 +437,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
     {
       amt = sec->reloc_count;
       amt *= sizeof (struct internal_reloc);
-      free_internal = (struct internal_reloc *) bfd_malloc (amt);
+      free_internal = bfd_malloc (amt);
       if (free_internal == NULL && sec->reloc_count > 0)
 	goto error_return;
       internal_relocs = free_internal;
@@ -487,7 +448,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
   erel_end = erel + relsz * sec->reloc_count;
   irel = internal_relocs;
   for (; erel < erel_end; erel += relsz, irel++)
-    bfd_coff_swap_reloc_in (abfd, (PTR) erel, (PTR) irel);
+    bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel);
 
   if (free_external != NULL)
     {
@@ -500,7 +461,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
       if (coff_section_data (abfd, sec) == NULL)
 	{
 	  amt = sizeof (struct coff_section_tdata);
-	  sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+	  sec->used_by_bfd = bfd_zalloc (abfd, amt);
 	  if (sec->used_by_bfd == NULL)
 	    goto error_return;
 	  coff_section_data (abfd, sec)->contents = NULL;
@@ -521,8 +482,7 @@ _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
 /* Set lineno_count for the output sections of a COFF file.  */
 
 int
-coff_count_linenumbers (abfd)
-     bfd *abfd;
+coff_count_linenumbers (bfd *abfd)
 {
   unsigned int limit = bfd_get_symcount (abfd);
   unsigned int i;
@@ -583,9 +543,8 @@ coff_count_linenumbers (abfd)
    area of the symbol if there is one.  */
 
 coff_symbol_type *
-coff_symbol_from (ignore_abfd, symbol)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
-     asymbol *symbol;
+coff_symbol_from (bfd *ignore_abfd ATTRIBUTE_UNUSED,
+		  asymbol *symbol)
 {
   if (!bfd_family_coff (bfd_asymbol_bfd (symbol)))
     return (coff_symbol_type *) NULL;
@@ -597,16 +556,14 @@ coff_symbol_from (ignore_abfd, symbol)
 }
 
 static void
-fixup_symbol_value (abfd, coff_symbol_ptr, syment)
-     bfd *abfd;
-     coff_symbol_type *coff_symbol_ptr;
-     struct internal_syment *syment;
+fixup_symbol_value (bfd *abfd,
+		    coff_symbol_type *coff_symbol_ptr,
+		    struct internal_syment *syment)
 {
-
-  /* Normalize the symbol flags */
+  /* Normalize the symbol flags.  */
   if (bfd_is_com_section (coff_symbol_ptr->symbol.section))
     {
-      /* a common symbol is undefined with a value */
+      /* A common symbol is undefined with a value.  */
       syment->n_scnum = N_UNDEF;
       syment->n_value = coff_symbol_ptr->symbol.value;
     }
@@ -655,14 +612,12 @@ fixup_symbol_value (abfd, coff_symbol_ptr, syment)
    do that here too.  */
 
 bfd_boolean
-coff_renumber_symbols (bfd_ptr, first_undef)
-     bfd *bfd_ptr;
-     int *first_undef;
+coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)
 {
   unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
   unsigned int native_index = 0;
-  struct internal_syment *last_file = (struct internal_syment *) NULL;
+  struct internal_syment *last_file = NULL;
   unsigned int symbol_index;
 
   /* COFF demands that undefined symbols come after all other symbols.
@@ -681,7 +636,7 @@ coff_renumber_symbols (bfd_ptr, first_undef)
     bfd_size_type amt;
 
     amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
-    newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
+    newsyms = bfd_alloc (bfd_ptr, amt);
     if (!newsyms)
       return FALSE;
     bfd_ptr->outsymbols = newsyms;
@@ -724,26 +679,22 @@ coff_renumber_symbols (bfd_ptr, first_undef)
 
 	  if (s->u.syment.n_sclass == C_FILE)
 	    {
-	      if (last_file != (struct internal_syment *) NULL)
+	      if (last_file != NULL)
 		last_file->n_value = native_index;
 	      last_file = &(s->u.syment);
 	    }
 	  else
-	    {
-
-	      /* Modify the symbol values according to their section and
-	         type */
+	    /* Modify the symbol values according to their section and
+	       type.  */
+	    fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
 
-	      fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
-	    }
 	  for (i = 0; i < s->u.syment.n_numaux + 1; i++)
 	    s[i].offset = native_index++;
 	}
       else
-	{
-	  native_index++;
-	}
+	native_index++;
     }
+
   obj_conv_table_size (bfd_ptr) = native_index;
 
   return TRUE;
@@ -754,8 +705,7 @@ coff_renumber_symbols (bfd_ptr, first_undef)
    symbol table.  */
 
 void
-coff_mangle_symbols (bfd_ptr)
-     bfd *bfd_ptr;
+coff_mangle_symbols (bfd *bfd_ptr)
 {
   unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
   asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
@@ -818,22 +768,20 @@ coff_mangle_symbols (bfd_ptr)
 }
 
 static void
-coff_fix_symbol_name (abfd, symbol, native, string_size_p,
-		      debug_string_section_p, debug_string_size_p)
-     bfd *abfd;
-     asymbol *symbol;
-     combined_entry_type *native;
-     bfd_size_type *string_size_p;
-     asection **debug_string_section_p;
-     bfd_size_type *debug_string_size_p;
+coff_fix_symbol_name (bfd *abfd,
+		      asymbol *symbol,
+		      combined_entry_type *native,
+		      bfd_size_type *string_size_p,
+		      asection **debug_string_section_p,
+		      bfd_size_type *debug_string_size_p)
 {
   unsigned int name_length;
   union internal_auxent *auxent;
   char *name = (char *) (symbol->name);
 
-  if (name == (char *) NULL)
+  if (name == NULL)
     {
-      /* coff symbols always have names, so we'll make one up */
+      /* COFF symbols always have names, so we'll make one up.  */
       symbol->name = "strange";
       name = (char *) symbol->name;
     }
@@ -861,9 +809,7 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
       if (bfd_coff_long_filenames (abfd))
 	{
 	  if (name_length <= filnmlen)
-	    {
-	      strncpy (auxent->x_file.x_fname, name, filnmlen);
-	    }
+	    strncpy (auxent->x_file.x_fname, name, filnmlen);
 	  else
 	    {
 	      auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
@@ -881,10 +827,9 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
   else
     {
       if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
-	{
-	  /* This name will fit into the symbol neatly */
-	  strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
-	}
+	/* This name will fit into the symbol neatly.  */
+	strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
+
       else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
 	{
 	  native->u.syment._n._n_n._n_offset = (*string_size_p
@@ -913,12 +858,12 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 
 	  if (!bfd_set_section_contents (abfd,
 					 *debug_string_section_p,
-					 (PTR) buf,
+					 (void *) buf,
 					 (file_ptr) *debug_string_size_p,
 					 (bfd_size_type) prefix_len)
 	      || !bfd_set_section_contents (abfd,
 					    *debug_string_section_p,
-					    (PTR) symbol->name,
+					    (void *) symbol->name,
 					    (file_ptr) (*debug_string_size_p
 							+ prefix_len),
 					    (bfd_size_type) name_length + 1))
@@ -942,20 +887,18 @@ coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 /* Write a symbol out to a COFF file.  */
 
 static bfd_boolean
-coff_write_symbol (abfd, symbol, native, written, string_size_p,
-		   debug_string_section_p, debug_string_size_p)
-     bfd *abfd;
-     asymbol *symbol;
-     combined_entry_type *native;
-     bfd_vma *written;
-     bfd_size_type *string_size_p;
-     asection **debug_string_section_p;
-     bfd_size_type *debug_string_size_p;
+coff_write_symbol (bfd *abfd,
+		   asymbol *symbol,
+		   combined_entry_type *native,
+		   bfd_vma *written,
+		   bfd_size_type *string_size_p,
+		   asection **debug_string_section_p,
+		   bfd_size_type *debug_string_size_p)
 {
   unsigned int numaux = native->u.syment.n_numaux;
   int type = native->u.syment.n_type;
   int class = native->u.syment.n_sclass;
-  PTR buf;
+  void * buf;
   bfd_size_type symesz;
 
   if (native->u.syment.n_sclass == C_FILE)
@@ -963,22 +906,17 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p,
 
   if (symbol->flags & BSF_DEBUGGING
       && bfd_is_abs_section (symbol->section))
-    {
-      native->u.syment.n_scnum = N_DEBUG;
-    }
+    native->u.syment.n_scnum = N_DEBUG;
+
   else if (bfd_is_abs_section (symbol->section))
-    {
-      native->u.syment.n_scnum = N_ABS;
-    }
+    native->u.syment.n_scnum = N_ABS;
+
   else if (bfd_is_und_section (symbol->section))
-    {
-      native->u.syment.n_scnum = N_UNDEF;
-    }
+    native->u.syment.n_scnum = N_UNDEF;
+
   else
-    {
-      native->u.syment.n_scnum =
-	symbol->section->output_section->target_index;
-    }
+    native->u.syment.n_scnum =
+      symbol->section->output_section->target_index;
 
   coff_fix_symbol_name (abfd, symbol, native, string_size_p,
 			debug_string_section_p, debug_string_size_p);
@@ -1005,9 +943,7 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p,
 	{
 	  bfd_coff_swap_aux_out (abfd,
 				 &((native + j + 1)->u.auxent),
-				 type,
-				 class,
-				 (int) j,
+				 type, class, (int) j,
 				 native->u.syment.n_numaux,
 				 buf);
 	  if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
@@ -1028,14 +964,12 @@ coff_write_symbol (abfd, symbol, native, written, string_size_p,
    or we may be linking a non COFF file to a COFF file.  */
 
 static bfd_boolean
-coff_write_alien_symbol (abfd, symbol, written, string_size_p,
-			 debug_string_section_p, debug_string_size_p)
-     bfd *abfd;
-     asymbol *symbol;
-     bfd_vma *written;
-     bfd_size_type *string_size_p;
-     asection **debug_string_section_p;
-     bfd_size_type *debug_string_size_p;
+coff_write_alien_symbol (bfd *abfd,
+			 asymbol *symbol,
+			 bfd_vma *written,
+			 bfd_size_type *string_size_p,
+			 asection **debug_string_section_p,
+			 bfd_size_type *debug_string_size_p)
 {
   combined_entry_type *native;
   combined_entry_type dummy;
@@ -1096,14 +1030,12 @@ coff_write_alien_symbol (abfd, symbol, written, string_size_p,
 /* Write a native symbol to a COFF file.  */
 
 static bfd_boolean
-coff_write_native_symbol (abfd, symbol, written, string_size_p,
-			  debug_string_section_p, debug_string_size_p)
-     bfd *abfd;
-     coff_symbol_type *symbol;
-     bfd_vma *written;
-     bfd_size_type *string_size_p;
-     asection **debug_string_section_p;
-     bfd_size_type *debug_string_size_p;
+coff_write_native_symbol (bfd *abfd,
+			  coff_symbol_type *symbol,
+			  bfd_vma *written,
+			  bfd_size_type *string_size_p,
+			  asection **debug_string_section_p,
+			  bfd_size_type *debug_string_size_p)
 {
   combined_entry_type *native = symbol->native;
   alent *lineno = symbol->lineno;
@@ -1114,6 +1046,7 @@ coff_write_native_symbol (abfd, symbol, written, string_size_p,
   if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
     {
       unsigned int count = 0;
+
       lineno[count].u.offset = *written;
       if (native->u.syment.n_numaux)
 	{
@@ -1147,8 +1080,7 @@ coff_write_native_symbol (abfd, symbol, written, string_size_p,
 /* Write out the COFF symbols.  */
 
 bfd_boolean
-coff_write_symbols (abfd)
-     bfd *abfd;
+coff_write_symbols (bfd *abfd)
 {
   bfd_size_type string_size;
   asection *debug_string_section;
@@ -1180,12 +1112,11 @@ coff_write_symbols (abfd)
 	}
     }
 
-  /* Seek to the right place */
+  /* Seek to the right place.  */
   if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
     return FALSE;
 
-  /* Output all the symbols we have */
-
+  /* Output all the symbols we have.  */
   written = 0;
   for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
     {
@@ -1211,8 +1142,7 @@ coff_write_symbols (abfd)
 
   obj_raw_syment_count (abfd) = written;
 
-  /* Now write out strings */
-
+  /* Now write out strings.  */
   if (string_size != 0)
     {
       unsigned int size = string_size + STRING_SIZE_SIZE;
@@ -1223,7 +1153,7 @@ coff_write_symbols (abfd)
 #else
  #error Change H_PUT_32
 #endif
-      if (bfd_bwrite ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd)
+      if (bfd_bwrite ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd)
 	  != sizeof (buffer))
 	return FALSE;
 
@@ -1265,18 +1195,16 @@ coff_write_symbols (abfd)
 
 	  if (c_symbol == NULL
 	      || c_symbol->native == NULL)
-	    {
-	      /* This is not a COFF symbol, so it certainly is not a
-	         file name, nor does it go in the .debug section.  */
-	      maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
-	    }
+	    /* This is not a COFF symbol, so it certainly is not a
+	       file name, nor does it go in the .debug section.  */
+	    maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
+
 	  else if (bfd_coff_symname_in_debug (abfd,
 					      &c_symbol->native->u.syment))
-	    {
-	      /* This symbol name is in the XCOFF .debug section.
-	         Don't write it into the string table.  */
-	      maxlen = name_length;
-	    }
+	    /* This symbol name is in the XCOFF .debug section.
+	       Don't write it into the string table.  */
+	    maxlen = name_length;
+
 	  else if (c_symbol->native->u.syment.n_sclass == C_FILE
 		   && c_symbol->native->u.syment.n_numaux > 0)
 	    {
@@ -1292,7 +1220,7 @@ coff_write_symbols (abfd)
 
 	  if (name_length > maxlen)
 	    {
-	      if (bfd_bwrite ((PTR) (q->name), (bfd_size_type) name_length + 1,
+	      if (bfd_bwrite ((void *) (q->name), (bfd_size_type) name_length + 1,
 			     abfd) != name_length + 1)
 		return FALSE;
 	    }
@@ -1311,7 +1239,7 @@ coff_write_symbols (abfd)
 #else
  #error Change H_PUT_32
 #endif
-      if (bfd_bwrite ((PTR) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
+      if (bfd_bwrite ((void *) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
 	  != STRING_SIZE_SIZE)
 	return FALSE;
     }
@@ -1331,12 +1259,11 @@ coff_write_symbols (abfd)
 }
 
 bfd_boolean
-coff_write_linenumbers (abfd)
-     bfd *abfd;
+coff_write_linenumbers (bfd *abfd)
 {
   asection *s;
   bfd_size_type linesz;
-  PTR buff;
+  void * buff;
 
   linesz = bfd_coff_linesz (abfd);
   buff = bfd_alloc (abfd, linesz);
@@ -1349,7 +1276,7 @@ coff_write_linenumbers (abfd)
 	  asymbol **q = abfd->outsymbols;
 	  if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
 	    return FALSE;
-	  /* Find all the linenumbers in this section */
+	  /* Find all the linenumbers in this section.  */
 	  while (*q)
 	    {
 	      asymbol *p = *q;
@@ -1360,9 +1287,9 @@ coff_write_linenumbers (abfd)
 			    (bfd_asymbol_bfd (p), p));
 		  if (l)
 		    {
-		      /* Found a linenumber entry, output */
+		      /* Found a linenumber entry, output.  */
 		      struct internal_lineno out;
-		      memset ((PTR) & out, 0, sizeof (out));
+		      memset ((void *) & out, 0, sizeof (out));
 		      out.l_lnno = 0;
 		      out.l_addr.l_symndx = l->u.offset;
 		      bfd_coff_swap_lineno_out (abfd, &out, buff);
@@ -1391,9 +1318,7 @@ coff_write_linenumbers (abfd)
 }
 
 alent *
-coff_get_lineno (ignore_abfd, symbol)
-     bfd *ignore_abfd ATTRIBUTE_UNUSED;
-     asymbol *symbol;
+coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol)
 {
   return coffsymbol (symbol)->lineno;
 }
@@ -1402,12 +1327,11 @@ coff_get_lineno (ignore_abfd, symbol)
    pointers to syments.  */
 
 static void
-coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
-     bfd *abfd;
-     combined_entry_type *table_base;
-     combined_entry_type *symbol;
-     unsigned int indaux;
-     combined_entry_type *auxent;
+coff_pointerize_aux (bfd *abfd,
+		     combined_entry_type *table_base,
+		     combined_entry_type *symbol,
+		     unsigned int indaux,
+		     combined_entry_type *auxent)
 {
   unsigned int type = symbol->u.syment.n_type;
   unsigned int class = symbol->u.syment.n_sclass;
@@ -1419,15 +1343,16 @@ coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
 	return;
     }
 
-  /* Don't bother if this is a file or a section */
+  /* Don't bother if this is a file or a section.  */
   if (class == C_STAT && type == T_NULL)
     return;
   if (class == C_FILE)
     return;
 
-  /* Otherwise patch up */
-#define N_TMASK coff_data (abfd)->local_n_tmask
+  /* Otherwise patch up.  */
+#define N_TMASK coff_data  (abfd)->local_n_tmask
 #define N_BTSHFT coff_data (abfd)->local_n_btshft
+  
   if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN)
       && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
     {
@@ -1450,8 +1375,7 @@ coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
    we didn't want to go to the trouble until someone needed it.  */
 
 static char *
-build_debug_section (abfd)
-     bfd *abfd;
+build_debug_section (bfd *abfd)
 {
   char *debug_section;
   file_ptr position;
@@ -1466,7 +1390,7 @@ build_debug_section (abfd)
     }
 
   sec_size = sect->size;
-  debug_section = (PTR) bfd_alloc (abfd, sec_size);
+  debug_section = bfd_alloc (abfd, sec_size);
   if (debug_section == NULL)
     return NULL;
 
@@ -1485,25 +1409,20 @@ build_debug_section (abfd)
 /* Return a pointer to a malloc'd copy of 'name'.  'name' may not be
    \0-terminated, but will not exceed 'maxlen' characters.  The copy *will*
    be \0-terminated.  */
+
 static char *
-copy_name (abfd, name, maxlen)
-     bfd *abfd;
-     char *name;
-     size_t maxlen;
+copy_name (bfd *abfd, char *name, size_t maxlen)
 {
   size_t len;
   char *newname;
 
   for (len = 0; len < maxlen; ++len)
-    {
-      if (name[len] == '\0')
-	{
-	  break;
-	}
-    }
+    if (name[len] == '\0')
+      break;
+
+  if ((newname = bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
+    return NULL;
 
-  if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
-    return (NULL);
   strncpy (newname, name, len);
   newname[len] = '\0';
   return newname;
@@ -1512,12 +1431,11 @@ copy_name (abfd, name, maxlen)
 /* Read in the external symbols.  */
 
 bfd_boolean
-_bfd_coff_get_external_symbols (abfd)
-     bfd *abfd;
+_bfd_coff_get_external_symbols (bfd *abfd)
 {
   bfd_size_type symesz;
   bfd_size_type size;
-  PTR syms;
+  void * syms;
 
   if (obj_coff_external_syms (abfd) != NULL)
     return TRUE;
@@ -1526,7 +1444,7 @@ _bfd_coff_get_external_symbols (abfd)
 
   size = obj_raw_syment_count (abfd) * symesz;
 
-  syms = (PTR) bfd_malloc (size);
+  syms = bfd_malloc (size);
   if (syms == NULL && size != 0)
     return FALSE;
 
@@ -1548,8 +1466,7 @@ _bfd_coff_get_external_symbols (abfd)
    detecting a missing string table in an archive.  */
 
 const char *
-_bfd_coff_read_string_table (abfd)
-     bfd *abfd;
+_bfd_coff_read_string_table (bfd *abfd)
 {
   char extstrsize[STRING_SIZE_SIZE];
   bfd_size_type strsize;
@@ -1596,7 +1513,7 @@ _bfd_coff_read_string_table (abfd)
       return NULL;
     }
 
-  strings = (char *) bfd_malloc (strsize);
+  strings = bfd_malloc (strsize);
   if (strings == NULL)
     return NULL;
 
@@ -1615,8 +1532,7 @@ _bfd_coff_read_string_table (abfd)
 /* Free up the external symbols and strings read from a COFF file.  */
 
 bfd_boolean
-_bfd_coff_free_symbols (abfd)
-     bfd *abfd;
+_bfd_coff_free_symbols (bfd *abfd)
 {
   if (obj_coff_external_syms (abfd) != NULL
       && ! obj_coff_keep_syms (abfd))
@@ -1639,8 +1555,7 @@ _bfd_coff_free_symbols (abfd)
    terminated string.  */
 
 combined_entry_type *
-coff_get_normalized_symtab (abfd)
-     bfd *abfd;
+coff_get_normalized_symtab (bfd *abfd)
 {
   combined_entry_type *internal;
   combined_entry_type *internal_ptr;
@@ -1657,7 +1572,7 @@ coff_get_normalized_symtab (abfd)
     return obj_raw_syments (abfd);
 
   size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
-  internal = (combined_entry_type *) bfd_zalloc (abfd, size);
+  internal = bfd_zalloc (abfd, size);
   if (internal == NULL && size != 0)
     return NULL;
   internal_end = internal + obj_raw_syment_count (abfd);
@@ -1667,22 +1582,22 @@ coff_get_normalized_symtab (abfd)
 
   raw_src = (char *) obj_coff_external_syms (abfd);
 
-  /* mark the end of the symbols */
+  /* Mark the end of the symbols.  */
   symesz = bfd_coff_symesz (abfd);
   raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
 
   /* FIXME SOMEDAY.  A string table size of zero is very weird, but
      probably possible.  If one shows up, it will probably kill us.  */
 
-  /* Swap all the raw entries */
+  /* Swap all the raw entries.  */
   for (internal_ptr = internal;
        raw_src < raw_end;
        raw_src += symesz, internal_ptr++)
     {
 
       unsigned int i;
-      bfd_coff_swap_sym_in (abfd, (PTR) raw_src,
-			    (PTR) & internal_ptr->u.syment);
+      bfd_coff_swap_sym_in (abfd, (void *) raw_src,
+			    (void *) & internal_ptr->u.syment);
       symbol_ptr = internal_ptr;
 
       for (i = 0;
@@ -1691,7 +1606,7 @@ coff_get_normalized_symtab (abfd)
 	{
 	  internal_ptr++;
 	  raw_src += symesz;
-	  bfd_coff_swap_aux_in (abfd, (PTR) raw_src,
+	  bfd_coff_swap_aux_in (abfd, (void *) raw_src,
 				symbol_ptr->u.syment.n_type,
 				symbol_ptr->u.syment.n_sclass,
 				(int) i, symbol_ptr->u.syment.n_numaux,
@@ -1712,11 +1627,11 @@ coff_get_normalized_symtab (abfd)
       if (internal_ptr->u.syment.n_sclass == C_FILE
 	  && internal_ptr->u.syment.n_numaux > 0)
 	{
-	  /* make a file symbol point to the name in the auxent, since
-	     the text ".file" is redundant */
+	  /* Make a file symbol point to the name in the auxent, since
+	     the text ".file" is redundant.  */
 	  if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0)
 	    {
-	      /* the filename is a long one, point into the string table */
+	      /* The filename is a long one, point into the string table.  */
 	      if (string_table == NULL)
 		{
 		  string_table = _bfd_coff_read_string_table (abfd);
@@ -1736,21 +1651,17 @@ coff_get_normalized_symtab (abfd)
                  multiple AUX entries.  */
 	      if (internal_ptr->u.syment.n_numaux > 1
 		  && coff_data (abfd)->pe)
-		{
-		  internal_ptr->u.syment._n._n_n._n_offset =
-		    ((long)
-		     copy_name (abfd,
-				(internal_ptr + 1)->u.auxent.x_file.x_fname,
-				internal_ptr->u.syment.n_numaux * symesz));
-		}
+		internal_ptr->u.syment._n._n_n._n_offset =
+		  ((long)
+		   copy_name (abfd,
+			      (internal_ptr + 1)->u.auxent.x_file.x_fname,
+			      internal_ptr->u.syment.n_numaux * symesz));
 	      else
-		{
-		  internal_ptr->u.syment._n._n_n._n_offset =
-		    ((long)
-		     copy_name (abfd,
-				(internal_ptr + 1)->u.auxent.x_file.x_fname,
-				(size_t) bfd_coff_filnmlen (abfd)));
-		}
+		internal_ptr->u.syment._n._n_n._n_offset =
+		  ((long)
+		   copy_name (abfd,
+			      (internal_ptr + 1)->u.auxent.x_file.x_fname,
+			      (size_t) bfd_coff_filnmlen (abfd)));
 	    }
 	}
       else
@@ -1761,15 +1672,15 @@ coff_get_normalized_symtab (abfd)
 	      size_t i;
 	      char *newstring;
 
-	      /* find the length of this string without walking into memory
+	      /* Find the length of this string without walking into memory
 	         that isn't ours.  */
 	      for (i = 0; i < 8; ++i)
 		if (internal_ptr->u.syment._n._n_name[i] == '\0')
 		  break;
 
-	      newstring = (PTR) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
+	      newstring = bfd_zalloc (abfd, (bfd_size_type) (i + 1));
 	      if (newstring == NULL)
-		return (NULL);
+		return NULL;
 	      strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
 	      internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
 	      internal_ptr->u.syment._n._n_n._n_zeroes = 0;
@@ -1807,13 +1718,11 @@ coff_get_normalized_symtab (abfd)
   BFD_ASSERT (obj_raw_syment_count (abfd)
 	      == (unsigned int) (internal_ptr - internal));
 
-  return (internal);
-}				/* coff_get_normalized_symtab() */
+  return internal;
+}
 
 long
-coff_get_reloc_upper_bound (abfd, asect)
-     bfd *abfd;
-     sec_ptr asect;
+coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
 {
   if (bfd_get_format (abfd) != bfd_object)
     {
@@ -1824,69 +1733,66 @@ coff_get_reloc_upper_bound (abfd, asect)
 }
 
 asymbol *
-coff_make_empty_symbol (abfd)
-     bfd *abfd;
+coff_make_empty_symbol (bfd *abfd)
 {
   bfd_size_type amt = sizeof (coff_symbol_type);
-  coff_symbol_type *new = (coff_symbol_type *) bfd_zalloc (abfd, amt);
+  coff_symbol_type *new = bfd_zalloc (abfd, amt);
+
   if (new == NULL)
-    return (NULL);
+    return NULL;
   new->symbol.section = 0;
   new->native = 0;
-  new->lineno = (alent *) NULL;
+  new->lineno = NULL;
   new->done_lineno = FALSE;
   new->symbol.the_bfd = abfd;
-  return &new->symbol;
+
+  return & new->symbol;
 }
 
 /* Make a debugging symbol.  */
 
 asymbol *
-coff_bfd_make_debug_symbol (abfd, ptr, sz)
-     bfd *abfd;
-     PTR ptr ATTRIBUTE_UNUSED;
-     unsigned long sz ATTRIBUTE_UNUSED;
+coff_bfd_make_debug_symbol (bfd *abfd,
+			    void * ptr ATTRIBUTE_UNUSED,
+			    unsigned long sz ATTRIBUTE_UNUSED)
 {
   bfd_size_type amt = sizeof (coff_symbol_type);
-  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
+  coff_symbol_type *new = bfd_alloc (abfd, amt);
+
   if (new == NULL)
-    return (NULL);
+    return NULL;
   /* @@ The 10 is a guess at a plausible maximum number of aux entries
      (but shouldn't be a constant).  */
   amt = sizeof (combined_entry_type) * 10;
-  new->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
+  new->native = bfd_zalloc (abfd, amt);
   if (!new->native)
-    return (NULL);
+    return NULL;
   new->symbol.section = bfd_abs_section_ptr;
   new->symbol.flags = BSF_DEBUGGING;
-  new->lineno = (alent *) NULL;
+  new->lineno = NULL;
   new->done_lineno = FALSE;
   new->symbol.the_bfd = abfd;
-  return &new->symbol;
+  
+  return & new->symbol;
 }
 
 void
-coff_get_symbol_info (abfd, symbol, ret)
-     bfd *abfd;
-     asymbol *symbol;
-     symbol_info *ret;
+coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
 {
   bfd_symbol_info (symbol, ret);
+
   if (coffsymbol (symbol)->native != NULL
       && coffsymbol (symbol)->native->fix_value)
-    {
-      ret->value = coffsymbol (symbol)->native->u.syment.n_value -
-	(unsigned long) obj_raw_syments (abfd);
-    }
+    ret->value = coffsymbol (symbol)->native->u.syment.n_value -
+      (unsigned long) obj_raw_syments (abfd);
 }
 
 /* Return the COFF syment for a symbol.  */
 
 bfd_boolean
-bfd_coff_get_syment (abfd, symbol, psyment)
-     bfd *abfd;
-     asymbol *symbol;
-     struct internal_syment *psyment;
+bfd_coff_get_syment (bfd *abfd,
+		     asymbol *symbol,
+		     struct internal_syment *psyment)
 {
   coff_symbol_type *csym;
 
@@ -1911,11 +1817,10 @@ bfd_coff_get_syment (abfd, symbol, psyment)
 /* Return the COFF auxent for a symbol.  */
 
 bfd_boolean
-bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
-     bfd *abfd;
-     asymbol *symbol;
-     int indx;
-     union internal_auxent *pauxent;
+bfd_coff_get_auxent (bfd *abfd,
+		     asymbol *symbol,
+		     int indx,
+		     union internal_auxent *pauxent)
 {
   coff_symbol_type *csym;
   combined_entry_type *ent;
@@ -1955,13 +1860,12 @@ bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
 /* Print out information about COFF symbol.  */
 
 void
-coff_print_symbol (abfd, filep, symbol, how)
-     bfd *abfd;
-     PTR filep;
-     asymbol *symbol;
-     bfd_print_symbol_type how;
+coff_print_symbol (bfd *abfd,
+		   void * filep,
+		   asymbol *symbol,
+		   bfd_print_symbol_type how)
 {
-  FILE *file = (FILE *) filep;
+  FILE * file = (FILE *) filep;
 
   switch (how)
     {
@@ -2002,7 +1906,7 @@ coff_print_symbol (abfd, filep, symbol, how)
 		   (unsigned long) val,
 		   symbol->name);
 #else
-	  /* Print out the wide, 64 bit, symbol value */
+	  /* Print out the wide, 64 bit, symbol value.  */
 	  fprintf (file,
 		   "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s",
 		   combined->u.syment.n_scnum,
@@ -2037,7 +1941,7 @@ coff_print_symbol (abfd, filep, symbol, how)
 
 		case C_STAT:
 		  if (combined->u.syment.n_type == T_NULL)
-		    /* probably a section symbol? */
+		    /* Probably a section symbol ?  */
 		    {
 		      fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
 			       (long) auxp->u.auxent.x_scn.x_scnlen,
@@ -2052,7 +1956,7 @@ coff_print_symbol (abfd, filep, symbol, how)
 				 auxp->u.auxent.x_scn.x_comdat);
 		      break;
 		    }
-		    /* else fall through */
+		    /* Otherwise fall through.  */
 		case C_EXT:
 		  if (ISFCN (combined->u.syment.n_type))
 		    {
@@ -2070,7 +1974,7 @@ coff_print_symbol (abfd, filep, symbol, how)
 			       llnos, next);
 		      break;
 		    }
-		  /* else fall through */
+		  /* Otherwise fall through.  */
 		default:
 		  fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
 			   auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
@@ -2101,7 +2005,7 @@ coff_print_symbol (abfd, filep, symbol, how)
 	}
       else
 	{
-	  bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
+	  bfd_print_symbol_vandf (abfd, (void *) file, symbol);
 	  fprintf (file, " %-5s %s %s %s",
 		   symbol->section->name,
 		   coffsymbol (symbol)->native ? "n" : "g",
@@ -2117,9 +2021,8 @@ coff_print_symbol (abfd, filep, symbol, how)
    override it.  */
 
 bfd_boolean
-_bfd_coff_is_local_label_name (abfd, name)
-     bfd *abfd ATTRIBUTE_UNUSED;
-     const char *name;
+_bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
+			       const char *name)
 {
   return name[0] == '.' && name[1] == 'L';
 }
@@ -2129,21 +2032,19 @@ _bfd_coff_is_local_label_name (abfd, name)
    nearest to the wanted location.  */
 
 bfd_boolean
-coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
-			functionname_ptr, line_ptr)
-     bfd *abfd;
-     asection *section;
-     asymbol **symbols;
-     bfd_vma offset;
-     const char **filename_ptr;
-     const char **functionname_ptr;
-     unsigned int *line_ptr;
+coff_find_nearest_line (bfd *abfd,
+			asection *section,
+			asymbol **symbols,
+			bfd_vma offset,
+			const char **filename_ptr,
+			const char **functionname_ptr,
+			unsigned int *line_ptr)
 {
   bfd_boolean found;
   unsigned int i;
   unsigned int line_base;
   coff_data_type *cof = coff_data (abfd);
-  /* Run through the raw syments if available */
+  /* Run through the raw syments if available.  */
   combined_entry_type *p;
   combined_entry_type *pend;
   alent *l;
@@ -2172,7 +2073,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
   *functionname_ptr = 0;
   *line_ptr = 0;
 
-  /* Don't try and find line numbers in a non coff file */
+  /* Don't try and find line numbers in a non coff file.  */
   if (!bfd_family_coff (abfd))
     return FALSE;
 
@@ -2242,8 +2143,8 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
 	}
     }
 
-  /* Now wander though the raw linenumbers of the section */
-  /* If we have been called on this section before, and the offset we
+  /* Now wander though the raw linenumbers of the section.  */
+  /* If we have been called on this section before, and th. e offset we
      want is further down then we can prime the lookup loop.  */
   sec_data = coff_section_data (abfd, section);
   if (sec_data != NULL
@@ -2270,7 +2171,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
 	{
 	  if (l->line_number == 0)
 	    {
-	      /* Get the symbol this line number points at */
+	      /* Get the symbol this line number points at.  */
 	      coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
 	      if (coff->symbol.value > offset)
 		break;
@@ -2324,7 +2225,7 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
   if (sec_data == NULL && section->owner == abfd)
     {
       amt = sizeof (struct coff_section_tdata);
-      section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+      section->used_by_bfd = bfd_zalloc (abfd, amt);
       sec_data = (struct coff_section_tdata *) section->used_by_bfd;
     }
   if (sec_data != NULL)
@@ -2339,31 +2240,25 @@ coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
 }
 
 int
-coff_sizeof_headers (abfd, reloc)
-     bfd *abfd;
-     bfd_boolean reloc;
+coff_sizeof_headers (bfd *abfd, bfd_boolean reloc)
 {
   size_t size;
 
   if (! reloc)
-    {
-      size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
-    }
+    size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
   else
-    {
-      size = bfd_coff_filhsz (abfd);
-    }
+    size = bfd_coff_filhsz (abfd);
 
   size += abfd->section_count * bfd_coff_scnhsz (abfd);
   return size;
 }
 
 /* Change the class of a coff symbol held by BFD.  */
+
 bfd_boolean
-bfd_coff_set_symbol_class (abfd, symbol, class)
-     bfd *         abfd;
-     asymbol *     symbol;
-     unsigned int  class;
+bfd_coff_set_symbol_class (bfd *         abfd,
+			   asymbol *     symbol,
+			   unsigned int  class)
 {
   coff_symbol_type * csym;
 
@@ -2383,7 +2278,7 @@ bfd_coff_set_symbol_class (abfd, symbol, class)
       combined_entry_type * native;
       bfd_size_type amt = sizeof (* native);
 
-      native = (combined_entry_type *) bfd_zalloc (abfd, amt);
+      native = bfd_zalloc (abfd, amt);
       if (native == NULL)
 	return FALSE;
 
@@ -2417,9 +2312,7 @@ bfd_coff_set_symbol_class (abfd, symbol, class)
       csym->native = native;
     }
   else
-    {
-      csym->native->u.syment.n_sclass = class;
-    }
+    csym->native->u.syment.n_sclass = class;
 
   return TRUE;
 }