* stabsread.c: Remove all uses of error(). Make error_type and

	read_type_number static.
	(define_symbol): Don't try to deal with a missing symbol
	descriptor which isn't followed by digit, '(', or '-'.
	* stabsread.h: Don't declare read_type_number here.
	* gdbtypes.h: Don't declare error_type here.
	* xcoffread.c: Remove NO_TYPEDEFS code.

5 files changed, 238 insertions, 242 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index d0f18ee..7a38126 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,13 @@
+Tue May 25 13:06:28 1993  Jim Kingdon  (kingdon@lioth.cygnus.com)
+
+	* stabsread.c: Remove all uses of error().  Make error_type and
+	read_type_number static.
+	(define_symbol): Don't try to deal with a missing symbol
+	descriptor which isn't followed by digit, '(', or '-'.
+	* stabsread.h: Don't declare read_type_number here.
+	* gdbtypes.h: Don't declare error_type here.
+	* xcoffread.c: Remove NO_TYPEDEFS code.
+
 Tue May 25 09:33:16 1993  Ian Lance Taylor  (ian@cygnus.com)
 
 	* mips-tdep.c: Removed #include of many header files, and #define
@@ -7,7 +17,7 @@ Tue May 25 09:36:13 1993  Jim Kingdon  (kingdon@lioth.cygnus.com)
 
 	* Many places: replace "the inferior" in messages with "the program"
 	or "the program being debugged".
-	* inflow.c (try_writing_regs): Revove; it's been #if 0'd forever
+	* inflow.c (try_writing_regs): Remove; it's been #if 0'd forever
 	and I'm getting sick of maintaining it.
 
 	* config/i386/linux.mh: Don't use \ newline; the awk scripts don't
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index e242530..667a8f5 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -635,9 +635,6 @@ extern struct type *
 builtin_type PARAMS ((char **));
 
 extern struct type *
-error_type PARAMS ((char **));
-
-extern struct type *
 lookup_typename PARAMS ((char *, struct block *, int));
 
 extern struct type *
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index 6260786..bd02dd6 100644
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -65,8 +65,9 @@ struct field_info
 static struct type *
 dbx_alloc_type PARAMS ((int [2], struct objfile *));
 
-static void
-read_huge_number PARAMS ((char **, int, long *, int *));
+static long read_huge_number PARAMS ((char **, int, int *));
+
+static struct type *error_type PARAMS ((char **));
 
 static void
 patch_block_stabs PARAMS ((struct pending *, struct pending_stabs *,
@@ -75,6 +76,9 @@ patch_block_stabs PARAMS ((struct pending *, struct pending_stabs *,
 static void
 fix_common_block PARAMS ((struct symbol *, int));
 
+static int
+read_type_number PARAMS ((char **, int *));
+
 static struct type *
 read_range_type PARAMS ((char **, int [2], struct objfile *));
 
@@ -122,7 +126,7 @@ read_array_type PARAMS ((char **, struct type *, struct objfile *));
 static struct type **
 read_args PARAMS ((char **, int, struct objfile *));
 
-static void
+static int
 read_cpp_abbrev PARAMS ((struct field_info *, char **, struct type *,
 			 struct objfile *));
 
@@ -256,8 +260,13 @@ dbx_lookup_type (typenums)
     return 0;
 
   if (filenum < 0 || filenum >= n_this_object_header_files)
-    error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
-	   filenum, index, symnum);
+    {
+      static struct complaint msg = {"\
+Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
+				0, 0};
+      complain (&msg, filenum, index, symnum);
+      goto error_return;
+    }
 
   if (filenum == 0)
     {
@@ -303,7 +312,16 @@ dbx_lookup_type (typenums)
 
       if (real_filenum >= n_header_files)
 	{
-	  abort ();
+	  struct type *temp_type;
+	  struct type **temp_type_p;
+
+	  warning ("GDB internal error: bad real_filenum");
+
+	error_return:
+	  temp_type = init_type (TYPE_CODE_ERROR, 0, 0, NULL, NULL);
+	  temp_type_p = (struct type **) xmalloc (sizeof (struct type *));
+	  *temp_type_p = temp_type;
+	  return temp_type_p;
 	}
 
       f = &header_files[real_filenum];
@@ -431,24 +449,31 @@ patch_block_stabs (symbols, stabs, objfile)
    or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
    Just a single number N is equivalent to (0,N).
    Return the two numbers by storing them in the vector TYPENUMS.
-   TYPENUMS will then be used as an argument to dbx_lookup_type.  */
+   TYPENUMS will then be used as an argument to dbx_lookup_type.
 
-void
+   Returns 0 for success, -1 for error.  */
+
+static int
 read_type_number (pp, typenums)
      register char **pp;
      register int *typenums;
 {
+  int nbits;
   if (**pp == '(')
     {
       (*pp)++;
-      typenums[0] = read_number (pp, ',');
-      typenums[1] = read_number (pp, ')');
+      typenums[0] = read_huge_number (pp, ',', &nbits);
+      if (nbits != 0) return -1;
+      typenums[1] = read_huge_number (pp, ')', &nbits);
+      if (nbits != 0) return -1;
     }
   else
     {
       typenums[0] = 0;
-      typenums[1] = read_number (pp, 0);
+      typenums[1] = read_huge_number (pp, 0, &nbits);
+      if (nbits != 0) return -1;
     }
+  return 0;
 }
 
 
@@ -566,10 +591,18 @@ define_symbol (valu, string, desc, type, objfile)
   p++;
 
   /* Determine the type of name being defined.  */
+#if 0
+  /* Getting GDB to correctly skip the symbol on an undefined symbol
+     descriptor and not ever dump core is a very dodgy proposition if
+     we do things this way.  I say the acorn RISC machine can just
+     fix their compiler.  */
   /* The Acorn RISC machine's compiler can put out locals that don't
      start with "234=" or "(3,4)=", so assume anything other than the
      deftypes we know how to handle is a local.  */
   if (!strchr ("cfFGpPrStTvVXCR", *p))
+#else
+  if (isdigit (*p) || *p == '(' || *p == '-')
+#endif
     deftype = 'l';
   else
     deftype = *p++;
@@ -582,8 +615,15 @@ define_symbol (valu, string, desc, type, objfile)
 	(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
   if (deftype == 'c')
     {
-      if (*p++ != '=')
-	error ("Invalid symbol data at symtab pos %d.", symnum);
+      if (*p != '=')
+	{
+	  SYMBOL_CLASS (sym) = LOC_CONST;
+	  SYMBOL_TYPE (sym) = error_type (&p);
+	  SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+	  add_symbol_to_list (sym, &file_symbols);
+	  return sym;
+	}
+      ++p;
       switch (*p++)
 	{
 	case 'r':
@@ -1053,7 +1093,12 @@ define_symbol (valu, string, desc, type, objfile)
       break;
 
     default:
-      error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype, symnum);
+      SYMBOL_CLASS (sym) = LOC_CONST;
+      SYMBOL_VALUE (sym) = 0;
+      SYMBOL_TYPE (sym) = error_type (&p);
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &file_symbols);
+      break;
     }
 
   /* When passing structures to a function, some systems sometimes pass
@@ -1105,7 +1150,7 @@ define_symbol (valu, string, desc, type, objfile)
    can define new types and new syntaxes, and old versions of the
    debugger will be able to read the new symbol tables.  */
 
-struct type *
+static struct type *
 error_type (pp)
      char **pp;
 {
@@ -1157,7 +1202,8 @@ read_type (pp, objfile)
   if ((**pp >= '0' && **pp <= '9')
       || **pp == '(')
     {
-      read_type_number (pp, typenums);
+      if (read_type_number (pp, typenums) != 0)
+	return error_type (pp);
       
       /* Type is not being defined here.  Either it already exists,
 	 or this is a forward reference to it.  dbx_alloc_type handles
@@ -1330,13 +1376,19 @@ read_type (pp, objfile)
 	 putting out the debugging information to do that, however.  */
 
       (*pp)--;
-      read_type_number (pp, xtypenums);
-      type = *dbx_lookup_type (xtypenums);
+      if (read_type_number (pp, xtypenums) != 0)
+	return error_type (pp);
       if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
 	/* It's being defined as itself.  That means it is "void".  */
 	type = init_type (TYPE_CODE_VOID, 0, 0, NULL, objfile);
+      else
+	type = *dbx_lookup_type (xtypenums);
       if (typenums[0] != -1)
 	*dbx_lookup_type (typenums) = type;
+      /* This can happen if we had '-' followed by a garbage character,
+	 for example.  */
+      if (type == NULL)
+	return error_type (pp);
       break;
 
     /* In the following types, we must be sure to overwrite any existing
@@ -1408,9 +1460,11 @@ read_type (pp, objfile)
 	  struct type *return_type;
 	  struct type **args;
 
-	  if (*(*pp)++ != ',')
-	    error ("invalid member type data format, at symtab pos %d.",
-		   symnum);
+	  if (**pp != ',')
+	    /* Invalid member type data format.  */
+	    return error_type (pp);
+	  else
+	    ++(*pp);
 
 	  return_type = read_type (pp, objfile);
 	  args = read_args (pp, ';', objfile);
@@ -1440,7 +1494,8 @@ read_type (pp, objfile)
     case 'e':				/* Enumeration type */
       type = dbx_alloc_type (typenums, objfile);
       type = read_enum_type (pp, type, objfile);
-      *dbx_lookup_type (typenums) = type;
+      if (typenums[0] != -1)
+	*dbx_lookup_type (typenums) = type;
       break;
 
     case 's':				/* Struct type */
@@ -1479,7 +1534,10 @@ read_type (pp, objfile)
     }
 
   if (type == 0)
-    abort ();
+    {
+      warning ("GDB internal error, type is NULL in stabsread.c\n");
+      return error_type (pp);
+    }
 
   return type;
 }
@@ -1649,7 +1707,9 @@ rs6000_builtin_type (typenum)
 
    For the case of overloaded operators, the format is op$::*.funcs, where
    $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
-   name (such as `+=') and `.' marks the end of the operator name.  */
+   name (such as `+=') and `.' marks the end of the operator name.
+
+   Returns 1 for success, 0 for failure.  */
 
 static int
 read_member_functions (fip, pp, type, objfile)
@@ -1829,6 +1889,8 @@ read_member_functions (fip, pp, type, objfile)
 	  switch (*(*pp)++)
 	    {
 	      case '*':
+	      {
+		int nbits;
 	        /* virtual member function, followed by index.
 		   The sign bit is set to distinguish pointers-to-methods
 		   from virtual function indicies.  Since the array is
@@ -1837,7 +1899,9 @@ read_member_functions (fip, pp, type, objfile)
 		   the sign bit out, and usable as a valid index into
 		   the array.  Remove the sign bit here.  */
 	        new_sublist -> fn_field.voffset =
-		  (0x7fffffff & read_number (pp, ';')) + 2;
+		  (0x7fffffff & read_huge_number (pp, ';', &nbits)) + 2;
+		if (nbits != 0)
+		  return 0;
 	      
 		STABS_CONTINUE (pp);
 		if (**pp == ';' || **pp == '\0')
@@ -1870,7 +1934,7 @@ read_member_functions (fip, pp, type, objfile)
 		      }
 		  }
 		break;
-	      
+	      }
 	      case '?':
 		/* static member function.  */
 		new_sublist -> fn_field.voffset = VOFFSET_STATIC;
@@ -1935,9 +1999,11 @@ read_member_functions (fip, pp, type, objfile)
 }
 
 /* Special GNU C++ name.
-   FIXME:  Still need to properly handle parse error conditions. */
 
-static void
+   Returns 1 for success, 0 for failure.  "failure" means that we can't
+   keep parsing and it's time for error_type().  */
+
+static int
 read_cpp_abbrev (fip, pp, type, objfile)
      struct field_info *fip;
      char **pp;
@@ -1998,10 +2064,20 @@ read_cpp_abbrev (fip, pp, type, objfile)
       if (p[-1] != ':')
 	{
 	  complain (&invalid_cpp_abbrev_complaint, *pp);
+	  return 0;
 	}
       fip->list->field.type = read_type (pp, objfile);
-      (*pp)++;			/* Skip the comma.  */
-      fip->list->field.bitpos = read_number (pp, ';');
+      if (**pp == ',')
+	(*pp)++;			/* Skip the comma.  */
+      else
+	return 0;
+
+      {
+	int nbits;
+	fip->list->field.bitpos = read_huge_number (pp, ';', &nbits);
+	if (nbits != 0)
+	  return 0;
+      }
       /* This field is unpacked.  */
       fip->list->field.bitsize = 0;
       fip->list->visibility = VISIBILITY_PRIVATE;
@@ -2015,6 +2091,7 @@ read_cpp_abbrev (fip, pp, type, objfile)
     {
       complain (&invalid_cpp_abbrev_complaint, *pp);
     }
+  return 1;
 }
 
 static void
@@ -2089,11 +2166,24 @@ read_one_struct_field (fip, pp, p, type, objfile)
       complain (&stabs_general_complaint, "bad structure-type format");
       return;
     }
-  
+
   (*pp)++;			/* Skip the comma.  */
-  fip -> list -> field.bitpos = read_number (pp, ',');
-  fip -> list -> field.bitsize = read_number (pp, ';');
-  
+
+  {
+    int nbits;
+    fip -> list -> field.bitpos = read_huge_number (pp, ',', &nbits);
+    if (nbits != 0)
+      {
+	complain (&stabs_general_complaint, "bad structure-type format");
+	return;
+      }
+    fip -> list -> field.bitsize = read_huge_number (pp, ';', &nbits);
+    if (nbits != 0)
+      {
+	complain (&stabs_general_complaint, "bad structure-type format");
+	return;
+      }
+  }
 #if 0
   /* FIXME-tiemann: Can't the compiler put out something which
      lets us distinguish these? (or maybe just not put out anything
@@ -2165,7 +2255,9 @@ read_one_struct_field (fip, pp, p, type, objfile)
 	'/1'	(VISIBILITY_PROTECTED)
 	'/2'	(VISIBILITY_PUBLIC)
 
-   or nothing, for C style fields with public visibility. */
+   or nothing, for C style fields with public visibility.
+
+   Returns 1 for success, 0 for failure.  */
        
 static int
 read_struct_fields (fip, pp, type, objfile)
@@ -2199,7 +2291,8 @@ read_struct_fields (fip, pp, type, objfile)
       p = *pp;
       if (*p == CPLUS_MARKER)
 	{
-	  read_cpp_abbrev (fip, pp, type, objfile);
+	  if (!read_cpp_abbrev (fip, pp, type, objfile))
+	    return 0;
 	  continue;
 	}
 
@@ -2208,10 +2301,12 @@ read_struct_fields (fip, pp, type, objfile)
 	 functions are delimited by a pair of ':'s.  When we hit the member
 	 functions (if any), terminate scan loop and return. */
 
-      while (*p != ':') 
+      while (*p != ':' && *p != '\0') 
 	{
 	  p++;
 	}
+      if (*p == '\0')
+	return 0;
 
       /* Check to see if we have hit the member functions yet.  */
       if (p[1] == ':')
@@ -2250,7 +2345,8 @@ read_struct_fields (fip, pp, type, objfile)
 	Visibility specifiers (2) _______________________________| |  |
 	Offset in bits from start of class ________________________|  |
 	Type number of base class ____________________________________|
- */
+
+  Return 1 for success, 0 for (error-type-inducing) failure.  */
 
 static int
 read_baseclasses (fip, pp, type, objfile)
@@ -2273,7 +2369,12 @@ read_baseclasses (fip, pp, type, objfile)
     }
 
   ALLOCATE_CPLUS_STRUCT_TYPE (type);
-  TYPE_N_BASECLASSES (type) = read_number (pp, ',');
+  {
+    int nbits;
+    TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits);
+    if (nbits != 0)
+      return 0;
+  }
 
 #if 0
   /* Some stupid compilers have trouble with the following, so break
@@ -2327,20 +2428,30 @@ read_baseclasses (fip, pp, type, objfile)
 	    return 0;
 	}
 
-      /* The remaining value is the bit offset of the portion of the object
-	 corresponding to this baseclass.  Always zero in the absence of
-	 multiple inheritance.  */
+      {
+	int nbits;
+	
+	/* The remaining value is the bit offset of the portion of the object
+	   corresponding to this baseclass.  Always zero in the absence of
+	   multiple inheritance.  */
 
-      new -> field.bitpos = read_number (pp, ',');
+	new -> field.bitpos = read_huge_number (pp, ',', &nbits);
+	if (nbits != 0)
+	  return 0;
+      }
 
-      /* The last piece of baseclass information is the type of the base
-	 class.  Read it, and remember it's type name as this field's name. */
+      /* The last piece of baseclass information is the type of the
+	 base class.  Read it, and remember it's type name as this
+	 field's name. */
 
       new -> field.type = read_type (pp, objfile);
       new -> field.name = type_name_no_tag (new -> field.type);
 
       /* skip trailing ';' and bump count of number of fields seen */
-      (*pp)++;
+      if (**pp == ';')
+	(*pp)++;
+      else
+	return 0;
     }
   return 1;
 }
