s/boolean/bfd_boolean/ s/true/TRUE/ s/false/FALSE/. Simplify

comparisons of bfd_boolean vars with TRUE/FALSE.  Formatting.

1 files changed, 323 insertions, 283 deletions

diff --git a/binutils/prdbg.c b/binutils/prdbg.c
index a05fe09..b29eec6 100644
--- a/binutils/prdbg.c
+++ b/binutils/prdbg.c
@@ -1,5 +1,5 @@
 /* prdbg.c -- Print out generic debugging information.
-   Copyright 1995, 1996 Free Software Foundation, Inc.
+   Copyright 1995, 1996, 2002 Free Software Foundation, Inc.
    Written by Ian Lance Taylor <ian@cygnus.com>.
 
    This file is part of GNU Binutils.
@@ -59,75 +59,115 @@ struct pr_stack
   const char *method;
 };
 
-static void indent PARAMS ((struct pr_handle *));
-static boolean push_type PARAMS ((struct pr_handle *, const char *));
-static boolean prepend_type PARAMS ((struct pr_handle *, const char *));
-static boolean append_type PARAMS ((struct pr_handle *, const char *));
-static boolean substitute_type PARAMS ((struct pr_handle *, const char *));
-static boolean indent_type PARAMS ((struct pr_handle *));
-static char *pop_type PARAMS ((struct pr_handle *));
-static void print_vma PARAMS ((bfd_vma, char *, boolean, boolean));
-static boolean pr_fix_visibility
+static void indent
+  PARAMS ((struct pr_handle *));
+static bfd_boolean push_type
+  PARAMS ((struct pr_handle *, const char *));
+static bfd_boolean prepend_type
+  PARAMS ((struct pr_handle *, const char *));
+static bfd_boolean append_type
+  PARAMS ((struct pr_handle *, const char *));
+static bfd_boolean substitute_type
+  PARAMS ((struct pr_handle *, const char *));
+static bfd_boolean indent_type
+  PARAMS ((struct pr_handle *));
+static char *pop_type
+  PARAMS ((struct pr_handle *));
+static void print_vma
+  PARAMS ((bfd_vma, char *, bfd_boolean, bfd_boolean));
+static bfd_boolean pr_fix_visibility
   PARAMS ((struct pr_handle *, enum debug_visibility));
-
-static boolean pr_start_compilation_unit PARAMS ((PTR, const char *));
-static boolean pr_start_source PARAMS ((PTR, const char *));
-static boolean pr_empty_type PARAMS ((PTR));
-static boolean pr_void_type PARAMS ((PTR));
-static boolean pr_int_type PARAMS ((PTR, unsigned int, boolean));
-static boolean pr_float_type PARAMS ((PTR, unsigned int));
-static boolean pr_complex_type PARAMS ((PTR, unsigned int));
-static boolean pr_bool_type PARAMS ((PTR, unsigned int));
-static boolean pr_enum_type
+static bfd_boolean pr_start_compilation_unit
+  PARAMS ((PTR, const char *));
+static bfd_boolean pr_start_source
+  PARAMS ((PTR, const char *));
+static bfd_boolean pr_empty_type
+  PARAMS ((PTR));
+static bfd_boolean pr_void_type
+  PARAMS ((PTR));
+static bfd_boolean pr_int_type
+  PARAMS ((PTR, unsigned int, bfd_boolean));
+static bfd_boolean pr_float_type
+  PARAMS ((PTR, unsigned int));
+static bfd_boolean pr_complex_type
+  PARAMS ((PTR, unsigned int));
+static bfd_boolean pr_bool_type
+  PARAMS ((PTR, unsigned int));
+static bfd_boolean pr_enum_type
   PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
-static boolean pr_pointer_type PARAMS ((PTR));
-static boolean pr_function_type PARAMS ((PTR, int, boolean));
-static boolean pr_reference_type PARAMS ((PTR));
-static boolean pr_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
-static boolean pr_array_type
-  PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
-static boolean pr_set_type PARAMS ((PTR, boolean));
-static boolean pr_offset_type PARAMS ((PTR));
-static boolean pr_method_type PARAMS ((PTR, boolean, int, boolean));
-static boolean pr_const_type PARAMS ((PTR));
-static boolean pr_volatile_type PARAMS ((PTR));
-static boolean pr_start_struct_type
-  PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
-static boolean pr_struct_field
+static bfd_boolean pr_pointer_type
+  PARAMS ((PTR));
+static bfd_boolean pr_function_type
+  PARAMS ((PTR, int, bfd_boolean));
+static bfd_boolean pr_reference_type
+  PARAMS ((PTR));
+static bfd_boolean pr_range_type
+  PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
+static bfd_boolean pr_array_type
+  PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, bfd_boolean));
+static bfd_boolean pr_set_type
+  PARAMS ((PTR, bfd_boolean));
+static bfd_boolean pr_offset_type
+  PARAMS ((PTR));
+static bfd_boolean pr_method_type
+  PARAMS ((PTR, bfd_boolean, int, bfd_boolean));
+static bfd_boolean pr_const_type
+  PARAMS ((PTR));
+static bfd_boolean pr_volatile_type
+  PARAMS ((PTR));
+static bfd_boolean pr_start_struct_type
+  PARAMS ((PTR, const char *, unsigned int, bfd_boolean, unsigned int));
+static bfd_boolean pr_struct_field
   PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
-static boolean pr_end_struct_type PARAMS ((PTR));
-static boolean pr_start_class_type
-  PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
-	   boolean));
-static boolean pr_class_static_member
+static bfd_boolean pr_end_struct_type
+  PARAMS ((PTR));
+static bfd_boolean pr_start_class_type
+  PARAMS ((PTR, const char *, unsigned int, bfd_boolean, unsigned int,
+	   bfd_boolean, bfd_boolean));
+static bfd_boolean pr_class_static_member
   PARAMS ((PTR, const char *, const char *, enum debug_visibility));
-static boolean pr_class_baseclass
-  PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
-static boolean pr_class_start_method PARAMS ((PTR, const char *));
-static boolean pr_class_method_variant
-  PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
-	   bfd_vma, boolean));
-static boolean pr_class_static_method_variant
-  PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
-static boolean pr_class_end_method PARAMS ((PTR));
-static boolean pr_end_class_type PARAMS ((PTR));
-static boolean pr_typedef_type PARAMS ((PTR, const char *));
-static boolean pr_tag_type
+static bfd_boolean pr_class_baseclass
+  PARAMS ((PTR, bfd_vma, bfd_boolean, enum debug_visibility));
+static bfd_boolean pr_class_start_method
+  PARAMS ((PTR, const char *));
+static bfd_boolean pr_class_method_variant
+  PARAMS ((PTR, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
+	   bfd_vma, bfd_boolean));
+static bfd_boolean pr_class_static_method_variant
+  PARAMS ((PTR, const char *, enum debug_visibility, bfd_boolean,
+	   bfd_boolean));
+static bfd_boolean pr_class_end_method
+  PARAMS ((PTR));
+static bfd_boolean pr_end_class_type
+  PARAMS ((PTR));
+static bfd_boolean pr_typedef_type
+  PARAMS ((PTR, const char *));
+static bfd_boolean pr_tag_type
   PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
-static boolean pr_typdef PARAMS ((PTR, const char *));
-static boolean pr_tag PARAMS ((PTR, const char *));
-static boolean pr_int_constant PARAMS ((PTR, const char *, bfd_vma));
-static boolean pr_float_constant PARAMS ((PTR, const char *, double));
-static boolean pr_typed_constant PARAMS ((PTR, const char *, bfd_vma));
-static boolean pr_variable
+static bfd_boolean pr_typdef
+  PARAMS ((PTR, const char *));
+static bfd_boolean pr_tag
+  PARAMS ((PTR, const char *));
+static bfd_boolean pr_int_constant
+  PARAMS ((PTR, const char *, bfd_vma));
+static bfd_boolean pr_float_constant
+  PARAMS ((PTR, const char *, double));
+static bfd_boolean pr_typed_constant
+  PARAMS ((PTR, const char *, bfd_vma));
+static bfd_boolean pr_variable
   PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
-static boolean pr_start_function PARAMS ((PTR, const char *, boolean));
-static boolean pr_function_parameter
+static bfd_boolean pr_start_function
+  PARAMS ((PTR, const char *, bfd_boolean));
+static bfd_boolean pr_function_parameter
   PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
-static boolean pr_start_block PARAMS ((PTR, bfd_vma));
-static boolean pr_end_block PARAMS ((PTR, bfd_vma));
-static boolean pr_end_function PARAMS ((PTR));
-static boolean pr_lineno PARAMS ((PTR, const char *, unsigned long, bfd_vma));
+static bfd_boolean pr_start_block
+  PARAMS ((PTR, bfd_vma));
+static bfd_boolean pr_end_block
+  PARAMS ((PTR, bfd_vma));
+static bfd_boolean pr_end_function
+  PARAMS ((PTR));
+static bfd_boolean pr_lineno
+  PARAMS ((PTR, const char *, unsigned long, bfd_vma));
 
 static const struct debug_write_fns pr_fns =
 {
@@ -179,7 +219,7 @@ static const struct debug_write_fns pr_fns =
 
 /* Print out the generic debugging information recorded in dhandle.  */
 
