自学教程：C++ CHECK_TYPEDEF函数代码示例

static intgccgo_string_p (struct type *type){  /* gccgo strings don't necessarily have a name we can use.  */  if (TYPE_NFIELDS (type) == 2)    {      struct type *type0 = TYPE_FIELD_TYPE (type, 0);      struct type *type1 = TYPE_FIELD_TYPE (type, 1);      CHECK_TYPEDEF (type0);      CHECK_TYPEDEF (type1);      if (TYPE_CODE (type0) == TYPE_CODE_PTR	  && strcmp (TYPE_FIELD_NAME (type, 0), "__data") == 0	  && TYPE_CODE (type1) == TYPE_CODE_INT	  && strcmp (TYPE_FIELD_NAME (type, 1), "__length") == 0)	{	  struct type *target_type = TYPE_TARGET_TYPE (type0);	  CHECK_TYPEDEF (target_type);	  if (TYPE_CODE (target_type) == TYPE_CODE_INT	      && TYPE_LENGTH (target_type) == 1	      && strcmp (TYPE_NAME (target_type), "uint8") == 0)	    return 1;	}    }  return 0;}

static voidm2_print_array_contents (struct type *type, const gdb_byte *valaddr,			 int embedded_offset, CORE_ADDR address,			 struct ui_file *stream, int recurse,			 const struct value_print_options *options,			 int len){  int eltlen;  CHECK_TYPEDEF (type);  if (TYPE_LENGTH (type) > 0)    {      eltlen = TYPE_LENGTH (type);      if (options->prettyprint_arrays)	print_spaces_filtered (2 + 2 * recurse, stream);      /* For an array of chars, print with string syntax.  */      if (eltlen == 1 &&	  ((TYPE_CODE (type) == TYPE_CODE_INT)	   || ((current_language->la_language == language_m2)	       && (TYPE_CODE (type) == TYPE_CODE_CHAR)))	  && (options->format == 0 || options->format == 's'))	val_print_string (type, address, len+1, stream, options);      else	{	  fprintf_filtered (stream, "{");	  val_print_array_elements (type, valaddr + embedded_offset,				    address, stream, recurse, options, 0);	  fprintf_filtered (stream, "}");	}    }}

/* Returns non-zero if the value is a structured type */intstructured_type (struct type *type){    CHECK_TYPEDEF (type);    switch (current_language->la_language)    {    case language_c:    case language_cplus:    case language_objc:        return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||               (TYPE_CODE (type) == TYPE_CODE_UNION) ||               (TYPE_CODE (type) == TYPE_CODE_ARRAY);    case language_pascal:        return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||               (TYPE_CODE(type) == TYPE_CODE_UNION) ||               (TYPE_CODE(type) == TYPE_CODE_SET) ||               (TYPE_CODE(type) == TYPE_CODE_ARRAY);    case language_m2:        return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||               (TYPE_CODE (type) == TYPE_CODE_SET) ||               (TYPE_CODE (type) == TYPE_CODE_ARRAY);    default:        return (0);    }}

static voidm2_print_unbounded_array (struct type *type, const gdb_byte *valaddr,			  int embedded_offset, CORE_ADDR address,			  struct ui_file *stream, int recurse,			  const struct value_print_options *options){  struct type *content_type;  CORE_ADDR addr;  LONGEST len;  struct value *val;  CHECK_TYPEDEF (type);  content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));  addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),			 (TYPE_FIELD_BITPOS (type, 0) / 8) +			 valaddr + embedded_offset);  val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),		       addr);  len = unpack_field_as_long (type, valaddr + embedded_offset, 1);  fprintf_filtered (stream, "{");    m2_print_array_contents (value_type (val), value_contents(val),			   value_embedded_offset (val), addr, stream,			   recurse, options, len);  fprintf_filtered (stream, ", HIGH = %d}", (int) len);}