@@ -2575,7 +2686,12 @@ read_struct_type (pp, type, objfile)
 
   /* First comes the total size in bytes.  */
 
-  TYPE_LENGTH (type) = read_number (pp, 0);
+  {
+    int nbits;
+    TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits);
+    if (nbits != 0)
+      return error_type (pp);
+  }
 
   /* Now read the baseclasses, if any, read the regular C struct or C++
      class member fields, attach the fields to the type, read the C++
@@ -2611,6 +2727,7 @@ read_array_type (pp, type, objfile)
   struct type *index_type, *element_type, *range_type;
   int lower, upper;
   int adjustable = 0;
+  int nbits;
 
   /* Format of an array type:
      "ar<index type>;lower;upper;<array_contents_type>".  Put code in
@@ -2630,14 +2747,18 @@ read_array_type (pp, type, objfile)
       (*pp)++;
       adjustable = 1;
     }
-  lower = read_number (pp, ';');
+  lower = read_huge_number (pp, ';', &nbits);
+  if (nbits != 0)
+    return error_type (pp);
 
   if (!(**pp >= '0' && **pp <= '9'))
     {
       (*pp)++;
       adjustable = 1;
     }
-  upper = read_number (pp, ';');
+  upper = read_huge_number (pp, ';', &nbits);
+  if (nbits != 0)
+    return error_type (pp);
   
   element_type = read_type (pp, objfile);
 
@@ -2699,12 +2820,15 @@ read_enum_type (pp, type, objfile)
      A semicolon or comma instead of a NAME means the end.  */
   while (**pp && **pp != ';' && **pp != ',')
     {
+      int nbits;
       STABS_CONTINUE (pp);
       p = *pp;
       while (*p != ':') p++;
       name = obsavestring (*pp, p - *pp, &objfile -> symbol_obstack);
       *pp = p + 1;
-      n = read_number (pp, ',');
+      n = read_huge_number (pp, ',', &nbits);
+      if (nbits != 0)
+	return error_type (pp);
 
       sym = (struct symbol *)
 	obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
@@ -2789,6 +2913,7 @@ read_sun_builtin_type (pp, typenums, objfile)
      int typenums[2];
      struct objfile *objfile;
 {
+  int type_bits;
   int nbits;
   int signed_type;
 
@@ -2817,23 +2942,29 @@ read_sun_builtin_type (pp, typenums, objfile)
      by this type, except that unsigned short is 4 instead of 2.
      Since this information is redundant with the third number,
      we will ignore it.  */
-  read_number (pp, ';');
+  read_huge_number (pp, ';', &nbits);
+  if (nbits != 0)
+    return error_type (pp);
 
   /* The second number is always 0, so ignore it too. */
-  read_number (pp, ';');
+  read_huge_number (pp, ';', &nbits);
+  if (nbits != 0)
+    return error_type (pp);
 
   /* The third number is the number of bits for this type. */
-  nbits = read_number (pp, 0);
+  type_bits = read_huge_number (pp, 0, &nbits);
+  if (nbits != 0)
+    return error_type (pp);
 
 #if 0
   /* FIXME.  Here we should just be able to make a type of the right
      number of bits and signedness.  FIXME.  */
 
-  if (nbits == TARGET_LONG_LONG_BIT)
+  if (type_bits == TARGET_LONG_LONG_BIT)
     return (lookup_fundamental_type (objfile,
 		 signed_type? FT_LONG_LONG: FT_UNSIGNED_LONG_LONG));
   
-  if (nbits == TARGET_INT_BIT)
+  if (type_bits == TARGET_INT_BIT)
     {
       /* FIXME -- the only way to distinguish `int' from `long'
 	 is to look at its name!  */
@@ -2856,21 +2987,21 @@ read_sun_builtin_type (pp, typenums, objfile)
 	}
     }
     
-  if (nbits == TARGET_SHORT_BIT)
+  if (type_bits == TARGET_SHORT_BIT)
     return (lookup_fundamental_type (objfile,
 		 signed_type? FT_SHORT: FT_UNSIGNED_SHORT));
   
-  if (nbits == TARGET_CHAR_BIT)
+  if (type_bits == TARGET_CHAR_BIT)
     return (lookup_fundamental_type (objfile,
 		 signed_type? FT_CHAR: FT_UNSIGNED_CHAR));
   
-  if (nbits == 0)
+  if (type_bits == 0)
     return lookup_fundamental_type (objfile, FT_VOID);
   
   return error_type (pp);
 #else
-  return init_type (nbits == 0 ? TYPE_CODE_VOID : TYPE_CODE_INT,
-		    nbits / TARGET_CHAR_BIT,
+  return init_type (type_bits == 0 ? TYPE_CODE_VOID : TYPE_CODE_INT,
+		    type_bits / TARGET_CHAR_BIT,
 		    signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *)NULL,
 		    objfile);
 #endif
@@ -2882,17 +3013,22 @@ read_sun_floating_type (pp, typenums, objfile)
      int typenums[2];
      struct objfile *objfile;
 {
+  int nbits;
   int details;
   int nbytes;
 
   /* The first number has more details about the type, for example
      FN_COMPLEX.  */
-  details = read_number (pp, ';');
+  details = read_huge_number (pp, ';', &nbits);
+  if (nbits != 0)
+    return error_type (pp);
 
   /* The second number is the number of bytes occupied by this type */
-  nbytes = read_number (pp, ';');
+  nbytes = read_huge_number (pp, ';', &nbits);
+  if (nbits != 0)
+    return error_type (pp);
 
-  if (**pp != 0 || details == NF_COMPLEX || details == NF_COMPLEX16
+  if (details == NF_COMPLEX || details == NF_COMPLEX16
       || details == NF_COMPLEX32)
     /* This is a type we can't handle, but we do know the size.
        We also will be able to give it a name.  */
@@ -2908,16 +3044,15 @@ read_sun_floating_type (pp, typenums, objfile)
    and that character is skipped if it does match.
    If END is zero, *PP is left pointing to that character.
 
-   If the number fits in a long, set *VALUE and set *BITS to 0.
-   If not, set *BITS to be the number of bits in the number.
+   If the number fits in a long, set *BITS to 0 and return the value.
+   If not, set *BITS to be the number of bits in the number and return 0.
 
-   If encounter garbage, set *BITS to -1.  */
+   If encounter garbage, set *BITS to -1 and return 0.  */
 
-static void
-read_huge_number (pp, end, valu, bits)
+static long
+read_huge_number (pp, end, bits)
      char **pp;
      int end;
-     long *valu;
      int *bits;
 {
   char *p = *pp;
@@ -3007,11 +3142,12 @@ read_huge_number (pp, end, valu, bits)
     }
   else
     {
-      if (valu)
-	*valu = n * sign;
       if (bits)
 	*bits = 0;
+      return n * sign;
     }
+  /* It's *BITS which has the interesting information.  */
+  return 0;
 }
 
 static struct type *
@@ -3029,7 +3165,10 @@ read_range_type (pp, typenums, objfile)
 
   /* First comes a type we are a subrange of.
      In C it is usually 0, 1 or the type being defined.  */
-  read_type_number (pp, rangenums);
+  /* FIXME: according to stabs.texinfo and AIX doc, this can be a type-id
+     not just a type number.  */
+  if (read_type_number (pp, rangenums) != 0)
+    return error_type (pp);
   self_subrange = (rangenums[0] == typenums[0] &&
 		   rangenums[1] == typenums[1]);
 
@@ -3039,8 +3178,8 @@ read_range_type (pp, typenums, objfile)
 
   /* The remaining two operands are usually lower and upper bounds
      of the range.  But in some special cases they mean something else.  */
-  read_huge_number (pp, ';', &n2, &n2bits);
-  read_huge_number (pp, ';', &n3, &n3bits);
+  n2 = read_huge_number (pp, ';', &n2bits);
+  n3 = read_huge_number (pp, ';', &n3bits);
 
   if (n2bits == -1 || n3bits == -1)
     return error_type (pp);
@@ -3177,50 +3316,6 @@ read_range_type (pp, typenums, objfile)
   return (result_type);
 }
 
-/* Read a number from the string pointed to by *PP.
-   The value of *PP is advanced over the number.
-   If END is nonzero, the character that ends the
-   number must match END, or an error happens;
-   and that character is skipped if it does match.
-   If END is zero, *PP is left pointing to that character.  */
-
-long
-read_number (pp, end)
-     char **pp;
-     int end;
-{
-  register char *p = *pp;
-  register long n = 0;
-  register int c;
-  int sign = 1;
-
-  /* Handle an optional leading minus sign.  */
-
-  if (*p == '-')
-    {
-      sign = -1;
-      p++;
-    }
-
-  /* Read the digits, as far as they go.  */
-
-  while ((c = *p++) >= '0' && c <= '9')
-    {
-      n *= 10;
-      n += c - '0';
-    }
-  if (end)
-    {
-      if (c && c != end)
-	error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c, symnum);
-    }
-  else
-    --p;
-
-  *pp = p;
-  return n * sign;
-}
-
 /* Read in an argument list.  This is a list of types, separated by commas
    and terminated with END.  Return the list of types read in, or (struct type
    **)-1 if there is an error.  */
