This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

C++ PATCH: demangling return types


This patch fixes new-ABI demangling of templated conversion operators
to not expect a return type, as recently specified in the spec.  At
the same time, some function paremeters and variables are renamed to
reflect their true role in this mechanism.

	* cp-demangle.c (demangle_encoding): Rename variable.
	(demangle_name): Rename parameter.  Handle return type
	suppression.
	(demangle_nested_name): Rename parameter.
	(demangle_prefix): Likewise.  Change return type suppression.
	(demangle_unqualified_name): Add parameter.  Flag constructors and
	conversion operators.
	(demangle_special_name): Fix comment.
	(demangle_type): Rename variable.
	(demangle_bare_function_type): Check for missing return type and
	parameter. 
	(demangle_class_enum_type): Rename parameter.
	(demangle_discriminator): Fix misspelling in comment.



Index: cp-demangle.c
===================================================================
RCS file: /cvs/gcc/egcs/libiberty/cp-demangle.c,v
retrieving revision 1.20
diff -c -p -r1.20 cp-demangle.c
*** cp-demangle.c	2000/09/05 05:48:59	1.20
--- cp-demangle.c	2000/09/05 22:32:00
*************** static status_t demangle_nested_name
*** 805,811 ****
  static status_t demangle_prefix
    PARAMS ((demangling_t, int *));
  static status_t demangle_unqualified_name
!   PARAMS ((demangling_t));
  static status_t demangle_source_name
    PARAMS ((demangling_t));
  static status_t demangle_number
--- 805,811 ----
  static status_t demangle_prefix
    PARAMS ((demangling_t, int *));
  static status_t demangle_unqualified_name
!   PARAMS ((demangling_t, int *));
  static status_t demangle_source_name
    PARAMS ((demangling_t));
  static status_t demangle_number