voidc_print_type (struct type *type,	      const char *varstring,	      struct ui_file *stream,	      int show, int level,	      const struct type_print_options *flags){  enum type_code code;  int demangled_args;  int need_post_space;  const char *local_name;  if (show > 0)    CHECK_TYPEDEF (type);  local_name = find_typedef_in_hash (flags, type);  if (local_name != NULL)    {      fputs_filtered (local_name, stream);      if (varstring != NULL && *varstring != '/0')	fputs_filtered (" ", stream);    }  else    {      c_type_print_base (type, stream, show, level, flags);      code = TYPE_CODE (type);      if ((varstring != NULL && *varstring != '/0')	  /* Need a space if going to print stars or brackets;	     but not if we will print just a type name.  */	  || ((show > 0 || TYPE_NAME (type) == 0)	      && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC		  || code == TYPE_CODE_METHOD		  || (code == TYPE_CODE_ARRAY		      && !TYPE_VECTOR (type))		  || code == TYPE_CODE_MEMBERPTR		  || code == TYPE_CODE_METHODPTR		  || code == TYPE_CODE_REF)))	fputs_filtered (" ", stream);      need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);      c_type_print_varspec_prefix (type, stream, show, 0, need_post_space,				   flags);    }  if (varstring != NULL)    {      fputs_filtered (varstring, stream);      /* For demangled function names, we have the arglist as part of         the name, so don't print an additional pair of ()'s.  */      if (local_name == NULL)	{	  demangled_args = strchr (varstring, '(') != NULL;	  c_type_print_varspec_suffix (type, stream, show,				       0, demangled_args,				       flags);	}    }}

/* Return a sequence of all fields.  Each field is a dictionary with   some pre-defined keys.  */static PyObject *typy_fields (PyObject *self, PyObject *args){    PyObject *result;    int i;    struct type *type = ((type_object *) self)->type;    volatile struct gdb_exception except;    TRY_CATCH (except, RETURN_MASK_ALL)    {        CHECK_TYPEDEF (type);    }

voidc_print_typedef (struct type *type, struct symbol *new_symbol,		 struct ui_file *stream){  CHECK_TYPEDEF (type);  fprintf_filtered (stream, "typedef ");  type_print (type, "", stream, 0);  if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0      || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),		 SYMBOL_LINKAGE_NAME (new_symbol)) != 0)    fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));  fprintf_filtered (stream, ";/n");}

enum go_typego_classify_struct_type (struct type *type){  CHECK_TYPEDEF (type);  /* Recognize strings as they're useful to be able to print without     pretty-printers.  */  if (gccgo_string_p (type)      || sixg_string_p (type))    return GO_TYPE_STRING;  return GO_TYPE_NONE;}

/* Returns non-zero if the value is numeric */intnumeric_type (struct type *type){    CHECK_TYPEDEF (type);    switch (TYPE_CODE (type))    {    case TYPE_CODE_INT:    case TYPE_CODE_FLT:        return 1;    default:        return 0;    }}

voidm2_print_typedef (struct type *type, struct symbol *new_symbol,		  struct ui_file *stream){  CHECK_TYPEDEF (type);  fprintf_filtered (stream, "TYPE ");  if (!TYPE_NAME (SYMBOL_TYPE (new_symbol))      || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),		 SYMBOL_LINKAGE_NAME (new_symbol)) != 0)    fprintf_filtered (stream, "%s = ", SYMBOL_PRINT_NAME (new_symbol));  else    fprintf_filtered (stream, "<builtin> = ");  type_print (type, "", stream, 0);  fprintf_filtered (stream, ";/n");}

/* Returns non-zero if the two types are the same */intsame_type (struct type *arg1, struct type *arg2){    CHECK_TYPEDEF (type);    if (structured_type (arg1) ? !structured_type (arg2) : structured_type (arg2))        /* One is structured and one isn't */        return 0;    else if (structured_type (arg1) && structured_type (arg2))        return arg1 == arg2;    else if (numeric_type (arg1) && numeric_type (arg2))        return (TYPE_CODE (arg2) == TYPE_CODE (arg1)) &&               (TYPE_UNSIGNED (arg1) == TYPE_UNSIGNED (arg2))               ? 1 : 0;    else        return arg1 == arg2;}