-boolean
+bfd_boolean
 print_debugging_info (f, dhandle)
      FILE *f;
      PTR dhandle;
@@ -208,7 +248,7 @@ indent (info)
 
 /* Push a type on the type stack.  */
 
-static boolean
+static bfd_boolean
 push_type (info, type)
      struct pr_handle *info;
      const char *type;
@@ -216,7 +256,7 @@ push_type (info, type)
   struct pr_stack *n;
 
   if (type == NULL)
-    return false;
+    return FALSE;
 
   n = (struct pr_stack *) xmalloc (sizeof *n);
   memset (n, 0, sizeof *n);
@@ -227,12 +267,12 @@ push_type (info, type)
   n->next = info->stack;
   info->stack = n;
 
-  return true;
+  return TRUE;
 }
 
 /* Prepend a string onto the type on the top of the type stack.  */
 
-static boolean
+static bfd_boolean
 prepend_type (info, s)
      struct pr_handle *info;
      const char *s;
@@ -246,12 +286,12 @@ prepend_type (info, s)
   free (info->stack->type);
   info->stack->type = n;
 
-  return true;
+  return TRUE;
 }
 
 /* Append a string to the type on the top of the type stack.  */
 
-static boolean
+static bfd_boolean
 append_type (info, s)
      struct pr_handle *info;
      const char *s;
@@ -259,7 +299,7 @@ append_type (info, s)
   unsigned int len;
 
   if (s == NULL)
-    return false;
+    return FALSE;
 
   assert (info->stack != NULL);
 
@@ -268,14 +308,14 @@ append_type (info, s)
 					 len + strlen (s) + 1);
   strcpy (info->stack->type + len, s);
 