*************** static status_t
*** 922,928 ****
  demangle_encoding (dm)
       demangling_t dm;
  {
!   int template_p;
    int start_position;
    template_arg_list_t old_arg_list = current_template_arg_list (dm);
    char peek = peek_char (dm);
--- 922,928 ----
  demangle_encoding (dm)
       demangling_t dm;
  {
!   int encode_return_type;
    int start_position;
    template_arg_list_t old_arg_list = current_template_arg_list (dm);
    char peek = peek_char (dm);
*************** demangle_encoding (dm)
*** 938,951 ****
    else
      {
        /* Now demangle the name.  */
!       RETURN_IF_ERROR (demangle_name (dm, &template_p));
  
        /* If there's anything left, the name was a function name, with
  	 maybe its return type, and its parameters types, following.  */
        if (!end_of_name_p (dm) 
  	  && peek_char (dm) != 'E')
  	{
! 	  if (template_p)
  	    /* Template functions have their return type encoded.  The
  	       return type should be inserted at start_position.  */
  	    RETURN_IF_ERROR 
--- 938,951 ----
    else
      {
        /* Now demangle the name.  */
!       RETURN_IF_ERROR (demangle_name (dm, &encode_return_type));
  
        /* If there's anything left, the name was a function name, with
  	 maybe its return type, and its parameters types, following.  */
        if (!end_of_name_p (dm) 
  	  && peek_char (dm) != 'E')
  	{
! 	  if (encode_return_type)
  	    /* Template functions have their return type encoded.  The
  	       return type should be inserted at start_position.  */
  	    RETURN_IF_ERROR 
*************** demangle_encoding (dm)
*** 980,1005 ****
                          ::= <substitution>  */
  
  static status_t
! demangle_name (dm, template_p)
       demangling_t dm;
!      int *template_p;
  {
    int start = substitution_start (dm);
    char peek = peek_char (dm);
    int is_std_substitution = 0;
  
    DEMANGLE_TRACE ("name", dm);
  
    switch (peek)
      {
      case 'N':
        /* This is a <nested-name>.  */
!       RETURN_IF_ERROR (demangle_nested_name (dm, template_p));
        break;
  
      case 'Z':
        RETURN_IF_ERROR (demangle_local_name (dm));
!       *template_p = 0;
        break;
  
      case 'S':
--- 980,1011 ----
                          ::= <substitution>  */
  
  static status_t
! demangle_name (dm, encode_return_type)
       demangling_t dm;
!      int *encode_return_type;
  {
    int start = substitution_start (dm);
    char peek = peek_char (dm);
    int is_std_substitution = 0;
  
+   /* Generally, the return type is encoded if the function is a
+      template-id, and suppressed otherwise.  There are a few cases,
+      though, in which the return type is not encoded even for a
+      templated function.  In these cases, this flag is set.  */
+   int suppress_return_type = 0;
+ 
    DEMANGLE_TRACE ("name", dm);
  
    switch (peek)
      {
      case 'N':
        /* This is a <nested-name>.  */
!       RETURN_IF_ERROR (demangle_nested_name (dm, encode_return_type));
        break;
  
      case 'Z':
        RETURN_IF_ERROR (demangle_local_name (dm));
!       *encode_return_type = 0;
        break;
  
      case 'S':
*************** demangle_name (dm, template_p)
*** 1010,1022 ****
  	  (void) next_char (dm);
  	  (void) next_char (dm);
  	  RETURN_IF_ERROR (result_append (dm, "std::"));
! 	  RETURN_IF_ERROR (demangle_unqualified_name (dm));
  	  is_std_substitution = 1;
  	}
        else
! 	{
! 	  RETURN_IF_ERROR (demangle_substitution (dm, template_p));
! 	}
        /* Check if a template argument list immediately follows.
  	 If so, then we just demangled an <unqualified-template-name>.  */
        if (peek_char (dm) == 'I') 
--- 1016,1027 ----
  	  (void) next_char (dm);
  	  (void) next_char (dm);
  	  RETURN_IF_ERROR (result_append (dm, "std::"));
! 	  RETURN_IF_ERROR 
! 	    (demangle_unqualified_name (dm, &suppress_return_type));
  	  is_std_substitution = 1;
  	}
        else
! 	RETURN_IF_ERROR (demangle_substitution (dm, encode_return_type));
        /* Check if a template argument list immediately follows.
  	 If so, then we just demangled an <unqualified-template-name>.  */
        if (peek_char (dm) == 'I') 
*************** demangle_name (dm, template_p)
*** 1027,1042 ****
  	    RETURN_IF_ERROR (substitution_add (dm, start, 0));
  	  /* Demangle the <template-args> here.  */
  	  RETURN_IF_ERROR (demangle_template_args (dm));
! 	  *template_p = 1;
  	}
        else
! 	*template_p = 0;
  
        break;
  
      default:
        /* This is an <unscoped-name> or <unscoped-template-name>.  */
!       RETURN_IF_ERROR (demangle_unqualified_name (dm));
  
        /* If the <unqualified-name> is followed by template args, this
  	 is an <unscoped-template-name>.  */
--- 1032,1047 ----
  	    RETURN_IF_ERROR (substitution_add (dm, start, 0));
  	  /* Demangle the <template-args> here.  */
  	  RETURN_IF_ERROR (demangle_template_args (dm));
! 	  *encode_return_type = !suppress_return_type;
  	}
        else
! 	*encode_return_type = 0;
  
        break;
  
      default:
        /* This is an <unscoped-name> or <unscoped-template-name>.  */
!       RETURN_IF_ERROR (demangle_unqualified_name (dm, &suppress_return_type));
  
        /* If the <unqualified-name> is followed by template args, this
  	 is an <unscoped-template-name>.  */
*************** demangle_name (dm, template_p)
*** 1046,1055 ****
  	  RETURN_IF_ERROR (substitution_add (dm, start, 0));
  
  	  RETURN_IF_ERROR (demangle_template_args (dm));
! 	  *template_p = 1;
  	}
        else
! 	*template_p = 0;
  
        break;
      }
--- 1051,1060 ----
  	  RETURN_IF_ERROR (substitution_add (dm, start, 0));
  
  	  RETURN_IF_ERROR (demangle_template_args (dm));
! 	  *encode_return_type = !suppress_return_type;
  	}
        else
! 	*encode_return_type = 0;
  
        break;
      }
*************** demangle_name (dm, template_p)
*** 1062,1070 ****
      <nested-name>     ::= N [<CV-qualifiers>] <prefix> <unqulified-name> E  */
  
  static status_t
! demangle_nested_name (dm, template_p)
       demangling_t dm;
!      int *template_p;
  {
    char peek;
  
--- 1067,1075 ----
      <nested-name>     ::= N [<CV-qualifiers>] <prefix> <unqulified-name> E  */
  
  static status_t
! demangle_nested_name (dm, encode_return_type)
       demangling_t dm;
!      int *encode_return_type;
  {
    char peek;
  
*************** demangle_nested_name (dm, template_p)
*** 1089,1095 ****
        RETURN_IF_ERROR (result_append_space (dm));
      }
    
!   RETURN_IF_ERROR (demangle_prefix (dm, template_p));
    /* No need to demangle the final <unqualified-name>; demangle_prefix
       will handle it.  */
    RETURN_IF_ERROR (demangle_char (dm, 'E'));
--- 1094,1100 ----
        RETURN_IF_ERROR (result_append_space (dm));
      }
    
!   RETURN_IF_ERROR (demangle_prefix (dm, encode_return_type));
    /* No need to demangle the final <unqualified-name>; demangle_prefix
       will handle it.  */
    RETURN_IF_ERROR (demangle_char (dm, 'E'));
*************** demangle_nested_name (dm, template_p)
*** 1108,1127 ****
                          ::= <substitution>  */
  
  static status_t
! demangle_prefix (dm, template_p)
       demangling_t dm;
!      int *template_p;
  {
    int start = substitution_start (dm);
    int nested = 0;
  
!   /* This flag is set to non-zero if the most recent (rightmost)
!      element in the prefix was a constructor.  */
!   int last_was_ctor = 0;
! 
!   /* TEMPLATE_P is updated as we decend the nesting chain.  After
!      <template-args>, it is set to non-zero; after everything else it
!      is set to zero.  */
  
    DEMANGLE_TRACE ("prefix", dm);
  
--- 1113,1134 ----
                          ::= <substitution>  */
  
  static status_t
! demangle_prefix (dm, encode_return_type)
       demangling_t dm;
!      int *encode_return_type;
  {
    int start = substitution_start (dm);
    int nested = 0;
  
!   /* ENCODE_RETURN_TYPE is updated as we decend the nesting chain.
!      After <template-args>, it is set to non-zero; after everything
!      else it is set to zero.  */
! 
!   /* Generally, the return type is encoded if the function is a
!      template-id, and suppressed otherwise.  There are a few cases,
!      though, in which the return type is not encoded even for a
!      templated function.  In these cases, this flag is set.  */
!   int suppress_return_type = 0;
  
    DEMANGLE_TRACE ("prefix", dm);
  
*************** demangle_prefix (dm, template_p)
*** 1134,1147 ****
  
        peek = peek_char (dm);
        
!       /* We'll initialize last_was_ctor to false, and set it to true
  	 if we end up demangling a constructor name.  However, make
  	 sure we're not actually about to demangle template arguments
  	 -- if so, this is the <template-args> following a
  	 <template-prefix>, so we'll want the previous flag value
  	 around.  */
        if (peek != 'I')
! 	last_was_ctor = 0;
  
        if (IS_DIGIT ((unsigned char) peek)
  	  || (peek >= 'a' && peek <= 'z')
--- 1141,1154 ----
  
        peek = peek_char (dm);
        
!       /* We'll initialize suppress_return_type to false, and set it to true
  	 if we end up demangling a constructor name.  However, make
  	 sure we're not actually about to demangle template arguments
  	 -- if so, this is the <template-args> following a
  	 <template-prefix>, so we'll want the previous flag value
  	 around.  */
        if (peek != 'I')
! 	suppress_return_type = 0;
  
        if (IS_DIGIT ((unsigned char) peek)
  	  || (peek >= 'a' && peek <= 'z')
*************** demangle_prefix (dm, template_p)
*** 1157,1174 ****
  	  if (peek == 'S')
  	    /* The substitution determines whether this is a
  	       template-id.  */
! 	    RETURN_IF_ERROR (demangle_substitution (dm, template_p));
  	  else
  	    {
  	      /* It's just a name.  */
! 	      RETURN_IF_ERROR (demangle_unqualified_name (dm));
! 	      *template_p = 0;
  	    }
- 
- 	  /* If this element was a constructor name, make a note of
- 	     that.  */
- 	  if (peek == 'C')
- 	    last_was_ctor = 1;
  	}
        else if (peek == 'Z')
  	RETURN_IF_ERROR (demangle_local_name (dm));
--- 1164,1177 ----
  	  if (peek == 'S')
  	    /* The substitution determines whether this is a
  	       template-id.  */
! 	    RETURN_IF_ERROR (demangle_substitution (dm, encode_return_type));
  	  else
  	    {
  	      /* It's just a name.  */
! 	      RETURN_IF_ERROR 
! 		(demangle_unqualified_name (dm, &suppress_return_type));
! 	      *encode_return_type = 0;
  	    }
  	}
        else if (peek == 'Z')
  	RETURN_IF_ERROR (demangle_local_name (dm));
*************** demangle_prefix (dm, template_p)
*** 1180,1193 ****
  	     demangled template arguments, thus the prefix was a
  	     <template-prefix>.  That's so that the caller knows to
  	     demangle the function's return type, if this turns out to
! 	     be a function name.  */
! 	  if (!last_was_ctor)
! 	    *template_p = 1;
! 	  else
! 	    /* But, if it's a member template constructor, report it
! 	       as untemplated.  We don't ever want to demangle the
! 	       return type of a constructor.  */
! 	    *template_p = 0;
  	}
        else if (peek == 'E')
  	/* All done.  */
--- 1183,1192 ----
  	     demangled template arguments, thus the prefix was a
  	     <template-prefix>.  That's so that the caller knows to
  	     demangle the function's return type, if this turns out to
! 	     be a function name.  But, if it's a member template
! 	     constructor or a templated conversion operator, report it
! 	     as untemplated.  Those never get encoded return types.  */
! 	  *encode_return_type = !suppress_return_type;
  	}
        else if (peek == 'E')
  	/* All done.  */
*************** demangle_prefix (dm, template_p)
*** 1198,1233 ****
        if (peek != 'S'
  	  && peek_char (dm) != 'E')
  	/* Add a new substitution for the prefix thus far.  */
! 	RETURN_IF_ERROR (substitution_add (dm, start, *template_p));
      }
  }
  
