import gdb-1999-07-07 post reformat

1 files changed, 271 insertions, 266 deletions

diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index 53dce63..6e67fbc 100644
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -3,21 +3,22 @@
    Contributed by Motorola.  Adapted from the C parser by Farooq Butt
    (fmbutt@engage.sps.mot.com).
 
-This file is part of GDB.
+   This file is part of GDB.
 
-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.  */
 
 #include "defs.h"
 #include "gdb_string.h"
@@ -35,7 +36,7 @@ struct type *builtin_type_f_character;
 struct type *builtin_type_f_logical;
 struct type *builtin_type_f_logical_s1;
 struct type *builtin_type_f_logical_s2;
-struct type *builtin_type_f_integer; 
+struct type *builtin_type_f_integer;
 struct type *builtin_type_f_integer_s2;
 struct type *builtin_type_f_real;
 struct type *builtin_type_f_real_s8;
@@ -48,21 +49,21 @@ struct type *builtin_type_f_void;
 /* Following is dubious stuff that had been in the xcoff reader. */
 
 struct saved_fcn
-{
-  long                         line_offset;  /* Line offset for function */ 
-  struct saved_fcn             *next;      
-}; 
+  {
+    long line_offset;		/* Line offset for function */
+    struct saved_fcn *next;
+  };
 
 
-struct saved_bf_symnum 
-{
-  long       symnum_fcn;  /* Symnum of function (i.e. .function directive) */
-  long       symnum_bf;   /* Symnum of .bf for this function */ 
-  struct saved_bf_symnum *next;  
-}; 
+struct saved_bf_symnum
+  {
+    long symnum_fcn;		/* Symnum of function (i.e. .function directive) */
+    long symnum_bf;		/* Symnum of .bf for this function */
+    struct saved_bf_symnum *next;
+  };
 
-typedef struct saved_fcn           SAVED_FUNCTION, *SAVED_FUNCTION_PTR; 
-typedef struct saved_bf_symnum     SAVED_BF, *SAVED_BF_PTR; 
+typedef struct saved_fcn SAVED_FUNCTION, *SAVED_FUNCTION_PTR;
+typedef struct saved_bf_symnum SAVED_BF, *SAVED_BF_PTR;
 
 /* Local functions */
 
@@ -83,9 +84,9 @@ static void patch_common_entries PARAMS ((SAVED_F77_COMMON_PTR, CORE_ADDR, int))
 #endif
 
 static struct type *f_create_fundamental_type PARAMS ((struct objfile *, int));
-static void f_printstr PARAMS ((GDB_FILE *stream, char *string, unsigned int length, int width, int force_ellipses));
-static void f_printchar PARAMS ((int c, GDB_FILE *stream));
-static void f_emit_char PARAMS ((int c, GDB_FILE *stream, int quoter));
+static void f_printstr PARAMS ((GDB_FILE * stream, char *string, unsigned int length, int width, int force_ellipses));
+static void f_printchar PARAMS ((int c, GDB_FILE * stream));
+static void f_emit_char PARAMS ((int c, GDB_FILE * stream, int quoter));
 
 /* Print the character C on STREAM as part of the contents of a literal
    string whose delimiter is QUOTER.  Note that that format for printing
@@ -100,7 +101,7 @@ f_emit_char (c, stream, quoter)
      int quoter;
 {
   c &= 0xFF;			/* Avoid sign bit follies */
