OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [include/] [demangle.h] - Blame information for rev 174

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* 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
  /* C++0x: An rvalue reference.  The one subtree is the type which is
300
     being referenced.  */
301
  DEMANGLE_COMPONENT_RVALUE_REFERENCE,
302
  /* A complex type.  The one subtree is the base type.  */
303
  DEMANGLE_COMPONENT_COMPLEX,
304
  /* An imaginary type.  The one subtree is the base type.  */
305
  DEMANGLE_COMPONENT_IMAGINARY,
306
  /* A builtin type.  This holds the builtin type information.  */
307
  DEMANGLE_COMPONENT_BUILTIN_TYPE,
308
  /* A vendor's builtin type.  This holds the name of the type.  */
309
  DEMANGLE_COMPONENT_VENDOR_TYPE,
310
  /* A function type.  The left subtree is the return type.  The right
311
     subtree is a list of ARGLIST nodes.  Either or both may be
312
     NULL.  */
313
  DEMANGLE_COMPONENT_FUNCTION_TYPE,
314
  /* An array type.  The left subtree is the dimension, which may be
315
     NULL, or a string (represented as DEMANGLE_COMPONENT_NAME), or an
316
     expression.  The right subtree is the element type.  */
317
  DEMANGLE_COMPONENT_ARRAY_TYPE,
318
  /* A pointer to member type.  The left subtree is the class type,
319
     and the right subtree is the member type.  CV-qualifiers appear
320
     on the latter.  */
321
  DEMANGLE_COMPONENT_PTRMEM_TYPE,
322
  /* An argument list.  The left subtree is the current argument, and
323
     the right subtree is either NULL or another ARGLIST node.  */
324
  DEMANGLE_COMPONENT_ARGLIST,
325
  /* A template argument list.  The left subtree is the current
326
     template argument, and the right subtree is either NULL or
327
     another TEMPLATE_ARGLIST node.  */
328
  DEMANGLE_COMPONENT_TEMPLATE_ARGLIST,
329
  /* An operator.  This holds information about a standard
330
     operator.  */
331
  DEMANGLE_COMPONENT_OPERATOR,
332
  /* An extended operator.  This holds the number of arguments, and
333
     the name of the extended operator.  */
334
  DEMANGLE_COMPONENT_EXTENDED_OPERATOR,
335
  /* A typecast, represented as a unary operator.  The one subtree is
336
     the type to which the argument should be cast.  */
337
  DEMANGLE_COMPONENT_CAST,
338
  /* A unary expression.  The left subtree is the operator, and the
339
     right subtree is the single argument.  */
340
  DEMANGLE_COMPONENT_UNARY,
341
  /* A binary expression.  The left subtree is the operator, and the
342
     right subtree is a BINARY_ARGS.  */
343
  DEMANGLE_COMPONENT_BINARY,
344
  /* Arguments to a binary expression.  The left subtree is the first
345
     argument, and the right subtree is the second argument.  */
346
  DEMANGLE_COMPONENT_BINARY_ARGS,
347
  /* A trinary expression.  The left subtree is the operator, and the
348
     right subtree is a TRINARY_ARG1.  */
349
  DEMANGLE_COMPONENT_TRINARY,
350
  /* Arguments to a trinary expression.  The left subtree is the first
351
     argument, and the right subtree is a TRINARY_ARG2.  */
352
  DEMANGLE_COMPONENT_TRINARY_ARG1,
353
  /* More arguments to a trinary expression.  The left subtree is the
354
     second argument, and the right subtree is the third argument.  */
355
  DEMANGLE_COMPONENT_TRINARY_ARG2,
356
  /* A literal.  The left subtree is the type, and the right subtree
357
     is the value, represented as a DEMANGLE_COMPONENT_NAME.  */
358
  DEMANGLE_COMPONENT_LITERAL,
359
  /* A negative literal.  Like LITERAL, but the value is negated.
360
     This is a minor hack: the NAME used for LITERAL points directly
361
     to the mangled string, but since negative numbers are mangled
362
     using 'n' instead of '-', we want a way to indicate a negative
363
     number which involves neither modifying the mangled string nor
364
     allocating a new copy of the literal in memory.  */
365
  DEMANGLE_COMPONENT_LITERAL_NEG,