-  return true;
+  return TRUE;
 }
 
 /* We use an underscore to indicate where the name should go in a type
    string.  This function substitutes a string for the underscore.  If
    there is no underscore, the name follows the type.  */
 
-static boolean
+static bfd_boolean
 substitute_type (info, s)
      struct pr_handle *info;
      const char *s;
@@ -298,7 +338,7 @@ substitute_type (info, s)
       free (info->stack->type);
       info->stack->type = n;
 
-      return true;
+      return TRUE;
     }
 
   if (strchr (s, '|') != NULL
@@ -307,11 +347,11 @@ substitute_type (info, s)
     {
       if (! prepend_type (info, "(")
 	  || ! append_type (info, ")"))
-	return false;
+	return FALSE;
     }
 
   if (*s == '\0')
-    return true;
+    return TRUE;
 
   return (append_type (info, " ")
 	  && append_type (info, s));
@@ -319,7 +359,7 @@ substitute_type (info, s)
 
 /* Indent the type at the top of the stack by appending spaces.  */
 
-static boolean
+static bfd_boolean
 indent_type (info)
      struct pr_handle *info;
 {
@@ -328,10 +368,10 @@ indent_type (info)
   for (i = 0; i < info->indent; i++)
     {
       if (! append_type (info, " "))
-	return false;
+	return FALSE;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Pop a type from the type stack.  */
@@ -359,8 +399,8 @@ static void
 print_vma (vma, buf, unsignedp, hexp)
      bfd_vma vma;
      char *buf;
-     boolean unsignedp;
-     boolean hexp;
+     bfd_boolean unsignedp;
+     bfd_boolean hexp;
 {
   if (sizeof (vma) <= sizeof (unsigned long))
     {
@@ -381,7 +421,7 @@ print_vma (vma, buf, unsignedp, hexp)
 
 /* Start a new compilation unit.  */
 
-static boolean
+static bfd_boolean
 pr_start_compilation_unit (p, filename)
      PTR p;
      const char *filename;
@@ -392,12 +432,12 @@ pr_start_compilation_unit (p, filename)
 
   fprintf (info->f, "%s:\n", filename);
 
-  return true;
+  return TRUE;
 }
 
 /* Start a source file within a compilation unit.  */
 
-static boolean
+static bfd_boolean
 pr_start_source (p, filename)
      PTR p;
      const char *filename;
@@ -408,12 +448,12 @@ pr_start_source (p, filename)
 
   fprintf (info->f, " %s:\n", filename);
 
-  return true;
+  return TRUE;
 }
 
 /* Push an empty type onto the type stack.  */
 
-static boolean
+static bfd_boolean
 pr_empty_type (p)
      PTR p;
 {
@@ -424,7 +464,7 @@ pr_empty_type (p)
 
 /* Push a void type onto the type stack.  */
 
-static boolean
+static bfd_boolean
 pr_void_type (p)
      PTR p;
 {
@@ -435,11 +475,11 @@ pr_void_type (p)
 
 /* Push an integer type onto the type stack.  */
 
-static boolean
+static bfd_boolean
 pr_int_type (p, size, unsignedp)
      PTR p;
      unsigned int size;
-     boolean unsignedp;
+     bfd_boolean unsignedp;
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char ab[10];
@@ -450,7 +490,7 @@ pr_int_type (p, size, unsignedp)
 
 /* Push a floating type onto the type stack.  */
 
-static boolean
+static bfd_boolean
 pr_float_type (p, size)
      PTR p;
      unsigned int size;
@@ -469,7 +509,7 @@ pr_float_type (p, size)
 
 /* Push a complex type onto the type stack.  */
 
-static boolean
+static bfd_boolean
 pr_complex_type (p, size)
      PTR p;
      unsigned int size;
@@ -477,14 +517,14 @@ pr_complex_type (p, size)
   struct pr_handle *info = (struct pr_handle *) p;
 
   if (! pr_float_type (p, size))
-    return false;
+    return FALSE;
 
   return prepend_type (info, "complex ");
 }
 
-/* Push a boolean type onto the type stack.  */
+/* Push a bfd_boolean type onto the type stack.  */
 
-static boolean
+static bfd_boolean
 pr_bool_type (p, size)
      PTR p;
      unsigned int size;
@@ -499,7 +539,7 @@ pr_bool_type (p, size)
 
 /* Push an enum type onto the type stack.  */
 
-static boolean
+static bfd_boolean
 pr_enum_type (p, tag, names, values)
      PTR p;
      const char *tag;
@@ -511,20 +551,20 @@ pr_enum_type (p, tag, names, values)
   bfd_signed_vma val;
 
   if (! push_type (info, "enum "))
-    return false;
+    return FALSE;
   if (tag != NULL)
     {
       if (! append_type (info, tag)
 	  || ! append_type (info, " "))
-	return false;
+	return FALSE;
     }
   if (! append_type (info, "{ "))
-    return false;
+    return FALSE;
 
   if (names == NULL)
     {
       if (! append_type (info, "/* undefined */"))
-	return false;
+	return FALSE;
     }
   else
     {
@@ -534,20 +574,20 @@ pr_enum_type (p, tag, names, values)
 	  if (i > 0)
 	    {
 	      if (! append_type (info, ", "))
-		return false;
+		return FALSE;
 	    }
 
 	  if (! append_type (info, names[i]))
-	    return false;
+	    return FALSE;
 
 	  if (values[i] != val)
 	    {
 	      char ab[20];
 
-	      print_vma (values[i], ab, false, false);
+	      print_vma (values[i], ab, FALSE, FALSE);
 	      if (! append_type (info, " = ")
 		  || ! append_type (info, ab))
-		return false;
+		return FALSE;
 	      val = values[i];
 	    }
 
@@ -560,7 +600,7 @@ pr_enum_type (p, tag, names, values)
 
 /* Turn the top type on the stack into a pointer.  */
 
-static boolean
+static bfd_boolean
 pr_pointer_type (p)
      PTR p;
 {
@@ -577,11 +617,11 @@ pr_pointer_type (p)
 
 /* Turn the top type on the stack into a function returning that type.  */
 
-static boolean
+static bfd_boolean
 pr_function_type (p, argcount, varargs)
      PTR p;
      int argcount;
-     boolean varargs;
+     bfd_boolean varargs;
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char **arg_types;
@@ -605,10 +645,10 @@ pr_function_type (p, argcount, varargs)
       for (i = argcount - 1; i >= 0; i--)
 	{
 	  if (! substitute_type (info, ""))
-	    return false;
+	    return FALSE;
 	  arg_types[i] = pop_type (info);
 	  if (arg_types[i] == NULL)
-	    return false;
+	    return FALSE;
 	  len += strlen (arg_types[i]) + 2;
 	}
       if (varargs)
@@ -645,16 +685,16 @@ pr_function_type (p, argcount, varargs)
   strcat (s, ")");
 
   if (! substitute_type (info, s))
-    return false;
+    return FALSE;
 
   free (s);
 
-  return true;
+  return TRUE;
 }
 
 /* Turn the top type on the stack into a reference to that type.  */
 
-static boolean
+static bfd_boolean
 pr_reference_type (p)
      PTR p;
 {
@@ -667,7 +707,7 @@ pr_reference_type (p)
 
 /* Make a range type.  */
 
-static boolean
+static bfd_boolean
 pr_range_type (p, lower, upper)
      PTR p;
      bfd_signed_vma lower;
@@ -679,10 +719,10 @@ pr_range_type (p, lower, upper)
   assert (info->stack != NULL);
 
   if (! substitute_type (info, ""))
-    return false;
+    return FALSE;
 
-  print_vma (lower, abl, false, false);
-  print_vma (upper, abu, false, false);
+  print_vma (lower, abl, FALSE, FALSE);
+  print_vma (upper, abu, FALSE, FALSE);
 
   return (prepend_type (info, "range (")
 	  && append_type (info, "):")
@@ -693,12 +733,12 @@ pr_range_type (p, lower, upper)
 
 /* Make an array type.  */
 
-static boolean
+static bfd_boolean
 pr_array_type (p, lower, upper, stringp)
      PTR p;
      bfd_signed_vma lower;
      bfd_signed_vma upper;
-     boolean stringp;
+     bfd_boolean stringp;
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *range_type;
@@ -706,7 +746,7 @@ pr_array_type (p, lower, upper, stringp)
 
   range_type = pop_type (info);
   if (range_type == NULL)
-    return false;
+    return FALSE;
 
   if (lower == 0)
     {
@@ -714,64 +754,64 @@ pr_array_type (p, lower, upper, stringp)
 	sprintf (ab, "|[]");
       else
 	{
-	  print_vma (upper + 1, abu, false, false);
+	  print_vma (upper + 1, abu, FALSE, FALSE);
 	  sprintf (ab, "|[%s]", abu);
 	}
     }
   else
     {
-      print_vma (lower, abl, false, false);
-      print_vma (upper, abu, false, false);
+      print_vma (lower, abl, FALSE, FALSE);
+      print_vma (upper, abu, FALSE, FALSE);
       sprintf (ab, "|[%s:%s]", abl, abu);
     }
 
   if (! substitute_type (info, ab))
-    return false;
+    return FALSE;
 
   if (strcmp (range_type, "int") != 0)
     {
       if (! append_type (info, ":")
 	  || ! append_type (info, range_type))
-	return false;
+	return FALSE;
     }
 
   if (stringp)
     {
       if (! append_type (info, " /* string */"))
-	return false;
+	return FALSE;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Make a set type.  */
 
-static boolean
+static bfd_boolean
 pr_set_type (p, bitstringp)
      PTR p;
-     boolean bitstringp;
+     bfd_boolean bitstringp;
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
   if (! substitute_type (info, ""))
-    return false;
+    return FALSE;
 
   if (! prepend_type (info, "set { ")
       || ! append_type (info, " }"))
-    return false;
+    return FALSE;
 
   if (bitstringp)
     {
       if (! append_type (info, "/* bitstring */"))
-	return false;
+	return FALSE;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Make an offset type.  */
 
-static boolean
+static bfd_boolean
 pr_offset_type (p)
      PTR p;
 {
@@ -779,11 +819,11 @@ pr_offset_type (p)
   char *t;
 
   if (! substitute_type (info, ""))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   return (substitute_type (info, "")
 	  && prepend_type (info, " ")
@@ -793,12 +833,12 @@ pr_offset_type (p)
 
 /* Make a method type.  */
 
-static boolean
+static bfd_boolean
 pr_method_type (p, domain, argcount, varargs)
      PTR p;
-     boolean domain;
+     bfd_boolean domain;
      int argcount;
-     boolean varargs;
+     bfd_boolean varargs;
 {
   struct pr_handle *info = (struct pr_handle *) p;
   unsigned int len;
@@ -813,10 +853,10 @@ pr_method_type (p, domain, argcount, varargs)
   else
     {
       if (! substitute_type (info, ""))
-	return false;
+	return FALSE;
       domain_type = pop_type (info);
       if (domain_type == NULL)
-	return false;
+	return FALSE;
       if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0
 	  && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
 	domain_type += sizeof "class " - 1;
@@ -841,10 +881,10 @@ pr_method_type (p, domain, argcount, varargs)
       for (i = argcount - 1; i >= 0; i--)
 	{
 	  if (! substitute_type (info, ""))
-	    return false;
+	    return FALSE;
 	  arg_types[i] = pop_type (info);
 	  if (arg_types[i] == NULL)
-	    return false;
+	    return FALSE;
 	  len += strlen (arg_types[i]) + 2;
 	}
       if (varargs)
@@ -885,16 +925,16 @@ pr_method_type (p, domain, argcount, varargs)
   strcat (s, ")");
 
   if (! substitute_type (info, s))
-    return false;
+    return FALSE;
 
   free (s);
 
-  return true;
+  return TRUE;
 }
 
 /* Make a const qualified type.  */
 
-static boolean
+static bfd_boolean
 pr_const_type (p)
      PTR p;
 {
@@ -905,7 +945,7 @@ pr_const_type (p)
 
 /* Make a volatile qualified type.  */
 
-static boolean
+static bfd_boolean
 pr_volatile_type (p)
      PTR p;
 {
@@ -916,12 +956,12 @@ pr_volatile_type (p)
 
 /* Start accumulating a struct type.  */
 
-static boolean
+static bfd_boolean
 pr_start_struct_type (p, tag, id, structp, size)
      PTR p;
      const char *tag;
      unsigned int id;
-     boolean structp;
+     bfd_boolean structp;
      unsigned int size;
 {
   struct pr_handle *info = (struct pr_handle *) p;
@@ -929,11 +969,11 @@ pr_start_struct_type (p, tag, id, structp, size)
   info->indent += 2;
 
   if (! push_type (info, structp ? "struct " : "union "))
-    return false;
+    return FALSE;
   if (tag != NULL)
     {
       if (! append_type (info, tag))
-	return false;
+	return FALSE;
     }
   else
     {
@@ -941,35 +981,35 @@ pr_start_struct_type (p, tag, id, structp, size)
 
       sprintf (idbuf, "%%anon%u", id);
       if (! append_type (info, idbuf))
-	return false;
+	return FALSE;
     }
 
   if (! append_type (info, " {"))
-    return false;
+    return FALSE;
   if (size != 0 || tag != NULL)
     {
       char ab[30];
 
       if (! append_type (info, " /*"))
-	return false;
+	return FALSE;
 
       if (size != 0)
 	{
 	  sprintf (ab, " size %u", size);
 	  if (! append_type (info, ab))
-	    return false;
+	    return FALSE;
 	}
       if (tag != NULL)
 	{
 	  sprintf (ab, " id %u", id);
 	  if (! append_type (info, ab))
-	    return false;
+	    return FALSE;
 	}
       if (! append_type (info, " */"))
-	return false;
+	return FALSE;
     }
   if (! append_type (info, "\n"))
-    return false;
+    return FALSE;
 
   info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
 
@@ -978,7 +1018,7 @@ pr_start_struct_type (p, tag, id, structp, size)
 
 /* Output the visibility of a field in a struct.  */
 
-static boolean
+static bfd_boolean
 pr_fix_visibility (info, visibility)
      struct pr_handle *info;
      enum debug_visibility visibility;
@@ -990,7 +1030,7 @@ pr_fix_visibility (info, visibility)
   assert (info->stack != NULL);
 
   if (info->stack->visibility == visibility)
-    return true;
+    return TRUE;
 
   switch (visibility)
     {
@@ -1008,7 +1048,7 @@ pr_fix_visibility (info, visibility)
       break;
     default:
       abort ();
-      return false;
+      return FALSE;
     }
 
   /* Trim off a trailing space in the struct string, to make the
@@ -1022,16 +1062,16 @@ pr_fix_visibility (info, visibility)
   if (! append_type (info, s)
       || ! append_type (info, ":\n")
       || ! indent_type (info))
-    return false;
+    return FALSE;
 
   info->stack->visibility = visibility;
 
-  return true;
+  return TRUE;
 }
 
 /* Add a field to a struct type.  */
 
-static boolean
+static bfd_boolean
 pr_struct_field (p, name, bitpos, bitsize, visibility)
      PTR p;
      const char *name;
@@ -1044,40 +1084,40 @@ pr_struct_field (p, name, bitpos, bitsize, visibility)
   char *t;
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   if (! append_type (info, "; /* "))
-    return false;
+    return FALSE;
 
   if (bitsize != 0)
     {
-      print_vma (bitsize, ab, true, false);
+      print_vma (bitsize, ab, TRUE, FALSE);
       if (! append_type (info, "bitsize ")
 	  || ! append_type (info, ab)
 	  || ! append_type (info, ", "))
-	return false;
+	return FALSE;
     }
 
-  print_vma (bitpos, ab, true, false);
+  print_vma (bitpos, ab, TRUE, FALSE);
   if (! append_type (info, "bitpos ")
       || ! append_type (info, ab)
       || ! append_type (info, " */\n")
       || ! indent_type (info))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   if (! pr_fix_visibility (info, visibility))
-    return false;
+    return FALSE;
 
   return append_type (info, t);
 }
 
 /* Finish a struct type.  */
 
-static boolean
+static bfd_boolean
 pr_end_struct_type (p)
      PTR p;
 {
@@ -1096,20 +1136,20 @@ pr_end_struct_type (p)
   *s++ = '}';
   *s = '\0';
 
-  return true;
+  return TRUE;
 }
 
 /* Start a class type.  */
 
-static boolean
+static bfd_boolean
 pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
      PTR p;
      const char *tag;
      unsigned int id;
-     boolean structp;
+     bfd_boolean structp;
      unsigned int size;
-     boolean vptr;
-     boolean ownvptr;
+     bfd_boolean vptr;
+     bfd_boolean ownvptr;
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *tv = NULL;
@@ -1120,15 +1160,15 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
     {
       tv = pop_type (info);
       if (tv == NULL)
-	return false;
+	return FALSE;
     }
 
   if (! push_type (info, structp ? "class " : "union class "))
-    return false;
+    return FALSE;
   if (tag != NULL)
     {
       if (! append_type (info, tag))
-	return false;
+	return FALSE;
     }
   else
     {
@@ -1136,15 +1176,15 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
 
       sprintf (idbuf, "%%anon%u", id);
       if (! append_type (info, idbuf))
-	return false;
+	return FALSE;
     }
 
   if (! append_type (info, " {"))
-    return false;
+    return FALSE;
   if (size != 0 || vptr || ownvptr || tag != NULL)
     {
       if (! append_type (info, " /*"))
-	return false;
+	return FALSE;
 
       if (size != 0)
 	{
@@ -1153,23 +1193,23 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
 	  sprintf (ab, "%u", size);
 	  if (! append_type (info, " size ")
 	      || ! append_type (info, ab))
-	    return false;
+	    return FALSE;
 	}
 
       if (vptr)
 	{
 	  if (! append_type (info, " vtable "))
-	    return false;
+	    return FALSE;
 	  if (ownvptr)
 	    {
 	      if (! append_type (info, "self "))
-		return false;
+		return FALSE;
 	    }
 	  else
 	    {
 	      if (! append_type (info, tv)
 		  || ! append_type (info, " "))
-		return false;
+		return FALSE;
 	    }
 	}
 
@@ -1179,11 +1219,11 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
 
 	  sprintf (ab, " id %u", id);
 	  if (! append_type (info, ab))
-	    return false;
+	    return FALSE;
 	}
 
       if (! append_type (info, " */"))
-	return false;
+	return FALSE;
     }
 
   info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
@@ -1194,7 +1234,7 @@ pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
 
 /* Add a static member to a class.  */
 
-static boolean
+static bfd_boolean
 pr_class_static_member (p, name, physname, visibility)
      PTR p;
      const char *name;
@@ -1205,32 +1245,32 @@ pr_class_static_member (p, name, physname, visibility)
   char *t;
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   if (! prepend_type (info, "static ")
       || ! append_type (info, "; /* ")
       || ! append_type (info, physname)
       || ! append_type (info, " */\n")
       || ! indent_type (info))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   if (! pr_fix_visibility (info, visibility))
-    return false;
+    return FALSE;
 
   return append_type (info, t);
 }
 
 /* Add a base class to a class.  */
 
-static boolean
+static bfd_boolean
 pr_class_baseclass (p, bitpos, virtual, visibility)
      PTR p;
      bfd_vma bitpos;
-     boolean virtual;
+     bfd_boolean virtual;
      enum debug_visibility visibility;
 {
   struct pr_handle *info = (struct pr_handle *) p;
@@ -1242,11 +1282,11 @@ pr_class_baseclass (p, bitpos, virtual, visibility)
   assert (info->stack != NULL && info->stack->next != NULL);
 
   if (! substitute_type (info, ""))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   if (strncmp (t, "class ", sizeof "class " - 1) == 0)
     t += sizeof "class " - 1;
@@ -1254,12 +1294,12 @@ pr_class_baseclass (p, bitpos, virtual, visibility)
   /* Push it back on to take advantage of the prepend_type and
      append_type routines.  */
   if (! push_type (info, t))
-    return false;
+    return FALSE;
 
   if (virtual)
     {
       if (! prepend_type (info, "virtual "))
-	return false;
+	return FALSE;
     }
 
   switch (visibility)
@@ -1279,15 +1319,15 @@ pr_class_baseclass (p, bitpos, virtual, visibility)
     }
 
   if (! prepend_type (info, prefix))
-    return false;
+    return FALSE;
 
   if (bitpos != 0)
     {
-      print_vma (bitpos, ab, true, false);
+      print_vma (bitpos, ab, TRUE, FALSE);
       if (! append_type (info, " /* bitpos ")
 	  || ! append_type (info, ab)
 	  || ! append_type (info, " */"))
-	return false;
+	return FALSE;
     }
 
   /* Now the top of the stack is something like "public A / * bitpos
@@ -1304,11 +1344,11 @@ pr_class_baseclass (p, bitpos, virtual, visibility)
     if (*l == ':')
       break;
   if (! prepend_type (info, l == s ? " : " : ", "))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
   memcpy (n, info->stack->type, s - info->stack->type);
@@ -1320,12 +1360,12 @@ pr_class_baseclass (p, bitpos, virtual, visibility)
 
   free (t);
 
-  return true;
+  return TRUE;
 }
 
 /* Start adding a method to a class.  */
 
-static boolean
+static bfd_boolean
 pr_class_start_method (p, name)
      PTR p;
      const char *name;
@@ -1334,21 +1374,21 @@ pr_class_start_method (p, name)
 
   assert (info->stack != NULL);
   info->stack->method = name;
-  return true;
+  return TRUE;
 }
 
 /* Add a variant to a method.  */
 
-static boolean
+static bfd_boolean
 pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
 			 context)
      PTR p;
      const char *physname;
      enum debug_visibility visibility;
-     boolean constp;
-     boolean volatilep;
+     bfd_boolean constp;
+     bfd_boolean volatilep;
      bfd_vma voffset;
-     boolean context;
+     bfd_boolean context;
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *method_type;
@@ -1361,12 +1401,12 @@ pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
   if (volatilep)
     {
       if (! append_type (info, " volatile"))
-	return false;
+	return FALSE;
     }
   if (constp)
     {
       if (! append_type (info, " const"))
-	return false;
+	return FALSE;
     }
 
   /* Stick the name of the method into its type.  */
@@ -1374,12 +1414,12 @@ pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
 			 (context
 			  ? info->stack->next->next->method
 			  : info->stack->next->method)))
-    return false;
+    return FALSE;
 
   /* Get the type.  */
   method_type = pop_type (info);
   if (method_type == NULL)
-    return false;
+    return FALSE;
 
   /* Pull off the context type if there is one.  */
   if (! context)
@@ -1388,19 +1428,19 @@ pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
     {
       context_type = pop_type (info);
       if (context_type == NULL)
-	return false;
+	return FALSE;
     }
 
   /* Now the top of the stack is the class.  */
 
   if (! pr_fix_visibility (info, visibility))
-    return false;
+    return FALSE;
 
   if (! append_type (info, method_type)
       || ! append_type (info, " /* ")
       || ! append_type (info, physname)
       || ! append_type (info, " "))
-    return false;
+    return FALSE;
   if (context || voffset != 0)
     {
       char ab[20];
@@ -1410,12 +1450,12 @@ pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
 	  if (! append_type (info, "context ")
 	      || ! append_type (info, context_type)
 	      || ! append_type (info, " "))
-	    return false;
+	    return FALSE;
 	}
-      print_vma (voffset, ab, true, false);
+      print_vma (voffset, ab, TRUE, FALSE);
       if (! append_type (info, "voffset ")
 	  || ! append_type (info, ab))
-	return false;
+	return FALSE;
     }
 
   return (append_type (info, " */;\n")
@@ -1424,13 +1464,13 @@ pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
 
 /* Add a static variant to a method.  */
 
-static boolean
+static bfd_boolean
 pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
      PTR p;
      const char *physname;
      enum debug_visibility visibility;
-     boolean constp;
-     boolean volatilep;
+     bfd_boolean constp;
+     bfd_boolean volatilep;
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *method_type;
@@ -1443,31 +1483,31 @@ pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
   if (volatilep)
     {
       if (! append_type (info, " volatile"))
-	return false;
+	return FALSE;
     }
   if (constp)
     {
       if (! append_type (info, " const"))
-	return false;
+	return FALSE;
     }
 
   /* Mark it as static.  */
   if (! prepend_type (info, "static "))
-    return false;
+    return FALSE;
 
   /* Stick the name of the method into its type.  */
   if (! substitute_type (info, info->stack->next->method))
-    return false;
+    return FALSE;
 
   /* Get the type.  */
   method_type = pop_type (info);
   if (method_type == NULL)
-    return false;
+    return FALSE;
 
   /* Now the top of the stack is the class.  */
 
   if (! pr_fix_visibility (info, visibility))
-    return false;
+    return FALSE;
 
   return (append_type (info, method_type)
 	  && append_type (info, " /* ")
@@ -1478,19 +1518,19 @@ pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
 
 /* Finish up a method.  */
 
-static boolean
+static bfd_boolean
 pr_class_end_method (p)
      PTR p;
 {
   struct pr_handle *info = (struct pr_handle *) p;
 
   info->stack->method = NULL;
-  return true;
+  return TRUE;
 }
 
 /* Finish up a class.  */
 
-static boolean
+static bfd_boolean
 pr_end_class_type (p)
      PTR p;
 {
@@ -1499,7 +1539,7 @@ pr_end_class_type (p)
 
 /* Push a type on the stack using a typedef name.  */
 
-static boolean
+static bfd_boolean
 pr_typedef_type (p, name)
      PTR p;
      const char *name;
@@ -1511,7 +1551,7 @@ pr_typedef_type (p, name)
 
 /* Push a type on the stack using a tag name.  */
 
-static boolean
+static bfd_boolean
 pr_tag_type (p, name, id, kind)
      PTR p;
      const char *name;
@@ -1541,11 +1581,11 @@ pr_tag_type (p, name, id, kind)
       break;
     default:
       abort ();
-      return false;
+      return FALSE;
     }
 
   if (! push_type (info, t))
-    return false;
+    return FALSE;
   if (name != NULL)
     tag = name;
   else
@@ -1555,20 +1595,20 @@ pr_tag_type (p, name, id, kind)
     }
 
   if (! append_type (info, tag))
-    return false;
+    return FALSE;
   if (name != NULL && kind != DEBUG_KIND_ENUM)
     {
       sprintf (idbuf, " /* id %u */", id);
       if (! append_type (info, idbuf))
-	return false;
+	return FALSE;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* Output a typedef.  */
 
-static boolean
+static bfd_boolean
 pr_typdef (p, name)
      PTR p;
      const char *name;
@@ -1577,24 +1617,24 @@ pr_typdef (p, name)
   char *s;
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   s = pop_type (info);
   if (s == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
   fprintf (info->f, "typedef %s;\n", s);
 
   free (s);
 
-  return true;
+  return TRUE;
 }
 
 /* Output a tag.  The tag should already be in the string on the
    stack, so all we have to do here is print it out.  */
 
-static boolean
+static bfd_boolean
 pr_tag (p, name)
      PTR p;
      const char *name ATTRIBUTE_UNUSED;
@@ -1604,19 +1644,19 @@ pr_tag (p, name)
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
   fprintf (info->f, "%s;\n", t);
 
   free (t);
 
-  return true;
+  return TRUE;
 }
 
 /* Output an integer constant.  */
 
-static boolean
+static bfd_boolean
 pr_int_constant (p, name, val)
      PTR p;
      const char *name;
@@ -1626,14 +1666,14 @@ pr_int_constant (p, name, val)
   char ab[20];
 
   indent (info);
-  print_vma (val, ab, false, false);
+  print_vma (val, ab, FALSE, FALSE);
   fprintf (info->f, "const int %s = %s;\n", name, ab);
-  return true;
+  return TRUE;
 }
 
 /* Output a floating point constant.  */
 
-static boolean
+static bfd_boolean
 pr_float_constant (p, name, val)
      PTR p;
      const char *name;
@@ -1643,12 +1683,12 @@ pr_float_constant (p, name, val)
 
   indent (info);
   fprintf (info->f, "const double %s = %g;\n", name, val);
-  return true;
+  return TRUE;
 }
 
 /* Output a typed constant.  */
 
-static boolean
+static bfd_boolean
 pr_typed_constant (p, name, val)
      PTR p;
      const char *name;
@@ -1660,20 +1700,20 @@ pr_typed_constant (p, name, val)
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
-  print_vma (val, ab, false, false);
+  print_vma (val, ab, FALSE, FALSE);
   fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
 
   free (t);
 
-  return true;
+  return TRUE;
 }
 
 /* Output a variable.  */
 
-static boolean
+static bfd_boolean
 pr_variable (p, name, kind, val)
      PTR p;
      const char *name;
@@ -1685,11 +1725,11 @@ pr_variable (p, name, kind, val)
   char ab[20];
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
   switch (kind)
@@ -1704,31 +1744,31 @@ pr_variable (p, name, kind, val)
     default:
       break;
     }
-  print_vma (val, ab, true, true);
+  print_vma (val, ab, TRUE, TRUE);
   fprintf (info->f, "%s /* %s */;\n", t, ab);
 
   free (t);
 
-  return true;
+  return TRUE;
 }
 
 /* Start outputting a function.  */
 
-static boolean
+static bfd_boolean
 pr_start_function (p, name, global)
      PTR p;
      const char *name;
-     boolean global;
+     bfd_boolean global;
 {
   struct pr_handle *info = (struct pr_handle *) p;
   char *t;
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   indent (info);
   if (! global)
@@ -1737,12 +1777,12 @@ pr_start_function (p, name, global)
 
   info->parameter = 1;
 
-  return true;
+  return TRUE;
 }
 
 /* Output a function parameter.  */
 
-static boolean
+static bfd_boolean
 pr_function_parameter (p, name, kind, val)
      PTR p;
      const char *name;
@@ -1757,15 +1797,15 @@ pr_function_parameter (p, name, kind, val)
       || kind == DEBUG_PARM_REF_REG)
     {
       if (! pr_reference_type (p))
-	return false;
+	return FALSE;
     }
 
   if (! substitute_type (info, name))
-    return false;
+    return FALSE;
 
   t = pop_type (info);
   if (t == NULL)
-    return false;
+    return FALSE;
 
   if (info->parameter != 1)
     fprintf (info->f, ", ");
@@ -1773,19 +1813,19 @@ pr_function_parameter (p, name, kind, val)
   if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
     fprintf (info->f, "register ");
 
-  print_vma (val, ab, true, true);
+  print_vma (val, ab, TRUE, TRUE);
   fprintf (info->f, "%s /* %s */", t, ab);
 
   free (t);
 
   ++info->parameter;
 
-  return true;
+  return TRUE;
 }
 
 /* Start writing out a block.  */
 
-static boolean
+static bfd_boolean
 pr_start_block (p, addr)
      PTR p;
      bfd_vma addr;
@@ -1800,17 +1840,17 @@ pr_start_block (p, addr)
     }
 
   indent (info);