-  
+
   if (PRINT_LITERAL_FORM (c))
     {
       if (c == '\\' || c == quoter)
@@ -174,29 +175,29 @@ f_printstr (stream, string, length, width, force_ellipses)
   extern int inspect_it;
   extern int repeat_count_threshold;
   extern int print_max;
-  
+
   if (length == 0)
     {
       fputs_filtered ("''", gdb_stdout);
       return;
     }
-  
+
   for (i = 0; i < length && things_printed < print_max; ++i)
     {
       /* Position of the character we are examining
-	 to see whether it is repeated.  */
+         to see whether it is repeated.  */
       unsigned int rep1;
       /* Number of repetitions we have detected so far.  */
       unsigned int reps;
-      
+
       QUIT;
-      
+
       if (need_comma)
 	{
 	  fputs_filtered (", ", stream);
 	  need_comma = 0;
 	}
-      
+
       rep1 = i + 1;
       reps = 1;
       while (rep1 < length && string[rep1] == string[i])
@@ -204,7 +205,7 @@ f_printstr (stream, string, length, width, force_ellipses)
 	  ++rep1;
 	  ++reps;
 	}
-      
+
       if (reps > repeat_count_threshold)
 	{
 	  if (in_quotes)
@@ -235,7 +236,7 @@ f_printstr (stream, string, length, width, force_ellipses)
 	  ++things_printed;
 	}
     }
-  
+
   /* Terminate the quotes if necessary.  */
   if (in_quotes)
     {
@@ -244,7 +245,7 @@ f_printstr (stream, string, length, width, force_ellipses)
       else
 	fputs_filtered ("'", stream);
     }
-  
+
   if (force_ellipses || i < length)
     fputs_filtered ("...", stream);
 }
@@ -259,7 +260,7 @@ f_create_fundamental_type (objfile, typeid)
      int typeid;
 {
   register struct type *type = NULL;
-  
+
   switch (typeid)
     {
     case FT_VOID:
@@ -315,10 +316,10 @@ f_create_fundamental_type (objfile, typeid)
     case FT_SIGNED_INTEGER:
       type = init_type (TYPE_CODE_INT,
 			TARGET_INT_BIT / TARGET_CHAR_BIT,
-			0, "integer", objfile); /* FIXME -fnf */
+			0, "integer", objfile);		/* FIXME -fnf */
       break;
     case FT_UNSIGNED_INTEGER:
-      type = init_type (TYPE_CODE_BOOL, 
+      type = init_type (TYPE_CODE_BOOL,
 			TARGET_INT_BIT / TARGET_CHAR_BIT,
 			TYPE_FLAG_UNSIGNED, "logical*4", objfile);
       break;
@@ -335,7 +336,7 @@ f_create_fundamental_type (objfile, typeid)
     case FT_SIGNED_LONG:
       type = init_type (TYPE_CODE_INT,
 			TARGET_LONG_BIT / TARGET_CHAR_BIT,
-			0, "long", objfile); /* FIXME -fnf */
+			0, "long", objfile);	/* FIXME -fnf */
       break;
     case FT_UNSIGNED_LONG:
       type = init_type (TYPE_CODE_INT,
@@ -397,9 +398,9 @@ f_create_fundamental_type (objfile, typeid)
       break;
     default:
       /* FIXME:  For now, if we are asked to produce a type not in this
-	 language, create the equivalent of a C integer type with the
-	 name "<?type?>".  When all the dust settles from the type
-	 reconstruction work, this should probably become an error. */
+         language, create the equivalent of a C integer type with the
+         name "<?type?>".  When all the dust settles from the type
+         reconstruction work, this should probably become an error. */
       type = init_type (TYPE_CODE_INT,
 			TARGET_INT_BIT / TARGET_CHAR_BIT,
 			0, "<?type?>", objfile);
@@ -408,52 +409,53 @@ f_create_fundamental_type (objfile, typeid)
     }
   return (type);
 }
-
 
+
 /* Table of operators and their precedences for printing expressions.  */
 