static voidprint_record (struct type *type, char *valaddr, struct ui_file *stream,	      int format, int recurse, enum val_prettyprint pretty){  CHECK_TYPEDEF (type);  fprintf_filtered (stream, "(");  if (print_field_values (type, valaddr, stream, format, recurse, pretty,			  0, type, valaddr) != 0 && pretty)    {      fprintf_filtered (stream, "/n");      print_spaces_filtered (2 * recurse, stream);    }  fprintf_filtered (stream, ")");}

/* Returns non-zero if its argument is of an ordered type.   An ordered type is one in which the elements can be tested for the   properties of "greater than", "less than", etc, or for which the   operations "increment" or "decrement" make sense. */intordered_type (struct type *type){    CHECK_TYPEDEF (type);    switch (TYPE_CODE (type))    {    case TYPE_CODE_INT:    case TYPE_CODE_CHAR:    case TYPE_CODE_ENUM:    case TYPE_CODE_FLT:    case TYPE_CODE_RANGE:        return 1;    default:        return 0;    }}

/* Returns non-zero if the type is integral */intintegral_type (struct type *type){    CHECK_TYPEDEF (type);    switch (current_language->la_language)    {    case language_c:    case language_cplus:    case language_objc:        return (TYPE_CODE (type) != TYPE_CODE_INT) &&               (TYPE_CODE (type) != TYPE_CODE_ENUM) ? 0 : 1;    case language_m2:    case language_pascal:        return TYPE_CODE (type) != TYPE_CODE_INT ? 0 : 1;    default:        error ("Language not supported.");    }}

static voidpascal_object_print_static_field (struct value *val,				  struct ui_file *stream,				  int recurse,				  const struct value_print_options *options){  struct type *type = value_type (val);  struct value_print_options opts;  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)    {      CORE_ADDR *first_dont_print, addr;      int i;      first_dont_print	= (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);      i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)	- first_dont_print;      while (--i >= 0)	{	  if (value_address (val) == first_dont_print[i])	    {	      fputs_filtered ("<same as static member of an already seen type>",			      stream);	      return;	    }	}      addr = value_address (val);      obstack_grow (&dont_print_statmem_obstack, (char *) &addr,		    sizeof (CORE_ADDR));      CHECK_TYPEDEF (type);      pascal_object_print_value_fields (type, value_contents (val), addr,					stream, recurse, NULL, options,					NULL, 1);      return;    }  opts = *options;  opts.deref_ref = 0;  common_val_print (val, stream, recurse, &opts, current_language);}

