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