-static const struct op_print f_op_print_tab[] = {
-  { "+",     BINOP_ADD, PREC_ADD, 0 },
-  { "+",     UNOP_PLUS, PREC_PREFIX, 0 },
-  { "-",     BINOP_SUB, PREC_ADD, 0 },
-  { "-",     UNOP_NEG, PREC_PREFIX, 0 },
-  { "*",     BINOP_MUL, PREC_MUL, 0 },
-  { "/",     BINOP_DIV, PREC_MUL, 0 },
-  { "DIV",   BINOP_INTDIV, PREC_MUL, 0 },
-  { "MOD",   BINOP_REM, PREC_MUL, 0 },
-  { "=",     BINOP_ASSIGN, PREC_ASSIGN, 1 },
-  { ".OR.",  BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0 },
-  { ".AND.", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0 },
-  { ".NOT.", UNOP_LOGICAL_NOT, PREC_PREFIX, 0 },
-  { ".EQ.",  BINOP_EQUAL, PREC_EQUAL, 0 },
-  { ".NE.",  BINOP_NOTEQUAL, PREC_EQUAL, 0 },
-  { ".LE.",  BINOP_LEQ, PREC_ORDER, 0 },
-  { ".GE.",  BINOP_GEQ, PREC_ORDER, 0 },
-  { ".GT.",  BINOP_GTR, PREC_ORDER, 0 },
-  { ".LT.",  BINOP_LESS, PREC_ORDER, 0 },
-  { "**",    UNOP_IND, PREC_PREFIX, 0 },
-  { "@",     BINOP_REPEAT, PREC_REPEAT, 0 },
-  { NULL,    0, 0, 0 }
+static const struct op_print f_op_print_tab[] =
+{
+  {"+", BINOP_ADD, PREC_ADD, 0},
+  {"+", UNOP_PLUS, PREC_PREFIX, 0},
+  {"-", BINOP_SUB, PREC_ADD, 0},
+  {"-", UNOP_NEG, PREC_PREFIX, 0},
+  {"*", BINOP_MUL, PREC_MUL, 0},
+  {"/", BINOP_DIV, PREC_MUL, 0},
+  {"DIV", BINOP_INTDIV, PREC_MUL, 0},
+  {"MOD", BINOP_REM, PREC_MUL, 0},
+  {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
+  {".OR.", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
+  {".AND.", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
+  {".NOT.", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
+  {".EQ.", BINOP_EQUAL, PREC_EQUAL, 0},
+  {".NE.", BINOP_NOTEQUAL, PREC_EQUAL, 0},
+  {".LE.", BINOP_LEQ, PREC_ORDER, 0},
+  {".GE.", BINOP_GEQ, PREC_ORDER, 0},
+  {".GT.", BINOP_GTR, PREC_ORDER, 0},
+  {".LT.", BINOP_LESS, PREC_ORDER, 0},
+  {"**", UNOP_IND, PREC_PREFIX, 0},
+  {"@", BINOP_REPEAT, PREC_REPEAT, 0},
+  {NULL, 0, 0, 0}
 };
 
-struct type ** CONST_PTR (f_builtin_types[]) = 
+struct type **CONST_PTR (f_builtin_types[]) =
 {
   &builtin_type_f_character,
-  &builtin_type_f_logical,
-  &builtin_type_f_logical_s1,
-  &builtin_type_f_logical_s2,
-  &builtin_type_f_integer,
-  &builtin_type_f_integer_s2,
-  &builtin_type_f_real,
-  &builtin_type_f_real_s8,
-  &builtin_type_f_real_s16,
-  &builtin_type_f_complex_s8,
-  &builtin_type_f_complex_s16,
+    &builtin_type_f_logical,
+    &builtin_type_f_logical_s1,
+    &builtin_type_f_logical_s2,
+    &builtin_type_f_integer,
+    &builtin_type_f_integer_s2,
+    &builtin_type_f_real,
+    &builtin_type_f_real_s8,
+    &builtin_type_f_real_s16,
+    &builtin_type_f_complex_s8,
+    &builtin_type_f_complex_s16,
 #if 0
-  &builtin_type_f_complex_s32,
+    &builtin_type_f_complex_s32,
 #endif
-  &builtin_type_f_void,
-  0
+    &builtin_type_f_void,
+    0
 };
 
 /* This is declared in c-lang.h but it is silly to import that file for what
@@ -461,7 +463,8 @@ struct type ** CONST_PTR (f_builtin_types[]) =
 extern int
 c_value_print PARAMS ((struct value *, GDB_FILE *, int, enum val_prettyprint));
 
-const struct language_defn f_language_defn = {
+const struct language_defn f_language_defn =
+{
   "fortran",
   language_fortran,
   f_builtin_types,
@@ -474,19 +477,19 @@ const struct language_defn f_language_defn = {
   f_printstr,			/* function to print string constant */
   f_emit_char,			/* Function to print a single character */
   f_create_fundamental_type,	/* Create fundamental type in this language */
-  f_print_type,		        /* Print a type using appropriate syntax */
+  f_print_type,			/* Print a type using appropriate syntax */
   f_val_print,			/* Print a value using appropriate syntax */
-  c_value_print,  /* FIXME */
-  {"",      "",   "",   ""},	/* Binary format info */
-  {"0%o",  "0",   "o", ""},	/* Octal format info */
-  {"%d",   "",    "d", ""},	/* Decimal format info */
-  {"0x%x", "0x",  "x", ""},	/* Hex format info */
+  c_value_print,		/* FIXME */
+  {"", "", "", ""},		/* Binary format info */
+  {"0%o", "0", "o", ""},	/* Octal format info */
+  {"%d", "", "d", ""},		/* Decimal format info */
+  {"0x%x", "0x", "x", ""},	/* Hex format info */
   f_op_print_tab,		/* expression operators for printing */
   0,				/* arrays are first-class (not c-style) */
   1,				/* String lower bound */
-  &builtin_type_f_character,	/* Type of string elements */ 
+  &builtin_type_f_character,	/* Type of string elements */
   LANG_MAGIC
-  };
+};
 
 void
 _initialize_f_language ()
@@ -495,68 +498,68 @@ _initialize_f_language ()
     init_type (TYPE_CODE_VOID, 1,
 	       0,
 	       "VOID", (struct objfile *) NULL);
-  
+
   builtin_type_f_character =
     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "character", (struct objfile *) NULL);
-  
+
   builtin_type_f_logical_s1 =
     init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 	       TYPE_FLAG_UNSIGNED,
 	       "logical*1", (struct objfile *) NULL);
-  
+
   builtin_type_f_integer_s2 =
     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "integer*2", (struct objfile *) NULL);