voidtypedef_print(struct type *type, struct symbol *newsym,              struct ui_file *stream){  CHECK_TYPEDEF(type);  switch (current_language->la_language)    {#ifdef _LANG_c    case language_c:    case language_cplus:    case language_objc:    case language_objcplus:      fprintf_filtered(stream, "typedef ");      type_print(type, "", stream, 0);      if ((TYPE_NAME((SYMBOL_TYPE(newsym))) == 0)	  || (strcmp(TYPE_NAME((SYMBOL_TYPE(newsym))),                     DEPRECATED_SYMBOL_NAME(newsym)) != 0))	fprintf_filtered(stream, " %s", SYMBOL_PRINT_NAME(newsym));      break;#endif /* _LANG_c */#ifdef _LANG_m2    case language_m2:      fprintf_filtered(stream, "TYPE ");      if (!TYPE_NAME(SYMBOL_TYPE(newsym))	  || (strcmp(TYPE_NAME((SYMBOL_TYPE(newsym))),                     DEPRECATED_SYMBOL_NAME(newsym)) != 0))	fprintf_filtered(stream, "%s = ", SYMBOL_PRINT_NAME(newsym));      else	fprintf_filtered(stream, "<builtin> = ");      type_print(type, "", stream, 0);      break;#endif /* _LANG_m2 */#ifdef _LANG_pascal    case language_pascal:      fprintf_filtered(stream, "type ");      fprintf_filtered(stream, "%s = ", SYMBOL_PRINT_NAME(newsym));      type_print(type, "", stream, 0);      break;#endif /* _LANG_pascal */    default:      error(_("Language not supported."));    }  fprintf_filtered(stream, ";/n");}

/* Returns non-zero if the value is a string type */intstring_type (struct type *type){    CHECK_TYPEDEF (type);    switch (current_language->la_language)    {    case language_m2:    case language_pascal:        return TYPE_CODE (type) != TYPE_CODE_STRING ? 0 : 1;    case language_c:    case language_cplus:    case language_objc:        /* C does not have distinct string type. */        return (0);    default:        return (0);    }}

/* Returns non-zero if the value is a character type */intcharacter_type (struct type *type){    CHECK_TYPEDEF (type);    switch (current_language->la_language)    {    case language_m2:    case language_pascal:        return TYPE_CODE (type) != TYPE_CODE_CHAR ? 0 : 1;    case language_c:    case language_cplus:    case language_objc:        return (TYPE_CODE (type) == TYPE_CODE_INT) &&               TYPE_LENGTH (type) == sizeof (char)               ? 1 : 0;    default:        return (0);    }}

voidpascal_print_type (struct type *type, char *varstring, struct ui_file *stream,		   int show, int level){  enum type_code code;  int demangled_args;  code = TYPE_CODE (type);  if (show > 0)    CHECK_TYPEDEF (type);  if ((code == TYPE_CODE_FUNC ||       code == TYPE_CODE_METHOD))    {      pascal_type_print_varspec_prefix (type, stream, show, 0);    }  /* first the name */  fputs_filtered (varstring, stream);  if ((varstring != NULL && *varstring != '/0') &&      !(code == TYPE_CODE_FUNC ||	code == TYPE_CODE_METHOD))    {      fputs_filtered (" : ", stream);    }  if (!(code == TYPE_CODE_FUNC ||	code == TYPE_CODE_METHOD))    {      pascal_type_print_varspec_prefix (type, stream, show, 0);    }  pascal_type_print_base (type, stream, show, level);  /* For demangled function names, we have the arglist as part of the name,     so don't print an additional pair of ()'s */  demangled_args = varstring ? strchr (varstring, '(') != NULL : 0;  pascal_type_print_varspec_suffix (type, stream, show, 0, demangled_args);}

/* Helper for expression_completer which recursively adds field and   method names from TYPE, a struct or union type, to the array   OUTPUT.  This function assumes that OUTPUT is correctly-sized.  */static voidadd_struct_fields (struct type *type, int *nextp, char **output,		   char *fieldname, int namelen){  int i;  int computed_type_name = 0;  char *type_name = NULL;  CHECK_TYPEDEF (type);  for (i = 0; i < TYPE_NFIELDS (type); ++i)    {      if (i < TYPE_N_BASECLASSES (type))	add_struct_fields (TYPE_BASECLASS (type, i), nextp, output,			   fieldname, namelen);      else if (TYPE_FIELD_NAME (type, i)	       && ! strncmp (TYPE_FIELD_NAME (type, i), fieldname, namelen))	{	  output[*nextp] = xstrdup (TYPE_FIELD_NAME (type, i));	  ++*nextp;	}    }  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)    {      char *name = TYPE_FN_FIELDLIST_NAME (type, i);      if (name && ! strncmp (name, fieldname, namelen))	{	  if (!computed_type_name)	    {	      type_name = type_name_no_tag (type);	      computed_type_name = 1;	    }	  /* Omit constructors from the completion list.  */	  if (type_name && strcmp (type_name, name))	    {	      output[*nextp] = xstrdup (name);	      ++*nextp;	    }	}    }}

intm2_get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp){  CHECK_TYPEDEF (type);  switch (TYPE_CODE (type))    {    case TYPE_CODE_CHAR:      if (TYPE_LENGTH (type) < sizeof (LONGEST))	{	  if (!TYPE_UNSIGNED (type))	    {	      *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));	      *highp = -*lowp - 1;	      return 0;	    }	}      /* fall through */    default:      return get_discrete_bounds (type, lowp, highp);    }}