! /* Demangles and emits an <unqualified-name>.  If the
!    <unqualified-name> is a function and the first element in the
!    argument list should be taken to be its return type,
!    ENCODE_RETURN_TYPE is non-zero.
  
      <unqualified-name>  ::= <operator-name>
  			::= <special-name>  
  			::= <source-name>  */
  
  static status_t
! demangle_unqualified_name (dm)
       demangling_t dm;
  {
    char peek = peek_char (dm);
  
    DEMANGLE_TRACE ("unqualified-name", dm);
  
    if (IS_DIGIT ((unsigned char) peek))
      RETURN_IF_ERROR (demangle_source_name (dm));
    else if (peek >= 'a' && peek <= 'z')
      {
        int num_args;
        RETURN_IF_ERROR (demangle_operator_name (dm, 0, &num_args));
      }
    else if (peek == 'C' || peek == 'D')
!     RETURN_IF_ERROR (demangle_ctor_dtor_name (dm));
    else
      return "Unexpected character in <unqualified-name>.";
  
--- 1197,1249 ----
        if (peek != 'S'
  	  && peek_char (dm) != 'E')
  	/* Add a new substitution for the prefix thus far.  */
! 	RETURN_IF_ERROR (substitution_add (dm, start, *encode_return_type));
      }
  }
  