@@ -3331,15 +3426,14 @@ cleanup_undefined_types ()
 		struct pending *ppt;
 		int i;
 		/* Name of the type, without "struct" or "union" */
-		char *typename = TYPE_NAME (*type);
-
-		if (!strncmp (typename, "struct ", 7))
-		  typename += 7;
-		if (!strncmp (typename, "union ", 6))
-		  typename += 6;
-		if (!strncmp (typename, "enum ", 5))
-		  typename += 5;
+		char *typename = type_name_no_tag (*type);
 
+		if (typename == NULL)
+		  {
+		    static struct complaint msg = {"need a type name", 0, 0};
+		    complain (&msg);
+		    break;
+		  }
 		for (ppt = file_symbols; ppt; ppt = ppt->next)
 		  {
 		    for (i = 0; i < ppt->nsyms; i++)
@@ -3383,9 +3477,13 @@ cleanup_undefined_types ()
 	  }
 	  break;
 
-	  default:
-	  badtype:
-	  error ("GDB internal error.  cleanup_undefined_types with bad type %d.", TYPE_CODE (*type));
+	default:
+	badtype:
+	  {
+	    static struct complaint msg = {"\
+GDB internal error.  cleanup_undefined_types with bad type %d.", 0, 0};
+	    complain (&msg, TYPE_CODE (*type));
+	  }
 	  break;
 	}
     }