/* Returns non-zero if the value is a boolean type */intboolean_type (struct type *type){    CHECK_TYPEDEF (type);    if (TYPE_CODE (type) == TYPE_CODE_BOOL)        return 1;    switch (current_language->la_language)    {    case language_c:    case language_cplus:    case language_objc:        /* Might be more cleanly handled by having a           TYPE_CODE_INT_NOT_BOOL for (the deleted) CHILL and such           languages, or a TYPE_CODE_INT_OR_BOOL for C.  */        if (TYPE_CODE (type) == TYPE_CODE_INT)            return 1;    default:        break;    }    return 0;}

/* Implements the la_val_print routine for language D.  */voidd_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,             CORE_ADDR address, struct ui_file *stream, int recurse,	     const struct value *val,             const struct value_print_options *options){  int ret;  CHECK_TYPEDEF (type);  switch (TYPE_CODE (type))    {      case TYPE_CODE_STRUCT:        ret = dynamic_array_type (type, valaddr, embedded_offset, address,				  stream, recurse, val, options);	if (ret == 0)	  break;      default:	c_val_print (type, valaddr, embedded_offset, address, stream,		     recurse, val, options);    }}

voidc_print_type (struct type *type, char *varstring, struct ui_file *stream,	      int show, int level){  enum type_code code;  int demangled_args;  int need_post_space;  if (show > 0)    CHECK_TYPEDEF (type);  c_type_print_base (type, stream, show, level);  code = TYPE_CODE (type);  if ((varstring != NULL && *varstring != '/0')      ||  /* Need a space if going to print stars or brackets;     but not if we will print just a type name.  */      ((show > 0 || TYPE_NAME (type) == 0)       &&       (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC	|| code == TYPE_CODE_METHOD	|| code == TYPE_CODE_ARRAY	|| code == TYPE_CODE_MEMBERPTR	|| code == TYPE_CODE_METHODPTR	|| code == TYPE_CODE_REF)))    fputs_filtered (" ", stream);  need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);  c_type_print_varspec_prefix (type, stream, show, 0, need_post_space);  if (varstring != NULL)    {      fputs_filtered (varstring, stream);      /* For demangled function names, we have the arglist as part of the name,         so don't print an additional pair of ()'s */      demangled_args = strchr (varstring, '(') != NULL;      c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);    }}

intis_object_type (struct type *type){  CHECK_TYPEDEF (type);  if (TYPE_CODE (type) == TYPE_CODE_PTR)    {      struct type *ttype = check_typedef (TYPE_TARGET_TYPE (type));      const char *name;      if (TYPE_CODE (ttype) != TYPE_CODE_STRUCT)	return 0;      while (TYPE_N_BASECLASSES (ttype) > 0)	ttype = TYPE_BASECLASS (ttype, 0);      name = TYPE_TAG_NAME (ttype);      if (name != NULL && strcmp (name, "java.lang.Object") == 0)	return 1;      name	= TYPE_NFIELDS (ttype) > 0 ? TYPE_FIELD_NAME (ttype, 0) : (char *) 0;      if (name != NULL && strcmp (name, "vtable") == 0)	return 1;    }  return 0;}

/* Helper for expression_completer which recursively counts the number   of named fields and methods in a structure or union type.  */static intcount_struct_fields (struct type *type){  int i, result = 0;  CHECK_TYPEDEF (type);  for (i = 0; i < TYPE_NFIELDS (type); ++i)    {      if (i < TYPE_N_BASECLASSES (type))	result += count_struct_fields (TYPE_BASECLASS (type, i));      else if (TYPE_FIELD_NAME (type, i))	++result;    }  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)    {      if (TYPE_FN_FIELDLIST_NAME (type, i))	++result;    }  return result;}

static voidpascal_object_print_static_field (struct value *val,				  struct ui_file *stream, int format,				  int recurse, enum val_prettyprint pretty){  struct type *type = value_type (val);  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)    {      CORE_ADDR *first_dont_print;      int i;      first_dont_print	= (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);      i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)	- first_dont_print;      while (--i >= 0)	{	  if (VALUE_ADDRESS (val) == first_dont_print[i])	    {	      fputs_filtered ("<same as static member of an already seen type>",			      stream);	      return;	    }	}      obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),		    sizeof (CORE_ADDR));      CHECK_TYPEDEF (type);      pascal_object_print_value_fields (type, value_contents (val), VALUE_ADDRESS (val),				  stream, format, recurse, pretty, NULL, 1);      return;    }  common_val_print (val, stream, format, 0, recurse, pretty);}