! /* Demangles and emits an <unqualified-name>.  If this
!    <unqualified-name> is for a special function type that should never
!    have its return type encoded (particularly, a constructor or
!    conversion operator), *SUPPRESS_RETURN_TYPE is set to 1; otherwise,
!    it is set to zero.
  
      <unqualified-name>  ::= <operator-name>
  			::= <special-name>  
  			::= <source-name>  */
  
  static status_t
! demangle_unqualified_name (dm, suppress_return_type)
       demangling_t dm;
+      int *suppress_return_type;
  {
    char peek = peek_char (dm);
  
    DEMANGLE_TRACE ("unqualified-name", dm);
  
+   /* By default, don't force suppression of the return type (though
+      non-template functions still don't get a return type encoded).  */ 
+   *suppress_return_type = 0;
+ 
    if (IS_DIGIT ((unsigned char) peek))
      RETURN_IF_ERROR (demangle_source_name (dm));
    else if (peek >= 'a' && peek <= 'z')
      {
        int num_args;
+ 
+       /* Conversion operators never have a return type encoded.  */
+       if (peek == 'c' && peek_char_next (dm) == 'v')
+ 	*suppress_return_type = 1;
+ 
        RETURN_IF_ERROR (demangle_operator_name (dm, 0, &num_args));
      }
    else if (peek == 'C' || peek == 'D')
!     {
!       /* Constructors never have a return type encoded.  */
!       if (peek == 'C')
! 	*suppress_return_type = 1;
! 
!       RETURN_IF_ERROR (demangle_ctor_dtor_name (dm));
!     }
    else
      return "Unexpected character in <unqualified-name>.";
  
*************** demangle_call_offset (dm)
*** 1725,1731 ****
  
     Also demangles the special g++ manglings,
  
!     <special-name> ::= CT <type> <offset number> _ <base type>
                                            # construction vtable
  		   ::= TF <type>	  # typeinfo function (old ABI only)
  		   ::= TJ <type>	  # java Class structure  */
--- 1741,1747 ----
  
     Also demangles the special g++ manglings,
  
!     <special-name> ::= TC <type> <offset number> _ <base type>
                                            # construction vtable
  		   ::= TF <type>	  # typeinfo function (old ABI only)
  		   ::= TJ <type>	  # java Class structure  */
*************** demangle_type (dm)
*** 2148,2154 ****
    int start = substitution_start (dm);
    char peek = peek_char (dm);
    char peek_next;
!   int template_p = 0;
    template_arg_list_t old_arg_list = current_template_arg_list (dm);
    int insert_pos;
  
--- 2164,2170 ----
    int start = substitution_start (dm);
    char peek = peek_char (dm);
    char peek_next;
!   int encode_return_type = 0;
    template_arg_list_t old_arg_list = current_template_arg_list (dm);
    int insert_pos;
  
*************** demangle_type (dm)
*** 2162,2168 ****
    /* A <class-enum-type> can start with a digit (a <source-name>), an
       N (a <nested-name>), or a Z (a <local-name>).  */
    if (IS_DIGIT ((unsigned char) peek) || peek == 'N' || peek == 'Z')
!     RETURN_IF_ERROR (demangle_class_enum_type (dm, &template_p));
    /* Lower-case letters begin <builtin-type>s, except for `r', which
       denotes restrict.  */
    else if (peek >= 'a' && peek <= 'z' && peek != 'r')
--- 2178,2184 ----
    /* A <class-enum-type> can start with a digit (a <source-name>), an
       N (a <nested-name>), or a Z (a <local-name>).  */
    if (IS_DIGIT ((unsigned char) peek) || peek == 'N' || peek == 'Z')
!     RETURN_IF_ERROR (demangle_class_enum_type (dm, &encode_return_type));
    /* Lower-case letters begin <builtin-type>s, except for `r', which
       denotes restrict.  */
    else if (peek >= 'a' && peek <= 'z' && peek != 'r')
*************** demangle_type (dm)
*** 2235,2241 ****
  	    /* Add a substitution candidate.  The template parameter
  	       `T' token is a substitution candidate by itself,
  	       without the template argument list.  */
! 	    RETURN_IF_ERROR (substitution_add (dm, start, template_p));
  
  	    /* Now demangle the template argument list.  */
  	    RETURN_IF_ERROR (demangle_template_args (dm));
--- 2251,2257 ----
  	    /* Add a substitution candidate.  The template parameter
  	       `T' token is a substitution candidate by itself,
  	       without the template argument list.  */
! 	    RETURN_IF_ERROR (substitution_add (dm, start, encode_return_type));
  
  	    /* Now demangle the template argument list.  */
  	    RETURN_IF_ERROR (demangle_template_args (dm));
*************** demangle_type (dm)
*** 2254,2260 ****
  	peek_next = peek_char_next (dm);
  	if (IS_DIGIT (peek_next) || peek_next == '_')
  	  {
! 	    RETURN_IF_ERROR (demangle_substitution (dm, &template_p));
  	    
  	    /* The substituted name may have been a template name.
  	       Check if template arguments follow, and if so, demangle
--- 2270,2276 ----
  	peek_next = peek_char_next (dm);
  	if (IS_DIGIT (peek_next) || peek_next == '_')
  	  {
! 	    RETURN_IF_ERROR (demangle_substitution (dm, &encode_return_type));
  	    
  	    /* The substituted name may have been a template name.
  	       Check if template arguments follow, and if so, demangle
*************** demangle_type (dm)
*** 2271,2277 ****
  	  /* While the special substitution token itself is not a
  	     substitution candidate, the <class-enum-type> is, so
  	     don't clear is_substitution_candidate.  */
! 	  RETURN_IF_ERROR (demangle_class_enum_type (dm, &template_p));
  
  	break;
  
--- 2287,2293 ----
  	  /* While the special substitution token itself is not a
  	     substitution candidate, the <class-enum-type> is, so
  	     don't clear is_substitution_candidate.  */
! 	  RETURN_IF_ERROR (demangle_class_enum_type (dm, &encode_return_type));
  
  	break;
  
*************** demangle_type (dm)
*** 2315,2321 ****
         <template-param>, pass its index since from the point of
         substitutions; a <template-param> token is a substitution
         candidate distinct from the type that is substituted for it.  */
!     RETURN_IF_ERROR (substitution_add (dm, start, template_p));
  
    /* Pop off template argument lists added during mangling of this
       type.  */
--- 2331,2337 ----
         <template-param>, pass its index since from the point of
         substitutions; a <template-param> token is a substitution
         candidate distinct from the type that is substituted for it.  */
!     RETURN_IF_ERROR (substitution_add (dm, start, encode_return_type));
  
    /* Pop off template argument lists added during mangling of this
       type.  */
*************** demangle_bare_function_type (dm, return_
*** 2536,2573 ****
  	     the only type in a parameter list; in that case, we want
  	     to print `foo ()' instead of `foo (void)'.  */
  	  if (peek_char (dm) == 'v')
  	    {
! 	      /* Consume the v.  */
! 	      advance_char (dm);
! 	      continue;
  	    }
- 	  /* Separate parameter types by commas.  */
- 	  if (sequence > 0)
- 	    RETURN_IF_ERROR (result_append (dm, ", "));
- 	  /* Demangle the type.  */
- 	  RETURN_IF_ERROR (demangle_type (dm));
  	}
  
        ++sequence;
      }
    RETURN_IF_ERROR (result_append_char (dm, ')'));
  
    return STATUS_OK;
  }
  