-  
+
   builtin_type_f_logical_s2 =
     init_type (TYPE_CODE_BOOL, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
 	       TYPE_FLAG_UNSIGNED,
 	       "logical*2", (struct objfile *) NULL);
-  
+
   builtin_type_f_integer =
     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "integer", (struct objfile *) NULL);
-  
+
   builtin_type_f_logical =
     init_type (TYPE_CODE_BOOL, TARGET_INT_BIT / TARGET_CHAR_BIT,
 	       TYPE_FLAG_UNSIGNED,
 	       "logical*4", (struct objfile *) NULL);
-  
+
   builtin_type_f_real =
     init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "real", (struct objfile *) NULL);
-  
+
   builtin_type_f_real_s8 =
     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "real*8", (struct objfile *) NULL);
-  
+
   builtin_type_f_real_s16 =
     init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "real*16", (struct objfile *) NULL);
-  
+
   builtin_type_f_complex_s8 =
     init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "complex*8", (struct objfile *) NULL);
   TYPE_TARGET_TYPE (builtin_type_f_complex_s8) = builtin_type_f_real;
-  
+
   builtin_type_f_complex_s16 =
     init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "complex*16", (struct objfile *) NULL);
   TYPE_TARGET_TYPE (builtin_type_f_complex_s16) = builtin_type_f_real_s8;
-  
+
   /* We have a new size == 4 double floats for the
      complex*32 data type */
-  
-  builtin_type_f_complex_s32 = 
+
+  builtin_type_f_complex_s32 =
     init_type (TYPE_CODE_COMPLEX, 2 * TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
 	       0,
 	       "complex*32", (struct objfile *) NULL);
@@ -565,215 +568,218 @@ _initialize_f_language ()
   builtin_type_string =
     init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
 	       0,
-	       "character string", (struct objfile *) NULL); 
-  
+	       "character string", (struct objfile *) NULL);
+
   add_language (&f_language_defn);
 }
 
 #if 0
 static SAVED_BF_PTR
-allocate_saved_bf_node()
+allocate_saved_bf_node ()
 {
   SAVED_BF_PTR new;
-  
+
   new = (SAVED_BF_PTR) xmalloc (sizeof (SAVED_BF));
-  return(new);
+  return (new);
 }
 
 static SAVED_FUNCTION *
