00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089 #ifdef HAVE_CONFIG_H
00090 #include "config.h"
00091 #endif
00092
00093 #include <stdio.h>
00094
00095 #ifdef HAVE_STDLIB_H
00096 #include <stdlib.h>
00097 #endif
00098 #ifdef HAVE_STRING_H
00099 #include <string.h>
00100 #endif
00101
00102 #include "ansidecl.h"
00103 #include "libiberty.h"
00104 #include "demangle.h"
00105 #include "cp-demangle.h"
00106
00107
00108
00109
00110
00111 #ifdef IN_GLIBCPP_V3
00112
00113 #define CP_STATIC_IF_GLIBCPP_V3 static
00114
00115 #define cplus_demangle_fill_name d_fill_name
00116 static int
00117 d_fill_name PARAMS ((struct demangle_component *, const char *, int));
00118
00119 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
00120 static int
00121 d_fill_extended_operator PARAMS ((struct demangle_component *, int,
00122 struct demangle_component *));
00123
00124 #define cplus_demangle_fill_ctor d_fill_ctor
00125 static int
00126 d_fill_ctor PARAMS ((struct demangle_component *, enum gnu_v3_ctor_kinds,
00127 struct demangle_component *));
00128
00129 #define cplus_demangle_fill_dtor d_fill_dtor
00130 static int
00131 d_fill_dtor PARAMS ((struct demangle_component *, enum gnu_v3_dtor_kinds,
00132 struct demangle_component *));
00133
00134 #define cplus_demangle_mangled_name d_mangled_name
00135 static struct demangle_component *
00136 d_mangled_name PARAMS ((struct d_info *, int));
00137
00138 #define cplus_demangle_type d_type
00139 static struct demangle_component *
00140 d_type PARAMS ((struct d_info *));
00141
00142 #define cplus_demangle_print d_print
00143 static char *
00144 d_print PARAMS ((int, const struct demangle_component *, int, size_t *));
00145
00146 #define cplus_demangle_init_info d_init_info
00147 static void
00148 d_init_info PARAMS ((const char *, int, size_t, struct d_info *));
00149
00150 #else
00151 #define CP_STATIC_IF_GLIBCPP_V3
00152 #endif
00153
00154
00155
00156 #ifdef __GNUC__
00157 #define CP_DYNAMIC_ARRAYS
00158 #else
00159 #ifdef __STDC__
00160 #ifdef __STDC_VERSION__
00161 #if __STDC_VERSION__ >= 199901L
00162 #define CP_DYNAMIC_ARRAYS
00163 #endif
00164 #endif
00165 #endif
00166 #endif
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
00178 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
00179 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
00180
00181
00182
00183 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
00184 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
00185 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
00186
00187
00188
00189 struct d_standard_sub_info
00190 {
00191
00192 char code;
00193
00194 const char *simple_expansion;
00195
00196 int simple_len;
00197
00198
00199 const char *full_expansion;
00200
00201 int full_len;
00202
00203
00204
00205 const char *set_last_name;
00206
00207 int set_last_name_len;
00208 };
00209
00210
00211
00212 #define d_left(dc) ((dc)->u.s_binary.left)
00213 #define d_right(dc) ((dc)->u.s_binary.right)
00214
00215
00216
00217 struct d_print_template
00218 {
00219
00220 struct d_print_template *next;
00221
00222 const struct demangle_component *template;
00223 };
00224
00225
00226
00227 struct d_print_mod
00228 {
00229
00230
00231 struct d_print_mod *next;
00232
00233 const struct demangle_component *mod;
00234
00235 int printed;
00236
00237 struct d_print_template *templates;
00238 };
00239
00240
00241
00242 struct d_print_info
00243 {
00244
00245 int options;
00246
00247 char *buf;
00248
00249 size_t len;
00250
00251 size_t alc;
00252
00253 struct d_print_template *templates;
00254
00255
00256 struct d_print_mod *modifiers;
00257
00258 int allocation_failure;
00259 };
00260
00261 #define d_print_saw_error(dpi) ((dpi)->buf == NULL)
00262
00263 #define d_append_char(dpi, c) \
00264 do \
00265 { \
00266 if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \
00267 (dpi)->buf[(dpi)->len++] = (c); \
00268 else \
00269 d_print_append_char ((dpi), (c)); \
00270 } \
00271 while (0)
00272
00273 #define d_append_buffer(dpi, s, l) \
00274 do \
00275 { \
00276 if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \
00277 { \
00278 memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \
00279 (dpi)->len += l; \
00280 } \
00281 else \
00282 d_print_append_buffer ((dpi), (s), (l)); \
00283 } \
00284 while (0)
00285
00286 #define d_append_string_constant(dpi, s) \
00287 d_append_buffer (dpi, (s), sizeof (s) - 1)
00288
00289 #define d_last_char(dpi) \
00290 ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
00291
00292 #ifdef CP_DEMANGLE_DEBUG
00293 static void
00294 d_dump PARAMS ((struct demangle_component *, int));
00295 #endif
00296
00297 static struct demangle_component *
00298 d_make_empty PARAMS ((struct d_info *));
00299
00300 static struct demangle_component *
00301 d_make_comp PARAMS ((struct d_info *, enum demangle_component_type,
00302 struct demangle_component *,
00303 struct demangle_component *));
00304
00305 static struct demangle_component *
00306 d_make_name PARAMS ((struct d_info *, const char *, int));
00307
00308 static struct demangle_component *
00309 d_make_builtin_type PARAMS ((struct d_info *,
00310 const struct demangle_builtin_type_info *));
00311
00312 static struct demangle_component *
00313 d_make_operator PARAMS ((struct d_info *,
00314 const struct demangle_operator_info *));
00315
00316 static struct demangle_component *
00317 d_make_extended_operator PARAMS ((struct d_info *, int,
00318 struct demangle_component *));
00319
00320 static struct demangle_component *
00321 d_make_ctor PARAMS ((struct d_info *, enum gnu_v3_ctor_kinds,
00322 struct demangle_component *));
00323
00324 static struct demangle_component *
00325 d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds,
00326 struct demangle_component *));
00327
00328 static struct demangle_component *
00329 d_make_template_param PARAMS ((struct d_info *, long));
00330
00331 static struct demangle_component *
00332 d_make_sub PARAMS ((struct d_info *, const char *, int));
00333
00334 static int
00335 has_return_type PARAMS ((struct demangle_component *));
00336
00337 static int
00338 is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *));
00339
00340 static struct demangle_component *
00341 d_encoding PARAMS ((struct d_info *, int));
00342
00343 static struct demangle_component *
00344 d_name PARAMS ((struct d_info *));
00345
00346 static struct demangle_component *
00347 d_nested_name PARAMS ((struct d_info *));
00348
00349 static struct demangle_component *
00350 d_prefix PARAMS ((struct d_info *));
00351
00352 static struct demangle_component *
00353 d_unqualified_name PARAMS ((struct d_info *));
00354
00355 static struct demangle_component *
00356 d_source_name PARAMS ((struct d_info *));
00357
00358 static long
00359 d_number PARAMS ((struct d_info *));
00360
00361 static struct demangle_component *
00362 d_identifier PARAMS ((struct d_info *, int));
00363
00364 static struct demangle_component *
00365 d_operator_name PARAMS ((struct d_info *));
00366
00367 static struct demangle_component *
00368 d_special_name PARAMS ((struct d_info *));
00369
00370 static int
00371 d_call_offset PARAMS ((struct d_info *, int));
00372
00373 static struct demangle_component *
00374 d_ctor_dtor_name PARAMS ((struct d_info *));
00375
00376 static struct demangle_component **
00377 d_cv_qualifiers PARAMS ((struct d_info *, struct demangle_component **, int));
00378
00379 static struct demangle_component *
00380 d_function_type PARAMS ((struct d_info *));
00381
00382 static struct demangle_component *
00383 d_bare_function_type PARAMS ((struct d_info *, int));
00384
00385 static struct demangle_component *
00386 d_class_enum_type PARAMS ((struct d_info *));
00387
00388 static struct demangle_component *
00389 d_array_type PARAMS ((struct d_info *));
00390
00391 static struct demangle_component *
00392 d_pointer_to_member_type PARAMS ((struct d_info *));
00393
00394 static struct demangle_component *
00395 d_template_param PARAMS ((struct d_info *));
00396
00397 static struct demangle_component *
00398 d_template_args PARAMS ((struct d_info *));
00399
00400 static struct demangle_component *
00401 d_template_arg PARAMS ((struct d_info *));
00402
00403 static struct demangle_component *
00404 d_expression PARAMS ((struct d_info *));
00405
00406 static struct demangle_component *
00407 d_expr_primary PARAMS ((struct d_info *));
00408
00409 static struct demangle_component *
00410 d_local_name PARAMS ((struct d_info *));
00411
00412 static int
00413 d_discriminator PARAMS ((struct d_info *));
00414
00415 static int
00416 d_add_substitution PARAMS ((struct d_info *, struct demangle_component *));
00417
00418 static struct demangle_component *
00419 d_substitution PARAMS ((struct d_info *, int));
00420
00421 static void
00422 d_print_resize PARAMS ((struct d_print_info *, size_t));
00423
00424 static void
00425 d_print_append_char PARAMS ((struct d_print_info *, int));
00426
00427 static void
00428 d_print_append_buffer PARAMS ((struct d_print_info *, const char *, size_t));
00429
00430 static void
00431 d_print_error PARAMS ((struct d_print_info *));
00432
00433 static void
00434 d_print_comp PARAMS ((struct d_print_info *,
00435 const struct demangle_component *));
00436
00437 static void
00438 d_print_java_identifier PARAMS ((struct d_print_info *, const char *, int));
00439
00440 static void
00441 d_print_mod_list PARAMS ((struct d_print_info *, struct d_print_mod *, int));
00442
00443 static void
00444 d_print_mod PARAMS ((struct d_print_info *,
00445 const struct demangle_component *));
00446
00447 static void
00448 d_print_function_type PARAMS ((struct d_print_info *,
00449 const struct demangle_component *,
00450 struct d_print_mod *));
00451
00452 static void
00453 d_print_array_type PARAMS ((struct d_print_info *,
00454 const struct demangle_component *,
00455 struct d_print_mod *));
00456
00457 static void
00458 d_print_expr_op PARAMS ((struct d_print_info *,
00459 const struct demangle_component *));
00460
00461 static void
00462 d_print_cast PARAMS ((struct d_print_info *,
00463 const struct demangle_component *));
00464
00465 static char *
00466 d_demangle PARAMS ((const char *, int, size_t *));
00467
00468 #ifdef CP_DEMANGLE_DEBUG
00469
00470 static void
00471 d_dump (dc, indent)
00472 struct demangle_component *dc;
00473 int indent;
00474 {
00475 int i;
00476
00477 if (dc == NULL)
00478 return;
00479
00480 for (i = 0; i < indent; ++i)
00481 putchar (' ');
00482
00483 switch (dc->type)
00484 {
00485 case DEMANGLE_COMPONENT_NAME:
00486 printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
00487 return;
00488 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
00489 printf ("template parameter %ld\n", dc->u.s_number.number);
00490 return;
00491 case DEMANGLE_COMPONENT_CTOR:
00492 printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
00493 d_dump (dc->u.s_ctor.name, indent + 2);
00494 return;
00495 case DEMANGLE_COMPONENT_DTOR:
00496 printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
00497 d_dump (dc->u.s_dtor.name, indent + 2);
00498 return;
00499 case DEMANGLE_COMPONENT_SUB_STD:
00500 printf ("standard substitution %s\n", dc->u.s_string.string);
00501 return;
00502 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
00503 printf ("builtin type %s\n", dc->u.s_builtin.type->name);
00504 return;
00505 case DEMANGLE_COMPONENT_OPERATOR:
00506 printf ("operator %s\n", dc->u.s_operator.op->name);
00507 return;
00508 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
00509 printf ("extended operator with %d args\n",
00510 dc->u.s_extended_operator.args);
00511 d_dump (dc->u.s_extended_operator.name, indent + 2);
00512 return;
00513
00514 case DEMANGLE_COMPONENT_QUAL_NAME:
00515 printf ("qualified name\n");
00516 break;
00517 case DEMANGLE_COMPONENT_LOCAL_NAME:
00518 printf ("local name\n");
00519 break;
00520 case DEMANGLE_COMPONENT_TYPED_NAME:
00521 printf ("typed name\n");
00522 break;
00523 case DEMANGLE_COMPONENT_TEMPLATE:
00524 printf ("template\n");
00525 break;
00526 case DEMANGLE_COMPONENT_VTABLE:
00527 printf ("vtable\n");
00528 break;
00529 case DEMANGLE_COMPONENT_VTT:
00530 printf ("VTT\n");
00531 break;
00532 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
00533 printf ("construction vtable\n");
00534 break;
00535 case DEMANGLE_COMPONENT_TYPEINFO:
00536 printf ("typeinfo\n");
00537 break;
00538 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
00539 printf ("typeinfo name\n");
00540 break;
00541 case DEMANGLE_COMPONENT_TYPEINFO_FN:
00542 printf ("typeinfo function\n");
00543 break;
00544 case DEMANGLE_COMPONENT_THUNK:
00545 printf ("thunk\n");
00546 break;
00547 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
00548 printf ("virtual thunk\n");
00549 break;
00550 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
00551 printf ("covariant thunk\n");
00552 break;
00553 case DEMANGLE_COMPONENT_JAVA_CLASS:
00554 printf ("java class\n");
00555 break;
00556 case DEMANGLE_COMPONENT_GUARD:
00557 printf ("guard\n");
00558 break;
00559 case DEMANGLE_COMPONENT_REFTEMP:
00560 printf ("reference temporary\n");
00561 break;
00562 case DEMANGLE_COMPONENT_RESTRICT:
00563 printf ("restrict\n");
00564 break;
00565 case DEMANGLE_COMPONENT_VOLATILE:
00566 printf ("volatile\n");
00567 break;
00568 case DEMANGLE_COMPONENT_CONST:
00569 printf ("const\n");
00570 break;
00571 case DEMANGLE_COMPONENT_RESTRICT_THIS:
00572 printf ("restrict this\n");
00573 break;
00574 case DEMANGLE_COMPONENT_VOLATILE_THIS:
00575 printf ("volatile this\n");
00576 break;
00577 case DEMANGLE_COMPONENT_CONST_THIS:
00578 printf ("const this\n");
00579 break;
00580 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
00581 printf ("vendor type qualifier\n");
00582 break;
00583 case DEMANGLE_COMPONENT_POINTER:
00584 printf ("pointer\n");
00585 break;
00586 case DEMANGLE_COMPONENT_REFERENCE:
00587 printf ("reference\n");
00588 break;
00589 case DEMANGLE_COMPONENT_COMPLEX:
00590 printf ("complex\n");
00591 break;
00592 case DEMANGLE_COMPONENT_IMAGINARY:
00593 printf ("imaginary\n");
00594 break;
00595 case DEMANGLE_COMPONENT_VENDOR_TYPE:
00596 printf ("vendor type\n");
00597 break;
00598 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
00599 printf ("function type\n");
00600 break;
00601 case DEMANGLE_COMPONENT_ARRAY_TYPE:
00602 printf ("array type\n");
00603 break;
00604 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
00605 printf ("pointer to member type\n");
00606 break;
00607 case DEMANGLE_COMPONENT_ARGLIST:
00608 printf ("argument list\n");
00609 break;
00610 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
00611 printf ("template argument list\n");
00612 break;
00613 case DEMANGLE_COMPONENT_CAST:
00614 printf ("cast\n");
00615 break;
00616 case DEMANGLE_COMPONENT_UNARY:
00617 printf ("unary operator\n");
00618 break;
00619 case DEMANGLE_COMPONENT_BINARY:
00620 printf ("binary operator\n");
00621 break;
00622 case DEMANGLE_COMPONENT_BINARY_ARGS:
00623 printf ("binary operator arguments\n");
00624 break;
00625 case DEMANGLE_COMPONENT_TRINARY:
00626 printf ("trinary operator\n");
00627 break;
00628 case DEMANGLE_COMPONENT_TRINARY_ARG1:
00629 printf ("trinary operator arguments 1\n");
00630 break;
00631 case DEMANGLE_COMPONENT_TRINARY_ARG2:
00632 printf ("trinary operator arguments 1\n");
00633 break;
00634 case DEMANGLE_COMPONENT_LITERAL:
00635 printf ("literal\n");
00636 break;
00637 case DEMANGLE_COMPONENT_LITERAL_NEG:
00638 printf ("negative literal\n");
00639 break;
00640 }
00641
00642 d_dump (d_left (dc), indent + 2);
00643 d_dump (d_right (dc), indent + 2);
00644 }
00645
00646 #endif
00647
00648
00649
00650 CP_STATIC_IF_GLIBCPP_V3
00651 int
00652 cplus_demangle_fill_name (p, s, len)
00653 struct demangle_component *p;
00654 const char *s;
00655 int len;
00656 {
00657 if (p == NULL || s == NULL || len == 0)
00658 return 0;
00659 p->type = DEMANGLE_COMPONENT_NAME;
00660 p->u.s_name.s = s;
00661 p->u.s_name.len = len;
00662 return 1;
00663 }
00664
00665
00666
00667 CP_STATIC_IF_GLIBCPP_V3
00668 int
00669 cplus_demangle_fill_extended_operator (p, args, name)
00670 struct demangle_component *p;
00671 int args;
00672 struct demangle_component *name;
00673 {
00674 if (p == NULL || args < 0 || name == NULL)
00675 return 0;
00676 p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
00677 p->u.s_extended_operator.args = args;
00678 p->u.s_extended_operator.name = name;
00679 return 1;
00680 }
00681
00682
00683
00684 CP_STATIC_IF_GLIBCPP_V3
00685 int
00686 cplus_demangle_fill_ctor (p, kind, name)
00687 struct demangle_component *p;
00688 enum gnu_v3_ctor_kinds kind;
00689 struct demangle_component *name;
00690 {
00691 if (p == NULL
00692 || name == NULL
00693 || (kind < gnu_v3_complete_object_ctor
00694 && kind > gnu_v3_complete_object_allocating_ctor))
00695 return 0;
00696 p->type = DEMANGLE_COMPONENT_CTOR;
00697 p->u.s_ctor.kind = kind;
00698 p->u.s_ctor.name = name;
00699 return 1;
00700 }
00701
00702
00703
00704 CP_STATIC_IF_GLIBCPP_V3
00705 int
00706 cplus_demangle_fill_dtor (p, kind, name)
00707 struct demangle_component *p;
00708 enum gnu_v3_dtor_kinds kind;
00709 struct demangle_component *name;
00710 {
00711 if (p == NULL
00712 || name == NULL
00713 || (kind < gnu_v3_deleting_dtor
00714 && kind > gnu_v3_base_object_dtor))
00715 return 0;
00716 p->type = DEMANGLE_COMPONENT_DTOR;
00717 p->u.s_dtor.kind = kind;
00718 p->u.s_dtor.name = name;
00719 return 1;
00720 }
00721
00722
00723
00724 static struct demangle_component *
00725 d_make_empty (di)
00726 struct d_info *di;
00727 {
00728 struct demangle_component *p;
00729
00730 if (di->next_comp >= di->num_comps)
00731 return NULL;
00732 p = &di->comps[di->next_comp];
00733 ++di->next_comp;
00734 return p;
00735 }
00736
00737
00738
00739 static struct demangle_component *
00740 d_make_comp (di, type, left, right)
00741 struct d_info *di;
00742 enum demangle_component_type type;
00743 struct demangle_component *left;
00744 struct demangle_component *right;
00745 {
00746 struct demangle_component *p;
00747
00748
00749
00750
00751 switch (type)
00752 {
00753
00754 case DEMANGLE_COMPONENT_QUAL_NAME:
00755 case DEMANGLE_COMPONENT_LOCAL_NAME:
00756 case DEMANGLE_COMPONENT_TYPED_NAME:
00757 case DEMANGLE_COMPONENT_TEMPLATE:
00758 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
00759 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
00760 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
00761 case DEMANGLE_COMPONENT_UNARY:
00762 case DEMANGLE_COMPONENT_BINARY:
00763 case DEMANGLE_COMPONENT_BINARY_ARGS:
00764 case DEMANGLE_COMPONENT_TRINARY:
00765 case DEMANGLE_COMPONENT_TRINARY_ARG1:
00766 case DEMANGLE_COMPONENT_TRINARY_ARG2:
00767 case DEMANGLE_COMPONENT_LITERAL:
00768 case DEMANGLE_COMPONENT_LITERAL_NEG:
00769 if (left == NULL || right == NULL)
00770 return NULL;
00771 break;
00772
00773
00774 case DEMANGLE_COMPONENT_VTABLE:
00775 case DEMANGLE_COMPONENT_VTT:
00776 case DEMANGLE_COMPONENT_TYPEINFO:
00777 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
00778 case DEMANGLE_COMPONENT_TYPEINFO_FN:
00779 case DEMANGLE_COMPONENT_THUNK:
00780 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
00781 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
00782 case DEMANGLE_COMPONENT_JAVA_CLASS:
00783 case DEMANGLE_COMPONENT_GUARD:
00784 case DEMANGLE_COMPONENT_REFTEMP:
00785 case DEMANGLE_COMPONENT_POINTER:
00786 case DEMANGLE_COMPONENT_REFERENCE:
00787 case DEMANGLE_COMPONENT_COMPLEX:
00788 case DEMANGLE_COMPONENT_IMAGINARY:
00789 case DEMANGLE_COMPONENT_VENDOR_TYPE:
00790 case DEMANGLE_COMPONENT_ARGLIST:
00791 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
00792 case DEMANGLE_COMPONENT_CAST:
00793 if (left == NULL)
00794 return NULL;
00795 break;
00796
00797
00798
00799 case DEMANGLE_COMPONENT_ARRAY_TYPE:
00800 if (right == NULL)
00801 return NULL;
00802 break;
00803
00804
00805
00806 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
00807 case DEMANGLE_COMPONENT_RESTRICT:
00808 case DEMANGLE_COMPONENT_VOLATILE:
00809 case DEMANGLE_COMPONENT_CONST:
00810 case DEMANGLE_COMPONENT_RESTRICT_THIS:
00811 case DEMANGLE_COMPONENT_VOLATILE_THIS:
00812 case DEMANGLE_COMPONENT_CONST_THIS:
00813 break;
00814
00815
00816 default:
00817 return NULL;
00818 }
00819
00820 p = d_make_empty (di);
00821 if (p != NULL)
00822 {
00823 p->type = type;
00824 p->u.s_binary.left = left;
00825 p->u.s_binary.right = right;
00826 }
00827 return p;
00828 }
00829
00830
00831
00832 static struct demangle_component *
00833 d_make_name (di, s, len)
00834 struct d_info *di;
00835 const char *s;
00836 int len;
00837 {
00838 struct demangle_component *p;
00839
00840 p = d_make_empty (di);
00841 if (! cplus_demangle_fill_name (p, s, len))
00842 return NULL;
00843 return p;
00844 }
00845
00846
00847
00848 static struct demangle_component *
00849 d_make_builtin_type (di, type)
00850 struct d_info *di;
00851 const struct demangle_builtin_type_info *type;
00852 {
00853 struct demangle_component *p;
00854
00855 if (type == NULL)
00856 return NULL;
00857 p = d_make_empty (di);
00858 if (p != NULL)
00859 {
00860 p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
00861 p->u.s_builtin.type = type;
00862 }
00863 return p;
00864 }
00865
00866
00867
00868 static struct demangle_component *
00869 d_make_operator (di, op)
00870 struct d_info *di;
00871 const struct demangle_operator_info *op;
00872 {
00873 struct demangle_component *p;
00874
00875 p = d_make_empty (di);
00876 if (p != NULL)
00877 {
00878 p->type = DEMANGLE_COMPONENT_OPERATOR;
00879 p->u.s_operator.op = op;
00880 }
00881 return p;
00882 }
00883
00884
00885
00886 static struct demangle_component *
00887 d_make_extended_operator (di, args, name)
00888 struct d_info *di;
00889 int args;
00890 struct demangle_component *name;
00891 {
00892 struct demangle_component *p;
00893
00894 p = d_make_empty (di);
00895 if (! cplus_demangle_fill_extended_operator (p, args, name))
00896 return NULL;
00897 return p;
00898 }
00899
00900
00901
00902 static struct demangle_component *
00903 d_make_ctor (di, kind, name)
00904 struct d_info *di;
00905 enum gnu_v3_ctor_kinds kind;
00906 struct demangle_component *name;
00907 {
00908 struct demangle_component *p;
00909
00910 p = d_make_empty (di);
00911 if (! cplus_demangle_fill_ctor (p, kind, name))
00912 return NULL;
00913 return p;
00914 }
00915
00916
00917
00918 static struct demangle_component *
00919 d_make_dtor (di, kind, name)
00920 struct d_info *di;
00921 enum gnu_v3_dtor_kinds kind;
00922 struct demangle_component *name;
00923 {
00924 struct demangle_component *p;
00925
00926 p = d_make_empty (di);
00927 if (! cplus_demangle_fill_dtor (p, kind, name))
00928 return NULL;
00929 return p;
00930 }
00931
00932
00933
00934 static struct demangle_component *
00935 d_make_template_param (di, i)
00936 struct d_info *di;
00937 long i;
00938 {
00939 struct demangle_component *p;
00940
00941 p = d_make_empty (di);
00942 if (p != NULL)
00943 {
00944 p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
00945 p->u.s_number.number = i;
00946 }
00947 return p;
00948 }
00949
00950
00951
00952 static struct demangle_component *
00953 d_make_sub (di, name, len)
00954 struct d_info *di;
00955 const char *name;
00956 int len;
00957 {
00958 struct demangle_component *p;
00959
00960 p = d_make_empty (di);
00961 if (p != NULL)
00962 {
00963 p->type = DEMANGLE_COMPONENT_SUB_STD;
00964 p->u.s_string.string = name;
00965 p->u.s_string.len = len;
00966 }
00967 return p;
00968 }
00969
00970
00971
00972
00973
00974 CP_STATIC_IF_GLIBCPP_V3
00975 struct demangle_component *
00976 cplus_demangle_mangled_name (di, top_level)
00977 struct d_info *di;
00978 int top_level;
00979 {
00980 if (d_next_char (di) != '_')
00981 return NULL;
00982 if (d_next_char (di) != 'Z')
00983 return NULL;
00984 return d_encoding (di, top_level);
00985 }
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996 static int
00997 has_return_type (dc)
00998 struct demangle_component *dc;
00999 {
01000 if (dc == NULL)
01001 return 0;
01002 switch (dc->type)
01003 {
01004 default:
01005 return 0;
01006 case DEMANGLE_COMPONENT_TEMPLATE:
01007 return ! is_ctor_dtor_or_conversion (d_left (dc));
01008 case DEMANGLE_COMPONENT_RESTRICT_THIS:
01009 case DEMANGLE_COMPONENT_VOLATILE_THIS:
01010 case DEMANGLE_COMPONENT_CONST_THIS:
01011 return has_return_type (d_left (dc));
01012 }
01013 }
01014
01015
01016
01017
01018 static int
01019 is_ctor_dtor_or_conversion (dc)
01020 struct demangle_component *dc;
01021 {
01022 if (dc == NULL)
01023 return 0;
01024 switch (dc->type)
01025 {
01026 default:
01027 return 0;
01028 case DEMANGLE_COMPONENT_QUAL_NAME:
01029 case DEMANGLE_COMPONENT_LOCAL_NAME:
01030 return is_ctor_dtor_or_conversion (d_right (dc));
01031 case DEMANGLE_COMPONENT_CTOR:
01032 case DEMANGLE_COMPONENT_DTOR:
01033 case DEMANGLE_COMPONENT_CAST:
01034 return 1;
01035 }
01036 }
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047 static struct demangle_component *
01048 d_encoding (di, top_level)
01049 struct d_info *di;
01050 int top_level;
01051 {
01052 char peek = d_peek_char (di);
01053
01054 if (peek == 'G' || peek == 'T')
01055 return d_special_name (di);
01056 else
01057 {
01058 struct demangle_component *dc;
01059
01060 dc = d_name (di);
01061
01062 if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
01063 {
01064
01065
01066
01067 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
01068 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
01069 || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
01070 dc = d_left (dc);
01071
01072
01073
01074
01075
01076 if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
01077 {
01078 struct demangle_component *dcr;
01079
01080 dcr = d_right (dc);
01081 while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
01082 || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
01083 || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
01084 dcr = d_left (dcr);
01085 dc->u.s_binary.right = dcr;
01086 }
01087
01088 return dc;
01089 }
01090
01091 peek = d_peek_char (di);
01092 if (peek == '\0' || peek == 'E')
01093 return dc;
01094 return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
01095 d_bare_function_type (di, has_return_type (dc)));
01096 }
01097 }
01098
01099
01100
01101
01102
01103
01104
01105
01106
01107
01108
01109
01110
01111 static struct demangle_component *
01112 d_name (di)
01113 struct d_info *di;
01114 {
01115 char peek = d_peek_char (di);
01116 struct demangle_component *dc;
01117
01118 switch (peek)
01119 {
01120 case 'N':
01121 return d_nested_name (di);
01122
01123 case 'Z':
01124 return d_local_name (di);
01125
01126 case 'S':
01127 {
01128 int subst;
01129
01130 if (d_peek_next_char (di) != 't')
01131 {
01132 dc = d_substitution (di, 0);
01133 subst = 1;
01134 }
01135 else
01136 {
01137 d_advance (di, 2);
01138 dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
01139 d_make_name (di, "std", 3),
01140 d_unqualified_name (di));
01141 di->expansion += 3;
01142 subst = 0;
01143 }
01144
01145 if (d_peek_char (di) != 'I')
01146 {
01147
01148
01149
01150 }
01151 else
01152 {
01153
01154
01155
01156
01157 if (! subst)
01158 {
01159 if (! d_add_substitution (di, dc))
01160 return NULL;
01161 }
01162 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
01163 d_template_args (di));
01164 }
01165
01166 return dc;
01167 }
01168
01169 default:
01170 dc = d_unqualified_name (di);
01171 if (d_peek_char (di) == 'I')
01172 {
01173
01174
01175
01176 if (! d_add_substitution (di, dc))
01177 return NULL;
01178 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
01179 d_template_args (di));
01180 }
01181 return dc;
01182 }
01183 }
01184
01185
01186
01187
01188
01189 static struct demangle_component *
01190 d_nested_name (di)
01191 struct d_info *di;
01192 {
01193 struct demangle_component *ret;
01194 struct demangle_component **pret;
01195
01196 if (d_next_char (di) != 'N')
01197 return NULL;
01198
01199 pret = d_cv_qualifiers (di, &ret, 1);
01200 if (pret == NULL)
01201 return NULL;
01202
01203 *pret = d_prefix (di);
01204 if (*pret == NULL)
01205 return NULL;
01206
01207 if (d_next_char (di) != 'E')
01208 return NULL;
01209
01210 return ret;
01211 }
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224 static struct demangle_component *
01225 d_prefix (di)
01226 struct d_info *di;
01227 {
01228 struct demangle_component *ret = NULL;
01229
01230 while (1)
01231 {
01232 char peek;
01233 enum demangle_component_type comb_type;
01234 struct demangle_component *dc;
01235
01236 peek = d_peek_char (di);
01237 if (peek == '\0')
01238 return NULL;
01239
01240
01241
01242
01243
01244 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
01245 if (IS_DIGIT (peek)
01246 || IS_LOWER (peek)
01247 || peek == 'C'
01248 || peek == 'D')
01249 dc = d_unqualified_name (di);
01250 else if (peek == 'S')
01251 dc = d_substitution (di, 1);
01252 else if (peek == 'I')
01253 {
01254 if (ret == NULL)
01255 return NULL;
01256 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
01257 dc = d_template_args (di);
01258 }
01259 else if (peek == 'T')
01260 dc = d_template_param (di);
01261 else if (peek == 'E')
01262 return ret;
01263 else
01264 return NULL;
01265
01266 if (ret == NULL)
01267 ret = dc;
01268 else
01269 ret = d_make_comp (di, comb_type, ret, dc);
01270
01271 if (peek != 'S' && d_peek_char (di) != 'E')
01272 {
01273 if (! d_add_substitution (di, ret))
01274 return NULL;
01275 }
01276 }
01277 }
01278
01279
01280
01281
01282
01283
01284 static struct demangle_component *
01285 d_unqualified_name (di)
01286 struct d_info *di;
01287 {
01288 char peek;
01289
01290 peek = d_peek_char (di);
01291 if (IS_DIGIT (peek))
01292 return d_source_name (di);
01293 else if (IS_LOWER (peek))
01294 {
01295 struct demangle_component *ret;
01296
01297 ret = d_operator_name (di);
01298 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
01299 di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
01300 return ret;
01301 }
01302 else if (peek == 'C' || peek == 'D')
01303 return d_ctor_dtor_name (di);
01304 else
01305 return NULL;
01306 }
01307
01308
01309
01310 static struct demangle_component *
01311 d_source_name (di)
01312 struct d_info *di;
01313 {
01314 long len;
01315 struct demangle_component *ret;
01316
01317 len = d_number (di);
01318 if (len <= 0)
01319 return NULL;
01320 ret = d_identifier (di, len);
01321 di->last_name = ret;
01322 return ret;
01323 }
01324
01325
01326
01327 static long
01328 d_number (di)
01329 struct d_info *di;
01330 {
01331 int negative;
01332 char peek;
01333 long ret;
01334
01335 negative = 0;
01336 peek = d_peek_char (di);
01337 if (peek == 'n')
01338 {
01339 negative = 1;
01340 d_advance (di, 1);
01341 peek = d_peek_char (di);
01342 }
01343
01344 ret = 0;
01345 while (1)
01346 {
01347 if (! IS_DIGIT (peek))
01348 {
01349 if (negative)
01350 ret = - ret;
01351 return ret;
01352 }
01353 ret = ret * 10 + peek - '0';
01354 d_advance (di, 1);
01355 peek = d_peek_char (di);
01356 }
01357 }
01358
01359
01360
01361 static struct demangle_component *
01362 d_identifier (di, len)
01363 struct d_info *di;
01364 int len;
01365 {
01366 const char *name;
01367
01368 name = d_str (di);
01369
01370 if (di->send - name < len)
01371 return NULL;
01372
01373 d_advance (di, len);
01374
01375
01376
01377
01378 if ((di->options & DMGL_JAVA) != 0
01379 && d_peek_char (di) == '$')
01380 d_advance (di, 1);
01381
01382
01383
01384
01385 if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
01386 && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
01387 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
01388 {
01389 const char *s;
01390
01391 s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
01392 if ((*s == '.' || *s == '_' || *s == '$')
01393 && s[1] == 'N')
01394 {
01395 di->expansion -= len - sizeof "(anonymous namespace)";
01396 return d_make_name (di, "(anonymous namespace)",
01397 sizeof "(anonymous namespace)" - 1);
01398 }
01399 }
01400
01401 return d_make_name (di, name, len);
01402 }
01403
01404
01405
01406
01407
01408
01409 #define NL(s) s, (sizeof s) - 1
01410
01411 CP_STATIC_IF_GLIBCPP_V3
01412 const struct demangle_operator_info cplus_demangle_operators[] =
01413 {
01414 { "aN", NL ("&="), 2 },
01415 { "aS", NL ("="), 2 },
01416 { "aa", NL ("&&"), 2 },
01417 { "ad", NL ("&"), 1 },
01418 { "an", NL ("&"), 2 },
01419 { "cl", NL ("()"), 0 },
01420 { "cm", NL (","), 2 },
01421 { "co", NL ("~"), 1 },
01422 { "dV", NL ("/="), 2 },
01423 { "da", NL ("delete[]"), 1 },
01424 { "de", NL ("*"), 1 },
01425 { "dl", NL ("delete"), 1 },
01426 { "dv", NL ("/"), 2 },
01427 { "eO", NL ("^="), 2 },
01428 { "eo", NL ("^"), 2 },
01429 { "eq", NL ("=="), 2 },
01430 { "ge", NL (">="), 2 },
01431 { "gt", NL (">"), 2 },
01432 { "ix", NL ("[]"), 2 },
01433 { "lS", NL ("<<="), 2 },
01434 { "le", NL ("<="), 2 },
01435 { "ls", NL ("<<"), 2 },
01436 { "lt", NL ("<"), 2 },
01437 { "mI", NL ("-="), 2 },
01438 { "mL", NL ("*="), 2 },
01439 { "mi", NL ("-"), 2 },
01440 { "ml", NL ("*"), 2 },
01441 { "mm", NL ("--"), 1 },
01442 { "na", NL ("new[]"), 1 },
01443 { "ne", NL ("!="), 2 },
01444 { "ng", NL ("-"), 1 },
01445 { "nt", NL ("!"), 1 },
01446 { "nw", NL ("new"), 1 },
01447 { "oR", NL ("|="), 2 },
01448 { "oo", NL ("||"), 2 },
01449 { "or", NL ("|"), 2 },
01450 { "pL", NL ("+="), 2 },
01451 { "pl", NL ("+"), 2 },
01452 { "pm", NL ("->*"), 2 },
01453 { "pp", NL ("++"), 1 },
01454 { "ps", NL ("+"), 1 },
01455 { "pt", NL ("->"), 2 },
01456 { "qu", NL ("?"), 3 },
01457 { "rM", NL ("%="), 2 },
01458 { "rS", NL (">>="), 2 },
01459 { "rm", NL ("%"), 2 },
01460 { "rs", NL (">>"), 2 },
01461 { "st", NL ("sizeof "), 1 },
01462 { "sz", NL ("sizeof "), 1 },
01463 { NULL, NULL, 0, 0 }
01464 };
01465
01466 static struct demangle_component *
01467 d_operator_name (di)
01468 struct d_info *di;
01469 {
01470 char c1;
01471 char c2;
01472
01473 c1 = d_next_char (di);
01474 c2 = d_next_char (di);
01475 if (c1 == 'v' && IS_DIGIT (c2))
01476 return d_make_extended_operator (di, c2 - '0', d_source_name (di));
01477 else if (c1 == 'c' && c2 == 'v')
01478 return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
01479 cplus_demangle_type (di), NULL);
01480 else
01481 {
01482
01483 int low = 0;
01484
01485
01486 int high = ((sizeof (cplus_demangle_operators)
01487 / sizeof (cplus_demangle_operators[0]))
01488 - 1);
01489
01490 while (1)
01491 {
01492 int i;
01493 const struct demangle_operator_info *p;
01494
01495 i = low + (high - low) / 2;
01496 p = cplus_demangle_operators + i;
01497
01498 if (c1 == p->code[0] && c2 == p->code[1])
01499 return d_make_operator (di, p);
01500
01501 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
01502 high = i;
01503 else
01504 low = i + 1;
01505 if (low == high)
01506 return NULL;
01507 }
01508 }
01509 }
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525 static struct demangle_component *
01526 d_special_name (di)
01527 struct d_info *di;
01528 {
01529 char c;
01530
01531 di->expansion += 20;
01532 c = d_next_char (di);
01533 if (c == 'T')
01534 {
01535 switch (d_next_char (di))
01536 {
01537 case 'V':
01538 di->expansion -= 5;
01539 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
01540 cplus_demangle_type (di), NULL);
01541 case 'T':
01542 di->expansion -= 10;
01543 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
01544 cplus_demangle_type (di), NULL);
01545 case 'I':
01546 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
01547 cplus_demangle_type (di), NULL);
01548 case 'S':
01549 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
01550 cplus_demangle_type (di), NULL);
01551
01552 case 'h':
01553 if (! d_call_offset (di, 'h'))
01554 return NULL;
01555 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
01556 d_encoding (di, 0), NULL);
01557
01558 case 'v':
01559 if (! d_call_offset (di, 'v'))
01560 return NULL;
01561 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
01562 d_encoding (di, 0), NULL);
01563
01564 case 'c':
01565 if (! d_call_offset (di, '\0'))
01566 return NULL;
01567 if (! d_call_offset (di, '\0'))
01568 return NULL;
01569 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
01570 d_encoding (di, 0), NULL);
01571
01572 case 'C':
01573 {
01574 struct demangle_component *derived_type;
01575 long offset;
01576 struct demangle_component *base_type;
01577
01578 derived_type = cplus_demangle_type (di);
01579 offset = d_number (di);
01580 if (offset < 0)
01581 return NULL;
01582 if (d_next_char (di) != '_')
01583 return NULL;
01584 base_type = cplus_demangle_type (di);
01585
01586
01587 di->expansion += 5;
01588 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
01589 base_type, derived_type);
01590 }
01591
01592 case 'F':
01593 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
01594 cplus_demangle_type (di), NULL);
01595 case 'J':
01596 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
01597 cplus_demangle_type (di), NULL);
01598
01599 default:
01600 return NULL;
01601 }
01602 }
01603 else if (c == 'G')
01604 {
01605 switch (d_next_char (di))
01606 {
01607 case 'V':
01608 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
01609
01610 case 'R':
01611 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
01612 NULL);
01613
01614 default:
01615 return NULL;
01616 }
01617 }
01618 else
01619 return NULL;
01620 }
01621
01622
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632
01633
01634
01635 static int
01636 d_call_offset (di, c)
01637 struct d_info *di;
01638 int c;
01639 {
01640 if (c == '\0')
01641 c = d_next_char (di);
01642
01643 if (c == 'h')
01644 d_number (di);
01645 else if (c == 'v')
01646 {
01647 d_number (di);
01648 if (d_next_char (di) != '_')
01649 return 0;
01650 d_number (di);
01651 }
01652 else
01653 return 0;
01654
01655 if (d_next_char (di) != '_')
01656 return 0;
01657
01658 return 1;
01659 }
01660
01661
01662
01663
01664
01665
01666
01667
01668
01669 static struct demangle_component *
01670 d_ctor_dtor_name (di)
01671 struct d_info *di;
01672 {
01673 if (di->last_name != NULL)
01674 {
01675 if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
01676 di->expansion += di->last_name->u.s_name.len;
01677 else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
01678 di->expansion += di->last_name->u.s_string.len;
01679 }
01680 switch (d_next_char (di))
01681 {
01682 case 'C':
01683 {
01684 enum gnu_v3_ctor_kinds kind;
01685
01686 switch (d_next_char (di))
01687 {
01688 case '1':
01689 kind = gnu_v3_complete_object_ctor;
01690 break;
01691 case '2':
01692 kind = gnu_v3_base_object_ctor;
01693 break;
01694 case '3':
01695 kind = gnu_v3_complete_object_allocating_ctor;
01696 break;
01697 default:
01698 return NULL;
01699 }
01700 return d_make_ctor (di, kind, di->last_name);
01701 }
01702
01703 case 'D':
01704 {
01705 enum gnu_v3_dtor_kinds kind;
01706
01707 switch (d_next_char (di))
01708 {
01709 case '0':
01710 kind = gnu_v3_deleting_dtor;
01711 break;
01712 case '1':
01713 kind = gnu_v3_complete_object_dtor;
01714 break;
01715 case '2':
01716 kind = gnu_v3_base_object_dtor;
01717 break;
01718 default:
01719 return NULL;
01720 }
01721 return d_make_dtor (di, kind, di->last_name);
01722 }
01723
01724 default:
01725 return NULL;
01726 }
01727 }
01728
01729
01730
01731
01732
01733
01734
01735
01736
01737
01738
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748 CP_STATIC_IF_GLIBCPP_V3
01749 const struct demangle_builtin_type_info
01750 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
01751 {
01752 { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
01753 { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
01754 { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
01755 { NL ("double"), NL ("double"), D_PRINT_FLOAT },
01756 { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
01757 { NL ("float"), NL ("float"), D_PRINT_FLOAT },
01758 { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
01759 { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
01760 { NL ("int"), NL ("int"), D_PRINT_INT },
01761 { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
01762 { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
01763 { NL ("long"), NL ("long"), D_PRINT_LONG },
01764 { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
01765 { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
01766 { NL ("unsigned __int128"), NL ("unsigned __int128"),
01767 D_PRINT_DEFAULT },
01768 { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
01769 { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
01770 { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
01771 { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
01772 { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
01773 { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
01774 { NL ("void"), NL ("void"), D_PRINT_VOID },
01775 { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
01776 { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
01777 { NL ("unsigned long long"), NL ("unsigned long long"),
01778 D_PRINT_UNSIGNED_LONG_LONG },
01779 { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
01780 };
01781
01782 CP_STATIC_IF_GLIBCPP_V3
01783 struct demangle_component *
01784 cplus_demangle_type (di)
01785 struct d_info *di;
01786 {
01787 char peek;
01788 struct demangle_component *ret;
01789 int can_subst;
01790
01791
01792
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802
01803
01804
01805
01806 peek = d_peek_char (di);
01807 if (peek == 'r' || peek == 'V' || peek == 'K')
01808 {
01809 struct demangle_component **pret;
01810
01811 pret = d_cv_qualifiers (di, &ret, 0);
01812 if (pret == NULL)
01813 return NULL;
01814 *pret = cplus_demangle_type (di);
01815 if (! d_add_substitution (di, ret))
01816 return NULL;
01817 return ret;
01818 }
01819
01820 can_subst = 1;
01821
01822 switch (peek)
01823 {
01824 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
01825 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
01826 case 'o': case 's': case 't':
01827 case 'v': case 'w': case 'x': case 'y': case 'z':
01828 ret = d_make_builtin_type (di,
01829 &cplus_demangle_builtin_types[peek - 'a']);
01830 di->expansion += ret->u.s_builtin.type->len;
01831 can_subst = 0;
01832 d_advance (di, 1);
01833 break;
01834
01835 case 'u':
01836 d_advance (di, 1);
01837 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
01838 d_source_name (di), NULL);
01839 break;
01840
01841 case 'F':
01842 ret = d_function_type (di);
01843 break;
01844
01845 case '0': case '1': case '2': case '3': case '4':
01846 case '5': case '6': case '7': case '8': case '9':
01847 case 'N':
01848 case 'Z':
01849 ret = d_class_enum_type (di);
01850 break;
01851
01852 case 'A':
01853 ret = d_array_type (di);
01854 break;
01855
01856 case 'M':
01857 ret = d_pointer_to_member_type (di);
01858 break;
01859
01860 case 'T':
01861 ret = d_template_param (di);
01862 if (d_peek_char (di) == 'I')
01863 {
01864
01865
01866
01867 if (! d_add_substitution (di, ret))
01868 return NULL;
01869 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
01870 d_template_args (di));
01871 }
01872 break;
01873
01874 case 'S':
01875
01876
01877 {
01878 char peek_next;
01879
01880 peek_next = d_peek_next_char (di);
01881 if (IS_DIGIT (peek_next)
01882 || peek_next == '_'
01883 || IS_UPPER (peek_next))
01884 {
01885 ret = d_substitution (di, 0);
01886
01887
01888 if (d_peek_char (di) == 'I')
01889 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
01890 d_template_args (di));
01891 else
01892 can_subst = 0;
01893 }
01894 else
01895 {
01896 ret = d_class_enum_type (di);
01897
01898
01899
01900
01901 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
01902 can_subst = 0;
01903 }
01904 }
01905 break;
01906
01907 case 'P':
01908 d_advance (di, 1);
01909 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
01910 cplus_demangle_type (di), NULL);
01911 break;
01912
01913 case 'R':
01914 d_advance (di, 1);
01915 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
01916 cplus_demangle_type (di), NULL);
01917 break;
01918
01919 case 'C':
01920 d_advance (di, 1);
01921 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
01922 cplus_demangle_type (di), NULL);
01923 break;
01924
01925 case 'G':
01926 d_advance (di, 1);
01927 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
01928 cplus_demangle_type (di), NULL);
01929 break;
01930
01931 case 'U':
01932 d_advance (di, 1);
01933 ret = d_source_name (di);
01934 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
01935 cplus_demangle_type (di), ret);
01936 break;
01937
01938 default:
01939 return NULL;
01940 }
01941
01942 if (can_subst)
01943 {
01944 if (! d_add_substitution (di, ret))
01945 return NULL;
01946 }
01947
01948 return ret;
01949 }
01950
01951
01952
01953 static struct demangle_component **
01954 d_cv_qualifiers (di, pret, member_fn)
01955 struct d_info *di;
01956 struct demangle_component **pret;
01957 int member_fn;
01958 {
01959 char peek;
01960
01961 peek = d_peek_char (di);
01962 while (peek == 'r' || peek == 'V' || peek == 'K')
01963 {
01964 enum demangle_component_type t;
01965
01966 d_advance (di, 1);
01967 if (peek == 'r')
01968 {
01969 t = (member_fn
01970 ? DEMANGLE_COMPONENT_RESTRICT_THIS
01971 : DEMANGLE_COMPONENT_RESTRICT);
01972 di->expansion += sizeof "restrict";
01973 }
01974 else if (peek == 'V')
01975 {
01976 t = (member_fn
01977 ? DEMANGLE_COMPONENT_VOLATILE_THIS
01978 : DEMANGLE_COMPONENT_VOLATILE);
01979 di->expansion += sizeof "volatile";
01980 }
01981 else
01982 {
01983 t = (member_fn
01984 ? DEMANGLE_COMPONENT_CONST_THIS
01985 : DEMANGLE_COMPONENT_CONST);
01986 di->expansion += sizeof "const";
01987 }
01988
01989 *pret = d_make_comp (di, t, NULL, NULL);
01990 if (*pret == NULL)
01991 return NULL;
01992 pret = &d_left (*pret);
01993
01994 peek = d_peek_char (di);
01995 }
01996
01997 return pret;
01998 }
01999
02000
02001
02002 static struct demangle_component *
02003 d_function_type (di)
02004 struct d_info *di;
02005 {
02006 struct demangle_component *ret;
02007
02008 if (d_next_char (di) != 'F')
02009 return NULL;
02010 if (d_peek_char (di) == 'Y')
02011 {
02012
02013
02014 d_advance (di, 1);
02015 }
02016 ret = d_bare_function_type (di, 1);
02017 if (d_next_char (di) != 'E')
02018 return NULL;
02019 return ret;
02020 }
02021
02022
02023
02024 static struct demangle_component *
02025 d_bare_function_type (di, has_return_type)
02026 struct d_info *di;
02027 int has_return_type;
02028 {
02029 struct demangle_component *return_type;
02030 struct demangle_component *tl;
02031 struct demangle_component **ptl;
02032
02033 return_type = NULL;
02034 tl = NULL;
02035 ptl = &tl;
02036 while (1)
02037 {
02038 char peek;
02039 struct demangle_component *type;
02040
02041 peek = d_peek_char (di);
02042 if (peek == '\0' || peek == 'E')
02043 break;
02044 type = cplus_demangle_type (di);
02045 if (type == NULL)
02046 return NULL;
02047 if (has_return_type)
02048 {
02049 return_type = type;
02050 has_return_type = 0;
02051 }
02052 else
02053 {
02054 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
02055 if (*ptl == NULL)
02056 return NULL;
02057 ptl = &d_right (*ptl);
02058 }
02059 }
02060
02061
02062
02063
02064 if (tl == NULL)
02065 return NULL;
02066
02067
02068 if (d_right (tl) == NULL
02069 && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
02070 && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
02071 {
02072 di->expansion -= d_left (tl)->u.s_builtin.type->len;
02073 tl = NULL;
02074 }
02075
02076 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl);
02077 }
02078
02079
02080
02081 static struct demangle_component *
02082 d_class_enum_type (di)
02083 struct d_info *di;
02084 {
02085 return d_name (di);
02086 }
02087
02088
02089
02090
02091
02092 static struct demangle_component *
02093 d_array_type (di)
02094 struct d_info *di;
02095 {
02096 char peek;
02097 struct demangle_component *dim;
02098
02099 if (d_next_char (di) != 'A')
02100 return NULL;
02101
02102 peek = d_peek_char (di);
02103 if (peek == '_')
02104 dim = NULL;
02105 else if (IS_DIGIT (peek))
02106 {
02107 const char *s;
02108
02109 s = d_str (di);
02110 do
02111 {
02112 d_advance (di, 1);
02113 peek = d_peek_char (di);
02114 }
02115 while (IS_DIGIT (peek));
02116 dim = d_make_name (di, s, d_str (di) - s);
02117 if (dim == NULL)
02118 return NULL;
02119 }
02120 else
02121 {
02122 dim = d_expression (di);
02123 if (dim == NULL)
02124 return NULL;
02125 }
02126
02127 if (d_next_char (di) != '_')
02128 return NULL;
02129
02130 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
02131 cplus_demangle_type (di));
02132 }
02133
02134
02135
02136 static struct demangle_component *
02137 d_pointer_to_member_type (di)
02138 struct d_info *di;
02139 {
02140 struct demangle_component *cl;
02141 struct demangle_component *mem;
02142 struct demangle_component **pmem;
02143
02144 if (d_next_char (di) != 'M')
02145 return NULL;
02146
02147 cl = cplus_demangle_type (di);
02148
02149
02150
02151
02152
02153
02154
02155
02156
02157
02158
02159
02160
02161
02162 pmem = d_cv_qualifiers (di, &mem, 1);
02163 if (pmem == NULL)
02164 return NULL;
02165 *pmem = cplus_demangle_type (di);
02166
02167 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
02168 }
02169
02170
02171
02172
02173
02174 static struct demangle_component *
02175 d_template_param (di)
02176 struct d_info *di;
02177 {
02178 long param;
02179
02180 if (d_next_char (di) != 'T')
02181 return NULL;
02182
02183 if (d_peek_char (di) == '_')
02184 param = 0;
02185 else
02186 {
02187 param = d_number (di);
02188 if (param < 0)
02189 return NULL;
02190 param += 1;
02191 }
02192
02193 if (d_next_char (di) != '_')
02194 return NULL;
02195
02196 ++di->did_subs;
02197
02198 return d_make_template_param (di, param);
02199 }
02200
02201
02202
02203 static struct demangle_component *
02204 d_template_args (di)
02205 struct d_info *di;
02206 {
02207 struct demangle_component *hold_last_name;
02208 struct demangle_component *al;
02209 struct demangle_component **pal;
02210
02211
02212
02213
02214 hold_last_name = di->last_name;
02215
02216 if (d_next_char (di) != 'I')
02217 return NULL;
02218
02219 al = NULL;
02220 pal = &al;
02221 while (1)
02222 {
02223 struct demangle_component *a;
02224
02225 a = d_template_arg (di);
02226 if (a == NULL)
02227 return NULL;
02228
02229 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
02230 if (*pal == NULL)
02231 return NULL;
02232 pal = &d_right (*pal);
02233
02234 if (d_peek_char (di) == 'E')
02235 {
02236 d_advance (di, 1);
02237 break;
02238 }
02239 }
02240
02241 di->last_name = hold_last_name;
02242
02243 return al;
02244 }
02245
02246
02247
02248
02249
02250
02251 static struct demangle_component *
02252 d_template_arg (di)
02253 struct d_info *di;
02254 {
02255 struct demangle_component *ret;
02256
02257 switch (d_peek_char (di))
02258 {
02259 case 'X':
02260 d_advance (di, 1);
02261 ret = d_expression (di);
02262 if (d_next_char (di) != 'E')
02263 return NULL;
02264 return ret;
02265
02266 case 'L':
02267 return d_expr_primary (di);
02268
02269 default:
02270 return cplus_demangle_type (di);
02271 }
02272 }
02273
02274
02275
02276
02277
02278
02279
02280
02281
02282
02283
02284 static struct demangle_component *
02285 d_expression (di)
02286 struct d_info *di;
02287 {
02288 char peek;
02289
02290 peek = d_peek_char (di);
02291 if (peek == 'L')
02292 return d_expr_primary (di);
02293 else if (peek == 'T')
02294 return d_template_param (di);
02295 else if (peek == 's' && d_peek_next_char (di) == 'r')
02296 {
02297 struct demangle_component *type;
02298 struct demangle_component *name;
02299
02300 d_advance (di, 2);
02301 type = cplus_demangle_type (di);
02302 name = d_unqualified_name (di);
02303 if (d_peek_char (di) != 'I')
02304 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
02305 else
02306 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
02307 d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
02308 d_template_args (di)));
02309 }
02310 else
02311 {
02312 struct demangle_component *op;
02313 int args;
02314
02315 op = d_operator_name (di);
02316 if (op == NULL)
02317 return NULL;
02318
02319 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
02320 di->expansion += op->u.s_operator.op->len - 2;
02321
02322 if (op->type == DEMANGLE_COMPONENT_OPERATOR
02323 && strcmp (op->u.s_operator.op->code, "st") == 0)
02324 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
02325 cplus_demangle_type (di));
02326
02327 switch (op->type)
02328 {
02329 default:
02330 return NULL;
02331 case DEMANGLE_COMPONENT_OPERATOR:
02332 args = op->u.s_operator.op->args;
02333 break;
02334 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
02335 args = op->u.s_extended_operator.args;
02336 break;
02337 case DEMANGLE_COMPONENT_CAST:
02338 args = 1;
02339 break;
02340 }
02341
02342 switch (args)
02343 {
02344 case 1:
02345 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
02346 d_expression (di));
02347 case 2:
02348 {
02349 struct demangle_component *left;
02350
02351 left = d_expression (di);
02352 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
02353 d_make_comp (di,
02354 DEMANGLE_COMPONENT_BINARY_ARGS,
02355 left,
02356 d_expression (di)));
02357 }
02358 case 3:
02359 {
02360 struct demangle_component *first;
02361 struct demangle_component *second;
02362
02363 first = d_expression (di);
02364 second = d_expression (di);
02365 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
02366 d_make_comp (di,
02367 DEMANGLE_COMPONENT_TRINARY_ARG1,
02368 first,
02369 d_make_comp (di,
02370 DEMANGLE_COMPONENT_TRINARY_ARG2,
02371 second,
02372 d_expression (di))));
02373 }
02374 default:
02375 return NULL;
02376 }
02377 }
02378 }
02379
02380
02381
02382
02383
02384
02385 static struct demangle_component *
02386 d_expr_primary (di)
02387 struct d_info *di;
02388 {
02389 struct demangle_component *ret;
02390
02391 if (d_next_char (di) != 'L')
02392 return NULL;
02393 if (d_peek_char (di) == '_')
02394 ret = cplus_demangle_mangled_name (di, 0);
02395 else
02396 {
02397 struct demangle_component *type;
02398 enum demangle_component_type t;
02399 const char *s;
02400
02401 type = cplus_demangle_type (di);
02402 if (type == NULL)
02403 return NULL;
02404
02405
02406
02407 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
02408 && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
02409 di->expansion -= type->u.s_builtin.type->len;
02410
02411
02412
02413
02414
02415
02416
02417
02418
02419
02420
02421
02422 t = DEMANGLE_COMPONENT_LITERAL;
02423 if (d_peek_char (di) == 'n')
02424 {
02425 t = DEMANGLE_COMPONENT_LITERAL_NEG;
02426 d_advance (di, 1);
02427 }
02428 s = d_str (di);
02429 while (d_peek_char (di) != 'E')
02430 d_advance (di, 1);
02431 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
02432 }
02433 if (d_next_char (di) != 'E')
02434 return NULL;
02435 return ret;
02436 }
02437
02438
02439
02440
02441
02442 static struct demangle_component *
02443 d_local_name (di)
02444 struct d_info *di;
02445 {
02446 struct demangle_component *function;
02447
02448 if (d_next_char (di) != 'Z')
02449 return NULL;
02450
02451 function = d_encoding (di, 0);
02452
02453 if (d_next_char (di) != 'E')
02454 return NULL;
02455
02456 if (d_peek_char (di) == 's')
02457 {
02458 d_advance (di, 1);
02459 if (! d_discriminator (di))
02460 return NULL;
02461 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
02462 d_make_name (di, "string literal",
02463 sizeof "string literal" - 1));
02464 }
02465 else
02466 {
02467 struct demangle_component *name;
02468
02469 name = d_name (di);
02470 if (! d_discriminator (di))
02471 return NULL;
02472 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
02473 }
02474 }
02475
02476
02477
02478
02479
02480
02481 static int
02482 d_discriminator (di)
02483 struct d_info *di;
02484 {
02485 long discrim;
02486
02487 if (d_peek_char (di) != '_')
02488 return 1;
02489 d_advance (di, 1);
02490 discrim = d_number (di);
02491 if (discrim < 0)
02492 return 0;
02493 return 1;
02494 }
02495
02496
02497
02498 static int
02499 d_add_substitution (di, dc)
02500 struct d_info *di;
02501 struct demangle_component *dc;
02502 {
02503 if (dc == NULL)
02504 return 0;
02505 if (di->next_sub >= di->num_subs)
02506 return 0;
02507 di->subs[di->next_sub] = dc;
02508 ++di->next_sub;
02509 return 1;
02510 }
02511
02512
02513
02514
02515
02516
02517
02518
02519
02520
02521
02522
02523
02524
02525
02526
02527
02528
02529
02530
02531 static const struct d_standard_sub_info standard_subs[] =
02532 {
02533 { 't', NL ("std"),
02534 NL ("std"),
02535 NULL, 0 },
02536 { 'a', NL ("std::allocator"),
02537 NL ("std::allocator"),
02538 NL ("allocator") },
02539 { 'b', NL ("std::basic_string"),
02540 NL ("std::basic_string"),
02541 NL ("basic_string") },
02542 { 's', NL ("std::string"),
02543 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
02544 NL ("basic_string") },
02545 { 'i', NL ("std::istream"),
02546 NL ("std::basic_istream<char, std::char_traits<char> >"),
02547 NL ("basic_istream") },
02548 { 'o', NL ("std::ostream"),
02549 NL ("std::basic_ostream<char, std::char_traits<char> >"),
02550 NL ("basic_ostream") },
02551 { 'd', NL ("std::iostream"),
02552 NL ("std::basic_iostream<char, std::char_traits<char> >"),
02553 NL ("basic_iostream") }
02554 };
02555
02556 static struct demangle_component *
02557 d_substitution (di, prefix)
02558 struct d_info *di;
02559 int prefix;
02560 {
02561 char c;
02562
02563 if (d_next_char (di) != 'S')
02564 return NULL;
02565
02566 c = d_next_char (di);
02567 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
02568 {
02569 int id;
02570
02571 id = 0;
02572 if (c != '_')
02573 {
02574 do
02575 {
02576 if (IS_DIGIT (c))
02577 id = id * 36 + c - '0';
02578 else if (IS_UPPER (c))
02579 id = id * 36 + c - 'A' + 10;
02580 else
02581 return NULL;
02582 c = d_next_char (di);
02583 }
02584 while (c != '_');
02585
02586 ++id;
02587 }
02588
02589 if (id >= di->next_sub)
02590 return NULL;
02591
02592 ++di->did_subs;
02593
02594 return di->subs[id];
02595 }
02596 else
02597 {
02598 int verbose;
02599 const struct d_standard_sub_info *p;
02600 const struct d_standard_sub_info *pend;
02601
02602 verbose = (di->options & DMGL_VERBOSE) != 0;
02603 if (! verbose && prefix)
02604 {
02605 char peek;
02606
02607 peek = d_peek_char (di);
02608 if (peek == 'C' || peek == 'D')
02609 verbose = 1;
02610 }
02611
02612 pend = (&standard_subs[0]
02613 + sizeof standard_subs / sizeof standard_subs[0]);
02614 for (p = &standard_subs[0]; p < pend; ++p)
02615 {
02616 if (c == p->code)
02617 {
02618 const char *s;
02619 int len;
02620
02621 if (p->set_last_name != NULL)
02622 di->last_name = d_make_sub (di, p->set_last_name,
02623 p->set_last_name_len);
02624 if (verbose)
02625 {
02626 s = p->full_expansion;
02627 len = p->full_len;
02628 }
02629 else
02630 {
02631 s = p->simple_expansion;
02632 len = p->simple_len;
02633 }
02634 di->expansion += len;
02635 return d_make_sub (di, s, len);
02636 }
02637 }
02638
02639 return NULL;
02640 }
02641 }
02642
02643
02644
02645 static void
02646 d_print_resize (dpi, add)
02647 struct d_print_info *dpi;
02648 size_t add;
02649 {
02650 size_t need;
02651
02652 if (dpi->buf == NULL)
02653 return;
02654 need = dpi->len + add;
02655 while (need > dpi->alc)
02656 {
02657 size_t newalc;
02658 char *newbuf;
02659
02660 newalc = dpi->alc * 2;
02661 newbuf = realloc (dpi->buf, newalc);
02662 if (newbuf == NULL)
02663 {
02664 free (dpi->buf);
02665 dpi->buf = NULL;
02666 dpi->allocation_failure = 1;
02667 return;
02668 }
02669 dpi->buf = newbuf;
02670 dpi->alc = newalc;
02671 }
02672 }
02673
02674
02675
02676 static void
02677 d_print_append_char (dpi, c)
02678 struct d_print_info *dpi;
02679 int c;
02680 {
02681 if (dpi->buf != NULL)
02682 {
02683 if (dpi->len >= dpi->alc)
02684 {
02685 d_print_resize (dpi, 1);
02686 if (dpi->buf == NULL)
02687 return;
02688 }
02689
02690 dpi->buf[dpi->len] = c;
02691 ++dpi->len;
02692 }
02693 }
02694
02695
02696
02697 static void
02698 d_print_append_buffer (dpi, s, l)
02699 struct d_print_info *dpi;
02700 const char *s;
02701 size_t l;
02702 {
02703 if (dpi->buf != NULL)
02704 {
02705 if (dpi->len + l > dpi->alc)
02706 {
02707 d_print_resize (dpi, l);
02708 if (dpi->buf == NULL)
02709 return;
02710 }
02711
02712 memcpy (dpi->buf + dpi->len, s, l);
02713 dpi->len += l;
02714 }
02715 }
02716
02717
02718
02719 static void
02720 d_print_error (dpi)
02721 struct d_print_info *dpi;
02722 {
02723 free (dpi->buf);
02724 dpi->buf = NULL;
02725 }
02726
02727
02728
02729
02730
02731
02732
02733
02734
02735 CP_STATIC_IF_GLIBCPP_V3
02736 char *
02737 cplus_demangle_print (options, dc, estimate, palc)
02738 int options;
02739 const struct demangle_component *dc;
02740 int estimate;
02741 size_t *palc;
02742 {
02743 struct d_print_info dpi;
02744
02745 dpi.options = options;
02746
02747 dpi.alc = estimate + 1;
02748 dpi.buf = malloc (dpi.alc);
02749 if (dpi.buf == NULL)
02750 {
02751 *palc = 1;
02752 return NULL;
02753 }
02754
02755 dpi.len = 0;
02756 dpi.templates = NULL;
02757 dpi.modifiers = NULL;
02758
02759 dpi.allocation_failure = 0;
02760
02761 d_print_comp (&dpi, dc);
02762
02763 d_append_char (&dpi, '\0');
02764
02765 if (dpi.buf != NULL)
02766 *palc = dpi.alc;
02767 else
02768 *palc = dpi.allocation_failure;
02769
02770 return dpi.buf;
02771 }
02772
02773
02774
02775 static void
02776 d_print_comp (dpi, dc)
02777 struct d_print_info *dpi;
02778 const struct demangle_component *dc;
02779 {
02780 if (dc == NULL)
02781 {
02782 d_print_error (dpi);
02783 return;
02784 }
02785 if (d_print_saw_error (dpi))
02786 return;
02787
02788 switch (dc->type)
02789 {
02790 case DEMANGLE_COMPONENT_NAME:
02791 if ((dpi->options & DMGL_JAVA) == 0)
02792 d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
02793 else
02794 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
02795 return;
02796
02797 case DEMANGLE_COMPONENT_QUAL_NAME:
02798 case DEMANGLE_COMPONENT_LOCAL_NAME:
02799 d_print_comp (dpi, d_left (dc));
02800 if ((dpi->options & DMGL_JAVA) == 0)
02801 d_append_string_constant (dpi, "::");
02802 else
02803 d_append_char (dpi, '.');
02804 d_print_comp (dpi, d_right (dc));
02805 return;
02806
02807 case DEMANGLE_COMPONENT_TYPED_NAME:
02808 {
02809 struct d_print_mod *hold_modifiers;
02810 struct demangle_component *typed_name;
02811 struct d_print_mod adpm[4];
02812 unsigned int i;
02813 struct d_print_template dpt;
02814
02815
02816
02817
02818 hold_modifiers = dpi->modifiers;
02819 i = 0;
02820 typed_name = d_left (dc);
02821 while (typed_name != NULL)
02822 {
02823 if (i >= sizeof adpm / sizeof adpm[0])
02824 {
02825 d_print_error (dpi);
02826 return;
02827 }
02828
02829 adpm[i].next = dpi->modifiers;
02830 dpi->modifiers = &adpm[i];
02831 adpm[i].mod = typed_name;
02832 adpm[i].printed = 0;
02833 adpm[i].templates = dpi->templates;
02834 ++i;
02835
02836 if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
02837 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
02838 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
02839 break;
02840
02841 typed_name = d_left (typed_name);
02842 }
02843
02844
02845
02846 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
02847 {
02848 dpt.next = dpi->templates;
02849 dpi->templates = &dpt;
02850 dpt.template = typed_name;
02851 }
02852
02853
02854
02855
02856
02857 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
02858 {
02859 struct demangle_component *local_name;
02860
02861 local_name = d_right (typed_name);
02862 while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
02863 || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
02864 || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
02865 {
02866 if (i >= sizeof adpm / sizeof adpm[0])
02867 {
02868 d_print_error (dpi);
02869 return;
02870 }
02871
02872 adpm[i] = adpm[i - 1];
02873 adpm[i].next = &adpm[i - 1];
02874 dpi->modifiers = &adpm[i];
02875
02876 adpm[i - 1].mod = local_name;
02877 adpm[i - 1].printed = 0;
02878 adpm[i - 1].templates = dpi->templates;
02879 ++i;
02880
02881 local_name = d_left (local_name);
02882 }
02883 }
02884
02885 d_print_comp (dpi, d_right (dc));
02886
02887 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
02888 dpi->templates = dpt.next;
02889
02890
02891
02892 while (i > 0)
02893 {
02894 --i;
02895 if (! adpm[i].printed)
02896 {
02897 d_append_char (dpi, ' ');
02898 d_print_mod (dpi, adpm[i].mod);
02899 }
02900 }
02901
02902 dpi->modifiers = hold_modifiers;
02903
02904 return;
02905 }
02906
02907 case DEMANGLE_COMPONENT_TEMPLATE:
02908 {
02909 struct d_print_mod *hold_dpm;
02910
02911
02912
02913
02914
02915 hold_dpm = dpi->modifiers;
02916 dpi->modifiers = NULL;
02917
02918 d_print_comp (dpi, d_left (dc));
02919 if (d_last_char (dpi) == '<')
02920 d_append_char (dpi, ' ');
02921 d_append_char (dpi, '<');
02922 d_print_comp (dpi, d_right (dc));
02923
02924
02925 if (d_last_char (dpi) == '>')
02926 d_append_char (dpi, ' ');
02927 d_append_char (dpi, '>');
02928
02929 dpi->modifiers = hold_dpm;
02930
02931 return;
02932 }
02933
02934 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
02935 {
02936 long i;
02937 struct demangle_component *a;
02938 struct d_print_template *hold_dpt;
02939
02940 if (dpi->templates == NULL)
02941 {
02942 d_print_error (dpi);
02943 return;
02944 }
02945 i = dc->u.s_number.number;
02946 for (a = d_right (dpi->templates->template);
02947 a != NULL;
02948 a = d_right (a))
02949 {
02950 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
02951 {
02952 d_print_error (dpi);
02953 return;
02954 }
02955 if (i <= 0)
02956 break;
02957 --i;
02958 }
02959 if (i != 0 || a == NULL)
02960 {
02961 d_print_error (dpi);
02962 return;
02963 }
02964
02965
02966
02967
02968
02969
02970 hold_dpt = dpi->templates;
02971 dpi->templates = hold_dpt->next;
02972
02973 d_print_comp (dpi, d_left (a));
02974
02975 dpi->templates = hold_dpt;
02976
02977 return;
02978 }
02979
02980 case DEMANGLE_COMPONENT_CTOR:
02981 d_print_comp (dpi, dc->u.s_ctor.name);
02982 return;
02983
02984 case DEMANGLE_COMPONENT_DTOR:
02985 d_append_char (dpi, '~');
02986 d_print_comp (dpi, dc->u.s_dtor.name);
02987 return;
02988
02989 case DEMANGLE_COMPONENT_VTABLE:
02990 d_append_string_constant (dpi, "vtable for ");
02991 d_print_comp (dpi, d_left (dc));
02992 return;
02993
02994 case DEMANGLE_COMPONENT_VTT:
02995 d_append_string_constant (dpi, "VTT for ");
02996 d_print_comp (dpi, d_left (dc));
02997 return;
02998
02999 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
03000 d_append_string_constant (dpi, "construction vtable for ");
03001 d_print_comp (dpi, d_left (dc));
03002 d_append_string_constant (dpi, "-in-");
03003 d_print_comp (dpi, d_right (dc));
03004 return;
03005
03006 case DEMANGLE_COMPONENT_TYPEINFO:
03007 d_append_string_constant (dpi, "typeinfo for ");
03008 d_print_comp (dpi, d_left (dc));
03009 return;
03010
03011 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
03012 d_append_string_constant (dpi, "typeinfo name for ");
03013 d_print_comp (dpi, d_left (dc));
03014 return;
03015
03016 case DEMANGLE_COMPONENT_TYPEINFO_FN:
03017 d_append_string_constant (dpi, "typeinfo fn for ");
03018 d_print_comp (dpi, d_left (dc));
03019 return;
03020
03021 case DEMANGLE_COMPONENT_THUNK:
03022 d_append_string_constant (dpi, "non-virtual thunk to ");
03023 d_print_comp (dpi, d_left (dc));
03024 return;
03025
03026 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
03027 d_append_string_constant (dpi, "virtual thunk to ");
03028 d_print_comp (dpi, d_left (dc));
03029 return;
03030
03031 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
03032 d_append_string_constant (dpi, "covariant return thunk to ");
03033 d_print_comp (dpi, d_left (dc));
03034 return;
03035
03036 case DEMANGLE_COMPONENT_JAVA_CLASS:
03037 d_append_string_constant (dpi, "java Class for ");
03038 d_print_comp (dpi, d_left (dc));
03039 return;
03040
03041 case DEMANGLE_COMPONENT_GUARD:
03042 d_append_string_constant (dpi, "guard variable for ");
03043 d_print_comp (dpi, d_left (dc));
03044 return;
03045
03046 case DEMANGLE_COMPONENT_REFTEMP:
03047 d_append_string_constant (dpi, "reference temporary for ");
03048 d_print_comp (dpi, d_left (dc));
03049 return;
03050
03051 case DEMANGLE_COMPONENT_SUB_STD:
03052 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
03053 return;
03054
03055 case DEMANGLE_COMPONENT_RESTRICT:
03056 case DEMANGLE_COMPONENT_VOLATILE:
03057 case DEMANGLE_COMPONENT_CONST:
03058 {
03059 struct d_print_mod *pdpm;
03060
03061
03062
03063
03064
03065 for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
03066 {
03067 if (! pdpm->printed)
03068 {
03069 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
03070 && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
03071 && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
03072 break;
03073 if (pdpm->mod->type == dc->type)
03074 {
03075 d_print_comp (dpi, d_left (dc));
03076 return;
03077 }
03078 }
03079 }
03080 }
03081
03082 case DEMANGLE_COMPONENT_RESTRICT_THIS:
03083 case DEMANGLE_COMPONENT_VOLATILE_THIS:
03084 case DEMANGLE_COMPONENT_CONST_THIS:
03085 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
03086 case DEMANGLE_COMPONENT_POINTER:
03087 case DEMANGLE_COMPONENT_REFERENCE:
03088 case DEMANGLE_COMPONENT_COMPLEX:
03089 case DEMANGLE_COMPONENT_IMAGINARY:
03090 {
03091
03092 struct d_print_mod dpm;
03093
03094 dpm.next = dpi->modifiers;
03095 dpi->modifiers = &dpm;
03096 dpm.mod = dc;
03097 dpm.printed = 0;
03098 dpm.templates = dpi->templates;
03099
03100 d_print_comp (dpi, d_left (dc));
03101
03102
03103
03104 if (! dpm.printed)
03105 d_print_mod (dpi, dc);
03106
03107 dpi->modifiers = dpm.next;
03108
03109 return;
03110 }
03111
03112 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
03113 if ((dpi->options & DMGL_JAVA) == 0)
03114 d_append_buffer (dpi, dc->u.s_builtin.type->name,
03115 dc->u.s_builtin.type->len);
03116 else
03117 d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
03118 dc->u.s_builtin.type->java_len);
03119 return;
03120
03121 case DEMANGLE_COMPONENT_VENDOR_TYPE:
03122 d_print_comp (dpi, d_left (dc));
03123 return;
03124
03125 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
03126 {
03127 if (d_left (dc) != NULL)
03128 {
03129 struct d_print_mod dpm;
03130
03131
03132
03133
03134 dpm.next = dpi->modifiers;
03135 dpi->modifiers = &dpm;
03136 dpm.mod = dc;
03137 dpm.printed = 0;
03138 dpm.templates = dpi->templates;
03139
03140 d_print_comp (dpi, d_left (dc));
03141
03142 dpi->modifiers = dpm.next;
03143
03144 if (dpm.printed)
03145 return;
03146
03147 d_append_char (dpi, ' ');
03148 }
03149
03150 d_print_function_type (dpi, dc, dpi->modifiers);
03151
03152 return;
03153 }
03154
03155 case DEMANGLE_COMPONENT_ARRAY_TYPE:
03156 {
03157 struct d_print_mod *hold_modifiers;
03158 struct d_print_mod adpm[4];
03159 unsigned int i;
03160 struct d_print_mod *pdpm;
03161
03162
03163
03164
03165
03166
03167
03168
03169
03170 hold_modifiers = dpi->modifiers;
03171
03172 adpm[0].next = hold_modifiers;
03173 dpi->modifiers = &adpm[0];
03174 adpm[0].mod = dc;
03175 adpm[0].printed = 0;
03176 adpm[0].templates = dpi->templates;
03177
03178 i = 1;
03179 pdpm = hold_modifiers;
03180 while (pdpm != NULL
03181 && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
03182 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
03183 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
03184 {
03185 if (! pdpm->printed)
03186 {
03187 if (i >= sizeof adpm / sizeof adpm[0])
03188 {
03189 d_print_error (dpi);
03190 return;
03191 }
03192
03193 adpm[i] = *pdpm;
03194 adpm[i].next = dpi->modifiers;
03195 dpi->modifiers = &adpm[i];
03196 pdpm->printed = 1;
03197 ++i;
03198 }
03199
03200 pdpm = pdpm->next;
03201 }
03202
03203 d_print_comp (dpi, d_right (dc));
03204
03205 dpi->modifiers = hold_modifiers;
03206
03207 if (adpm[0].printed)
03208 return;
03209
03210 while (i > 1)
03211 {
03212 --i;
03213 d_print_mod (dpi, adpm[i].mod);
03214 }
03215
03216 d_print_array_type (dpi, dc, dpi->modifiers);
03217
03218 return;
03219 }
03220
03221 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
03222 {
03223 struct d_print_mod dpm;
03224
03225 dpm.next = dpi->modifiers;
03226 dpi->modifiers = &dpm;
03227 dpm.mod = dc;
03228 dpm.printed = 0;
03229 dpm.templates = dpi->templates;
03230
03231 d_print_comp (dpi, d_right (dc));
03232
03233
03234
03235 if (! dpm.printed)
03236 {
03237 d_append_char (dpi, ' ');
03238 d_print_comp (dpi, d_left (dc));
03239 d_append_string_constant (dpi, "::*");
03240 }
03241
03242 dpi->modifiers = dpm.next;
03243
03244 return;
03245 }
03246
03247 case DEMANGLE_COMPONENT_ARGLIST:
03248 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
03249 d_print_comp (dpi, d_left (dc));
03250 if (d_right (dc) != NULL)
03251 {
03252 d_append_string_constant (dpi, ", ");
03253 d_print_comp (dpi, d_right (dc));
03254 }
03255 return;
03256
03257 case DEMANGLE_COMPONENT_OPERATOR:
03258 {
03259 char c;
03260
03261 d_append_string_constant (dpi, "operator");
03262 c = dc->u.s_operator.op->name[0];
03263 if (IS_LOWER (c))
03264 d_append_char (dpi, ' ');
03265 d_append_buffer (dpi, dc->u.s_operator.op->name,
03266 dc->u.s_operator.op->len);
03267 return;
03268 }
03269
03270 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
03271 d_append_string_constant (dpi, "operator ");
03272 d_print_comp (dpi, dc->u.s_extended_operator.name);
03273 return;
03274
03275 case DEMANGLE_COMPONENT_CAST:
03276 d_append_string_constant (dpi, "operator ");
03277 d_print_cast (dpi, dc);
03278 return;
03279
03280 case DEMANGLE_COMPONENT_UNARY:
03281 if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
03282 d_print_expr_op (dpi, d_left (dc));
03283 else
03284 {
03285 d_append_char (dpi, '(');
03286 d_print_cast (dpi, d_left (dc));
03287 d_append_char (dpi, ')');
03288 }
03289 d_append_char (dpi, '(');
03290 d_print_comp (dpi, d_right (dc));
03291 d_append_char (dpi, ')');
03292 return;
03293
03294 case DEMANGLE_COMPONENT_BINARY:
03295 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
03296 {
03297 d_print_error (dpi);
03298 return;
03299 }
03300
03301
03302
03303
03304 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
03305 && d_left (dc)->u.s_operator.op->len == 1
03306 && d_left (dc)->u.s_operator.op->name[0] == '>')
03307 d_append_char (dpi, '(');
03308
03309 d_append_char (dpi, '(');
03310 d_print_comp (dpi, d_left (d_right (dc)));
03311 d_append_string_constant (dpi, ") ");
03312 d_print_expr_op (dpi, d_left (dc));
03313 d_append_string_constant (dpi, " (");
03314 d_print_comp (dpi, d_right (d_right (dc)));
03315 d_append_char (dpi, ')');
03316
03317 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
03318 && d_left (dc)->u.s_operator.op->len == 1
03319 && d_left (dc)->u.s_operator.op->name[0] == '>')
03320 d_append_char (dpi, ')');
03321
03322 return;
03323
03324 case DEMANGLE_COMPONENT_BINARY_ARGS:
03325
03326 d_print_error (dpi);
03327 return;
03328
03329 case DEMANGLE_COMPONENT_TRINARY:
03330 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
03331 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
03332 {
03333 d_print_error (dpi);
03334 return;
03335 }
03336 d_append_char (dpi, '(');
03337 d_print_comp (dpi, d_left (d_right (dc)));
03338 d_append_string_constant (dpi, ") ");
03339 d_print_expr_op (dpi, d_left (dc));
03340 d_append_string_constant (dpi, " (");
03341 d_print_comp (dpi, d_left (d_right (d_right (dc))));
03342 d_append_string_constant (dpi, ") : (");
03343 d_print_comp (dpi, d_right (d_right (d_right (dc))));
03344 d_append_char (dpi, ')');
03345 return;
03346
03347 case DEMANGLE_COMPONENT_TRINARY_ARG1:
03348 case DEMANGLE_COMPONENT_TRINARY_ARG2:
03349
03350 d_print_error (dpi);
03351 return;
03352
03353 case DEMANGLE_COMPONENT_LITERAL:
03354 case DEMANGLE_COMPONENT_LITERAL_NEG:
03355 {
03356 enum d_builtin_type_print tp;
03357
03358
03359 tp = D_PRINT_DEFAULT;
03360 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
03361 {
03362 tp = d_left (dc)->u.s_builtin.type->print;
03363 switch (tp)
03364 {
03365 case D_PRINT_INT:
03366 case D_PRINT_UNSIGNED:
03367 case D_PRINT_LONG:
03368 case D_PRINT_UNSIGNED_LONG:
03369 case D_PRINT_LONG_LONG:
03370 case D_PRINT_UNSIGNED_LONG_LONG:
03371 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
03372 {
03373 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
03374 d_append_char (dpi, '-');
03375 d_print_comp (dpi, d_right (dc));
03376 switch (tp)
03377 {
03378 default:
03379 break;
03380 case D_PRINT_UNSIGNED:
03381 d_append_char (dpi, 'u');
03382 break;
03383 case D_PRINT_LONG:
03384 d_append_char (dpi, 'l');
03385 break;
03386 case D_PRINT_UNSIGNED_LONG:
03387 d_append_string_constant (dpi, "ul");
03388 break;
03389 case D_PRINT_LONG_LONG:
03390 d_append_string_constant (dpi, "ll");
03391 break;
03392 case D_PRINT_UNSIGNED_LONG_LONG:
03393 d_append_string_constant (dpi, "ull");
03394 break;
03395 }
03396 return;
03397 }
03398 break;
03399
03400 case D_PRINT_BOOL:
03401 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
03402 && d_right (dc)->u.s_name.len == 1
03403 && dc->type == DEMANGLE_COMPONENT_LITERAL)
03404 {
03405 switch (d_right (dc)->u.s_name.s[0])
03406 {
03407 case '0':
03408 d_append_string_constant (dpi, "false");
03409 return;
03410 case '1':
03411 d_append_string_constant (dpi, "true");
03412 return;
03413 default:
03414 break;
03415 }
03416 }
03417 break;
03418
03419 default:
03420 break;
03421 }
03422 }
03423
03424 d_append_char (dpi, '(');
03425 d_print_comp (dpi, d_left (dc));
03426 d_append_char (dpi, ')');
03427 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
03428 d_append_char (dpi, '-');
03429 if (tp == D_PRINT_FLOAT)
03430 d_append_char (dpi, '[');
03431 d_print_comp (dpi, d_right (dc));
03432 if (tp == D_PRINT_FLOAT)
03433 d_append_char (dpi, ']');
03434 }
03435 return;
03436
03437 default:
03438 d_print_error (dpi);
03439 return;
03440 }
03441 }
03442
03443
03444
03445
03446
03447
03448 static void
03449 d_print_java_identifier (dpi, name, len)
03450 struct d_print_info *dpi;
03451 const char *name;
03452 int len;
03453 {
03454 const char *p;
03455 const char *end;
03456
03457 end = name + len;
03458 for (p = name; p < end; ++p)
03459 {
03460 if (end - p > 3
03461 && p[0] == '_'
03462 && p[1] == '_'
03463 && p[2] == 'U')
03464 {
03465 unsigned long c;
03466 const char *q;
03467
03468 c = 0;
03469 for (q = p + 3; q < end; ++q)
03470 {
03471 int dig;
03472
03473 if (IS_DIGIT (*q))
03474 dig = *q - '0';
03475 else if (*q >= 'A' && *q <= 'F')
03476 dig = *q - 'A' + 10;
03477 else if (*q >= 'a' && *q <= 'f')
03478 dig = *q - 'a' + 10;
03479 else
03480 break;
03481
03482 c = c * 16 + dig;
03483 }
03484
03485
03486 if (q < end && *q == '_' && c < 256)
03487 {
03488 d_append_char (dpi, c);
03489 p = q;
03490 continue;
03491 }
03492 }
03493
03494 d_append_char (dpi, *p);
03495 }
03496 }
03497
03498
03499
03500
03501 static void
03502 d_print_mod_list (dpi, mods, suffix)
03503 struct d_print_info *dpi;
03504 struct d_print_mod *mods;
03505 int suffix;
03506 {
03507 struct d_print_template *hold_dpt;
03508
03509 if (mods == NULL || d_print_saw_error (dpi))
03510 return;
03511
03512 if (mods->printed
03513 || (! suffix
03514 && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
03515 || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
03516 || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
03517 {
03518 d_print_mod_list (dpi, mods->next, suffix);
03519 return;
03520 }
03521
03522 mods->printed = 1;
03523
03524 hold_dpt = dpi->templates;
03525 dpi->templates = mods->templates;
03526
03527 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
03528 {
03529 d_print_function_type (dpi, mods->mod, mods->next);
03530 dpi->templates = hold_dpt;
03531 return;
03532 }
03533 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
03534 {
03535 d_print_array_type (dpi, mods->mod, mods->next);
03536 dpi->templates = hold_dpt;
03537 return;
03538 }
03539 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
03540 {
03541 struct d_print_mod *hold_modifiers;
03542 struct demangle_component *dc;
03543
03544
03545
03546
03547
03548
03549 hold_modifiers = dpi->modifiers;
03550 dpi->modifiers = NULL;
03551 d_print_comp (dpi, d_left (mods->mod));
03552 dpi->modifiers = hold_modifiers;
03553
03554 if ((dpi->options & DMGL_JAVA) == 0)
03555 d_append_string_constant (dpi, "::");
03556 else
03557 d_append_char (dpi, '.');
03558
03559 dc = d_right (mods->mod);
03560 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
03561 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
03562 || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
03563 dc = d_left (dc);
03564
03565 d_print_comp (dpi, dc);
03566
03567 dpi->templates = hold_dpt;
03568 return;
03569 }
03570
03571 d_print_mod (dpi, mods->mod);
03572
03573 dpi->templates = hold_dpt;
03574
03575 d_print_mod_list (dpi, mods->next, suffix);
03576 }
03577
03578
03579
03580 static void
03581 d_print_mod (dpi, mod)
03582 struct d_print_info *dpi;
03583 const struct demangle_component *mod;
03584 {
03585 switch (mod->type)
03586 {
03587 case DEMANGLE_COMPONENT_RESTRICT:
03588 case DEMANGLE_COMPONENT_RESTRICT_THIS:
03589 d_append_string_constant (dpi, " restrict");
03590 return;
03591 case DEMANGLE_COMPONENT_VOLATILE:
03592 case DEMANGLE_COMPONENT_VOLATILE_THIS:
03593 d_append_string_constant (dpi, " volatile");
03594 return;
03595 case DEMANGLE_COMPONENT_CONST:
03596 case DEMANGLE_COMPONENT_CONST_THIS:
03597 d_append_string_constant (dpi, " const");
03598 return;
03599 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
03600 d_append_char (dpi, ' ');
03601 d_print_comp (dpi, d_right (mod));
03602 return;
03603 case DEMANGLE_COMPONENT_POINTER:
03604
03605 if ((dpi->options & DMGL_JAVA) == 0)
03606 d_append_char (dpi, '*');
03607 return;
03608 case DEMANGLE_COMPONENT_REFERENCE:
03609 d_append_char (dpi, '&');
03610 return;
03611 case DEMANGLE_COMPONENT_COMPLEX:
03612 d_append_string_constant (dpi, "complex ");
03613 return;
03614 case DEMANGLE_COMPONENT_IMAGINARY:
03615 d_append_string_constant (dpi, "imaginary ");
03616 return;
03617 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
03618 if (d_last_char (dpi) != '(')
03619 d_append_char (dpi, ' ');
03620 d_print_comp (dpi, d_left (mod));
03621 d_append_string_constant (dpi, "::*");
03622 return;
03623 case DEMANGLE_COMPONENT_TYPED_NAME:
03624 d_print_comp (dpi, d_left (mod));
03625 return;
03626 default:
03627
03628
03629 d_print_comp (dpi, mod);
03630 return;
03631 }
03632 }
03633
03634
03635
03636 static void
03637 d_print_function_type (dpi, dc, mods)
03638 struct d_print_info *dpi;
03639 const struct demangle_component *dc;
03640 struct d_print_mod *mods;
03641 {
03642 int need_paren;
03643 int saw_mod;
03644 int need_space;
03645 struct d_print_mod *p;
03646 struct d_print_mod *hold_modifiers;
03647
03648 need_paren = 0;
03649 saw_mod = 0;
03650 need_space = 0;
03651 for (p = mods; p != NULL; p = p->next)
03652 {
03653 if (p->printed)
03654 break;
03655
03656 saw_mod = 1;
03657 switch (p->mod->type)
03658 {
03659 case DEMANGLE_COMPONENT_POINTER:
03660 case DEMANGLE_COMPONENT_REFERENCE:
03661 need_paren = 1;
03662 break;
03663 case DEMANGLE_COMPONENT_RESTRICT:
03664 case DEMANGLE_COMPONENT_VOLATILE:
03665 case DEMANGLE_COMPONENT_CONST:
03666 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
03667 case DEMANGLE_COMPONENT_COMPLEX:
03668 case DEMANGLE_COMPONENT_IMAGINARY:
03669 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
03670 need_space = 1;
03671 need_paren = 1;
03672 break;
03673 case DEMANGLE_COMPONENT_RESTRICT_THIS:
03674 case DEMANGLE_COMPONENT_VOLATILE_THIS:
03675 case DEMANGLE_COMPONENT_CONST_THIS:
03676 break;
03677 default:
03678 break;
03679 }
03680 if (need_paren)
03681 break;
03682 }
03683
03684 if (d_left (dc) != NULL && ! saw_mod)
03685 need_paren = 1;
03686
03687 if (need_paren)
03688 {
03689 if (! need_space)
03690 {
03691 if (d_last_char (dpi) != '('
03692 && d_last_char (dpi) != '*')
03693 need_space = 1;
03694 }
03695 if (need_space && d_last_char (dpi) != ' ')
03696 d_append_char (dpi, ' ');
03697 d_append_char (dpi, '(');
03698 }
03699
03700 hold_modifiers = dpi->modifiers;
03701 dpi->modifiers = NULL;
03702
03703 d_print_mod_list (dpi, mods, 0);
03704
03705 if (need_paren)
03706 d_append_char (dpi, ')');
03707
03708 d_append_char (dpi, '(');
03709
03710 if (d_right (dc) != NULL)
03711 d_print_comp (dpi, d_right (dc));
03712
03713 d_append_char (dpi, ')');
03714
03715 d_print_mod_list (dpi, mods, 1);
03716
03717 dpi->modifiers = hold_modifiers;
03718 }
03719
03720
03721
03722 static void
03723 d_print_array_type (dpi, dc, mods)
03724 struct d_print_info *dpi;
03725 const struct demangle_component *dc;
03726 struct d_print_mod *mods;
03727 {
03728 int need_space;
03729
03730 need_space = 1;
03731 if (mods != NULL)
03732 {
03733 int need_paren;
03734 struct d_print_mod *p;
03735
03736 need_paren = 0;
03737 for (p = mods; p != NULL; p = p->next)
03738 {
03739 if (! p->printed)
03740 {
03741 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
03742 {
03743 need_space = 0;
03744 break;
03745 }
03746 else
03747 {
03748 need_paren = 1;
03749 need_space = 1;
03750 break;
03751 }
03752 }
03753 }
03754
03755 if (need_paren)
03756 d_append_string_constant (dpi, " (");
03757
03758 d_print_mod_list (dpi, mods, 0);
03759
03760 if (need_paren)
03761 d_append_char (dpi, ')');
03762 }
03763
03764 if (need_space)
03765 d_append_char (dpi, ' ');
03766
03767 d_append_char (dpi, '[');
03768
03769 if (d_left (dc) != NULL)
03770 d_print_comp (dpi, d_left (dc));
03771
03772 d_append_char (dpi, ']');
03773 }
03774
03775
03776
03777 static void
03778 d_print_expr_op (dpi, dc)
03779 struct d_print_info *dpi;
03780 const struct demangle_component *dc;
03781 {
03782 if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
03783 d_append_buffer (dpi, dc->u.s_operator.op->name,
03784 dc->u.s_operator.op->len);
03785 else
03786 d_print_comp (dpi, dc);
03787 }
03788
03789
03790
03791 static void
03792 d_print_cast (dpi, dc)
03793 struct d_print_info *dpi;
03794 const struct demangle_component *dc;
03795 {
03796 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
03797 d_print_comp (dpi, d_left (dc));
03798 else
03799 {
03800 struct d_print_mod *hold_dpm;
03801 struct d_print_template dpt;
03802
03803
03804
03805
03806
03807
03808 hold_dpm = dpi->modifiers;
03809 dpi->modifiers = NULL;
03810
03811 dpt.next = dpi->templates;
03812 dpi->templates = &dpt;
03813 dpt.template = d_left (dc);
03814
03815 d_print_comp (dpi, d_left (d_left (dc)));
03816
03817 dpi->templates = dpt.next;
03818
03819 if (d_last_char (dpi) == '<')
03820 d_append_char (dpi, ' ');
03821 d_append_char (dpi, '<');
03822 d_print_comp (dpi, d_right (d_left (dc)));
03823
03824
03825 if (d_last_char (dpi) == '>')
03826 d_append_char (dpi, ' ');
03827 d_append_char (dpi, '>');
03828
03829 dpi->modifiers = hold_dpm;
03830 }
03831 }
03832
03833
03834
03835
03836 CP_STATIC_IF_GLIBCPP_V3
03837 void
03838 cplus_demangle_init_info (mangled, options, len, di)
03839 const char *mangled;
03840 int options;
03841 size_t len;
03842 struct d_info *di;
03843 {
03844 di->s = mangled;
03845 di->send = mangled + len;
03846 di->options = options;
03847
03848 di->n = mangled;
03849
03850
03851
03852
03853 di->num_comps = 2 * len;
03854 di->next_comp = 0;
03855
03856
03857
03858 di->num_subs = len;
03859 di->next_sub = 0;
03860 di->did_subs = 0;
03861
03862 di->last_name = NULL;
03863
03864 di->expansion = 0;
03865 }
03866
03867
03868
03869
03870
03871
03872
03873
03874 static char *
03875 d_demangle (mangled, options, palc)
03876 const char* mangled;
03877 int options;
03878 size_t *palc;
03879 {
03880 size_t len;
03881 int type;
03882 struct d_info di;
03883 struct demangle_component *dc;
03884 int estimate;
03885 char *ret;
03886
03887 *palc = 0;
03888
03889 len = strlen (mangled);
03890
03891 if (mangled[0] == '_' && mangled[1] == 'Z')
03892 type = 0;
03893 else if (strncmp (mangled, "_GLOBAL_", 8) == 0
03894 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
03895 && (mangled[9] == 'D' || mangled[9] == 'I')
03896 && mangled[10] == '_')
03897 {
03898 char *r;
03899
03900 r = malloc (40 + len - 11);
03901 if (r == NULL)
03902 *palc = 1;
03903 else
03904 {
03905 if (mangled[9] == 'I')
03906 strcpy (r, "global constructors keyed to ");
03907 else
03908 strcpy (r, "global destructors keyed to ");
03909 strcat (r, mangled + 11);
03910 }
03911 return r;
03912 }
03913 else
03914 {
03915 if ((options & DMGL_TYPES) == 0)
03916 return NULL;
03917 type = 1;
03918 }
03919
03920 cplus_demangle_init_info (mangled, options, len, &di);
03921
03922 {
03923 #ifdef CP_DYNAMIC_ARRAYS
03924 __extension__ struct demangle_component comps[di.num_comps];
03925 __extension__ struct demangle_component *subs[di.num_subs];
03926
03927 di.comps = &comps[0];
03928 di.subs = &subs[0];
03929 #else
03930 di.comps = ((struct demangle_component *)
03931 malloc (di.num_comps * sizeof (struct demangle_component)));
03932 di.subs = ((struct demangle_component **)
03933 malloc (di.num_subs * sizeof (struct demangle_component *)));
03934 if (di.comps == NULL || di.subs == NULL)
03935 {
03936 if (di.comps != NULL)
03937 free (di.comps);
03938 if (di.subs != NULL)
03939 free (di.subs);
03940 *palc = 1;
03941 return NULL;
03942 }
03943 #endif
03944
03945 if (! type)
03946 dc = cplus_demangle_mangled_name (&di, 1);
03947 else
03948 dc = cplus_demangle_type (&di);
03949
03950
03951
03952
03953
03954 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
03955 dc = NULL;
03956
03957 #ifdef CP_DEMANGLE_DEBUG
03958 if (dc == NULL)
03959 printf ("failed demangling\n");
03960 else
03961 d_dump (dc, 0);
03962 #endif
03963
03964
03965
03966 estimate = len + di.expansion + 10 * di.did_subs;
03967 estimate += estimate / 8;
03968
03969 ret = NULL;
03970 if (dc != NULL)
03971 ret = cplus_demangle_print (options, dc, estimate, palc);
03972
03973 #ifndef CP_DYNAMIC_ARRAYS
03974 free (di.comps);
03975 free (di.subs);
03976 #endif
03977
03978 #ifdef CP_DEMANGLE_DEBUG
03979 if (ret != NULL)
03980 {
03981 int rlen;
03982
03983 rlen = strlen (ret);
03984 if (rlen > 2 * estimate)
03985 printf ("*** Length %d much greater than estimate %d\n",
03986 rlen, estimate);
03987 else if (rlen > estimate)
03988 printf ("*** Length %d greater than estimate %d\n",
03989 rlen, estimate);
03990 else if (rlen < estimate / 2)
03991 printf ("*** Length %d much less than estimate %d\n",
03992 rlen, estimate);
03993 }
03994 #endif
03995 }
03996
03997 return ret;
03998 }
03999
04000 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
04001
04002 extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *));
04003
04004
04005
04006
04007
04008
04009
04010
04011
04012
04013
04014
04015
04016
04017
04018
04019
04020
04021
04022
04023
04024
04025
04026
04027
04028
04029
04030 char *
04031 __cxa_demangle (mangled_name, output_buffer, length, status)
04032 const char *mangled_name;
04033 char *output_buffer;
04034 size_t *length;
04035 int *status;
04036 {
04037 char *demangled;
04038 size_t alc;
04039
04040 if (mangled_name == NULL)
04041 {
04042 if (status != NULL)
04043 *status = -3;
04044 return NULL;
04045 }
04046
04047 if (output_buffer != NULL && length == NULL)
04048 {
04049 if (status != NULL)
04050 *status = -3;
04051 return NULL;
04052 }
04053
04054 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
04055
04056 if (demangled == NULL)
04057 {
04058 if (status != NULL)
04059 {
04060 if (alc == 1)
04061 *status = -1;
04062 else
04063 *status = -2;
04064 }
04065 return NULL;
04066 }
04067
04068 if (output_buffer == NULL)
04069 {
04070 if (length != NULL)
04071 *length = alc;
04072 }
04073 else
04074 {
04075 if (strlen (demangled) < *length)
04076 {
04077 strcpy (output_buffer, demangled);
04078 free (demangled);
04079 demangled = output_buffer;
04080 }
04081 else
04082 {
04083 free (output_buffer);
04084 *length = alc;
04085 }
04086 }
04087
04088 if (status != NULL)
04089 *status = 0;
04090
04091 return demangled;
04092 }
04093
04094 #else
04095
04096
04097
04098
04099
04100 char *
04101 cplus_demangle_v3 (mangled, options)
04102 const char* mangled;
04103 int options;
04104 {
04105 size_t alc;
04106
04107 return d_demangle (mangled, options, &alc);
04108 }
04109
04110
04111
04112
04113
04114
04115
04116
04117 char *
04118 java_demangle_v3 (mangled)
04119 const char* mangled;
04120 {
04121 size_t alc;
04122 char *demangled;
04123 int nesting;
04124 char *from;
04125 char *to;
04126
04127 demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS, &alc);
04128
04129 if (demangled == NULL)
04130 return NULL;
04131
04132 nesting = 0;
04133 from = demangled;
04134 to = from;
04135 while (*from != '\0')
04136 {
04137 if (strncmp (from, "JArray<", 7) == 0)
04138 {
04139 from += 7;
04140 ++nesting;
04141 }
04142 else if (nesting > 0 && *from == '>')
04143 {
04144 while (to > demangled && to[-1] == ' ')
04145 --to;
04146 *to++ = '[';
04147 *to++ = ']';
04148 --nesting;
04149 ++from;
04150 }
04151 else
04152 *to++ = *from++;
04153 }
04154
04155 *to = '\0';
04156
04157 return demangled;
04158 }
04159
04160 #endif
04161
04162 #ifndef IN_GLIBCPP_V3
04163
04164
04165
04166
04167
04168 static int
04169 is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
04170 const char *mangled;
04171 enum gnu_v3_ctor_kinds *ctor_kind;
04172 enum gnu_v3_dtor_kinds *dtor_kind;
04173 {
04174 struct d_info di;
04175 struct demangle_component *dc;
04176 int ret;
04177
04178 *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
04179 *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
04180
04181 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
04182
04183 {
04184 #ifdef CP_DYNAMIC_ARRAYS
04185 __extension__ struct demangle_component comps[di.num_comps];
04186 __extension__ struct demangle_component *subs[di.num_subs];
04187
04188 di.comps = &comps[0];
04189 di.subs = &subs[0];
04190 #else
04191 di.comps = ((struct demangle_component *)
04192 malloc (di.num_comps * sizeof (struct demangle_component)));
04193 di.subs = ((struct demangle_component **)
04194 malloc (di.num_subs * sizeof (struct demangle_component *)));
04195 if (di.comps == NULL || di.subs == NULL)
04196 {
04197 if (di.comps != NULL)
04198 free (di.comps);
04199 if (di.subs != NULL)
04200 free (di.subs);
04201 return 0;
04202 }
04203 #endif
04204
04205 dc = cplus_demangle_mangled_name (&di, 1);
04206
04207
04208
04209
04210 ret = 0;
04211 while (dc != NULL)
04212 {
04213 switch (dc->type)
04214 {
04215 default:
04216 dc = NULL;
04217 break;
04218 case DEMANGLE_COMPONENT_TYPED_NAME:
04219 case DEMANGLE_COMPONENT_TEMPLATE:
04220 case DEMANGLE_COMPONENT_RESTRICT_THIS:
04221 case DEMANGLE_COMPONENT_VOLATILE_THIS:
04222 case DEMANGLE_COMPONENT_CONST_THIS:
04223 dc = d_left (dc);
04224 break;
04225 case DEMANGLE_COMPONENT_QUAL_NAME:
04226 case DEMANGLE_COMPONENT_LOCAL_NAME:
04227 dc = d_right (dc);
04228 break;
04229 case DEMANGLE_COMPONENT_CTOR:
04230 *ctor_kind = dc->u.s_ctor.kind;
04231 ret = 1;
04232 dc = NULL;
04233 break;
04234 case DEMANGLE_COMPONENT_DTOR:
04235 *dtor_kind = dc->u.s_dtor.kind;
04236 ret = 1;
04237 dc = NULL;
04238 break;
04239 }
04240 }
04241
04242 #ifndef CP_DYNAMIC_ARRAYS
04243 free (di.subs);
04244 free (di.comps);
04245 #endif
04246 }
04247
04248 return ret;
04249 }
04250
04251
04252
04253
04254 enum gnu_v3_ctor_kinds
04255 is_gnu_v3_mangled_ctor (name)
04256 const char *name;
04257 {
04258 enum gnu_v3_ctor_kinds ctor_kind;
04259 enum gnu_v3_dtor_kinds dtor_kind;
04260
04261 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
04262 return (enum gnu_v3_ctor_kinds) 0;
04263 return ctor_kind;
04264 }
04265
04266
04267
04268
04269
04270 enum gnu_v3_dtor_kinds
04271 is_gnu_v3_mangled_dtor (name)
04272 const char *name;
04273 {
04274 enum gnu_v3_ctor_kinds ctor_kind;
04275 enum gnu_v3_dtor_kinds dtor_kind;
04276
04277 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
04278 return (enum gnu_v3_dtor_kinds) 0;
04279 return dtor_kind;
04280 }
04281
04282 #endif
04283
04284 #ifdef STANDALONE_DEMANGLER
04285
04286 #include "getopt.h"
04287 #include "dyn-string.h"
04288
04289 static void print_usage PARAMS ((FILE* fp, int exit_value));
04290
04291 #define IS_ALPHA(CHAR) \
04292 (((CHAR) >= 'a' && (CHAR) <= 'z') \
04293 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
04294
04295
04296 #define is_mangled_char(CHAR) \
04297 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
04298 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
04299
04300
04301 const char* program_name;
04302
04303
04304
04305 static void
04306 print_usage (fp, exit_value)
04307 FILE* fp;
04308 int exit_value;
04309 {
04310 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
04311 fprintf (fp, "Options:\n");
04312 fprintf (fp, " -h,--help Display this message.\n");
04313 fprintf (fp, " -p,--no-params Don't display function parameters\n");
04314 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
04315 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
04316
04317 exit (exit_value);
04318 }
04319
04320
04321 static const struct option long_options[] =
04322 {
04323 { "help", no_argument, NULL, 'h' },
04324 { "no-params", no_argument, NULL, 'p' },
04325 { "verbose", no_argument, NULL, 'v' },
04326 { NULL, no_argument, NULL, 0 },
04327 };
04328
04329
04330
04331
04332
04333
04334 int
04335 main (argc, argv)
04336 int argc;
04337 char *argv[];
04338 {
04339 int i;
04340 int opt_char;
04341 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
04342
04343
04344 program_name = argv[0];
04345
04346
04347 do
04348 {
04349 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
04350 switch (opt_char)
04351 {
04352 case '?':
04353 print_usage (stderr, 1);
04354 break;
04355
04356 case 'h':
04357 print_usage (stdout, 0);
04358 break;
04359
04360 case 'p':
04361 options &= ~ DMGL_PARAMS;
04362 break;
04363
04364 case 'v':
04365 options |= DMGL_VERBOSE;
04366 break;
04367 }
04368 }
04369 while (opt_char != -1);
04370
04371 if (optind == argc)
04372
04373 {
04374 dyn_string_t mangled = dyn_string_new (3);
04375 char *s;
04376
04377
04378 while (!feof (stdin))
04379 {
04380 char c;
04381
04382
04383
04384 c = getchar ();
04385 while (!feof (stdin) && is_mangled_char (c))
04386 {
04387 dyn_string_append_char (mangled, c);
04388 if (feof (stdin))
04389 break;
04390 c = getchar ();
04391 }
04392
04393 if (dyn_string_length (mangled) > 0)
04394 {
04395 #ifdef IN_GLIBCPP_V3
04396 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
04397 #else
04398 s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
04399 #endif
04400
04401 if (s != NULL)
04402 {
04403 fputs (s, stdout);
04404 free (s);
04405 }
04406 else
04407 {
04408
04409
04410 fputs (dyn_string_buf (mangled), stdout);
04411 }
04412
04413 dyn_string_clear (mangled);
04414 }
04415
04416
04417
04418 if (!feof (stdin))
04419 putchar (c);
04420 }
04421
04422 dyn_string_delete (mangled);
04423 }
04424 else
04425
04426 {
04427
04428 for (i = optind; i < argc; ++i)
04429 {
04430 char *s;
04431 #ifdef IN_GLIBCPP_V3
04432 int status;
04433 #endif
04434
04435
04436 #ifdef IN_GLIBCPP_V3
04437 s = __cxa_demangle (argv[i], NULL, NULL, &status);
04438 #else
04439 s = cplus_demangle_v3 (argv[i], options);
04440 #endif
04441
04442
04443 if (s != NULL)
04444 {
04445 printf ("%s\n", s);
04446 free (s);
04447 }
04448 else
04449 {
04450 #ifdef IN_GLIBCPP_V3
04451 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
04452 #else
04453 fprintf (stderr, "Failed: %s\n", argv[i]);
04454 #endif
04455 }
04456 }
04457 }
04458
04459 return 0;
04460 }
04461
04462 #endif