! /* Demangles and emits a <class-enum-type>.  *TEMPLATE_P is set to
     non-zero if the type is a template-id, zero otherwise.  
  
      <class-enum-type> ::= <name>  */
  
  static status_t
! demangle_class_enum_type (dm, template_p)
       demangling_t dm;
!      int *template_p;
  {
    DEMANGLE_TRACE ("class-enum-type", dm);
  
!   RETURN_IF_ERROR (demangle_name (dm, template_p));
    return STATUS_OK;
  }
  
--- 2552,2597 ----
  	     the only type in a parameter list; in that case, we want
  	     to print `foo ()' instead of `foo (void)'.  */
  	  if (peek_char (dm) == 'v')
+ 	    /* Consume the v.  */
+ 	    advance_char (dm);
+ 	  else
  	    {
! 	      /* Separate parameter types by commas.  */
! 	      if (sequence > 0)
! 		RETURN_IF_ERROR (result_append (dm, ", "));
! 	      /* Demangle the type.  */
! 	      RETURN_IF_ERROR (demangle_type (dm));
  	    }
  	}
  
        ++sequence;
      }
    RETURN_IF_ERROR (result_append_char (dm, ')'));
  
+   /* We should have demangled at least one parameter type (which would
+      be void, for a function that takes no parameters), plus the
+      return type, if we were supposed to demangle that.  */
+   if (sequence == -1)
+     return "Missing function return type.";
+   else if (sequence == 0)
+     return "Missing function parameter.";
+ 
    return STATUS_OK;
  }
  
! /* Demangles and emits a <class-enum-type>.  *ENCODE_RETURN_TYPE is set to
     non-zero if the type is a template-id, zero otherwise.  
  
      <class-enum-type> ::= <name>  */
  
  static status_t
! demangle_class_enum_type (dm, encode_return_type)
       demangling_t dm;
!      int *encode_return_type;
  {
    DEMANGLE_TRACE ("class-enum-type", dm);
  
!   RETURN_IF_ERROR (demangle_name (dm, encode_return_type));
    return STATUS_OK;
  }
  
*************** demangle_discriminator (dm, suppress_fir
*** 3204,3210 ****
       int suppress_first;
  {
    /* Output for <discriminator>s to the demangled name is completely
!      supressed if not in verbose mode.  */
  
    if (peek_char (dm) == '_')
      {
--- 3228,3234 ----
       int suppress_first;
  {
    /* Output for <discriminator>s to the demangled name is completely
!      suppressed if not in verbose mode.  */
  
    if (peek_char (dm) == '_')
      {


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]