-allocate_saved_function_node()
+allocate_saved_function_node ()
 {
   SAVED_FUNCTION *new;
-  
+
   new = (SAVED_FUNCTION *) xmalloc (sizeof (SAVED_FUNCTION));
-  return(new);
+  return (new);
 }
 
-static SAVED_F77_COMMON_PTR allocate_saved_f77_common_node()
+static SAVED_F77_COMMON_PTR
+allocate_saved_f77_common_node ()
 {
   SAVED_F77_COMMON_PTR new;
-  
+
   new = (SAVED_F77_COMMON_PTR) xmalloc (sizeof (SAVED_F77_COMMON));
-  return(new);
+  return (new);
 }
 
-static COMMON_ENTRY_PTR allocate_common_entry_node()
+static COMMON_ENTRY_PTR
+allocate_common_entry_node ()
 {
   COMMON_ENTRY_PTR new;
-  
+
   new = (COMMON_ENTRY_PTR) xmalloc (sizeof (COMMON_ENTRY));
-  return(new);
+  return (new);
 }
 #endif
 
-SAVED_F77_COMMON_PTR head_common_list=NULL;     /* Ptr to 1st saved COMMON  */
-SAVED_F77_COMMON_PTR tail_common_list=NULL;     /* Ptr to last saved COMMON  */
-SAVED_F77_COMMON_PTR current_common=NULL;       /* Ptr to current COMMON */
+SAVED_F77_COMMON_PTR head_common_list = NULL;	/* Ptr to 1st saved COMMON  */
+SAVED_F77_COMMON_PTR tail_common_list = NULL;	/* Ptr to last saved COMMON  */
+SAVED_F77_COMMON_PTR current_common = NULL;	/* Ptr to current COMMON */
 
 #if 0
-static SAVED_BF_PTR saved_bf_list=NULL;          /* Ptr to (.bf,function) 
-                                                    list*/
-static SAVED_BF_PTR saved_bf_list_end=NULL;      /* Ptr to above list's end */
-static SAVED_BF_PTR current_head_bf_list=NULL;   /* Current head of above list
-						  */
+static SAVED_BF_PTR saved_bf_list = NULL;	/* Ptr to (.bf,function) 
+						   list */
+static SAVED_BF_PTR saved_bf_list_end = NULL;	/* Ptr to above list's end */
+static SAVED_BF_PTR current_head_bf_list = NULL;	/* Current head of above list
+							 */
 
-static SAVED_BF_PTR tmp_bf_ptr;                  /* Generic temporary for use 
-                                                    in macros */ 
+static SAVED_BF_PTR tmp_bf_ptr;	/* Generic temporary for use 
+				   in macros */
 
 /* The following function simply enters a given common block onto 
    the global common block chain */
 
 static void