-  print_vma (addr, ab, true, true);
+  print_vma (addr, ab, TRUE, TRUE);
   fprintf (info->f, "{ /* %s */\n", ab);
 
   info->indent += 2;
 
-  return true;
+  return TRUE;
 }
 
 /* Write out line number information.  */
 
-static boolean
+static bfd_boolean
 pr_lineno (p, filename, lineno, addr)
      PTR p;
      const char *filename;
@@ -1821,15 +1861,15 @@ pr_lineno (p, filename, lineno, addr)
   char ab[20];
 
   indent (info);
-  print_vma (addr, ab, true, true);
+  print_vma (addr, ab, TRUE, TRUE);
   fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
 
-  return true;
+  return TRUE;
 }
 
 /* Finish writing out a block.  */
 
-static boolean
+static bfd_boolean
 pr_end_block (p, addr)
      PTR p;
      bfd_vma addr;
@@ -1840,17 +1880,17 @@ pr_end_block (p, addr)
   info->indent -= 2;
 
   indent (info);
-  print_vma (addr, ab, true, true);
+  print_vma (addr, ab, TRUE, TRUE);
   fprintf (info->f, "} /* %s */\n", ab);
 
-  return true;
+  return TRUE;
 }
 
 /* Finish writing out a function.  */
 
-static boolean
+static bfd_boolean
 pr_end_function (p)
      PTR p ATTRIBUTE_UNUSED;
 {
-  return true;
+  return TRUE;
 }