voidgo_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,	      CORE_ADDR address, struct ui_file *stream, int recurse,	      const struct value *val,	      const struct value_print_options *options){  CHECK_TYPEDEF (type);  switch (TYPE_CODE (type))    {      case TYPE_CODE_STRUCT:	{	  enum go_type go_type = go_classify_struct_type (type);	  switch (go_type)	    {	    case GO_TYPE_STRING:	      if (! options->raw)		{		  print_go_string (type, valaddr, embedded_offset, address,				   stream, recurse, val, options);		  return;		}	      break;	    default:	      break;	    }	}	/* Fall through.  */      default:	c_val_print (type, valaddr, embedded_offset, address, stream,		     recurse, val, options);	break;    }}

static struct type *gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc){  struct type *known_type;  struct type *rtti_type;  CORE_ADDR vtbl;  struct minimal_symbol *minsym;  char *demangled_name;  struct type *btype;  if (full)    *full = 0;  if (top)    *top = -1;  if (using_enc)    *using_enc = 0;  /* Get declared type */  known_type = value_type (v);  CHECK_TYPEDEF (known_type);  /* RTTI works only or class objects */  if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)    return NULL;  /* Plan on this changing in the future as i get around to setting     the vtables properly for G++ compiled stuff.  Also, I'll be using     the type info functions, which are always right.  Deal with it     until then.     JCI - This pretty much useless.  This gets the "true" type      correctly when there is single inheritance - but in all such       cases that I could find gdb already knows that.  In cases      where this points INTO the object (like non-virtual diamond      graphs) the demangled name is something like OUTER::INNER      and this is not a symbol gdb can resolve, so we fail & return      NULL anyway.  Seems like this really isn't going to work till      we actually call the RTTI function & parse it. */  /* If the type has no vptr fieldno, try to get it filled in */  if (TYPE_VPTR_FIELDNO(known_type) < 0)    fill_in_vptr_fieldno(known_type);  /* If we still can't find one, give up */  if (TYPE_VPTR_FIELDNO(known_type) < 0)    return NULL;  /* Make sure our basetype and known type match, otherwise, cast     so we can get at the vtable properly.  */  btype = TYPE_VPTR_BASETYPE (known_type);  CHECK_TYPEDEF (btype);  if (btype != known_type )    {      v = value_cast (btype, v);      if (using_enc)        *using_enc=1;    }  /*    We can't use value_ind here, because it would want to use RTTI, and    we'd waste a bunch of time figuring out we already know the type.    Besides, we don't care about the type, just the actual pointer  */  if (VALUE_ADDRESS (value_field (v, TYPE_VPTR_FIELDNO (known_type))) == 0)    return NULL;  vtbl=value_as_address(value_field(v,TYPE_VPTR_FIELDNO(known_type)));  /* Try to find a symbol that is the vtable */  minsym=lookup_minimal_symbol_by_pc(vtbl);  if (minsym==NULL      || (demangled_name=DEPRECATED_SYMBOL_NAME (minsym))==NULL      || !is_vtable_name (demangled_name))    return NULL;  /* If we just skip the prefix, we get screwed by namespaces */  demangled_name=cplus_demangle(demangled_name,DMGL_PARAMS|DMGL_ANSI);  *(strchr(demangled_name,' '))=0;  /* Lookup the type for the name */  /* FIXME: chastain/2003-11-26: block=NULL is bogus.  See pr gdb/1465. */  rtti_type = cp_lookup_rtti_type (demangled_name, NULL);  if (rtti_type == NULL)    return NULL;  if (TYPE_N_BASECLASSES(rtti_type) > 1 &&  full && (*full) != 1)    {      if (top)        *top=TYPE_BASECLASS_BITPOS(rtti_type,TYPE_VPTR_FIELDNO(rtti_type))/8;      if (top && ((*top) >0))        {          if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))            {              if (full)                *full=0;            }          else            {              if (full)                *full=1;            }//.........这里部分代码省略.........