diff --git a/gdb/stabsread.h b/gdb/stabsread.h
index 3296195..c7c0299 100644
--- a/gdb/stabsread.h
+++ b/gdb/stabsread.h
@@ -136,9 +136,6 @@ EXTERN int n_allocated_this_object_header_files;
 extern struct complaint unknown_symtype_complaint;
 extern struct complaint unknown_symchar_complaint;
 
-extern void
-read_type_number PARAMS ((char **, int *));
-
 extern struct type *
 read_type PARAMS ((char **, struct objfile *));
 
diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c
index d02e843..585a4f0 100644
--- a/gdb/xcoffread.c
+++ b/gdb/xcoffread.c
@@ -1597,116 +1597,10 @@ process_xcoff_symbol (cs, objfile)
 
     case C_DECL:      			/* a type decleration?? */
 
-#if defined(NO_TYPEDEFS)
-	qq =  (char*) strchr (name, ':');
-	if (!qq)			/* skip if there is no ':' */
-	  return NULL;
-
-	nameless = (qq == name);
-
-	struct_and_type_combined = (qq[1] == 'T' && qq[2] == 't');
-	pp = qq + (struct_and_type_combined ? 3 : 2);
-
-
-	/* To handle GNU C++ typename abbreviation, we need to be able to fill
-	   in a type's name as soon as space for that type is allocated. */
-
-	if (struct_and_type_combined && name != qq) {
-
-	   int typenums[2];
-	   struct type *tmp_type;
-	   char *tmp_pp = pp;
-
-	   read_type_number (&tmp_pp, typenums);
-	   tmp_type = dbx_alloc_type (typenums, objfile);
-
-	   if (tmp_type && !TYPE_NAME (tmp_type) && !nameless)
-	     TYPE_NAME (tmp_type) = SYMBOL_NAME (sym) =
-				obsavestring (name, qq-name,
-					      &objfile->symbol_obstack);
-	}
-	ttype = SYMBOL_TYPE (sym) = read_type (&pp, objfile);
-
-	/* if there is no name for this typedef, you don't have to keep its
-	   symbol, since nobody could ask for it. Otherwise, build a symbol
-	   and add it into symbol_list. */
-
-	if (nameless)
-	  return;
-
-	/* Transarc wants to eliminate type definitions from the symbol table.
-	   Limited debugging capabilities, but faster symbol table processing
-	   and less memory usage. Note that tag definitions (starting with
-	   'T') will remain intact. */
-
-	if (qq[1] != 'T' && (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0')) {
-
-	  if (SYMBOL_NAME (sym))
-	      TYPE_NAME (ttype) = SYMBOL_NAME (sym);
-	  else
-	      TYPE_NAME (ttype) = obsavestring (name, qq-name);
-
-	  return;
-	}
-
-	/* read_type() will return null if type (or tag) definition was
-	   unnnecessarily duplicated. Also, if the symbol doesn't have a name,
-	   there is no need to keep it in symbol table. */
-	/* The above argument no longer valid. read_type() never returns NULL. */
-
-	if (!ttype)
-	  return NULL;
-
-	/* if there is no name for this typedef, you don't have to keep its
-	   symbol, since nobody could ask for it. Otherwise, build a symbol
-	   and add it into symbol_list. */
-
-	if (qq[1] == 'T')
-	    SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
-	else if (qq[1] == 't')
-	    SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-	else {
-	    warning ("Unrecognized stab string.\n");
-	    return NULL;
-	}
-
-	SYMBOL_CLASS (sym) = LOC_TYPEDEF;
-	if (!SYMBOL_NAME (sym))
-	    SYMBOL_NAME (sym) = obsavestring (name, qq-name);
-
-	SYMBOL_DUP (sym, sym2);
-	add_symbol_to_list 
-	     (sym2, within_function ? &local_symbols : &file_symbols);
-
-	/* For a combination of struct and type, add one more symbol
-	   for the type. */
-
-	if (struct_and_type_combined) {
-	    SYMBOL_DUP (sym, sym2);
-	    SYMBOL_NAMESPACE (sym2) = VAR_NAMESPACE;
-	    add_symbol_to_list 
-	       (sym2, within_function ? &local_symbols : &file_symbols);
-	}
-
-	/*  assign a name to the type node. */
-
-	if (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0') {
-	  if (struct_and_type_combined)
-	    TYPE_NAME (ttype) = SYMBOL_NAME (sym);
-	  else if  (qq[1] == 'T')		/* struct namespace */
-	    TYPE_NAME (ttype) = concat (
-		TYPE_CODE (ttype) == TYPE_CODE_UNION ? "union " :
-		TYPE_CODE (ttype) == TYPE_CODE_STRUCT? "struct " : "enum ",
-		SYMBOL_NAME (sym), NULL);
-	}
-	break;
-
-#else /* !NO_TYPEDEFS */
       sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
       if (sym != NULL)
 	SYMBOL_SECTION (sym) = cs->c_secnum;
       return sym;
-#endif
 
     case C_GSYM:
       add_stab_to_list (name, &global_stabs);