-add_common_block(name,offset,secnum,func_stab)
+add_common_block (name, offset, secnum, func_stab)
      char *name;
      CORE_ADDR offset;
      int secnum;
      char *func_stab;
 {
   SAVED_F77_COMMON_PTR tmp;
-  char *c,*local_copy_func_stab; 
-  
+  char *c, *local_copy_func_stab;
+
   /* If the COMMON block we are trying to add has a blank 
      name (i.e. "#BLNK_COM") then we set it to __BLANK
      because the darn "#" character makes GDB's input 
-     parser have fits. */ 
-  
-  
-  if (STREQ(name,BLANK_COMMON_NAME_ORIGINAL) ||
-      STREQ(name,BLANK_COMMON_NAME_MF77))
+     parser have fits. */
+
+
+  if (STREQ (name, BLANK_COMMON_NAME_ORIGINAL) ||
+      STREQ (name, BLANK_COMMON_NAME_MF77))
     {
-      
-      free(name);
-      name = alloca(strlen(BLANK_COMMON_NAME_LOCAL) + 1); 
-      strcpy(name,BLANK_COMMON_NAME_LOCAL); 
+
+      free (name);
+      name = alloca (strlen (BLANK_COMMON_NAME_LOCAL) + 1);
+      strcpy (name, BLANK_COMMON_NAME_LOCAL);
     }
-  
-  tmp = allocate_saved_f77_common_node();
-  
-  local_copy_func_stab = xmalloc (strlen(func_stab) + 1);
-  strcpy(local_copy_func_stab,func_stab); 
-  
-  tmp->name = xmalloc(strlen(name) + 1);
-  
+
+  tmp = allocate_saved_f77_common_node ();
+
+  local_copy_func_stab = xmalloc (strlen (func_stab) + 1);
+  strcpy (local_copy_func_stab, func_stab);
+
+  tmp->name = xmalloc (strlen (name) + 1);
+
   /* local_copy_func_stab is a stabstring, let us first extract the 
-     function name from the stab by NULLing out the ':' character. */ 
-  
-  
-  c = NULL; 
-  c = strchr(local_copy_func_stab,':');
-  
+     function name from the stab by NULLing out the ':' character. */
+
+
+  c = NULL;
+  c = strchr (local_copy_func_stab, ':');
+
   if (c)
     *c = '\0';
   else
-    error("Malformed function STAB found in add_common_block()");
-  
-  
-  tmp->owning_function = xmalloc (strlen(local_copy_func_stab) + 1); 
-  
-  strcpy(tmp->owning_function,local_copy_func_stab); 
-  
-  strcpy(tmp->name,name);
-  tmp->offset = offset; 
+    error ("Malformed function STAB found in add_common_block()");
+
+
+  tmp->owning_function = xmalloc (strlen (local_copy_func_stab) + 1);
+
+  strcpy (tmp->owning_function, local_copy_func_stab);
+
+  strcpy (tmp->name, name);
+  tmp->offset = offset;
   tmp->next = NULL;
   tmp->entries = NULL;
-  tmp->secnum = secnum; 
-  
+  tmp->secnum = secnum;
+
   current_common = tmp;
-  
+
   if (head_common_list == NULL)
     {
       head_common_list = tail_common_list = tmp;
     }
   else
     {
-      tail_common_list->next = tmp; 
+      tail_common_list->next = tmp;
       tail_common_list = tmp;
     }
 }
 #endif
 
 /* The following function simply enters a given common entry onto 
-   the "current_common" block that has been saved away. */ 
+   the "current_common" block that has been saved away. */
 
 #if 0
 static void
-add_common_entry(entry_sym_ptr)
-     struct symbol *entry_sym_ptr; 
+add_common_entry (entry_sym_ptr)
+     struct symbol *entry_sym_ptr;
 {
   COMMON_ENTRY_PTR tmp;
-  
-  
-  
+
+
+
   /* The order of this list is important, since 
      we expect the entries to appear in decl.
-     order when we later issue "info common" calls */ 
-  
-  tmp = allocate_common_entry_node();
-  
+     order when we later issue "info common" calls */
+
+  tmp = allocate_common_entry_node ();
+
   tmp->next = NULL;
   tmp->symbol = entry_sym_ptr;
-  
+
   if (current_common == NULL)
-    error("Attempt to add COMMON entry with no block open!");
-  else         
+    error ("Attempt to add COMMON entry with no block open!");
+  else
     {
       if (current_common->entries == NULL)
 	{
 	  current_common->entries = tmp;
-	  current_common->end_of_entries = tmp; 
+	  current_common->end_of_entries = tmp;
 	}
       else
 	{
-	  current_common->end_of_entries->next = tmp; 
-	  current_common->end_of_entries = tmp; 
+	  current_common->end_of_entries->next = tmp;
+	  current_common->end_of_entries = tmp;
 	}
     }
 }
 #endif
 
-/* This routine finds the first encountred COMMON block named "name" */ 
+/* This routine finds the first encountred COMMON block named "name" */
 
 #if 0
 static SAVED_F77_COMMON_PTR