366
  /* A libgcj compiled resource.  The left subtree is the name of the
367
     resource.  */
368
  DEMANGLE_COMPONENT_JAVA_RESOURCE,
369
  /* A name formed by the concatenation of two parts.  The left
370
     subtree is the first part and the right subtree the second.  */
371
  DEMANGLE_COMPONENT_COMPOUND_NAME,
372
  /* A name formed by a single character.  */
373
  DEMANGLE_COMPONENT_CHARACTER
374
};
375
 
376
/* Types which are only used internally.  */
377
 
378
struct demangle_operator_info;
379
struct demangle_builtin_type_info;
380
 
381
/* A node in the tree representation is an instance of a struct
382
   demangle_component.  Note that the field names of the struct are
383
   not well protected against macros defined by the file including
384
   this one.  We can fix this if it ever becomes a problem.  */
385
 
386
struct demangle_component
387
{
388
  /* The type of this component.  */
389
  enum demangle_component_type type;
390
 
391
  union
392
  {
393
    /* For DEMANGLE_COMPONENT_NAME.  */
394
    struct
395
    {
396
      /* A pointer to the name (which need not NULL terminated) and
397
         its length.  */
398
      const char *s;
399
      int len;
400
    } s_name;
401
 
402
    /* For DEMANGLE_COMPONENT_OPERATOR.  */
403
    struct
404
    {
405
      /* Operator.  */
406
      const struct demangle_operator_info *op;
407
    } s_operator;
408
 
409
    /* For DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */
410
    struct
411
    {
412
      /* Number of arguments.  */
413
      int args;
414
      /* Name.  */
415
      struct demangle_component *name;
416
    } s_extended_operator;
417
 
418
    /* For DEMANGLE_COMPONENT_CTOR.  */
419
    struct
420
    {
421
      /* Kind of constructor.  */
422
      enum gnu_v3_ctor_kinds kind;
423
      /* Name.  */
424
      struct demangle_component *name;
425
    } s_ctor;
426
 
427
    /* For DEMANGLE_COMPONENT_DTOR.  */
428
    struct
429
    {
430
      /* Kind of destructor.  */
431
      enum gnu_v3_dtor_kinds kind;
432
      /* Name.  */
433
      struct demangle_component *name;
434
    } s_dtor;
435
 
436
    /* For DEMANGLE_COMPONENT_BUILTIN_TYPE.  */
437
    struct
438
    {
439
      /* Builtin type.  */
440
      const struct demangle_builtin_type_info *type;
441
    } s_builtin;
442
 
443
    /* For DEMANGLE_COMPONENT_SUB_STD.  */
444
    struct
445
    {
446
      /* Standard substitution string.  */
447
      const char* string;
448
      /* Length of string.  */
449
      int len;
450
    } s_string;
451
 
452
    /* For DEMANGLE_COMPONENT_TEMPLATE_PARAM.  */
453
    struct
454
    {
455
      /* Template parameter index.  */
456
      long number;
457
    } s_number;
458
 
459
    /* For DEMANGLE_COMPONENT_CHARACTER.  */
460
    struct
461
    {
462
      int character;
463
    } s_character;
464
 
465
    /* For other types.  */
466
    struct
467
    {
468
      /* Left (or only) subtree.  */
469
      struct demangle_component *left;
470
      /* Right subtree.  */
471
      struct demangle_component *right;
472
    } s_binary;
473
 
474
  } u;
475
};
476
 
477
/* People building mangled trees are expected to allocate instances of
478
   struct demangle_component themselves.  They can then call one of
479
   the following functions to fill them in.  */
480
 
481
/* Fill in most component types with a left subtree and a right
482
   subtree.  Returns non-zero on success, zero on failure, such as an
483
   unrecognized or inappropriate component type.  */
484
 
485
extern int
486
cplus_demangle_fill_component (struct demangle_component *fill,
487
                               enum demangle_component_type,
488
                               struct demangle_component *left,
489
                               struct demangle_component *right);
490
 
491
/* Fill in a DEMANGLE_COMPONENT_NAME.  Returns non-zero on success,
492
   zero for bad arguments.  */
493
 
494
extern int
495
cplus_demangle_fill_name (struct demangle_component *fill,
496
                          const char *, int);
497
 
