/[gnats]/gnats/include/demangle.h
ViewVC logotype

Diff of /gnats/include/demangle.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2 by jsm, Tue Oct 26 07:10:16 1999 UTC revision 1.3 by chewie, Sat Nov 13 05:14:17 2004 UTC
# Line 1  Line 1 
1  /* Defs for interface to demanglers.  /* Defs for interface to demanglers.
2     Copyright 1992, 1995, 1996 Free Software Foundation, Inc.     Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002,
3       2003, 2004 Free Software Foundation, Inc.
4        
5     This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
# Line 20  Line 21 
21  #if !defined (DEMANGLE_H)  #if !defined (DEMANGLE_H)
22  #define DEMANGLE_H  #define DEMANGLE_H
23    
24  #include <ansidecl.h>  #include "libiberty.h"
25    
26    #ifdef __cplusplus
27    extern "C" {
28    #endif /* __cplusplus */
29    
30  /* Options passed to cplus_demangle (in 2nd parameter). */  /* Options passed to cplus_demangle (in 2nd parameter). */
31    
32  #define DMGL_NO_OPTS    0               /* For readability... */  #define DMGL_NO_OPTS     0              /* For readability... */
33  #define DMGL_PARAMS     (1 << 0)        /* Include function args */  #define DMGL_PARAMS      (1 << 0)       /* Include function args */
34  #define DMGL_ANSI       (1 << 1)        /* Include const, volatile, etc */  #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
35  #define DMGL_JAVA       (1 << 2)        /* Demangle as Java rather than C++. */  #define DMGL_JAVA        (1 << 2)       /* Demangle as Java rather than C++. */
36    #define DMGL_VERBOSE     (1 << 3)       /* Include implementation details.  */
37  #define DMGL_AUTO       (1 << 8)  #define DMGL_TYPES       (1 << 4)       /* Also try to demangle type encodings.  */
38  #define DMGL_GNU        (1 << 9)  
39  #define DMGL_LUCID      (1 << 10)  #define DMGL_AUTO        (1 << 8)
40  #define DMGL_ARM        (1 << 11)  #define DMGL_GNU         (1 << 9)
41  #define DMGL_HP         (1 << 12)       /* For the HP aCC compiler; same as ARM  #define DMGL_LUCID       (1 << 10)
42                                             except for template arguments, etc. */  #define DMGL_ARM         (1 << 11)
43  #define DMGL_EDG        (1 << 13)  #define DMGL_HP          (1 << 12)       /* For the HP aCC compiler;
44                                                same as ARM except for
45                                                template arguments, etc. */
46    #define DMGL_EDG         (1 << 13)
47    #define DMGL_GNU_V3      (1 << 14)
48    #define DMGL_GNAT        (1 << 15)
49    
50  /* If none of these are set, use 'current_demangling_style' as the default. */  /* If none of these are set, use 'current_demangling_style' as the default. */
51  #define DMGL_STYLE_MASK (DMGL_AUTO|DMGL_GNU|DMGL_LUCID|DMGL_ARM|DMGL_HP|DMGL_EDG)  #define DMGL_STYLE_MASK (DMGL_AUTO|DMGL_GNU|DMGL_LUCID|DMGL_ARM|DMGL_HP|DMGL_EDG|DMGL_GNU_V3|DMGL_JAVA|DMGL_GNAT)
52    
53  /* Enumeration of possible demangling styles.  /* Enumeration of possible demangling styles.
54    
# Line 50  Line 60 
60    
61  extern enum demangling_styles  extern enum demangling_styles
62  {  {
63      no_demangling = -1,
64    unknown_demangling = 0,    unknown_demangling = 0,
65    auto_demangling = DMGL_AUTO,    auto_demangling = DMGL_AUTO,
66    gnu_demangling = DMGL_GNU,    gnu_demangling = DMGL_GNU,
67    lucid_demangling = DMGL_LUCID,    lucid_demangling = DMGL_LUCID,
68    arm_demangling = DMGL_ARM,    arm_demangling = DMGL_ARM,
69    hp_demangling = DMGL_HP,    hp_demangling = DMGL_HP,
70    edg_demangling = DMGL_EDG    edg_demangling = DMGL_EDG,
71      gnu_v3_demangling = DMGL_GNU_V3,
72      java_demangling = DMGL_JAVA,
73      gnat_demangling = DMGL_GNAT
74  } current_demangling_style;  } current_demangling_style;
75    
76  /* Define string names for the various demangling styles. */  /* Define string names for the various demangling styles. */
77    
78  #define AUTO_DEMANGLING_STYLE_STRING    "auto"  #define NO_DEMANGLING_STYLE_STRING            "none"
79  #define GNU_DEMANGLING_STYLE_STRING     "gnu"  #define AUTO_DEMANGLING_STYLE_STRING          "auto"
80  #define LUCID_DEMANGLING_STYLE_STRING   "lucid"  #define GNU_DEMANGLING_STYLE_STRING           "gnu"
81  #define ARM_DEMANGLING_STYLE_STRING     "arm"  #define LUCID_DEMANGLING_STYLE_STRING         "lucid"
82  #define HP_DEMANGLING_STYLE_STRING      "hp"  #define ARM_DEMANGLING_STYLE_STRING           "arm"
83  #define EDG_DEMANGLING_STYLE_STRING     "edg"  #define HP_DEMANGLING_STYLE_STRING            "hp"
84    #define EDG_DEMANGLING_STYLE_STRING           "edg"
85    #define GNU_V3_DEMANGLING_STYLE_STRING        "gnu-v3"
86    #define JAVA_DEMANGLING_STYLE_STRING          "java"
87    #define GNAT_DEMANGLING_STYLE_STRING          "gnat"
88    
89  /* Some macros to test what demangling style is active. */  /* Some macros to test what demangling style is active. */
90    
# Line 77  extern enum demangling_styles Line 95  extern enum demangling_styles
95  #define ARM_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_ARM)  #define ARM_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_ARM)
96  #define HP_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_HP)  #define HP_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_HP)
97  #define EDG_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_EDG)  #define EDG_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_EDG)
98    #define GNU_V3_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_GNU_V3)
99    #define JAVA_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_JAVA)
100    #define GNAT_DEMANGLING (((int) CURRENT_DEMANGLING_STYLE) & DMGL_GNAT)
101    
102    /* Provide information about the available demangle styles. This code is
103       pulled from gdb into libiberty because it is useful to binutils also.  */
104    
105    extern const struct demangler_engine
106    {
107      const char *const demangling_style_name;
108      const enum demangling_styles demangling_style;
109      const char *const demangling_style_doc;
110    } libiberty_demanglers[];
111    
112  extern char *  extern char *
113  cplus_demangle PARAMS ((const char *mangled, int options));  cplus_demangle PARAMS ((const char *mangled, int options));
# Line 92  cplus_mangle_opname PARAMS ((const char Line 123  cplus_mangle_opname PARAMS ((const char
123  extern void  extern void
124  set_cplus_marker_for_demangling PARAMS ((int ch));  set_cplus_marker_for_demangling PARAMS ((int ch));
125    
126    extern enum demangling_styles
127    cplus_demangle_set_style PARAMS ((enum demangling_styles style));
128    
129    extern enum demangling_styles
130    cplus_demangle_name_to_style PARAMS ((const char *name));
131    
132    /* V3 ABI demangling entry points, defined in cp-demangle.c.  */
133    extern char*
134    cplus_demangle_v3 PARAMS ((const char* mangled, int options));
135    
136    extern char*
137    java_demangle_v3 PARAMS ((const char* mangled));
138    
139    
140    enum gnu_v3_ctor_kinds {
141      gnu_v3_complete_object_ctor = 1,
142      gnu_v3_base_object_ctor,
143      gnu_v3_complete_object_allocating_ctor
144    };
145    
146    /* Return non-zero iff NAME is the mangled form of a constructor name
147       in the G++ V3 ABI demangling style.  Specifically, return an `enum
148       gnu_v3_ctor_kinds' value indicating what kind of constructor
149       it is.  */
150    extern enum gnu_v3_ctor_kinds
151            is_gnu_v3_mangled_ctor PARAMS ((const char *name));
152    
153    
154    enum gnu_v3_dtor_kinds {
155      gnu_v3_deleting_dtor = 1,
156      gnu_v3_complete_object_dtor,
157      gnu_v3_base_object_dtor
158    };
159    
160    /* Return non-zero iff NAME is the mangled form of a destructor name
161       in the G++ V3 ABI demangling style.  Specifically, return an `enum
162       gnu_v3_dtor_kinds' value, indicating what kind of destructor
163       it is.  */
164    extern enum gnu_v3_dtor_kinds
165            is_gnu_v3_mangled_dtor PARAMS ((const char *name));
166    
167    /* The V3 demangler works in two passes.  The first pass builds a tree
168       representation of the mangled name, and the second pass turns the
169       tree representation into a demangled string.  Here we define an
170       interface to permit a caller to build their own tree
171       representation, which they can pass to the demangler to get a
172       demangled string.  This can be used to canonicalize user input into
173       something which the demangler might output.  It could also be used
174       by other demanglers in the future.  */
175    
176    /* These are the component types which may be found in the tree.  Many
177       component types have one or two subtrees, referred to as left and
178       right (a component type with only one subtree puts it in the left
179       subtree).  */
180    
181    enum demangle_component_type
182    {
183      /* A name, with a length and a pointer to a string.  */
184      DEMANGLE_COMPONENT_NAME,
185      /* A qualified name.  The left subtree is a class or namespace or
186         some such thing, and the right subtree is a name qualified by
187         that class.  */
188      DEMANGLE_COMPONENT_QUAL_NAME,
189      /* A local name.  The left subtree describes a function, and the
190         right subtree is a name which is local to that function.  */
191      DEMANGLE_COMPONENT_LOCAL_NAME,
192      /* A typed name.  The left subtree is a name, and the right subtree
193         describes that name as a function.  */
194      DEMANGLE_COMPONENT_TYPED_NAME,
195      /* A template.  The left subtree is a template name, and the right
196         subtree is a template argument list.  */
197      DEMANGLE_COMPONENT_TEMPLATE,
198      /* A template parameter.  This holds a number, which is the template
199         parameter index.  */
200      DEMANGLE_COMPONENT_TEMPLATE_PARAM,
201      /* A constructor.  This holds a name and the kind of
202         constructor.  */
203      DEMANGLE_COMPONENT_CTOR,
204      /* A destructor.  This holds a name and the kind of destructor.  */
205      DEMANGLE_COMPONENT_DTOR,
206      /* A vtable.  This has one subtree, the type for which this is a
207         vtable.  */
208      DEMANGLE_COMPONENT_VTABLE,
209      /* A VTT structure.  This has one subtree, the type for which this
210         is a VTT.  */
211      DEMANGLE_COMPONENT_VTT,
212      /* A construction vtable.  The left subtree is the type for which
213         this is a vtable, and the right subtree is the derived type for
214         which this vtable is built.  */
215      DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
216      /* A typeinfo structure.  This has one subtree, the type for which
217         this is the tpeinfo structure.  */
218      DEMANGLE_COMPONENT_TYPEINFO,
219      /* A typeinfo name.  This has one subtree, the type for which this
220         is the typeinfo name.  */
221      DEMANGLE_COMPONENT_TYPEINFO_NAME,
222      /* A typeinfo function.  This has one subtree, the type for which
223         this is the tpyeinfo function.  */
224      DEMANGLE_COMPONENT_TYPEINFO_FN,
225      /* A thunk.  This has one subtree, the name for which this is a
226         thunk.  */
227      DEMANGLE_COMPONENT_THUNK,
228      /* A virtual thunk.  This has one subtree, the name for which this
229         is a virtual thunk.  */
230      DEMANGLE_COMPONENT_VIRTUAL_THUNK,
231      /* A covariant thunk.  This has one subtree, the name for which this
232         is a covariant thunk.  */
233      DEMANGLE_COMPONENT_COVARIANT_THUNK,
234      /* A Java class.  This has one subtree, the type.  */
235      DEMANGLE_COMPONENT_JAVA_CLASS,
236      /* A guard variable.  This has one subtree, the name for which this
237         is a guard variable.  */
238      DEMANGLE_COMPONENT_GUARD,
239      /* A reference temporary.  This has one subtree, the name for which
240         this is a temporary.  */
241      DEMANGLE_COMPONENT_REFTEMP,
242      /* A standard substitution.  This holds the name of the
243         substitution.  */
244      DEMANGLE_COMPONENT_SUB_STD,
245      /* The restrict qualifier.  The one subtree is the type which is
246         being qualified.  */
247      DEMANGLE_COMPONENT_RESTRICT,
248      /* The volatile qualifier.  The one subtree is the type which is
249         being qualified.  */
250      DEMANGLE_COMPONENT_VOLATILE,
251      /* The const qualifier.  The one subtree is the type which is being
252         qualified.  */
253      DEMANGLE_COMPONENT_CONST,
254      /* The restrict qualifier modifying a member function.  The one
255         subtree is the type which is being qualified.  */
256      DEMANGLE_COMPONENT_RESTRICT_THIS,
257      /* The volatile qualifier modifying a member function.  The one
258         subtree is the type which is being qualified.  */
259      DEMANGLE_COMPONENT_VOLATILE_THIS,
260      /* The const qualifier modifying a member function.  The one subtree
261         is the type which is being qualified.  */
262      DEMANGLE_COMPONENT_CONST_THIS,
263      /* A vendor qualifier.  The left subtree is the type which is being
264         qualified, and the right subtree is the name of the
265         qualifier.  */
266      DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
267      /* A pointer.  The one subtree is the type which is being pointed
268         to.  */
269      DEMANGLE_COMPONENT_POINTER,
270      /* A reference.  The one subtree is the type which is being
271         referenced.  */
272      DEMANGLE_COMPONENT_REFERENCE,
273      /* A complex type.  The one subtree is the base type.  */
274      DEMANGLE_COMPONENT_COMPLEX,
275      /* An imaginary type.  The one subtree is the base type.  */
276      DEMANGLE_COMPONENT_IMAGINARY,
277      /* A builtin type.  This holds the builtin type information.  */
278      DEMANGLE_COMPONENT_BUILTIN_TYPE,
279      /* A vendor's builtin type.  This holds the name of the type.  */
280      DEMANGLE_COMPONENT_VENDOR_TYPE,
281      /* A function type.  The left subtree is the return type.  The right
282         subtree is a list of ARGLIST nodes.  Either or both may be
283         NULL.  */
284      DEMANGLE_COMPONENT_FUNCTION_TYPE,
285      /* An array type.  The left subtree is the dimension, which may be
286         NULL, or a string (represented as DEMANGLE_COMPONENT_NAME), or an
287         expression.  The right subtree is the element type.  */
288      DEMANGLE_COMPONENT_ARRAY_TYPE,
289      /* A pointer to member type.  The left subtree is the class type,
290         and the right subtree is the member type.  CV-qualifiers appear
291         on the latter.  */
292      DEMANGLE_COMPONENT_PTRMEM_TYPE,
293      /* An argument list.  The left subtree is the current argument, and
294         the right subtree is either NULL or another ARGLIST node.  */
295      DEMANGLE_COMPONENT_ARGLIST,
296      /* A template argument list.  The left subtree is the current
297         template argument, and the right subtree is either NULL or
298         another TEMPLATE_ARGLIST node.  */
299      DEMANGLE_COMPONENT_TEMPLATE_ARGLIST,
300      /* An operator.  This holds information about a standard
301         operator.  */
302      DEMANGLE_COMPONENT_OPERATOR,
303      /* An extended operator.  This holds the number of arguments, and
304         the name of the extended operator.  */
305      DEMANGLE_COMPONENT_EXTENDED_OPERATOR,
306      /* A typecast, represented as a unary operator.  The one subtree is
307         the type to which the argument should be cast.  */
308      DEMANGLE_COMPONENT_CAST,
309      /* A unary expression.  The left subtree is the operator, and the
310         right subtree is the single argument.  */
311      DEMANGLE_COMPONENT_UNARY,
312      /* A binary expression.  The left subtree is the operator, and the
313         right subtree is a BINARY_ARGS.  */
314      DEMANGLE_COMPONENT_BINARY,
315      /* Arguments to a binary expression.  The left subtree is the first
316         argument, and the right subtree is the second argument.  */
317      DEMANGLE_COMPONENT_BINARY_ARGS,
318      /* A trinary expression.  The left subtree is the operator, and the
319         right subtree is a TRINARY_ARG1.  */
320      DEMANGLE_COMPONENT_TRINARY,
321      /* Arguments to a trinary expression.  The left subtree is the first
322         argument, and the right subtree is a TRINARY_ARG2.  */
323      DEMANGLE_COMPONENT_TRINARY_ARG1,
324      /* More arguments to a trinary expression.  The left subtree is the
325         second argument, and the right subtree is the third argument.  */
326      DEMANGLE_COMPONENT_TRINARY_ARG2,
327      /* A literal.  The left subtree is the type, and the right subtree
328         is the value, represented as a DEMANGLE_COMPONENT_NAME.  */
329      DEMANGLE_COMPONENT_LITERAL,
330      /* A negative literal.  Like LITERAL, but the value is negated.
331         This is a minor hack: the NAME used for LITERAL points directly
332         to the mangled string, but since negative numbers are mangled
333         using 'n' instead of '-', we want a way to indicate a negative
334         number which involves neither modifying the mangled string nor
335         allocating a new copy of the literal in memory.  */
336      DEMANGLE_COMPONENT_LITERAL_NEG
337    };
338    
339    /* Types which are only used internally.  */
340    
341    struct demangle_operator_info;
342    struct demangle_builtin_type_info;
343    
344    /* A node in the tree representation is an instance of a struct
345       demangle_component.  Note that the field names of the struct are
346       not well protected against macros defined by the file including
347       this one.  We can fix this if it ever becomes a problem.  */
348    
349    struct demangle_component
350    {
351      /* The type of this component.  */
352      enum demangle_component_type type;
353    
354      union
355      {
356        /* For DEMANGLE_COMPONENT_NAME.  */
357        struct
358        {
359          /* A pointer to the name (which need not NULL terminated) and
360             its length.  */
361          const char *s;
362          int len;
363        } s_name;
364    
365        /* For DEMANGLE_COMPONENT_OPERATOR.  */
366        struct
367        {
368          /* Operator.  */
369          const struct demangle_operator_info *op;
370        } s_operator;
371    
372        /* For DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */
373        struct
374        {
375          /* Number of arguments.  */
376          int args;
377          /* Name.  */
378          struct demangle_component *name;
379        } s_extended_operator;
380    
381        /* For DEMANGLE_COMPONENT_CTOR.  */
382        struct
383        {
384          /* Kind of constructor.  */
385          enum gnu_v3_ctor_kinds kind;
386          /* Name.  */
387          struct demangle_component *name;
388        } s_ctor;
389    
390        /* For DEMANGLE_COMPONENT_DTOR.  */
391        struct
392        {
393          /* Kind of destructor.  */
394          enum gnu_v3_dtor_kinds kind;
395          /* Name.  */
396          struct demangle_component *name;
397        } s_dtor;
398    
399        /* For DEMANGLE_COMPONENT_BUILTIN_TYPE.  */
400        struct
401        {
402          /* Builtin type.  */
403          const struct demangle_builtin_type_info *type;
404        } s_builtin;
405    
406        /* For DEMANGLE_COMPONENT_SUB_STD.  */
407        struct
408        {
409          /* Standard substitution string.  */
410          const char* string;
411          /* Length of string.  */
412          int len;
413        } s_string;
414    
415        /* For DEMANGLE_COMPONENT_TEMPLATE_PARAM.  */
416        struct
417        {
418          /* Template parameter index.  */
419          long number;
420        } s_number;
421    
422        /* For other types.  */
423        struct
424        {
425          /* Left (or only) subtree.  */
426          struct demangle_component *left;
427          /* Right subtree.  */
428          struct demangle_component *right;
429        } s_binary;
430    
431      } u;
432    };
433    
434    /* People building mangled trees are expected to allocate instances of
435       struct demangle_component themselves.  They can then call one of
436       the following functions to fill them in.  */
437    
438    /* Fill in most component types with a left subtree and a right
439       subtree.  Returns non-zero on success, zero on failure, such as an
440       unrecognized or inappropriate component type.  */
441    
442    extern int
443    cplus_demangle_fill_component PARAMS ((struct demangle_component *fill,
444                                           enum demangle_component_type,
445                                           struct demangle_component *left,
446                                           struct demangle_component *right));
447    
448    /* Fill in a DEMANGLE_COMPONENT_NAME.  Returns non-zero on success,
449       zero for bad arguments.  */
450    
451    extern int
452    cplus_demangle_fill_name PARAMS ((struct demangle_component *fill,
453                                      const char *, int));
454    
455    /* Fill in a DEMANGLE_COMPONENT_BUILTIN_TYPE, using the name of the
456       builtin type (e.g., "int", etc.).  Returns non-zero on success,
457       zero if the type is not recognized.  */
458    
459    extern int
460    cplus_demangle_fill_builtin_type PARAMS ((struct demangle_component *fill,
461                                              const char *typename));
462    
463    /* Fill in a DEMANGLE_COMPONENT_OPERATOR, using the name of the
464       operator and the number of arguments which it takes (the latter is
465       used to disambiguate operators which can be both binary and unary,
466       such as '-').  Returns non-zero on success, zero if the operator is
467       not recognized.  */
468    
469    extern int
470    cplus_demangle_fill_operator PARAMS ((struct demangle_component *fill,
471                                          const char *opname, int args));
472    
473    /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR, providing the
474       number of arguments and the name.  Returns non-zero on success,
475       zero for bad arguments.  */
476    
477    extern int
478    cplus_demangle_fill_extended_operator PARAMS ((struct demangle_component *fill,
479                                                   int numargs,
480                                                   struct demangle_component *nm));
481    
482    /* Fill in a DEMANGLE_COMPONENT_CTOR.  Returns non-zero on success,
483       zero for bad arguments.  */
484    
485    extern int
486    cplus_demangle_fill_ctor PARAMS ((struct demangle_component *fill,
487                                      enum gnu_v3_ctor_kinds kind,
488                                      struct demangle_component *name));
489    
490    /* Fill in a DEMANGLE_COMPONENT_DTOR.  Returns non-zero on success,
491       zero for bad arguments.  */
492    
493    extern int
494    cplus_demangle_fill_dtor PARAMS ((struct demangle_component *fill,
495                                      enum gnu_v3_dtor_kinds kind,
496                                      struct demangle_component *name));
497    
498    /* This function translates a mangled name into a struct
499       demangle_component tree.  The first argument is the mangled name.
500       The second argument is DMGL_* options.  This returns a pointer to a
501       tree on success, or NULL on failure.  On success, the third
502       argument is set to a block of memory allocated by malloc.  This
503       block should be passed to free when the tree is no longer
504       needed.  */
505    
506    extern struct demangle_component *
507    cplus_demangle_v3_components PARAMS ((const char *mangled,
508                                          int options,
509                                          void **mem));
510    
511    /* This function takes a struct demangle_component tree and returns
512       the corresponding demangled string.  The first argument is DMGL_*
513       options.  The second is the tree to demangle.  The third is a guess
514       at the length of the demangled string, used to initially allocate
515       the return buffer.  The fourth is a pointer to a size_t.  On
516       success, this function returns a buffer allocated by malloc(), and
517       sets the size_t pointed to by the fourth argument to the size of
518       the allocated buffer (not the length of the returned string).  On
519       failure, this function returns NULL, and sets the size_t pointed to
520       by the fourth argument to 0 for an invalid tree, or to 1 for a
521       memory allocation error.  */
522    
523    extern char *
524    cplus_demangle_print PARAMS ((int options,
525                                  const struct demangle_component *tree,
526                                  int estimated_length,
527                                  size_t *p_allocated_size));
528    
529    #ifdef __cplusplus
530    }
531    #endif /* __cplusplus */
532    
533  #endif  /* DEMANGLE_H */  #endif  /* DEMANGLE_H */

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26