-find_first_common_named(name)
-     char *name; 
+find_first_common_named (name)
+     char *name;
 {
-  
+
   SAVED_F77_COMMON_PTR tmp;
-  
+
   tmp = head_common_list;
-  
+
   while (tmp != NULL)
     {
-      if (STREQ(tmp->name,name))
-	return(tmp);
+      if (STREQ (tmp->name, name))
+	return (tmp);
       else
 	tmp = tmp->next;
     }
-  return(NULL); 
+  return (NULL);
 }
 #endif
 
 /* This routine finds the first encountred COMMON block named "name" 
-   that belongs to function funcname */ 
+   that belongs to function funcname */
 
-SAVED_F77_COMMON_PTR find_common_for_function(name, funcname)
+SAVED_F77_COMMON_PTR
+find_common_for_function (name, funcname)
      char *name;
-     char *funcname; 
+     char *funcname;
 {
-  
+
   SAVED_F77_COMMON_PTR tmp;
-  
+
   tmp = head_common_list;
-  
+
   while (tmp != NULL)
     {
-      if (STREQ(tmp->name,name) && STREQ(tmp->owning_function,funcname))
-	return(tmp);
+      if (STREQ (tmp->name, name) && STREQ (tmp->owning_function, funcname))
+	return (tmp);
       else
 	tmp = tmp->next;
     }
-  return(NULL); 
+  return (NULL);
 }
 
 
@@ -781,7 +787,7 @@ SAVED_F77_COMMON_PTR find_common_for_function(name, funcname)
 
 /* The following function is called to patch up the offsets 
    for the statics contained in the COMMON block named
-   "name."  */ 
+   "name."  */
 
 static void
 patch_common_entries (blk, offset, secnum)
@@ -790,19 +796,19 @@ patch_common_entries (blk, offset, secnum)
      int secnum;
 {
   COMMON_ENTRY_PTR entry;
-  
-  blk->offset = offset;  /* Keep this around for future use. */ 
-  
+
+  blk->offset = offset;		/* Keep this around for future use. */
+
   entry = blk->entries;
-  
+
   while (entry != NULL)
     {
-      SYMBOL_VALUE (entry->symbol) += offset; 
+      SYMBOL_VALUE (entry->symbol) += offset;
       SYMBOL_SECTION (entry->symbol) = secnum;
-      
+
       entry = entry->next;
     }
-  blk->secnum = secnum; 
+  blk->secnum = secnum;
 }
 
 /* Patch all commons named "name" that need patching.Since COMMON
@@ -817,30 +823,30 @@ patch_all_commons_by_name (name, offset, secnum)
      CORE_ADDR offset;
      int secnum;
 {
-  
+
   SAVED_F77_COMMON_PTR tmp;
-  
+
   /* For blank common blocks, change the canonical reprsentation 
      of a blank name */
-  
-  if ((STREQ(name,BLANK_COMMON_NAME_ORIGINAL)) ||
-      (STREQ(name,BLANK_COMMON_NAME_MF77)))
+
+  if ((STREQ (name, BLANK_COMMON_NAME_ORIGINAL)) ||
+      (STREQ (name, BLANK_COMMON_NAME_MF77)))
     {
-      free(name);
-      name = alloca(strlen(BLANK_COMMON_NAME_LOCAL) + 1); 
-      strcpy(name,BLANK_COMMON_NAME_LOCAL); 
+      free (name);
+      name = alloca (strlen (BLANK_COMMON_NAME_LOCAL) + 1);
+      strcpy (name, BLANK_COMMON_NAME_LOCAL);
     }
-  
+
   tmp = head_common_list;
-  
+
   while (tmp != NULL)
     {
-      if (COMMON_NEEDS_PATCHING(tmp))
-	if (STREQ(tmp->name,name))
-	  patch_common_entries(tmp,offset,secnum); 
-      
+      if (COMMON_NEEDS_PATCHING (tmp))
+	if (STREQ (tmp->name, name))
+	  patch_common_entries (tmp, offset, secnum);
+
       tmp = tmp->next;
-    }   
+    }
 }
 #endif
 