498
/* Fill in a DEMANGLE_COMPONENT_BUILTIN_TYPE, using the name of the
499
   builtin type (e.g., "int", etc.).  Returns non-zero on success,
500
   zero if the type is not recognized.  */
501
 
502
extern int
503
cplus_demangle_fill_builtin_type (struct demangle_component *fill,
504
                                  const char *type_name);
505
 
506
/* Fill in a DEMANGLE_COMPONENT_OPERATOR, using the name of the
507
   operator and the number of arguments which it takes (the latter is
508
   used to disambiguate operators which can be both binary and unary,
509
   such as '-').  Returns non-zero on success, zero if the operator is
510
   not recognized.  */
511
 
512
extern int
513
cplus_demangle_fill_operator (struct demangle_component *fill,
514
                              const char *opname, int args);
515
 
516
/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR, providing the
517
   number of arguments and the name.  Returns non-zero on success,
518
   zero for bad arguments.  */
519
 
520
extern int
521
cplus_demangle_fill_extended_operator (struct demangle_component *fill,
522
                                       int numargs,
523
                                       struct demangle_component *nm);
524
 
525
/* Fill in a DEMANGLE_COMPONENT_CTOR.  Returns non-zero on success,
526
   zero for bad arguments.  */
527
 
528
extern int
529
cplus_demangle_fill_ctor (struct demangle_component *fill,
530
                          enum gnu_v3_ctor_kinds kind,
531
                          struct demangle_component *name);
532
 
533
/* Fill in a DEMANGLE_COMPONENT_DTOR.  Returns non-zero on success,
534
   zero for bad arguments.  */
535
 
536
extern int
537
cplus_demangle_fill_dtor (struct demangle_component *fill,
538
                          enum gnu_v3_dtor_kinds kind,
539
                          struct demangle_component *name);
540
 
541
/* This function translates a mangled name into a struct
542
   demangle_component tree.  The first argument is the mangled name.
543
   The second argument is DMGL_* options.  This returns a pointer to a
544
   tree on success, or NULL on failure.  On success, the third
545
   argument is set to a block of memory allocated by malloc.  This
546
   block should be passed to free when the tree is no longer
547
   needed.  */
548
 
549
extern struct demangle_component *
550
cplus_demangle_v3_components (const char *mangled, int options, void **mem);
551
 
552
/* This function takes a struct demangle_component tree and returns
553
   the corresponding demangled string.  The first argument is DMGL_*
554
   options.  The second is the tree to demangle.  The third is a guess
555
   at the length of the demangled string, used to initially allocate
556
   the return buffer.  The fourth is a pointer to a size_t.  On
557
   success, this function returns a buffer allocated by malloc(), and
558
   sets the size_t pointed to by the fourth argument to the size of
559
   the allocated buffer (not the length of the returned string).  On
560
   failure, this function returns NULL, and sets the size_t pointed to
561
   by the fourth argument to 0 for an invalid tree, or to 1 for a
562
   memory allocation error.  */
563
 
564
extern char *
565
cplus_demangle_print (int options,
566
                      const struct demangle_component *tree,
567
                      int estimated_length,
568
                      size_t *p_allocated_size);
569
 
570
/* This function takes a struct demangle_component tree and passes back
571
   a demangled string in one or more calls to a callback function.
572
   The first argument is DMGL_* options.  The second is the tree to
573
   demangle.  The third is a pointer to a callback function; on each call
574
   this receives an element of the demangled string, its length, and an
575
   opaque value.  The fourth is the opaque value passed to the callback.
576
   The callback is called once or more to return the full demangled
577
   string.  The demangled element string is always nul-terminated, though
578
   its length is also provided for convenience.  In contrast to
579
   cplus_demangle_print(), this function does not allocate heap memory
580
   to grow output strings (except perhaps where alloca() is implemented
581
   by malloc()), and so is normally safe for use where the heap has been
582
   corrupted.  On success, this function returns 1; on failure, 0.  */
583
 
584
extern int
585
cplus_demangle_print_callback (int options,
586
                               const struct demangle_component *tree,
587
                               demangle_callbackref callback, void *opaque);
588
 
589
#ifdef __cplusplus
590
}
591
#endif /* __cplusplus */
592
 
593
#endif  /* DEMANGLE_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.