@@ -850,7 +856,7 @@ patch_all_commons_by_name (name, offset, secnum)
    #line pragmas sometimes cause line ranges to get messed up 
    we simply create a linear list.  This list can then be searched 
    first by a queueing algorithm and upon failure fall back to 
-   a linear scan. */ 
+   a linear scan. */
 
 #if 0
 #define ADD_BF_SYMNUM(bf_sym,fcn_sym) \
@@ -876,24 +882,24 @@ else \
 	       \
 		 saved_bf_list_end->next = tmp_bf_ptr;  \
 		   saved_bf_list_end = tmp_bf_ptr; \
-		   } 
+		   }
 #endif
 
-/* This function frees the entire (.bf,function) list */ 
+/* This function frees the entire (.bf,function) list */
 
 #if 0
-static void 
-  clear_bf_list()
+static void
+clear_bf_list ()
 {
-  
+
   SAVED_BF_PTR tmp = saved_bf_list;
-  SAVED_BF_PTR next = NULL; 
-  
+  SAVED_BF_PTR next = NULL;
+
   while (tmp != NULL)
     {
       next = tmp->next;
-      free(tmp);
-      tmp=next;
+      free (tmp);
+      tmp = next;
     }
   saved_bf_list = NULL;
 }
@@ -909,66 +915,65 @@ get_bf_for_fcn (the_function)
 {
   SAVED_BF_PTR tmp;
   int nprobes = 0;
-  
+
   /* First use a simple queuing algorithm (i.e. look and see if the 
      item at the head of the queue is the one you want)  */
-  
+
   if (saved_bf_list == NULL)
-    fatal ("cannot get .bf node off empty list"); 
-  
-  if (current_head_bf_list != NULL) 
+    fatal ("cannot get .bf node off empty list");
+
+  if (current_head_bf_list != NULL)
     if (current_head_bf_list->symnum_fcn == the_function)
       {
-	if (global_remote_debug) 
-	  fprintf(stderr,"*"); 
+	if (global_remote_debug)
+	  fprintf (stderr, "*");
 
-	tmp = current_head_bf_list; 
+	tmp = current_head_bf_list;
 	current_head_bf_list = current_head_bf_list->next;
-	return(tmp->symnum_bf); 
+	return (tmp->symnum_bf);
       }
-  
+
   /* If the above did not work (probably because #line directives were 
      used in the sourcefile and they messed up our internal tables) we now do
      the ugly linear scan */
-  
-  if (global_remote_debug) 
-    fprintf(stderr,"\ndefaulting to linear scan\n"); 
-  
-  nprobes = 0; 
+
+  if (global_remote_debug)
+    fprintf (stderr, "\ndefaulting to linear scan\n");
+
+  nprobes = 0;
   tmp = saved_bf_list;
   while (tmp != NULL)
     {
-      nprobes++; 
+      nprobes++;
       if (tmp->symnum_fcn == the_function)
-	{ 
+	{
 	  if (global_remote_debug)
-	    fprintf(stderr,"Found in %d probes\n",nprobes);
+	    fprintf (stderr, "Found in %d probes\n", nprobes);
 	  current_head_bf_list = tmp->next;
-	  return(tmp->symnum_bf);
-	} 
-      tmp= tmp->next; 
+	  return (tmp->symnum_bf);
+	}
+      tmp = tmp->next;
     }
-  
-  return(-1); 
+
+  return (-1);
 }
 
-static SAVED_FUNCTION_PTR saved_function_list=NULL; 
-static SAVED_FUNCTION_PTR saved_function_list_end=NULL; 
+static SAVED_FUNCTION_PTR saved_function_list = NULL;
+static SAVED_FUNCTION_PTR saved_function_list_end = NULL;
 
 static void
-clear_function_list()
+clear_function_list ()
 {
   SAVED_FUNCTION_PTR tmp = saved_function_list;
-  SAVED_FUNCTION_PTR next = NULL; 
-  
+  SAVED_FUNCTION_PTR next = NULL;
+
   while (tmp != NULL)
     {
       next = tmp->next;
-      free(tmp);
+      free (tmp);
       tmp = next;
     }
-  
+
   saved_function_list = NULL;
 }
 #endif
-