开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
edg-decode.c
资源名称：vxWorks_src.rar　[点击查看]
上传用户：baixin
上传日期：2008-03-13
资源大小：4795k
文件大小：93k
源码类别：

嵌入式/单片机编程

开发平台：

MultiPlatform

edg-decode.c：源码内容
  1. /******************************************************************************
  2. *                                                               ___  /       *
  3. *                                                               /            *
  4. * Edison Design Group C++/C Front End                        - | ^/ | -      *
  5. *                                                                  /         *
  6. *                                                             /  | |         *
  7. * Copyright 1996-1999 Edison Design Group Inc.                   [_]          *
  8. *                                                                             *
  9. ******************************************************************************/
  10. /*
  11. Copyright (c) 1996-1999, Edison Design Group, Inc.
  13. Redistribution and use in source and binary forms are permitted
  14. provided that the above copyright notice and this paragraph are
  15. duplicated in all source code forms.  The name of Edison Design
  16. Group, Inc. may not be used to endorse or promote products derived
  17. from this software without specific prior written permission.
  18. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
  19. IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  20. WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21. Any use of this software is at the user's own risk.
  22. */
  23. /*
  25. edg-decode.c -- Name demangler for C++.
  27. The demangling is intended to work only on names of external entities.
  28. There is some name mangling done for internal entities, or by the
  29. C-generating back end, that this program does not try to decode.
  30. */
  32. #include <stdio.h>
  33. #include <stddef.h>
  34. #include <string.h>
  35. #include <ctype.h>
  36. typedef size_t sizeof_t;
  37. typedef int a_boolean;
  38. #define FALSE 0
  39. #define TRUE 1
  42. /*
  43. Block used to hold state variables.  A block is used so that these routines
  44. will be reentrant.
  45. */
  46. typedef struct a_decode_control_block *a_decode_control_block_ptr;
  47. typedef struct a_decode_control_block {
  48.   unsigned long
  49. input_id_len;
  50. /* Length of the input identifier, not counting the
  51.    final null. */
  52.   char *output_id;
  53. /* Pointer to buffer for demangled version of
  54.    the current identifier. */
  55.   sizeof_t output_id_len;
  56. /* Length of output_id, not counting the final
  57.    null. */
  58.   sizeof_t output_id_size;
  59. /* Allocated size of output_id. */
  60.   a_boolean err_in_id;
  61. /* TRUE if any error was encountered in the current
  62.    identifier. */
  63.   a_boolean output_overflow_err;
  64. /* TRUE if the demangled output overflowed the
  65.    output buffer. */
  66.   unsigned long suppress_id_output;
  67. /* If > 0, demangled id output is suppressed.  This
  68.    might be because of an error or just as a way
  69.    of avoiding output during some processing. */
  70.   char *end_of_constant;
  71. /* While scanning a constant, this can be set to the
  72.    character after the end of the constant as an
  73.    aid to disambiguation.  NULL otherwise. */
  74.   sizeof_t uncompressed_length;
  75. /* If non-zero, the original name was compressed,
  76.    and this indicates the length of the uncompressed
  77.    (but still mangled) name. */
  78. #ifndef WRS_ORIG /* WRS LOCAL */
  79.   a_boolean suppress_function_params;
  80. /* TRUE if we do not want to see function parameters;
  81.    used by GDB to compose a stack trace. */
  82.   a_boolean suppress_return_types;
  83. /* TRUE if we should avoid printing return types
  84.    (since they don't participate in overloading).  */
  85.   a_boolean sourcelike_template_params;
  86. /* TRUE if we should display template parameters so
  87.    they look like a usage in program source code.  */
  88. #endif
  89. } a_decode_control_block;
  92. /*
  93. Block that contains information used to control the output of template
  94. parameter lists.
  95. */
  96. typedef struct a_template_param_block *a_template_param_block_ptr;
  97. typedef struct a_template_param_block {
  98.   unsigned long nesting_level;
  99. /* Number of levels of template nesting at this
  100.    point (1 == top level). */
  101.   char *final_specialization;
  102. /* Set to point to the mangled encoding for the final
  103.    specialization encountered while working from
  104.    outermost template to innermost.  NULL if
  105.    no specialization has been found yet. */
  106.   a_boolean set_final_specialization;
  107. /* TRUE if final_specialization should be set while
  108.    scanning. */
  109.   a_boolean actual_template_args_until_final_specialization;
  110. /* TRUE if template parameter names should not be
  111.    put out.  Reset when the final_specialization
  112.    position is reached. */
  113.   a_boolean output_only_correspondences;
  114. /* TRUE if doing a post-pass to output only template
  115.    parameter/argument correspondences and not
  116.    anything else.  suppress_id_output will have been
  117.    incremented to suppress everything else, and
  118.    gets decremented temporarily when correspondences
  119.    are output. */
  120.   a_boolean first_correspondence;
  121. /* TRUE until the first template parameter/argument
  122.    correspondence is put out. */
  123.   a_boolean use_old_form_for_template_output;
  124. /* TRUE if templates should be output in the old
  125.    form that always puts actual argument values
  126.    in template argument lists. */
  127. #ifndef WRS_ORIG /* WRS LOCAL */
  128.   a_boolean base_name_only;
  129. /* TRUE if we are printing a bare basename, without
  130.    template parameters; this is used for printing the
  131.    implicit names of Constructors and Destructors. */
  132. #endif
  133. } a_template_param_block;
  136. /*
  137. Declarations needed because of forward references:
  138. */
  139. static char *demangle_name(char                       *ptr,
  140.                            unsigned long              nchars,
  141.                            a_boolean                  stop_on_underscores,
  142.                            char                       *mclass,
  143.                            a_template_param_block_ptr temp_par_info,
  144.                            a_decode_control_block_ptr dctl);
  145. static char *demangle_name_with_preceding_length(
  146.                                 char                       *ptr,
  147.                                 a_template_param_block_ptr temp_par_info,
  148.                                 a_decode_control_block_ptr dctl);
  149. static char *demangle_operation(char                       *ptr,
  150.                                 a_decode_control_block_ptr dctl);
  151. static char *demangle_operator(char      *ptr,
  152.                                int       *mangled_length,
  153.                                a_boolean *takes_type);
  154. static char *demangle_type(char                       *ptr,
  155.                            a_decode_control_block_ptr dctl);
  156. static char *full_demangle_type_name(char                       *ptr,
  157.                                      a_boolean                  base_name_only,
  158.                                      a_template_param_block_ptr temp_par_info,
  159.                                      a_decode_control_block_ptr dctl);
  160. static char *demangle_template_arguments(
  161.                                       char                       *ptr,
  162.                                       a_boolean                  partial_spec,
  163.                                       a_template_param_block_ptr temp_par_info,
  164.                                       a_decode_control_block_ptr dctl);
  165. /*
  166. Interface to full_demangle_type_name for the simple case.
  167. */
  168. #define demangle_type_name(ptr, dctl)                                 
  169.   full_demangle_type_name((ptr), /*base_name_only=*/FALSE,            
  170.                           /*temp_par_info=*/(a_template_param_block_ptr)NULL, 
  171.                           (dctl))
  172. static char *full_demangle_identifier(char                       *ptr,
  173.                                       unsigned long              nchars,
  174.                                       a_decode_control_block_ptr dctl);
  175. /* Interface to full_demangle_identifier for the simple case. */
  176. #define demangle_identifier(ptr, dctl)                                
  177.   full_demangle_identifier((ptr), (unsigned long)0, (dctl))
  180. static void write_id_ch(char                       ch,
  181.                         a_decode_control_block_ptr dctl)
  182. /*
  183. Add the indicated character to the demangled version of the current identifier.
  184. */
  185. {
  186.   if (!dctl->suppress_id_output) {
  187.     if (!dctl->output_overflow_err) {
  188.       /* Test for buffer overflow, leaving room for a terminating null. */
  189.       if (dctl->output_id_len >= dctl->output_id_size-1) {
  190.         /* There's no room for the character in the buffer. */
  191.         dctl->output_overflow_err = TRUE;
  192.         /* Make sure the (truncated) output is null-terminated. */
  193.         dctl->output_id[dctl->output_id_size-1] = '';
  194.       } else {
  195.         /* No overflow; put the character in the buffer. */
  196.         dctl->output_id[dctl->output_id_len] = ch;
  197.       }  /* if */
  198.     }  /* if */
  199.     /* Keep track of the number of characters (even if output has overflowed
  200.        the buffer). */
  201.     dctl->output_id_len++;
  202.   }  /* if */
  203. }  /* write_id_ch */
  206. static void write_id_str(char                      *str,
  207.                         a_decode_control_block_ptr dctl)
  208. /*
  209. Add the indicated string to the demangled version of the current identifier.
  210. */
  211. {
  212.   char *p = str;
  214.   if (!dctl->suppress_id_output) {
  215.     for (; *p != ''; p++) write_id_ch(*p, dctl);
  216.   }  /* if */
  217. }  /* write_id_str */
  220. static void bad_mangled_name(a_decode_control_block_ptr dctl)
  221. /*
  222. A bad name mangling has been encountered.  Record an error.
  223. */
  224. {
  225.   if (!dctl->err_in_id) {
  226.     dctl->err_in_id = TRUE;
  227.     dctl->suppress_id_output++;
  228.   }  /* if */
  229. }  /* bad_mangled_name */
  232. static a_boolean start_of_id_is(char *str, char *id)
  233. /*
  234. Return TRUE if the identifier (at id) begins with the string str.
  235. */
  236. {
  237.   a_boolean is_start = FALSE;
  239.   for (;;) {
  240.     char chs = *str++;
  241.     if (chs == '') {
  242.       is_start = TRUE;
  243.       break;
  244.     }  /* if */
  245.     if (chs != *id++) break;
  246.   }  /* for */
  247.   return is_start;
  248. }  /* start_of_id_is */
  251. static char *advance_past_underscore(char                       *p,
  252.                                      a_decode_control_block_ptr dctl)
  253. /*
  254. An underscore is expected at *p.  If it's there, advance past it.  If
  255. not, call bad_mangled_name.  In either case, return the updated value of p.
  256. */
  257. {
  258.   if (*p == '_') {
  259.     p++;
  260.   } else {
  261.     bad_mangled_name(dctl);
  262.   }  /* if */
  263.   return p;
  264. }  /* advance_past_underscore */
  267. static char *get_length(char                       *p,
  268.                         unsigned long              *num,
  269.                         a_decode_control_block_ptr dctl)
  270. /*
  271. Accumulate a number indicating a length, starting at position p, and
  272. return its value in *num.  Return a pointer to the character position
  273. following the number.
  274. */
  275. {
  276.   unsigned long n = 0;
  278.   if (!isdigit((unsigned char)*p)) {
  279.     bad_mangled_name(dctl);
  280.     goto end_of_routine;
  281.   }  /* if */
  282.   do {
  283.     n = n*10 + (*p - '0');
  284.     if (n > dctl->input_id_len) {
  285.       /* Bad number. */
  286.       bad_mangled_name(dctl);
  287.       n = dctl->input_id_len;
  288.       goto end_of_routine;
  289.     }  /* if */
  290.     p++;
  291.   } while (isdigit((unsigned char)*p));
  292. end_of_routine:
  293.   *num = n;
  294.   return p;
  295. }  /* get_length */
  298. static char *get_number(char                       *p,
  299.                         unsigned long              *num,
  300.                         a_decode_control_block_ptr dctl)
  301. /*
  302. Accumulate a number starting at position p and return its value in *num.
  303. Return a pointer to the character position following the number.
  304. */
  305. {
  306.   unsigned long n = 0;
  308.   if (!isdigit((unsigned char)*p)) {
  309.     bad_mangled_name(dctl);
  310.     goto end_of_routine;
  311.   }  /* if */
  312.   do {
  313.     n = n*10 + (*p - '0');
  314.     p++;
  315.   } while (isdigit((unsigned char)*p));
  316. end_of_routine:
  317.   *num = n;
  318.   return p;
  319. }  /* get_number */
  322. static char *get_single_digit_number(char                       *p,
  323.                                      unsigned long              *num,
  324.                                      a_decode_control_block_ptr dctl)
  325. /*
  326. Accumulate a number starting at position p and return its value in *num.
  327. The number is a single digit.  Return a pointer to the character position
  328. following the number.
  329. */
  330. {
  331.   *num = 0;
  332.   if (!isdigit((unsigned char)*p)) {
  333.     bad_mangled_name(dctl);
  334.     goto end_of_routine;
  335.   }  /* if */
  336.   *num = (*p - '0');
  337.   p++;
  338. end_of_routine:
  339.   return p;
  340. }  /* get_single_digit_number */
  343. static char *get_length_with_optional_underscore(
  344.                                                char                       *p,
  345.                                                unsigned long              *num,
  346.                                                a_decode_control_block_ptr dctl)
  347. /*
  348. Accumulate a number starting at position p and return its value in *num.
  349. If the number has more than one digit, it is followed by an underscore.
  350. (Or, in a newer representation, surrounded by underscores.)
  351. Return a pointer to the character position following the number.
  352. */
  353. {
  354.   if (*p == '_') {
  355.     /* New encoding (not from cfront) -- the length is surrounded by
  356.        underscores whether it's a single digit or several digits,
  357.        e.g., "L_10_1234567890". */
  358.     p++;
  359.     /* Multi-digit number followed by underscore. */
  360.     p = get_length(p, num, dctl);
  361.     p = advance_past_underscore(p, dctl);
  362.   } else if (isdigit((unsigned char)p[0]) && isdigit((unsigned char)p[1]) &&
  363.              (dctl->end_of_constant == NULL || p+2 < dctl->end_of_constant) &&
  364.              p[2] == '_') {
  365.     /* The cfront version -- a multi-digit length is followed by an
  366.        underscore, e.g., "L10_1234567890".  This doesn't work well because
  367.        something like "L11", intended to have a one-digit length, can
  368.        be made ambiguous by following it by a "_" for some other reason.
  369.        (That's resolved in most cases by the check against end_of_constant.)
  370.        So this form is not used in new cases where that can come up, e.g.,
  371.        nontype template arguments for functions.  In any case, interpret
  372.        "multi-digit" as "2-digit" and don't look further for the underscore. */
  373.     /* Multi-digit number followed by underscore. */
  374.     p = get_length(p, num, dctl);
  375.     p = advance_past_underscore(p, dctl);
  376.   } else {
  377.     /* Single-digit number not followed by underscore. */
  378.     p = get_single_digit_number(p, num, dctl);
  379.   }  /* if */
  380.   return p;
  381. }  /* get_length_with_optional_underscore */
  384. static a_boolean is_immediate_type_qualifier(char *p)
  385. /*
  386. Return TRUE if the encoding pointed to is one that indicates type
  387. qualification.
  388. */
  389. {
  390.   a_boolean is_type_qual = FALSE;
  392.   if (*p == 'C' || *p == 'V') {
  393.     /* This is a type qualifier. */
  394.     is_type_qual = TRUE;
  395.   }  /* if */
  396.   return is_type_qual;
  397. }  /* is_immediate_type_qualifier */
  400. static void write_template_parameter_name(unsigned long              depth,
  401.                                           unsigned long              position,
  402.                                           a_boolean                  nontype,
  403.                                           a_decode_control_block_ptr dctl)
  404. /*
  405. Output a representation of a template parameter with depth and position
  406. as indicated.  It's a nontype parameter if nontype is TRUE.
  407. */
  408. {
  409.   char buffer[100];
  410.   char letter = '';
  412.   if (nontype) {
  413.     /* Nontype parameter. */
  414.     /* Use a code letter for the first few levels, then the depth number. */
  415.     if (depth == 1) {
  416.       letter = 'N';
  417.     } else if (depth == 2) {
  418.       letter = 'O';
  419.     } else if (depth == 3) {
  420.       letter = 'P';
  421.     }  /* if */
  422.     if (letter != '') {
  423.       (void)sprintf(buffer, "%c%lu", letter, position);
  424.     } else {
  425.       (void)sprintf(buffer, "N_%lu_%lu", depth, position);
  426.     }  /* if */
  427.   } else {
  428.     /* Normal type parameter. */
  429.     /* Use a code letter for the first few levels, then the depth number. */
  430.     if (depth == 1) {
  431.       letter = 'T';
  432.     } else if (depth == 2) {
  433.       letter = 'U';
  434.     } else if (depth == 3) {
  435.       letter = 'V';
  436.     }  /* if */
  437.     if (letter != '') {
  438.       (void)sprintf(buffer, "%c%lu", letter, position);
  439.     } else {
  440.       (void)sprintf(buffer, "T_%lu_%lu", depth, position);
  441.     }  /* if */
  442.   }  /* if */
  443.   write_id_str(buffer, dctl);
  444. }  /* write_template_parameter_name */
  447. static char *demangle_template_parameter_name(
  448.                                             char                       *ptr,
  449.                                             a_boolean                  nontype,
  450.                                             a_decode_control_block_ptr dctl)
  451. /*
  452. Demangle a template parameter name at the indicated location.  The parameter
  453. is a nontype parameter if nontype is TRUE.  Return a pointer to the character
  454. position following what was demangled.
  455. */
  456. {
  457.   char          *p = ptr;
  458.   unsigned long position, depth = 1;
  460.   /* This comes up with the modern mangling for template functions.
  461.      Form is "ZnZ" or "Zn_mZ", where n is the parameter number and m
  462.      is the depth number (1 if not specified). */
  463.   p++;  /* Advance past the "Z". */
  464.   /* Get the position number. */
  465.   p = get_number(p, &position, dctl);
  466.   if (*p == '_' && p[1] != '_') {
  467.     /* Form including depth ("Zn_mZ"). */
  468.     p++;
  469.     p = get_number(p, &depth, dctl);
  470.   }  /* if */
  471.   /* Output the template parameter name. */
  472.   write_template_parameter_name(depth, position, nontype, dctl);
  473.   if (p[0] == '_' && p[1] == '_' && p[2] == 't' && p[3] == 'm' &&
  474.       p[4] == '_' && p[5] == '_') {
  475.     /* A template template parameter followed by a template
  476.        argument list. */
  477.     p = demangle_template_arguments(p+6, /*partial_spec=*/FALSE,
  478.                                     (a_template_param_block_ptr)NULL, dctl);
  479.   }  /* if */
  480.   /* Check for the final "Z".  This appears in the mangling to avoid
  481.      ambiguities when the template parameter is followed by something whose
  482.      encoding begins with a digit, e.g., a class name. */
  483.   if (*p != 'Z') {
  484.     bad_mangled_name(dctl);
  485.   } else {
  486.     p++;
  487.   }  /* if */
  488.   return p;
  489. }  /* demangle_template_parameter_name */
  492. static char *demangle_constant(char                       *ptr,
  493.                                a_decode_control_block_ptr dctl)
  494. /*
  495. Demangle a constant (e.g., a nontype template class argument) beginning at
  496. ptr, and output the demangled form.  Return a pointer to the character
  497. position following what was demangled.
  498. */
  499. {
  500.   char          *p = ptr, *type = NULL, *index;
  501.   unsigned long nchars;
  503.   /* A constant has a form like
  504.        CiL15   <-- integer constant 5
  505.            ^-- Literal constant representation.
  506.           ^--- Length of literal constant.
  507.          ^---- L indicates literal constant; c indicates address
  508.                of variable, etc.
  509.        ^^----- Type of template argument, with "const" added.
  510.      A template parameter constant or a constant expression does not have
  511.      the initial "C" and type.
  512.   */
  513.   if (*p == 'C') {
  514.     /* Advance past the type. */
  515.     type = p;
  516.     dctl->suppress_id_output++;
  517.     p = demangle_type(p, dctl);
  518.     dctl->suppress_id_output--;
  519.   }  /* if */
  520.   /* The next thing has one of the following forms:
  521.        3abc        Address of "abc".
  522.        L211        Literal constant; length ("2") followed by the characters of
  523.                    the constant ("11").
  524.        LM0_L2n1_1j Pointer-to-member-function constant; the three parts
  525.                    correspond to the triplet of values in the __mptr
  526.                    data structure.
  527.        Z1Z         Template parameter.
  528.        Opl2Z1ZZ2ZO Expression.
  529.   */
  530.   if (isdigit((unsigned char)*p)) {
  531.     /* A name preceded by its length, e.g., "3abc".  Put out "&name". */
  532.     write_id_ch('&', dctl);
  533.     /* Process the length and name. */
  534.     p = demangle_name_with_preceding_length(p,
  535.                                             (a_template_param_block_ptr)NULL,
  536.                                             dctl);
  537.   } else if (*p == 'L') {
  538.     if (p[1] != 'M') {
  539.       /* Normal literal constant.  Form is something like
  540.            L3n12     encoding for -12
  541.              ^^^---- Characters of constant.  Some characters get remapped:
  542.                        n --> -
  543.                        p --> +
  544.                        d --> .
  545.             ^------- Length of constant.
  546.          Output is
  547.            (type)constant
  548.          That is, the literal constant preceded by a cast to the right type.
  549.       */
  550.       /* See if the type is bool. */
  551.       a_boolean is_bool = (type+2 == p && *(type+1) == 'b'), is_nonzero;
  552.       /* If the type is bool, don't put out the cast. */
  553.       if (!is_bool) {
  554.         write_id_ch('(', dctl);
  555.         /* Start at type+1 to avoid the "C" for const. */
  556.         (void)demangle_type(type+1, dctl);
  557.         write_id_ch(')', dctl);
  558.       }  /* if */
  559.       p++;  /* Advance past the "L". */
  560.       /* Get the length of the constant. */
  561.       p = get_length_with_optional_underscore(p, &nchars, dctl);
  562.       /* Process the characters of the literal constant. */
  563.       is_nonzero = FALSE;
  564.       for (; nchars > 0; nchars--, p++) {
  565.         /* Remap characters where necessary. */
  566.         char ch = *p;
  567.         switch (ch) {
  568.           case '':
  569.           case '_':
  570.             /* Ran off end of string. */
  571.             bad_mangled_name(dctl);
  572.             goto end_of_routine;
  573.           case 'p':
  574.             ch = '+';
  575.             break;
  576.           case 'n':
  577.             ch = '-';
  578.             break;
  579.           case 'd':
  580.             ch = '.';
  581.             break;
  582.         }  /* switch */
  583.         if (is_bool) {
  584.           /* For the bool case, just keep track of whether the constant is
  585.              non-zero; true or false will be output later. */
  586.           if (ch != '0') is_nonzero = TRUE;
  587.         } else {
  588.           /* Normal (non-bool) case.  Output the character of the constant. */
  589.           write_id_ch(ch, dctl);
  590.         }  /* if */
  591.       }  /* for */
  592.       if (is_bool) {
  593.         /* For bool, output true or false. */
  594.         write_id_str((char *)(is_nonzero ? "true" : "false"), dctl);
  595.       }  /* if */
  596.     } else {
  597.       /* Pointer-to-member-function.  The form of the constant is
  598.            LM0_L2n1_1j  Non-virtual function
  599.            LM0_L11_0    Virtual function
  600.            LM0_L10_0    Null pointer
  601.          The three parts match the three components of the __mptr structure:
  602.          (delta, index, function or offset).  The index is -1 for a non-virtual
  603.          function, 0 for a null pointer, and greater than 0 for a virtual
  604.          function.  The index is represented like an integer constant (see
  605.          above).  For virtual functions, the last component is always "0"
  606.          even if the offset is not zero. */
  607.       /* Advance past the "LM". */
  608.       p += 2;
  609.       /* Advance over the first component, ignoring it. */
  610.       while (isdigit((unsigned char)*p)) p++;
  611.       p = advance_past_underscore(p, dctl);
  612.       /* The index component should be next. */
  613.       if (*p != 'L') {
  614.         bad_mangled_name(dctl);
  615.         goto end_of_routine;
  616.       }  /* if */
  617.       p++;
  618.       /* Get the index length. */
  619.       /* Note that get_length_with_optional_underscore is not used because
  620.          this is an ambiguous situation: an underscore follows the index
  621.          value, and there's no way to tell if it's the multi-digit
  622.          indicator for the length or the separator between fields. */
  623.       if (*p == '_') {
  624.         /* New-form encoding, no ambiguity. */
  625.         p = get_length_with_optional_underscore(p, &nchars, dctl);
  626.       } else {
  627.         p = get_single_digit_number(p, &nchars, dctl);
  628.       }  /* if */
  629.       /* Remember the start of the index. */
  630.       index = p;
  631.       /* Skip the rest of the index. */
  632.       while (isdigit((unsigned char)*p) || (*p == 'n')) p++;
  633.       p = advance_past_underscore(p, dctl);
  634.       /* If the index number starts with 'n', this is a non-virtual
  635.          function. */
  636.       if (*index == 'n') {
  637.         /* Non-virtual function. */
  638.         /* The third component is a name preceded by its length, e.g.,
  639.            "1f".  Put out "&A::f", where "A" is the class type retrieved
  640.            from the type. */
  641.         write_id_ch('&', dctl);
  642.         /* Start at type+2 to skip the "C" for const and the "M" for
  643.            pointer-to-member. */
  644.         (void)demangle_type_name(type+2, dctl);
  645.         write_id_str("::", dctl);
  646.         /* Demangle the length and name. */
  647.         p = demangle_name_with_preceding_length(p,
  648.                                               (a_template_param_block_ptr)NULL,
  649.                                                 dctl);
  650.       } else {
  651.         /* Not a non-virtual function.  The encoding for the third component
  652.            should be simply "0". */
  653.         if (*p != '0') {
  654.           bad_mangled_name(dctl);
  655.           goto end_of_routine;
  656.         }  /* if */
  657.         p++;
  658.         if (nchars == 1 && *index == '0') {
  659.           /* Null pointer constant.  Output "(type)0", that is, a zero cast
  660.              to the pointer-to-member type. */
  661.           write_id_ch('(', dctl);
  662.           (void)demangle_type(type, dctl);
  663.           write_id_str(")0", dctl);
  664.         } else {
  665.           /* Virtual function.  This case can't really be demangled properly,
  666.              because the mangled name doesn't have enough information.
  667.              Output "&A::virtual-function-n". */
  668.           write_id_ch('&', dctl);
  669.           /* Start at type+2 to skip the "C" for const and the "M" for
  670.              pointer-to-member. */
  671.           (void)demangle_type_name(type+2, dctl);
  672.           write_id_str("::", dctl);
  673.           write_id_str("virtual-function-", dctl);
  674.           /* Write the index number. */
  675.           for (; nchars > 0; nchars--, index++) write_id_ch(*index, dctl);
  676.         }  /* if */
  677.       }  /* if */
  678.     }  /* if */
  679.   } else if (*p == 'Z') {
  680.     /* A template parameter. */
  681.     p = demangle_template_parameter_name(p, /*nontype=*/TRUE, dctl);
  682.   } else if (*p == 'O') {
  683.     /* An operation. */
  684.     p = demangle_operation(p, dctl);
  685.   } else {
  686.     /* The constant starts with something unexpected. */
  687.     bad_mangled_name(dctl);
  688.   }  /* if */
  689. end_of_routine:
  690.   return p;
  691. }  /* demangle_constant */
  694. static char *demangle_operation(char                       *ptr,
  695.                                 a_decode_control_block_ptr dctl)
  696. /*
  697. Demangle an operation in a constant expression (these come up in template
  698. arguments and array sizes, in template function parameter lists) beginning
  699. at ptr, and output the demangled form.  Return a pointer to the character
  700. position following what was demangled.
  701. */
  702. {
  703.   char          *p = ptr, *operator_str;
  704.   int           op_length;
  705.   unsigned long num_operands;
  706.   a_boolean     takes_type;
  708.   /* An operation has the form
  709.        Opl2Z1ZZ2ZO <-- "Z1 + Z2", Z1/Z2 indicating nontype template parameters.
  710.                  ^---- "O" to end the operation encoding.
  711.               ^^^----- Second operand.
  712.            ^^^-------- First operand.
  713.           ^----------- Count of operands.
  714.         ^^------------ Operation, using same encoding as for operator
  715.                        function names.
  716.        ^-------------- "O" for operation.
  717.   */
  718.   p++;  /* Advance past the "O". */
  719.   /* Decode the operator name, e.g., "pl" is "+". */
  720.   operator_str = demangle_operator(p, &op_length, &takes_type);
  721.   if (operator_str == NULL) {
  722.     bad_mangled_name(dctl);
  723.   } else {
  724.     p += op_length;
  725.     /* Put parentheses around the operation. */
  726.     write_id_ch('(', dctl);
  727.     /* For a cast, sizeof, or __ALIGNOF__, get the type. */
  728.     if (takes_type) {
  729.       if (strcmp(operator_str, "cast") == 0) {
  730.         write_id_ch('(', dctl);
  731.         operator_str = "";
  732.       } else {
  733.         write_id_str(operator_str, dctl);
  734.       }  /* if */
  735.       p = demangle_type(p, dctl);
  736.       write_id_ch(')', dctl);
  737.     }  /* if */
  738.     /* Get the count of operands. */
  739.     p = get_single_digit_number(p, &num_operands, dctl);
  740.     /* sizeof and __ALIGNOF__ take zero operands. */
  741.     if (num_operands != 0) {
  742.       if (num_operands == 1) {
  743.         /* Unary operator -- operator comes first. */
  744.         write_id_str(operator_str, dctl);
  745.       }  /* if */
  746.       /* Process the first operand. */
  747.       p = demangle_constant(p, dctl);
  748.       if (num_operands > 1) {
  749.         /* Binary and ternary operators -- operator comes after first
  750.            operand. */
  751.         write_id_str(operator_str, dctl);
  752.         /* Process the second operand. */
  753.         p = demangle_constant(p, dctl);
  754.         if (num_operands > 2) {
  755.           /* Ternary operand -- "?". */
  756.           write_id_ch(':', dctl);
  757.           /* Process the third operand. */
  758.           p = demangle_constant(p, dctl);
  759.         }  /* if */
  760.       }  /* if */
  761.     }  /* if */
  762.     write_id_ch(')', dctl);
  763.     /* Check for the final "O". */
  764.     if (*p != 'O') {
  765.       bad_mangled_name(dctl);
  766.     } else {
  767.       p++;
  768.     }  /* if */
  769.   }  /* if */
  770.   return p;
  771. }  /* demangle_operation */
  774. static void clear_template_param_block(a_template_param_block_ptr tpbp)
  775. /*
  776. Clear the fields of the indicated template parameter block.
  777. */
  778. {
  779.   tpbp->nesting_level = 0;
  780.   tpbp->final_specialization = NULL;
  781.   tpbp->set_final_specialization = FALSE;
  782.   tpbp->actual_template_args_until_final_specialization = FALSE;
  783.   tpbp->output_only_correspondences = FALSE;
  784.   tpbp->first_correspondence = FALSE;
  785.   tpbp->use_old_form_for_template_output = FALSE;
  786.   tpbp->base_name_only = FALSE;
  787. }  /* clear_template_param_block */
  790. static char *demangle_template_arguments(
  791.                                       char                       *ptr,
  792.                                       a_boolean                  partial_spec,
  793.                                       a_template_param_block_ptr temp_par_info,
  794.                                       a_decode_control_block_ptr dctl)
  795. /*
  796. Demangle the template class arguments beginning at ptr and output the
  797. demangled form.  Return a pointer to the character position following what was
  798. demangled.  ptr points to just past the "__tm__", "__ps__", or "__pt__"
  799. string.  partial_spec is TRUE if this is a partial-specialization
  800. parameter list ("__ps__").  When temp_par_info != NULL, it points to a
  801. block that controls output of extra information on template parameters.
  802. */
  803. {
  804.   char          *p = ptr, *arg_base;
  805.   unsigned long nchars, position;
  806.   a_boolean     nontype, skipped, unskipped;
  808.   if (temp_par_info != NULL && !partial_spec) temp_par_info->nesting_level++;
  809.   /* A template argument list looks like
  810.        __tm__3_ii
  811.                ^^---- Argument types.
  812.              ^------- Size of argument types, including the underscore.
  813.              ^------- ptr points here.
  814.      For the first argument list of a partial specialization, "__tm__" is
  815.      replaced by "__ps__".  For old-form mangling of templates, "__tm__"
  816.      is replaced by "__pt__".
  817.   */
  818.   write_id_ch('<', dctl);
  819.   /* Scan the size. */
  820.   p = get_length(p, &nchars, dctl);
  821.   arg_base = p;
  822.   p = advance_past_underscore(p, dctl);
  823.   /* Loop to process the arguments. */
  824.   for (position = 1;; position++) {
  825.     if (dctl->err_in_id) break;  /* Avoid infinite loops on errors. */
  826.     if (*p == '' || *p == '_') {
  827.       /* We ran off the end of the string. */
  828.       bad_mangled_name(dctl);
  829.       break;
  830.     }  /* if */
  831.     /* "X" identifies the beginning of a nontype argument. */
  832.     nontype = (*p == 'X');
  833.     skipped = unskipped = FALSE;
  834.     if (!partial_spec && temp_par_info != NULL &&
  835.         !temp_par_info->use_old_form_for_template_output &&
  836.         !temp_par_info->actual_template_args_until_final_specialization) {
  837.       /* Doing something special: writing out the template parameter name. */
  838.       if (temp_par_info->output_only_correspondences) {
  839.         /* This is the second pass, which writes out parameter/argument
  840.            correspondences, e.g., "T1=int".  Output has been suppressed
  841.            in general, and is turned on briefly here. */
  842.         dctl->suppress_id_output--;
  843.         unskipped = TRUE;
  844.         /* Put out a comma between entries and a left bracket preceding the
  845.            first entry. */
  846.         if (temp_par_info->first_correspondence) {
  847.           write_id_str(" [with ", dctl);
  848.           temp_par_info->first_correspondence = FALSE;
  849.         } else {
  850.           write_id_str(", ", dctl);
  851.         }  /* if */
  852.       }  /* if */
  853.       /* Write the template parameter name. */
  854.       write_template_parameter_name(temp_par_info->nesting_level, position,
  855.                                     nontype, dctl);
  856.       if (temp_par_info->output_only_correspondences) {
  857.         /* This is the second pass, to write out correspondences, so put the
  858.            argument value out after the parameter name. */
  859.         write_id_ch('=', dctl);
  860.       } else {
  861.         /* This is the first pass.  The argument value is skipped.  In
  862.            the second pass, its value will be written out. */
  863.         /* We still have to scan over the argument value, but suppress
  864.            output. */
  865.         dctl->suppress_id_output++;
  866.         skipped = TRUE;
  867.       }  /* if */
  868.     }  /* if */
  869.     /* Write the argument value. */
  870.     if (nontype) {
  871.       /* Nontype argument. */
  872.       char *saved_end_of_constant = dctl->end_of_constant;
  873.       p++;  /* Advance past the "X". */
  874.       /* Note the end position of the constant.  This is used to decide
  875.          that certain lengths are implausible as a way to resolve
  876.          ambiguities. */
  877.       dctl->end_of_constant = arg_base + nchars;
  878.       p = demangle_constant(p, dctl);
  879.       dctl->end_of_constant = saved_end_of_constant;
  880.     } else {
  881.       /* Type argument. */
  882.       p = demangle_type(p, dctl);
  883.     }  /* if */
  884.     if (skipped) dctl->suppress_id_output--;
  885.     if (unskipped) dctl->suppress_id_output++;
  886.     /* Stop after the last argument. */
  887.     if ((p - arg_base) >= nchars) break;
  888.     write_id_str(", ", dctl);
  889.   }  /* for */
  890.   write_id_ch('>', dctl);
  891.   return p;
  892. }  /* demangle_template_arguments */
  895. static char *demangle_operator(char      *ptr,
  896.                                int       *mangled_length,
  897.                                a_boolean *takes_type)
  898. /*
  899. Examine the first few characters at ptr to see if they are an encoding for
  900. an operator (e.g., "pl" for plus).  If so, return a pointer to a string for
  901. the operator (e.g., "+"), set *mangled_length to the number of characters
  902. in the encoding, and *takes_type to TRUE if the operator takes a type
  903. modifier (e.g., cast).  If the first few characters are not an operator
  904. encoding, return NULL.
  905. */
  906. {
  907.   char *s;
  908.   int  len = 2;
  910.   *takes_type = FALSE;
  911.   /* The length-3 codes are tested first to avoid taking their first two
  912.      letters as one of the length-2 codes. */
  913.   if (start_of_id_is("apl", ptr)) {
  914.     s = "+=";
  915.     len = 3;
  916.   } else if (start_of_id_is("ami", ptr)) {
  917.     s = "-=";
  918.     len = 3;
  919.   } else if (start_of_id_is("amu", ptr)) {
  920.     s = "*=";
  921.     len = 3;
  922.   } else if (start_of_id_is("adv", ptr)) {
  923.     s = "/=";
  924.     len = 3;
  925.   } else if (start_of_id_is("amd", ptr)) {
  926.     s = "%=";
  927.     len = 3;
  928.   } else if (start_of_id_is("aer", ptr)) {
  929.     s = "^=";
  930.     len = 3;
  931.   } else if (start_of_id_is("aad", ptr)) {
  932.     s = "&=";
  933.     len = 3;
  934.   } else if (start_of_id_is("aor", ptr)) {
  935.     s = "|=";
  936.     len = 3;
  937.   } else if (start_of_id_is("ars", ptr)) {
  938.     s = ">>=";
  939.     len = 3;
  940.   } else if (start_of_id_is("als", ptr)) {
  941.     s = "<<=";
  942.     len = 3;
  943.   } else if (start_of_id_is("nwa", ptr)) {
  944.     s = "new[]";
  945.     len = 3;
  946.   } else if (start_of_id_is("dla", ptr)) {
  947.     s = "delete[]";
  948.     len = 3;
  949.   } else if (start_of_id_is("nw", ptr)) {
  950.     s = "new";
  951.   } else if (start_of_id_is("dl", ptr)) {
  952.     s = "delete";
  953.   } else if (start_of_id_is("pl", ptr)) {
  954.     s = "+";
  955.   } else if (start_of_id_is("mi", ptr)) {
  956.     s = "-";
  957.   } else if (start_of_id_is("ml", ptr)) {
  958.     s = "*";
  959.   } else if (start_of_id_is("dv", ptr)) {
  960.     s = "/";
  961.   } else if (start_of_id_is("md", ptr)) {
  962.     s = "%";
  963.   } else if (start_of_id_is("er", ptr)) {
  964.     s = "^";
  965.   } else if (start_of_id_is("ad", ptr)) {
  966.     s = "&";
  967.   } else if (start_of_id_is("or", ptr)) {
  968.     s = "|";
  969.   } else if (start_of_id_is("co", ptr)) {
  970.     s = "~";
  971.   } else if (start_of_id_is("nt", ptr)) {
  972.     s = "!";
  973.   } else if (start_of_id_is("as", ptr)) {
  974.     s = "=";
  975.   } else if (start_of_id_is("lt", ptr)) {
  976.     s = "<";
  977.   } else if (start_of_id_is("gt", ptr)) {
  978.     s = ">";
  979.   } else if (start_of_id_is("ls", ptr)) {
  980.     s = "<<";
  981.   } else if (start_of_id_is("rs", ptr)) {
  982.     s = ">>";
  983.   } else if (start_of_id_is("eq", ptr)) {
  984.     s = "==";
  985.   } else if (start_of_id_is("ne", ptr)) {
  986.     s = "!=";
  987.   } else if (start_of_id_is("le", ptr)) {
  988.     s = "<=";
  989.   } else if (start_of_id_is("ge", ptr)) {
  990.     s = ">=";
  991.   } else if (start_of_id_is("aa", ptr)) {
  992.     s = "&&";
  993.   } else if (start_of_id_is("oo", ptr)) {
  994.     s = "||";
  995.   } else if (start_of_id_is("pp", ptr)) {
  996.     s = "++";
  997.   } else if (start_of_id_is("mm", ptr)) {
  998.     s = "--";
  999.   } else if (start_of_id_is("cm", ptr)) {
  1000.     s = ",";
  1001.   } else if (start_of_id_is("rm", ptr)) {
  1002.     s = "->*";
  1003.   } else if (start_of_id_is("rf", ptr)) {
  1004.     s = "->";
  1005.   } else if (start_of_id_is("cl", ptr)) {
  1006.     s = "()";
  1007.   } else if (start_of_id_is("vc", ptr)) {
  1008.     s = "[]";
  1009.   } else if (start_of_id_is("qs", ptr)) {
  1010.     s = "?";
  1011.   } else if (start_of_id_is("cs", ptr)) {
  1012.     s = "cast";
  1013.     *takes_type = TRUE;
  1014.   } else if (start_of_id_is("sz", ptr)) {
  1015.     s = "sizeof(";
  1016.     *takes_type = TRUE;
  1017.   } else if (start_of_id_is("af", ptr)) {
  1018.     s = "__ALIGNOF__(";
  1019.     *takes_type = TRUE;
  1020.   } else if (start_of_id_is("uu", ptr)) {
  1021.     s = "__uuidof(";
  1022.     *takes_type = TRUE;
  1023.   } else {
  1024.     s = NULL;
  1025.   }  /* if */
  1026.   *mangled_length = len;
  1027.   return s;
  1028. }  /* demangle_operator */
  1031. static a_boolean is_operator_function_name(char *ptr,
  1032.                                            char **demangled_name,
  1033.                                            int  *mangled_length)
  1034. /*
  1035. Examine the string beginning at ptr to see if it is the mangled name for
  1036. an operator function.  If so, return TRUE and set *demangled_name to
  1037. the demangled form, and *mangled_length to the length of the mangled form.
  1038. */
  1039. {
  1040.   char      *s, *end_ptr;
  1041.   int       len;
  1042.   a_boolean takes_type;
  1044.   /* Get the operator name.*/
  1045.   s = demangle_operator(ptr, &len, &takes_type);
  1046.   if (s != NULL) {
  1047.     /* Make sure we took the whole name and nothing more. */
  1048.     end_ptr = ptr + len;
  1049.     if (*end_ptr == '' || (end_ptr[0] == '_' && end_ptr[1] == '_')) {
  1050.       /* Okay. */
  1051.     } else {
  1052.       s = NULL;
  1053.     }  /* if */
  1054.   }  /* if */
  1055.   *demangled_name = s;
  1056.   *mangled_length = len;
  1057.   return (s != NULL);
  1058. }  /* demangle_operator_function_name */
  1061. static void note_specialization(char                       *ptr,
  1062.                                 a_template_param_block_ptr temp_par_info)
  1063. /*
  1064. Note the fact that a specialization indication has been encountered at ptr
  1065. while scanning a mangled name.  temp_par_info, if non-NULL, points to
  1066. a block of information related to template parameter processing.
  1067. */
  1068. {
  1069.   if (temp_par_info != NULL) {
  1070.     if (temp_par_info->set_final_specialization) {
  1071.       /* Remember the location of the last specialization seen. */
  1072.       temp_par_info->final_specialization = ptr;
  1073.     } else if (temp_par_info->actual_template_args_until_final_specialization&&
  1074.                ptr == temp_par_info->final_specialization) {
  1075.       /* Stop doing the special processing for specializations when the
  1076.          final specialization is reached. */
  1077.       temp_par_info->actual_template_args_until_final_specialization = FALSE;
  1078.     }  /* if */
  1079.   }  /* if */
  1080. }  /* note_specialization */
  1083. static char get_char(char          *ptr,
  1084.                      char          *base_ptr,
  1085.                      unsigned long nchars)
  1086. /*
  1087. Get and return the character pointed to by ptr.  However, if nchars is
  1088. non-zero, the string from which the character is to be extracted starts
  1089. at base_ptr and has length nchars.  An attempt to get a character past
  1090. the end of the string returns a null character.
  1091. */
  1092. {
  1093.   char ch;
  1095.   if (nchars > 0 && ptr >= base_ptr+nchars) {
  1096.     ch = '';
  1097.   } else {
  1098.     ch = *ptr;
  1099.   }  /* if */
  1100.   return ch;
  1101. }  /* get_char */
  1104. static char *demangle_name(char                       *ptr,
  1105.                            unsigned long              nchars,
  1106.                            a_boolean                  stop_on_underscores,
  1107.                            char                       *mclass,
  1108.                            a_template_param_block_ptr temp_par_info,
  1109.                            a_decode_control_block_ptr dctl)
  1110. /*
  1111. Demangle the name at ptr and output the demangled form.  Return a pointer
  1112. to the character position following what was demangled.  A "name" is
  1113. usually just a string of alphanumeric characters.  However, names of
  1114. constructors, destructors, and operator functions require special
  1115. handling, as do template entity names.  nchars indicates the number
  1116. of characters in the name, or is zero if the name is open-ended
  1117. (it's ended by a null or double underscore).  A double underscore
  1118. ends the name if stop_on_underscores is TRUE (though some sequences
  1119. beginning with two underscores, e.g., "__pt", end the name even if
  1120. stop_on_underscores is FALSE).  mclass, when non-NULL, points to
  1121. the mangled form of the class of which this name is a member.
  1122. When it's non-NULL, constructor and destructor names will be put
  1123. out in the proper form (otherwise, they are left in their original
  1124. forms).  When temp_par_info != NULL, it points to a block that
  1125. controls output of extra information on template parameters.
  1126. */
  1127. {
  1128.   char      *p, *end_ptr = NULL;
  1129.   a_boolean is_special_name = FALSE, is_pt, is_partial_spec = FALSE;
  1130.   a_boolean partial_spec_output_suppressed = FALSE;
  1131.   char      *demangled_name;
  1132.   int       mangled_length;
  1134.   /* See if the name is special in some way. */
  1135.   if ((nchars == 0 || nchars >= 4) && ptr[0] == '_' && ptr[1] == '_') {
  1136.     /* Name beginning with two underscores. */
  1137.     p = ptr + 2;
  1138.     if (start_of_id_is("ct", p)) {
  1139.       /* Constructor. */
  1140.       end_ptr = p + 2;
  1141.       if (mclass == NULL) {
  1142.         /* The mangled name for the class is not provided, so handle this as
  1143.            a normal name. */
  1144.       } else {
  1145.         /* Output the class name for the constructor name. */
  1146.         is_special_name = TRUE;
  1147.         (void)full_demangle_type_name(mclass, /*base_name_only=*/TRUE,
  1148.                                       /*temp_par_info=*/
  1149.                                               (a_template_param_block_ptr)NULL,
  1150.                                       dctl);
  1151.       }  /* if */
  1152.     } else if (start_of_id_is("dt", p)) {
  1153.       /* Destructor. */
  1154.       end_ptr = p + 2;
  1155.       if (mclass == NULL) {
  1156.         /* The mangled name for the class is not provided, so handle this as
  1157.            a normal name. */
  1158.       } else {
  1159.         /* Output ~class-name for the destructor name. */
  1160.         is_special_name = TRUE;
  1161.         write_id_ch('~', dctl);
  1162.         (void)full_demangle_type_name(mclass, /*base_name_only=*/TRUE,
  1163.                                       /*temp_par_info=*/
  1164.                                               (a_template_param_block_ptr)NULL,
  1165.                                       dctl);
  1166.       }  /* if */
  1167.     } else if (start_of_id_is("op", p)) {
  1168.       /* Conversion function.  Name looks like __opi__... where the part
  1169.          after "op" encodes the type (e.g., "opi" is "operator int"). */
  1170.       is_special_name = TRUE;
  1171.       write_id_str("operator ", dctl);
  1172.       end_ptr = demangle_type(p+2, dctl);
  1173.     } else if (is_operator_function_name(p, &demangled_name,
  1174.                                          &mangled_length)) {
  1175.       /* Operator function. */
  1176.       is_special_name = TRUE;
  1177.       write_id_str("operator ", dctl);
  1178.       write_id_str(demangled_name, dctl);
  1179.       end_ptr = p + mangled_length;
  1180.     } else if (nchars != 0 && start_of_id_is("N", p)) {
  1181.       /* __Nxxxx: unnamed namespace name.  Put out "<unnamed>" and ignore
  1182.          the characters after "__N". */
  1183.       is_special_name = TRUE;
  1184.       write_id_str("<unnamed>", dctl);
  1185.       end_ptr = p + nchars - 2;
  1186.     } else {
  1187.       /* Something unrecognized. */
  1188.     }  /* if */
  1189.   }  /* if */
  1190.   /* Here, end_ptr non-null means the end of the string has been found
  1191.      already (because the name is special in some way). */
  1192.   if (end_ptr == NULL) {
  1193.     /* Not a special name. Find the end of the string and set end_ptr.
  1194.        Also look for template-related things that terminate the name
  1195.        earlier. */
  1196.     for (p = ptr; ; p++) {
  1197.       char ch = get_char(p, ptr, nchars);
  1198.       /* Stop at the end of the string (real, or as indicated by nchars). */
  1199.       if (ch == '') break;
  1200.       /* Stop on a double underscore, but not one at the start of the string.
  1201.          More than 2 underscores in a row does not terminate the string,
  1202.          so that something like the name for "void f_()" (i.e., "f___Fv")
  1203.          can be demangled successfully. */
  1204.       if (ch == '_' && p != ptr &&
  1205.           get_char(p+1, ptr, nchars) == '_' &&
  1206.           get_char(p+2, ptr, nchars) != '_' &&
  1207.           /* When stop_on_underscores is FALSE, stop only on "__tm", "__ps",
  1208.              "__pt", or "__S".  Double underscores can appear in the middle
  1209.              of some names, e.g., member names used as template arguments. */
  1210.           (stop_on_underscores ||
  1211.            (get_char(p+2, ptr, nchars) == 't' &&
  1212.             get_char(p+3, ptr, nchars) == 'm') ||
  1213.            (get_char(p+2, ptr, nchars) == 'p' &&
  1214.             get_char(p+3, ptr, nchars) == 's') ||
  1215.            (get_char(p+2, ptr, nchars) == 'p' &&
  1216.             get_char(p+3, ptr, nchars) == 't') ||
  1217.            get_char(p+2, ptr, nchars) == 'S')) {
  1218.         break;
  1219.       }  /* if */
  1220.     }  /* for */
  1221.     end_ptr = p;
  1222.   }  /* if */
  1223.   /* Here, end_ptr indicates the character after the end of the initial
  1224.      part of the name. */
  1225.   if (!is_special_name) {
  1226.     /* Output the characters of the base name. */
  1227.     for (p = ptr; p < end_ptr; p++) write_id_ch(*p, dctl);
  1228.   }  /* if */
  1229.   /* If there's a template argument list for a partial specialization
  1230.      (beginning with "__ps__"), process it. */
  1231.   if ((nchars == 0 || (end_ptr-ptr+6) < nchars) &&
  1232.       start_of_id_is("__ps__", end_ptr)) {
  1233.     /* Write the arguments.  This first argument list gives the arguments
  1234.        that appear in the partial specialization declaration:
  1235.          template <class T, class U> struct A { ... };
  1236.          template <class T> struct A<T *, int> { ... };
  1237.                                      ^^^^^^^^this argument list
  1238.        This first argument list will be followed by another argument list
  1239.        that gives the arguments according to the partial specialization.
  1240.        For A<int *, int> according to the example above, the second
  1241.        argument list is <int>.  The second argument list is scanned but
  1242.        not put out, except when argument correspondences are output. */
  1243.     end_ptr = demangle_template_arguments(end_ptr+6, /*partial_spec=*/TRUE,
  1244.                                           temp_par_info, dctl);
  1245.     note_specialization(end_ptr, temp_par_info);
  1246.     is_partial_spec = TRUE;
  1247.   }  /* if */
  1248.   /* If there's a specialization indication ("__S"), ignore it. */
  1249.   if (get_char(end_ptr, ptr, nchars)   == '_' &&
  1250.       get_char(end_ptr+1, ptr, nchars) == '_' &&
  1251.       get_char(end_ptr+2, ptr, nchars) == 'S') {
  1252.     note_specialization(end_ptr, temp_par_info);
  1253.     end_ptr += 3;
  1254.   }  /* if */
  1255.   /* If there's a template argument list (beginning with "__pt__" or "__tm__"),
  1256.      process it. */
  1257.   if ((nchars == 0 || (end_ptr-ptr+6) < nchars) &&
  1258.       ((is_pt = start_of_id_is("__pt__", end_ptr)) ||
  1259.        start_of_id_is("__tm__", end_ptr))) {
  1260.     /* The "__pt__ form indicates an old-style mangled template name. */
  1261.     if (is_pt && temp_par_info != NULL ) {
  1262.       temp_par_info->use_old_form_for_template_output = TRUE;
  1263.     }  /* if */
  1264.     /* For the second argument list of a partial specialization,
  1265.        process the argument list but suppress output. */
  1266.     if (is_partial_spec && temp_par_info != NULL &&
  1267.         !temp_par_info->output_only_correspondences) {
  1268.       dctl->suppress_id_output++;
  1269.       partial_spec_output_suppressed = TRUE;
  1270.     }  /* if */
  1271.     /* Write the arguments. */
  1272. #ifndef WRS_ORIG /* WRS LOCAL */
  1273.     /* But not if we are printing an implicit Ctor/Dtor name! */
  1274.     if (temp_par_info != NULL && temp_par_info->base_name_only)
  1275.       dctl->suppress_id_output++;
  1276. #endif
  1277.     end_ptr = demangle_template_arguments(end_ptr+6, /*partial_spec=*/FALSE,
  1278.                                           temp_par_info, dctl);
  1279. #ifndef WRS_ORIG /* WRS LOCAL */
  1280.     if (temp_par_info != NULL && temp_par_info->base_name_only)
  1281.       dctl->suppress_id_output--;
  1282. #endif
  1283.     if (partial_spec_output_suppressed) dctl->suppress_id_output--;
  1284.     /* If there's a(nother) specialization indication ("__S"), ignore it. */
  1285.     if (get_char(end_ptr, ptr, nchars)   == '_' &&
  1286.         get_char(end_ptr+1, ptr, nchars) == '_' &&
  1287.         get_char(end_ptr+2, ptr, nchars) == 'S') {
  1288.       note_specialization(end_ptr, temp_par_info);
  1289.       end_ptr += 3;
  1290.     }  /* if */
  1291.   }  /* if */
  1292.   /* Check that we took exactly the characters we should have. */
  1293.   if (((nchars != 0) ? (end_ptr-ptr == nchars) : (*end_ptr == '')) ||
  1294.       (stop_on_underscores &&
  1295.        get_char(end_ptr,   ptr, nchars) == '_' &&
  1296.        get_char(end_ptr+1, ptr, nchars) == '_')) {
  1297.     /* Okay. */
  1298.   } else {
  1299.     bad_mangled_name(dctl);
  1300.   }  /* if */
  1301.   return end_ptr;
  1302. }  /* demangle_name */
  1305. static char *demangle_function_local_indication(
  1306.                                              char                       *ptr,
  1307.                                              unsigned long              nchars,
  1308.                                              a_decode_control_block_ptr dctl)
  1309. /*
  1310. Demangle the function name and block number in a function-local indication:
  1312.     __L2__f__Fv
  1313.                ^-- returned pointer points here
  1314.           ^------- mangled function name
  1315.        ^---------- block number within function (ptr points here on entry)
  1317. ptr points to the character after the "__L".  If nchars is non-zero, it
  1318. indicates the length of the string, starting from ptr.  Return a pointer
  1319. to the character following the mangled function name.  Output a function
  1320. indication like "f(void)::".
  1321. */
  1322. {
  1323.   char          *p = ptr;
  1324.   unsigned long block_number;
  1326.   /* Get the block number. */
  1327.   p = get_number(ptr, &block_number, dctl);
  1328.   /* Check for the two underscores following the block number. */
  1329.   if (p[0] != '_' || p[1] != '_') {
  1330.     bad_mangled_name(dctl);
  1331.   } else {
  1332.     p += 2;
  1333.   }  /* if */
  1334.   /* Put out the function name. */
  1335.   if (nchars != 0) nchars -= (p - ptr);
  1336.   p = full_demangle_identifier(p, nchars, dctl);
  1337.   /* Put out the block number if needed.  Block 0 is the top-level block
  1338.      of the function, and need not be identified. */
  1339.   if (block_number != 0) {
  1340.     char buffer[30];
  1341.     write_id_str("[block ", dctl);
  1342.     (void)sprintf(buffer, "%lu", block_number);
  1343.     write_id_str(buffer, dctl);
  1344.     write_id_ch(']', dctl);
  1345.   }  /* if */
  1346.   write_id_str("::", dctl);
  1347.   return p;
  1348. }  /* demangle_function_local_indication */
  1351. static char *demangle_name_with_preceding_length(
  1352.                                    char                       *ptr,
  1353.                                    a_template_param_block_ptr temp_par_info,
  1354.                                    a_decode_control_block_ptr dctl)
  1355. /*
  1356. Demangle a name that is preceded by a length, e.g., "3abc" for the type
  1357. name "abc".  Return a pointer to the character position following what
  1358. was demangled.  When temp_par_info != NULL, it points to a block that
  1359. controls output of extra information on template parameters.
  1360. */
  1361. {
  1362.   char          *p = ptr;
  1363.   char          *p2;
  1364.   unsigned long nchars, nchars2;
  1365.   a_boolean     has_function_local_info = FALSE;
  1367.   /* Get the length. */
  1368.   p = get_length(p, &nchars, dctl);
  1369.   if (nchars >= 8) {
  1370.     /* Look for a function-local indication, e.g., "__Ln__f" for block
  1371.        "n" of function "f". */
  1372.     for (p2 = p+1; p2+6 < p+nchars; p2++) {
  1373.       if (p2[0] == '_' && p2[1] == '_' && p2[2] == 'L') {
  1374.         has_function_local_info = TRUE;
  1375.         nchars2 = nchars;
  1376.         /* Set the length for the scan below to stop just before "__L". */
  1377.         nchars = p2 - p;
  1378.         p2 += 3;  /* Points to block number after "__L". */
  1379.         nchars2 -= (p2 - p);
  1380.         /* Scan and output the block number and function name. */
  1381.         p2 = demangle_function_local_indication(p2, nchars2, dctl);
  1382.         break;
  1383.       }  /* if */
  1384.     }  /* for */
  1385.   }  /* if */
  1386.   /* Demangle the name. */
  1387.   p = demangle_name(p, nchars, /*stop_on_underscores=*/FALSE,
  1388.                     (char *)NULL, temp_par_info, dctl);
  1389.   if (has_function_local_info) p = p2;
  1390.   return p;
  1391. }  /* demangle_name_with_preceding_length */
  1394. static char *demangle_simple_type_name(
  1395.                                    char                       *ptr,
  1396.                                    a_template_param_block_ptr temp_par_info,
  1397.                                    a_decode_control_block_ptr dctl)
  1398. /*
  1399. Demangle a type name (or namespace name) consisting of a length followed
  1400. by the name.  Return a pointer to the character position following what
  1401. was demangled.  The name is not a nested name, but it can have template
  1402. arguments.  When temp_par_info != NULL, it points to a block that
  1403. controls output of extra information on template parameters.
  1404. */
  1405. {
  1406.   char *p = ptr;
  1408.   if (*p == 'Z') {
  1409.     /* A template parameter name. */
  1410.     p = demangle_template_parameter_name(p, /*nontype=*/FALSE, dctl);
  1411.   } else {
  1412.     /* A simple mangled type name consists of digits indicating the length of
  1413.        the name followed by the name itself, e.g., "3abc". */
  1414.     p = demangle_name_with_preceding_length(p, temp_par_info, dctl);
  1415.   }  /* if */
  1416.   return p;
  1417. }  /* demangle_simple_type_name */
  1420. static char *full_demangle_type_name(char                       *ptr,
  1421.                                      a_boolean                  base_name_only,
  1422.                                      a_template_param_block_ptr temp_par_info,
  1423.                                      a_decode_control_block_ptr dctl)
  1424. /*
  1425. Demangle the type name at ptr and output the demangled form.  Return a pointer
  1426. to the character position following what was demangled.  The name can be
  1427. a simple type name or a nested type name, or the name of a namespace.
  1428. If base_name_only is TRUE, do not put out any nested type qualifiers,
  1429. e.g., put out "A::x" as simply "x".  When temp_par_info != NULL, it
  1430. points to a block that controls output of extra information on template
  1431. parameters.  Note that this routine is called for namespaces too
  1432. (the mangling is the same as for class names; you can't actually tell
  1433. the difference in a mangled name).  See demangle_type_name for an
  1434. interface to this routine for the simple case.
  1435. */
  1436. {
  1437.   char          *p = ptr;
  1438.   unsigned long nquals;
  1440.   if (*p == 'Q') {
  1441.     /* A nested type name has the form
  1442.          Q2_5outer5inner   (outer::inner)
  1443.             ^-----^--------Names from outermost to innermost
  1444.           ^----------------Number of levels of qualification.
  1445.        Note that the levels in the qualifier can be class names or namespace
  1446.        names. */
  1447.     p = get_number(p+1, &nquals, dctl);
  1448.     p = advance_past_underscore(p, dctl);
  1449.     /* Handle each level of qualification. */
  1450.     for (; nquals > 0; nquals--) {
  1451.       if (dctl->err_in_id) break;  /* Avoid infinite loops on errors. */
  1452.       /* Do not put out the nested type qualifiers if base_name_only is
  1453.          TRUE. */
  1454.       if (base_name_only && nquals != 1) dctl->suppress_id_output++;
  1455.       p = demangle_simple_type_name(p, temp_par_info, dctl);
  1456.       if (nquals != 1) write_id_str("::", dctl);
  1457.       if (base_name_only && nquals != 1) dctl->suppress_id_output--;
  1458.     }  /* for */
  1459.   } else {
  1460. #ifndef WRS_ORIG /* WRS LOCAL */
  1461.     a_template_param_block ctdt_temp_par_info;
  1462.     if (base_name_only)
  1463.       {
  1464. /* Also need to suppress template parameters when printing these! */
  1465. temp_par_info = &ctdt_temp_par_info;
  1466. clear_template_param_block(temp_par_info);
  1467. temp_par_info->base_name_only = TRUE;
  1468.       }
  1469.     /* N.B. when base_name_only is true, temp_par_info is also NULL.
  1470. We need it to pass down base_name_only, so we create a blank one
  1471. at this level. But note, we don't preserve temp_par_info so if you
  1472. add code that needs the old one, also add code to save/restore it. */
  1473. #endif
  1474.     /* A simple (non-nested) type name. */
  1475.     p = demangle_simple_type_name(p, temp_par_info, dctl);
  1476.   }  /* if */
  1477.   return p;
  1478. }  /* full_demangle_type_name */
  1481. static char *demangle_vtbl_class_name(char                       *ptr,
  1482.                                       a_decode_control_block_ptr dctl)
  1483. /*
  1484. Demangle a class or base class name that is one component of a virtual
  1485. function table name.  Such names are mangled mostly as types, but with
  1486. a few special quirks.
  1487. */
  1488. {
  1489.   char      *p = ptr;
  1490.   a_boolean nested_name_case = FALSE;
  1492.   /* If the name begins with a number, "Q", and another number, assume
  1493.      it's a name with a form like "7Q2_1A1B", which is used to encode
  1494.      A::B as the complete object class name component of a virtual
  1495.      function table name.  This doesn't have any particular sense to
  1496.      it; it's just what cfront does (and EDG's front end does the same
  1497.      at ABI versions >= 2.30 in cfront compatibility mode).  This could
  1498.      fail if the user actually has a class with a name that begins
  1499.      like "Q2_", but there's not much we can do about that. */
  1500.   if (isdigit((unsigned char)*p)) {
  1501.     do { p++; } while (isdigit((unsigned char)*p));
  1502.     if (*p == 'Q') {
  1503.       char *save_p = p;
  1504.       p++;
  1505.       if (isdigit((unsigned char)*p)) {
  1506.         do { p++; } while (isdigit((unsigned char)*p));
  1507.         if (*p == '_') {
  1508.           /* Yes, this is the strange nested name case.  Start the demangling
  1509.              at the "Q". */
  1510.           nested_name_case = TRUE;
  1511.           p = save_p;
  1512.         }  /* if */
  1513.       }  /* if */
  1514.     }  /* if */
  1515.   }  /* if */
  1516.   if (!nested_name_case) p = ptr;
  1517.   /* Now use the normal routine to demangle the class name. */
  1518.   p = demangle_type_name(p, dctl);
  1519.   return p;
  1520. }  /* demangle_vtbl_class_name */
  1523. static char *demangle_type_qualifiers(
  1524.                                      char                       *ptr,
  1525.                                      a_boolean                  trailing_space,
  1526.                                      a_decode_control_block_ptr dctl)
  1527. /*
  1528. Demangle any type qualifiers (const/volatile) at the indicated location.
  1529. Return a pointer to the character position following what was demangled.
  1530. If trailing_space is TRUE, add a space at the end if any qualifiers were
  1531. put out.
  1532. */
  1533. {
  1534.   char      *p = ptr;
  1535.   a_boolean any_quals = FALSE;
  1537.   for (;; p++) {
  1538.     if (*p == 'C') {
  1539.       if (any_quals) write_id_ch(' ', dctl);
  1540.       write_id_str("const", dctl);
  1541.     } else if (*p == 'V') {
  1542.       if (any_quals) write_id_ch(' ', dctl);
  1543.       write_id_str("volatile", dctl);
  1544.     } else {
  1545.       break;
  1546.     }  /* if */
  1547.     any_quals = TRUE;
  1548.   }  /* for */
  1549.   if (any_quals && trailing_space) write_id_ch(' ', dctl);
  1550.   return p;
  1551. }  /* demangle_type_qualifiers */
  1554. static char *demangle_type_specifier(char                       *ptr,
  1555.                                      a_decode_control_block_ptr dctl)
  1556. /*
  1557. Demangle the type at ptr and output the specifier part.  Return a pointer
  1558. to the character position following what was demangled.
  1559. */
  1560. {
  1561.   char *p = ptr, *s;
  1563.   /* Process type qualifiers. */
  1564.   p = demangle_type_qualifiers(p, /*trailing_space=*/TRUE, dctl);
  1565.   if (isdigit((unsigned char)*p) || *p == 'Q' || *p == 'Z') {
  1566.     /* Named type, like class or enum, e.g., "3abc". */
  1567.     p = demangle_type_name(p, dctl);
  1568.   } else {
  1569.     /* Builtin type. */
  1570.     /* Handle signed and unsigned. */
  1571.     if (*p == 'S') {
  1572.       write_id_str("signed ", dctl);
  1573.       p++;
  1574.     } else if (*p == 'U') {
  1575.       write_id_str("unsigned ", dctl);
  1576.       p++;
  1577.     }  /* if */
  1578.     switch (*p++) {
  1579.       case 'v':
  1580.         s = "void";
  1581.         break;
  1582.       case 'c':
  1583.         s = "char";
  1584.         break;
  1585.       case 'w':
  1586.         s = "wchar_t";
  1587.         break;
  1588.       case 'b':
  1589.         s = "bool";
  1590.         break;
  1591.       case 's':
  1592.         s = "short";
  1593.         break;
  1594.       case 'i':
  1595.         s = "int";
  1596.         break;
  1597.       case 'l':
  1598.         s = "long";
  1599.         break;
  1600.       case 'L':
  1601.         s = "long long";
  1602.         break;
  1603.       case 'f':
  1604.         s = "float";
  1605.         break;
  1606.       case 'd':
  1607.         s = "double";
  1608.         break;
  1609.       case 'r':
  1610.         s = "long double";
  1611.         break;
  1612.       case 'm':
  1613.         /* Microsoft intrinsic __intN types (Visual C++ 6.0 and later). */
  1614.         switch (*p++) {
  1615.           case '1':
  1616.             s = "__int8";
  1617.             break;
  1618.           case '2':
  1619.             s = "__int16";
  1620.             break;
  1621.           case '4':
  1622.             s = "__int32";
  1623.             break;
  1624.           case '8':
  1625.             s = "__int64";
  1626.             break;
  1627.           default:
  1628.             bad_mangled_name(dctl);
  1629.             s = "";
  1630.         }  /* switch */
  1631.         break;
  1632.       default:
  1633.         bad_mangled_name(dctl);
  1634.         s = "";
  1635.     }  /* switch */
  1636.     write_id_str(s, dctl);
  1637.   }  /* if */
  1638.   return p;
  1639. }  /* demangle_type_specifier */
  1642. static char *demangle_function_parameters(char                       *ptr,
  1643.                                           a_decode_control_block_ptr dctl)
  1644. /*
  1645. Demangle the parameter list beginning at ptr and output the demangled form.
  1646. Return a pointer to the character position following what was demangled.
  1647. */
  1648. {
  1649.   char      *p = ptr;
  1650.   char      *param_pos[10];
  1651.   unsigned  long curr_param_num, param_num, nreps;
  1652.   a_boolean any_params = FALSE;
  1654.   write_id_ch('(', dctl);
  1655.   if (*p == 'v') {
  1656.     /* Void parameter list. */
  1657.     p++;
  1658.   } else {
  1659.     any_params = TRUE;
  1660.     /* Loop for each parameter. */
  1661.     curr_param_num = 1;
  1662.     for (;;) {
  1663.       if (dctl->err_in_id) break;  /* Avoid infinite loops on errors. */
  1664.       if (*p == 'T' || *p == 'N') {
  1665.         /* Tn means repeat the type of parameter "n". */
  1666.         /* Nmn means "m" repetitions of the type of parameter "n".  "m"
  1667.            is a one-digit number. */
  1668.         /* "n" is also treated as a single-digit number; the front end enforces
  1669.            that (in non-cfront object code compatibility mode).  cfront does
  1670.            not, which leads to some ambiguities when "n" is followed by
  1671.            a class name. */
  1672.         if (*p++ == 'N') {
  1673.           /* Get the number of repetitions. */
  1674.           p = get_single_digit_number(p, &nreps, dctl);
  1675.         } else {
  1676.           nreps = 1;
  1677.         }  /* if */
  1678.         /* Get the parameter number. */
  1679.         p = get_single_digit_number(p, &param_num, dctl);
  1680.         if (param_num < 1 || param_num >= curr_param_num ||
  1681.             param_pos[param_num] == NULL) {
  1682.           /* Parameter number out of range. */
  1683.           bad_mangled_name(dctl);
  1684.           goto end_of_routine;
  1685.         }  /* if */
  1686.         /* Produce "nreps" copies of parameter "param_num". */
  1687.         for (; nreps > 0; nreps--) {
  1688.           if (dctl->err_in_id) break;  /* Avoid infinite loops on errors. */
  1689.           if (curr_param_num < 10) param_pos[curr_param_num] = NULL;
  1690.           (void)demangle_type(param_pos[param_num], dctl);
  1691.           if (nreps != 1) write_id_str(", ", dctl);
  1692.           curr_param_num++;
  1693.         }  /* if */
  1694.       } else {
  1695.         /* A normal parameter. */
  1696.         if (curr_param_num < 10) param_pos[curr_param_num] = p;
  1697.         p = demangle_type(p, dctl);
  1698.         curr_param_num++;
  1699.       }  /* if */
  1700.       /* Stop after the last parameter. */
  1701.       if (*p == '' || *p == 'e' || *p == '_') break;
  1702.       write_id_str(", ", dctl);
  1703.     }  /* for */
  1704.   }  /* if */
  1705.   if (*p == 'e') {
  1706.     /* Ellipsis. */
  1707.     if (any_params) write_id_str(", ", dctl);
  1708.     write_id_str("...", dctl);
  1709.     p++;
  1710.   }  /* if */
  1711.   write_id_ch(')', dctl);
  1712. end_of_routine:
  1713.   return p;
  1714. }  /* demangle_function_parameters */
  1717. static char *skip_extern_C_indication(char *ptr)
  1718. /*
  1719. ptr points to the character after the "F" of a function type.  Skip over
  1720. and ignore an indication of extern "C" following the "F", if one is present.
  1721. Return a pointer to the character following the extern "C" indication.
  1722. There's no syntax for representing the extern "C" in the function type, so
  1723. just ignore it.
  1724. */
  1725. {
  1726.   if (*ptr == 'K') ptr++;
  1727.   return ptr;
  1728. }  /* skip_extern_C_indication */
  1731. static char *demangle_type_first_part(
  1732.                                char                       *ptr,
  1733.                                a_boolean                  under_lhs_declarator,
  1734.                                a_boolean                  need_trailing_space,
  1735.                                a_decode_control_block_ptr dctl)
  1736. /*
  1737. Demangle the type at ptr and output the specifier part and the part of the
  1738. declarator that precedes the name.  Return a pointer to the character
  1739. position following what was demangled.  If under_lhs_declarator is TRUE,
  1740. this type is directly under a type that uses a left-side declarator,
  1741. e.g., a pointer type.  (That's used to control use of parentheses around
  1742. parts of the declarator.)  If need_trailing_space is TRUE, put a space
  1743. at the end of the specifiers part (needed if the declarator part is
  1744. not empty, because it contains a name or a derived type).
  1745. */
  1746. {
  1747.   char *p = ptr, *qualp = p;
  1748.   char kind;
  1750.   /* Remove type qualifiers. */
  1751.   while (is_immediate_type_qualifier(p)) p++;
  1752.   kind = *p;
  1753.   if (kind == 'P' || kind == 'R') {
  1754.     /* Pointer or reference type, e.g., "Pc" is pointer to char. */
  1755.     p = demangle_type_first_part(p+1, /*under_lhs_declarator=*/TRUE,
  1756.                                  /*need_trailing_space=*/TRUE, dctl);
  1757.     /* Output "*" or "&" for pointer or reference. */
  1758.     if (kind == 'R') {
  1759.       write_id_ch('&', dctl);
  1760.     } else {
  1761.       write_id_ch('*', dctl);
  1762.     }  /* if */
  1763.     /* Output the type qualifiers on the pointer, if any. */
  1764.     (void)demangle_type_qualifiers(qualp, /*trailing_space=*/TRUE, dctl);
  1765.   } else if (kind == 'M') {
  1766.     /* Pointer-to-member type, e.g., "M1Ai" is pointer to member of A of
  1767.        type int. */
  1768.     char *classp = p+1;
  1769.     /* Skip over the class name. */
  1770.     dctl->suppress_id_output++;
  1771.     p = demangle_type_name(classp, dctl);
  1772.     dctl->suppress_id_output--;
  1773.     p = demangle_type_first_part(p, /*under_lhs_declarator=*/TRUE,
  1774.                                  /*need_trailing_space=*/TRUE, dctl);
  1775.     /* Output Classname::*. */
  1776.     (void)demangle_type_name(classp, dctl);
  1777.     write_id_str("::*", dctl);
  1778.     /* Output the type qualifiers on the pointer, if any. */
  1779.     (void)demangle_type_qualifiers(qualp, /*trailing_space=*/TRUE, dctl);
  1780.   } else if (kind == 'F') {
  1781.     /* Function type, e.g., "Fii_f" is function(int, int) returning float.
  1782.        The return type is not present for top-level function types (except
  1783.        for template functions). */
  1784.     p = skip_extern_C_indication(p+1);
  1785.     /* Skip over the parameter types without outputting anything. */
  1786.     dctl->suppress_id_output++;
  1787.     p = demangle_function_parameters(p, dctl);
  1788.     dctl->suppress_id_output--;
  1789.     if (*p == '_' && p[1] != '_') {
  1790.       /* The return type is present. */
  1791. #ifndef WRS_ORIG /* WRS LOCAL */
  1792.       if (dctl->suppress_return_types) dctl->suppress_id_output++;
  1793. #endif
  1794.       p = demangle_type_first_part(p+1, /*under_lhs_declarator=*/FALSE,
  1795.                                    /*need_trailing_space=*/TRUE, dctl);
  1796. #ifndef WRS_ORIG /* WRS LOCAL */
  1797.       if (dctl->suppress_return_types) dctl->suppress_id_output--;
  1798. #endif
  1799.     }  /* if */
  1800.     /* This is a right-side declarator, so if it's under a left-side declarator
  1801.        parentheses are needed. */
  1802.     if (under_lhs_declarator) write_id_ch('(', dctl);
  1803.   } else if (kind == 'A') {
  1804.     /* Array type, e.g., "A10_i" is array[10] of int. */
  1805.     p++;
  1806.     if (*p == '_') {
  1807.       /* Length is specified by a constant expression based on template
  1808.          parameters.  Ignore the expression. */
  1809.       p++;
  1810.       dctl->suppress_id_output++;
  1811.       p = demangle_constant(p, dctl);
  1812.       dctl->suppress_id_output--;
  1813.     } else {
  1814.       /* Normal constant number of elements. */
  1815.       /* Skip the array size. */
  1816.       while (isdigit((unsigned char)*p)) p++;
  1817.     }  /* if */
  1818.     p = advance_past_underscore(p, dctl);
  1819.     /* Process the element type. */
  1820.     p = demangle_type_first_part(p, /*under_lhs_declarator=*/FALSE,
  1821.                                  /*need_trailing_space=*/TRUE, dctl);
  1822.     /* This is a right-side declarator, so if it's under a left-side declarator
  1823.        parentheses are needed. */
  1824.     if (under_lhs_declarator) write_id_ch('(', dctl);
  1825.   } else {
  1826.     /* No declarator part to process.  Handle the specifier type. */
  1827.     p = demangle_type_specifier(qualp, dctl);
  1828.     if (need_trailing_space) write_id_ch(' ', dctl);
  1829.   }  /* if */
  1830.   return p;
  1831. }  /* demangle_type_first_part */
  1834. static void demangle_type_second_part(
  1835.                                char                       *ptr,
  1836.                                a_boolean                  under_lhs_declarator,
  1837.                                a_decode_control_block_ptr dctl)
  1838. /*
  1839. Demangle the type at ptr and output the part of the declarator that follows the
  1840. name.  This routine does not return a pointer to the character position
  1841. following what was demangled; it is assumed that the caller will save
  1842. that from the call of demangle_type_first_part, and it saves a lot of
  1843. time if this routine can avoid scanning the specifiers again.
  1844. If under_lhs_declarator is TRUE, this type is directly under a type that
  1845. uses a left-side declarator, e.g., a pointer type.  (That's used to control
  1846. use of parentheses around parts of the declarator.)
  1847. */
  1848. {
  1849.   char *p = ptr, *qualp = p;
  1850.   char kind;
  1852.   /* Remove type qualifiers. */
  1853.   while (is_immediate_type_qualifier(p)) p++;
  1854.   kind = *p;
  1855.   if (kind == 'P' || kind == 'R') {
  1856.     /* Pointer or reference type, e.g., "Pc" is pointer to char. */
  1857.     demangle_type_second_part(p+1, /*under_lhs_declarator=*/TRUE, dctl);
  1858.   } else if (kind == 'M') {
  1859.     /* Pointer-to-member type, e.g., "M1Ai" is pointer to member of A of
  1860.        type int. */
  1861.     /* Advance over the class name. */
  1862.     dctl->suppress_id_output++;
  1863.     p = demangle_type_name(p+1, dctl);
  1864.     dctl->suppress_id_output--;
  1865.     demangle_type_second_part(p, /*under_lhs_declarator=*/TRUE, dctl);
  1866.   } else if (kind == 'F') {
  1867.     /* Function type, e.g., "Fii_f" is function(int, int) returning float.
  1868.        The return type is not present for top-level function types (except
  1869.        for template functions). */
  1870.     /* This is a right-side declarator, so if it's under a left-side declarator
  1871.        parentheses are needed. */
  1872.     if (under_lhs_declarator) write_id_ch(')', dctl);
  1873.     p = skip_extern_C_indication(p+1);
  1874.     /* Put out the parameter types. */
  1875. #ifndef WRS_ORIG /* WRS LOCAL */
  1876.     if (dctl->suppress_function_params) dctl->suppress_id_output++;
  1877. #endif
  1878.     p = demangle_function_parameters(p, dctl);
  1879. #ifndef WRS_ORIG /* WRS LOCAL */
  1880.     if (dctl->suppress_function_params) dctl->suppress_id_output--;
  1881. #endif
  1882.     /* Put out any cv-qualifiers (member functions). */
  1883.     /* Note that such things could come up on nonmember functions in the
  1884.        presence of typedefs.  In such a case what we generate here will not
  1885.        be valid C, but it's a reasonable representation of the mangled
  1886.        type, and there's no way of getting the typedef name in there,
  1887.        so let it be. */
  1888.     if (*qualp != 'F') {
  1889.       write_id_ch(' ', dctl);
  1890.       (void)demangle_type_qualifiers(qualp, /*trailing_space=*/FALSE, dctl);
  1891.     }  /* if */
  1892.     if (*p == '_' && p[1] != '_') {
  1893.       /* Process the return type. */
  1894.       demangle_type_second_part(p+1, /*under_lhs_declarator=*/FALSE, dctl);
  1895.     }  /* if */
  1896.   } else if (kind == 'A') {
  1897.     /* Array type, e.g., "A10_i" is array[10] of int. */
  1898.     /* This is a right-side declarator, so if it's under a left-side declarator
  1899.        parentheses are needed. */
  1900.     if (under_lhs_declarator) write_id_ch(')', dctl);
  1901.     write_id_ch('[', dctl);
  1902.     p++;
  1903.     if (*p == '_') {
  1904.       /* Length is specified by a constant expression based on template
  1905.          parameters. */
  1906.       p++;
  1907.       p = demangle_constant(p, dctl);
  1908.     } else {
  1909.       /* Normal constant number of elements. */
  1910.       if (*p == '0' && p[1] == '_') {
  1911.         /* Size is zero, so do not put out a size (the result is "[]"). */
  1912.         p++;
  1913.       } else {
  1914.         /* Put out the array size. */
  1915.         while (isdigit((unsigned char)*p)) write_id_ch(*p++, dctl);
  1916.       }  /* if */
  1917.     }  /* if */
  1918.     p = advance_past_underscore(p, dctl);
  1919.     write_id_ch(']', dctl);
  1920.     /* Process the element type. */
  1921.     demangle_type_second_part(p, /*under_lhs_declarator=*/FALSE, dctl);
  1922.   } else {
  1923.     /* No declarator part to process.  No need to scan the specifiers type --
  1924.        it was done by demangle_type_first_part. */
  1925.   }  /* if */
  1926. }  /* demangle_type_second_part */
  1929. static char *demangle_type(char                       *ptr,
  1930.                            a_decode_control_block_ptr dctl)
  1931. /*
  1932. Demangle the type at ptr and output the demangled form.  Return a pointer to
  1933. the character position following what was demangled.
  1934. */
  1935. {
  1936.   char *p;
  1938.   /* Generate the specifier part of the type. */
  1939.   p = demangle_type_first_part(ptr, /*under_lhs_declarator=*/FALSE,
  1940.                                /*need_trailing_space=*/FALSE, dctl);
  1941.   /* Generate the declarator part of the type. */
  1942.   demangle_type_second_part(ptr, /*under_lhs_declarator=*/FALSE, dctl);
  1943.   return p;
  1944. }  /* demangle_type */
  1947. static char *full_demangle_identifier(char                       *ptr,
  1948.                                       unsigned long              nchars,
  1949.                                       a_decode_control_block_ptr dctl)
  1950. /*
  1951. Demangle the identifier at ptr and output the demangled form.  Return
  1952. a pointer to the character position following what was demangled.
  1953. If nchars > 0, take no more than that many characters.
  1954. */
  1955. {
  1956.   char          *p = ptr, *pname, *end_ptr, *function_local_end_ptr = NULL;
  1957.   char          *final_specialization, *end_ptr_first_scan;
  1958.   char          ch;
  1959.   a_boolean     member_function = TRUE;
  1960.   a_template_param_block
  1961.                 temp_par_info;
  1963.   clear_template_param_block(&temp_par_info);
  1964. #ifndef WRS_ORIG /* WRS LOCAL */
  1965.   if (dctl->sourcelike_template_params)
  1966.     temp_par_info.use_old_form_for_template_output = TRUE;
  1967. #endif
  1968.   /* Scan through the name (the first part of the mangled name) without
  1969.      generating output, to see what's beyond it.  Special processing is
  1970.      necessary for names of constructors, conversion routines, etc. */
  1971.   /* If the name has a specialization indication in it (which can happen for
  1972.      function names), note that fact. */
  1973.   temp_par_info.set_final_specialization = TRUE;
  1974.   dctl->suppress_id_output++;
  1975.   p = demangle_name(ptr, nchars, /*stop_on_underscores=*/TRUE,
  1976.                     (char *)NULL, &temp_par_info, dctl);
  1977.   dctl->suppress_id_output--;
  1978.   final_specialization = temp_par_info.final_specialization;
  1979.   clear_template_param_block(&temp_par_info);
  1980. #ifndef WRS_ORIG /* WRS LOCAL */
  1981.   if (dctl->sourcelike_template_params)
  1982.     temp_par_info.use_old_form_for_template_output = TRUE;
  1983. #endif
  1984.   temp_par_info.final_specialization = final_specialization;
  1985.   if (get_char(p, ptr, nchars) == '') {
  1986.     /* There is no mangled part of the name.  This happens for strange
  1987.        cases like
  1988.          extern "C" int operator +(A, A);
  1989.        which gets mangled as "__pl".  Just write out the name and stop. */
  1990.     end_ptr = demangle_name(ptr, nchars,
  1991.                             /*stop_on_underscores=*/TRUE,
  1992.                             (char *)NULL,
  1993.                             (a_template_param_block_ptr)NULL, dctl);
  1994.   } else {
  1995.     /* There's more.  There should be a "__" between the name and the
  1996.        additional mangled information. */
  1997.     if (get_char(p, ptr, nchars) != '_' || get_char(p+1, ptr, nchars) != '_') {
  1998.       bad_mangled_name(dctl);
  1999.       end_ptr = p;
  2000.       goto end_of_routine;
  2001.     }  /* if */
  2002.     end_ptr = p + 2;
  2003.     /* Now ptr points to the original-name part of the mangled name, and
  2004.        end_ptr points to the mangled-name part at the end.
  2005.          f__1AFv
  2006.             ^---- end_ptr
  2007.          ^------- ptr
  2008.        The mangled-name part is
  2009.          (a)  A class name for a static data member.
  2010.          (b)  A class name followed by "F" followed by the encoding for the
  2011.               parameter types for a member function.
  2012.          (c)  "F" followed by the encoding for the parameter types for a
  2013.               nonmember function.
  2014.          (d)  "L" plus a local block number, followed by the mangled function
  2015.               name, for a function-local entity.
  2016.        Members of namespaces are encoded similarly. */
  2017.     p = end_ptr;
  2018.     pname = NULL;
  2019.     ch = get_char(end_ptr, ptr, nchars);
  2020.     if (ch == 'L') {
  2021.       unsigned long nchars2 = nchars;
  2022.       /* The name of an entity within a function, mangled on promotion out
  2023.          of the function.  For example, "i__L1__f__Fv" for "i" from block 1
  2024.          of function "f(void)".  Note that this is not the same mangling
  2025.          used by cfront (in the cfront scheme, the __L1 is at the end, and
  2026.          the number is different). */
  2027.       /* Set a length for the name without the function-local indication,
  2028.          for the processing in the rest of this routine. */
  2029.       nchars = (p - 2) - ptr;
  2030.       /* Demangle the function name and block number. */
  2031.       p++;  /* Points to the block number following "__L". */
  2032.       if (nchars2 != 0) nchars2 -= (p - ptr);
  2033.       function_local_end_ptr =
  2034.                           demangle_function_local_indication(p, nchars2, dctl);
  2035.       p = end_ptr = ptr + nchars;
  2036.       member_function = FALSE;
  2037.       /* Go on to demangle the name of the local entity. */
  2038.     } else if (ch != 'F') {
  2039.       /* A class (or namespace) name must be next. */
  2040.       /* Remember the location of the parent entity name. */
  2041.       pname = end_ptr;
  2042.       /* Scan over the class name, producing no output, and remembering the
  2043.          position of the final specialization, if any.  If we already
  2044.          found a specialization on the function name, it's the final one
  2045.          and we shouldn't change it. */
  2046.       dctl->suppress_id_output++;
  2047.       if (temp_par_info.final_specialization == NULL) {
  2048.         temp_par_info.set_final_specialization = TRUE;
  2049.       }  /* if */
  2050.       end_ptr = full_demangle_type_name(pname, /*base_name_only=*/FALSE,
  2051.                                         &temp_par_info, dctl);
  2052.       temp_par_info.set_final_specialization = FALSE;
  2053.       dctl->suppress_id_output--;
  2054.       /* If the name ends here, this is a simple member (e.g., a static
  2055.          data member). */
  2056.       ch = get_char(end_ptr, ptr, nchars);
  2057.       if (ch == '' ||
  2058.           (ch == '_' && get_char(end_ptr+1, ptr, nchars) == '_')) {
  2059.         member_function = FALSE;
  2060.       }  /* if */
  2061.     }  /* if */
  2062.     if (member_function) {
  2063.       /* "S" here means a static member function (ignore). */
  2064.       if (get_char(end_ptr, ptr, nchars) == 'S') end_ptr++;
  2065.       /* Write the specifier part of the type. */
  2066.       end_ptr_first_scan =
  2067.                   demangle_type_first_part(end_ptr,
  2068.                                            /*under_lhs_declarator=*/FALSE,
  2069.                                            /*need_trailing_space=*/TRUE, dctl);
  2070.     }  /* if */
  2071.     temp_par_info.nesting_level = 0;
  2072.     if (pname != NULL) {
  2073.       /* Write the parent class or namespace qualifier. */
  2074.       if (temp_par_info.final_specialization != NULL) {
  2075.         /* Up to the final specialization, put out actual template arguments
  2076.            for specializations. */
  2077.         temp_par_info.actual_template_args_until_final_specialization = TRUE;
  2078.       }  /* if */
  2079.       (void)full_demangle_type_name(pname, /*base_name_only=*/FALSE,
  2080.                                     &temp_par_info, dctl);
  2081.       /* Force template parameter information out on the function even if
  2082.          it is specialized. */
  2083.       temp_par_info.actual_template_args_until_final_specialization = FALSE;
  2084.       write_id_str("::", dctl);
  2085.     }  /* if */
  2086.     /* Write the name of the member. */
  2087.     (void)demangle_name(ptr, nchars, /*stop_on_underscores=*/TRUE,
  2088.                         pname, &temp_par_info, dctl);
  2089.     if (member_function) {
  2090.       /* Write the declarator part of the type. */
  2091.       demangle_type_second_part(end_ptr, /*under_lhs_declarator=*/FALSE,
  2092.                                 dctl);
  2093.       end_ptr = end_ptr_first_scan;
  2094.     }  /* if */
  2095.     if (!temp_par_info.use_old_form_for_template_output &&
  2096.         temp_par_info.nesting_level != 0) {
  2097.       /* Put out correspondences for template parameters, e.g, "T=int". */
  2098.       temp_par_info.nesting_level = 0;
  2099.       temp_par_info.first_correspondence = TRUE;
  2100.       temp_par_info.output_only_correspondences = TRUE;
  2101.       /* Output is suppressed in general, and turned on only where
  2102.          appropriate. */
  2103.       dctl->suppress_id_output++;
  2104.       if (pname != NULL) {
  2105.         /* Write the parent class or namespace qualifier. */
  2106.         if (temp_par_info.final_specialization != NULL) {
  2107.           /* Up to the final specialization, put out actual template arguments
  2108.              for specializations. */
  2109.           temp_par_info.actual_template_args_until_final_specialization = TRUE;
  2110.         }  /* if */
  2111.         (void)full_demangle_type_name(pname, /*base_name_only=*/FALSE,
  2112.                                       &temp_par_info, dctl);
  2113.       }  /* if */
  2114.       /* Force template parameter information out on the function even if
  2115.          it is specialized. */
  2116.       temp_par_info.actual_template_args_until_final_specialization = FALSE;
  2117.       /* Write the name of the member. */
  2118.       (void)demangle_name(ptr, nchars, /*stop_on_underscores=*/TRUE,
  2119.                           pname, &temp_par_info, dctl);
  2120.       dctl->suppress_id_output--;
  2121.       if (!temp_par_info.first_correspondence) {
  2122.         /* End the list of correspondences. */
  2123.         write_id_ch(']', dctl);
  2124.       }  /* if */
  2125.     }  /* if */
  2126.   }  /* if */
  2127. end_of_routine:
  2128.   /* When a function-local indication is scanned, end_ptr has been set
  2129.      to the end of the local entity name, and needs to be set to after the
  2130.      function-local indication at the end of the whole name. */
  2131.   if (function_local_end_ptr != NULL) end_ptr = function_local_end_ptr;
  2132.   return end_ptr;
  2133. }  /* full_demangle_identifier */
  2136. static char *demangle_static_variable_name(char                       *ptr,
  2137.                                            a_decode_control_block_ptr dctl)
  2138. /*
  2139. Demangle the name of a static variable promoted to being external by
  2140. addition of a prefix "__STV__" and a suffix of a module id.  Just put out
  2141. the part in the middle, which is the original name.
  2142. */
  2143. {
  2144.   char *start_ptr;
  2146.   ptr += 7;  /* Move to after "__STV__". */
  2147.   /* Copy the name until "__". */
  2148.   start_ptr = ptr;
  2149.   while (*ptr != '_' || ptr[1] != '_' || ptr == start_ptr) {
  2150.     if (*ptr == '') {
  2151.       bad_mangled_name(dctl);
  2152.       break;
  2153.     }  /* if */
  2154.     write_id_ch(*ptr, dctl);
  2155.     ptr++;
  2156.   }  /* while */
  2157.   /* Advance over the module id part of the name. */
  2158.   while (*ptr != '') ptr++;
  2159.   return ptr;
  2160. }  /* demangle_static_variable_name */
  2163. static char *demangle_static_function_name(char                       *ptr,
  2164.                                            a_decode_control_block_ptr dctl)
  2165. /*
  2166. Demangle the name of a static function promoted to being external by
  2167. addition of a prefix "__STF__" and a suffix of a module id.  Just put out
  2168. the part in the middle, which is the original mangled name.
  2169. */
  2170. {
  2171.   ptr += 7;  /* Move to after "__STF__". */
  2172.   /* Demangle the function name. */
  2173.   ptr = demangle_identifier(ptr, dctl);
  2174.   /* Advance over the module id part of the name. */
  2175.   while (*ptr != '') ptr++;
  2176.   return ptr;
  2177. }  /* demangle_static_function_name */
  2180. static char *demangle_local_name(char                       *ptr,
  2181.                                  a_decode_control_block_ptr dctl)
  2182. /*
  2183. Demangle the local name at ptr and output the demangled form.  Return
  2184. a pointer to the character position following what was demangled.
  2185. This demangles the "__nn_mm_name" form produced by the C-generating
  2186. back end.  This is not something visible unless the C-generating back end
  2187. is used, and it's a local name, which is ordinarily outside the charter
  2188. of these demangling routines, but it's an easy and common case, so...
  2190. Also handles the cfront-style __nnName form.
  2191. */
  2192. {
  2193.   char *p = ptr+2;
  2195.   /* Check for the initial two numbers and underscores.  The caller checked
  2196.      for the two initial underscores and the digit following that. */
  2197.   do { p++; } while (isdigit((unsigned char)*p));
  2198.   if (isalpha((unsigned char)*p)) {
  2199.     /* Cfront-style local name, like "__2name". */
  2200.   } else {
  2201.     if (*p != '_') {
  2202.       bad_mangled_name(dctl);
  2203.       goto end_of_routine;
  2204.     }  /* if */
  2205.     p++;
  2206.     if (!isdigit((unsigned char)*p)) {
  2207.       bad_mangled_name(dctl);
  2208.       goto end_of_routine;
  2209.     }  /* if */
  2210.     do { p++; } while (isdigit((unsigned char)*p));
  2211.     if (*p != '_') {
  2212.       bad_mangled_name(dctl);
  2213.       goto end_of_routine;
  2214.     }  /* if */
  2215.     p++;
  2216.   }  /* if */
  2217.   /* Copy the rest of the string to output. */
  2218.   while (*p != '') {
  2219.     write_id_ch(*p, dctl);
  2220.     p++;
  2221.   }  /* while */
  2222. end_of_routine:
  2223.   return p;
  2224. }  /* demangle_local_name */
  2227. static char *uncompress_mangled_name(char                       *id,
  2228.                                      a_decode_control_block_ptr dctl)
  2229. /*
  2230. Uncompress the compressed mangled name beginning at id.  Return the
  2231. address of the uncompressed name.
  2232. */
  2233. {
  2234.   char          *uncompressed_name = id;
  2235.   unsigned long length;
  2237.   /* Advance past "__CPR". */
  2238.   id += 5;
  2239.   /* Accumulate the length of the uncompressed name. */
  2240.   if (!isdigit((unsigned char)*id)) {
  2241.     bad_mangled_name(dctl);
  2242.     goto end_of_routine;
  2243.   }  /* if */
  2244.   id = get_number(id, &length, dctl);
  2245.   /* Check for the two underscores following the length. */
  2246.   if (id[0] != '_' || id[1] != '_') {
  2247.     bad_mangled_name(dctl);
  2248.     goto end_of_routine;
  2249.   }  /* if */
  2250.   /* Save the uncompressed length so it can be used later in telling the
  2251.      caller how big a buffer is required. */
  2252.   dctl->uncompressed_length = length;
  2253.   id += 2;
  2254.   if (length+1 >= dctl->output_id_size) {
  2255.     /* The buffer supplied by the caller is too small to contain the
  2256.        uncompressed name. */
  2257.     dctl->output_overflow_err = TRUE;
  2258.     goto end_of_routine;
  2259.   } else {
  2260.     char *src, *dst;
  2261.     /* Uncompress to the end of the buffer supplied by the caller, then
  2262.        do the demangling in the space remaining at the beginning. */
  2263.     uncompressed_name = dctl->output_id+dctl->output_id_size-(length+1);
  2264.     dctl->output_id_size -= length+1;
  2265.     /* Set the "input length" -- really the output size -- now.  This
  2266.        is used for error checking on the numbers scanned in the decompression
  2267.        processing (which are positions in the uncompressed string, really,
  2268.        not in the input string). */
  2269.     dctl->input_id_len = length;
  2270.     dst = uncompressed_name;
  2271.     for (src = id; *src != '';) {
  2272.       char ch = *src++;
  2273.       if (ch != 'J') {
  2274.         /* Just copy this character. */
  2275.         *dst++ = ch;
  2276.       } else {
  2277.         if (*src == 'J') {
  2278.           /* "JJ" indicates a simple "J". */
  2279.           /* Simple "J". */
  2280.           *dst++ = 'J';
  2281.         } else {
  2282.           /* "JnnnJ" indicates a repetition of a string that appeared
  2283.              earlier, at position "nnn". */
  2284.           unsigned long pos, prev_len;
  2285.           char          *prev_str, *prev_str2;
  2286.           src = get_length(src, &pos, dctl);
  2287.           if (*src != 'J') {
  2288.             bad_mangled_name(dctl);
  2289.             goto end_of_routine;
  2290.           }  /* if */
  2291.           prev_str = uncompressed_name+pos;
  2292.           if (!isdigit(*prev_str)) {
  2293.             bad_mangled_name(dctl);
  2294.             goto end_of_routine;
  2295.           }  /* if */
  2296.           /* Get the length of the repeated string. */
  2297.           prev_str2 = get_length(prev_str, &prev_len, dctl);
  2298.           /* Copy the repeated string to the uncompressed output. */
  2299.           prev_str2 += prev_len;
  2300.           while (prev_str < prev_str2) *dst++ = *prev_str++;
  2301.         }  /* if */
  2302.         /* Advance past the final "J". */
  2303.         src++;
  2304.       }  /* if */
  2305.     }  /* for */
  2306.     if (dst - uncompressed_name != length) {
  2307.       /* The length didn't come out right. */
  2308.       bad_mangled_name(dctl);
  2309.     }  /* if */
  2310.     /* Add the final null. */
  2311.     *dst++ = '';
  2312.   }  /* if */
  2313. end_of_routine:;
  2314.   return uncompressed_name;
  2315. }  /* uncompress_mangled_name */
  2317. #ifndef WRS_ORIG /* WRS LOCAL */
  2318. /* Forward decl to new enhanced entry point. */
  2319. void decode_identifier_styled(char      *id,
  2320.       int       act_like_gnu,
  2321.       int       suppress_function_params,
  2322.       char      *output_buffer,
  2323.       sizeof_t  output_buffer_size,
  2324.       a_boolean *err,
  2325.       a_boolean *buffer_overflow_err,
  2326.       sizeof_t  *required_buffer_size);
  2327. #endif
  2329. void decode_identifier(char      *id,
  2330.                        char      *output_buffer,
  2331.                        sizeof_t  output_buffer_size,
  2332.                        a_boolean *err,
  2333.                        a_boolean *buffer_overflow_err,
  2334.                        sizeof_t  *required_buffer_size)
  2335. /*
  2336. Demangle the identifier id (which is null-terminated), and put the demangled
  2337. form (null-terminated) into the output_buffer provided by the caller.
  2338. output_buffer_size gives the allocated size of output_buffer.  If there
  2339. is some error in the demangling process, *err will be returned TRUE.
  2340. In addition, if the error is that the output buffer is too small,
  2341. *buffer_overflow_err will (also) be returned TRUE, and *required_buffer_size
  2342. is set to the size of buffer required to do the demangling.  Note that
  2343. if the mangled name is compressed, and the buffer size is smaller than
  2344. the size of the uncompressed mangled name, the size returned will be
  2345. enough to uncompress the name but not enough to produce the demangled form.
  2346. The caller must be prepared in that case to loop a second time (the
  2347. length returned the second time will be correct).
  2348. */
  2349. #ifndef WRS_ORIG /* WRS LOCAL */
  2350. {
  2351.   decode_identifier_styled(id, /* act_like_gnu= */ 0,
  2352.    /* suppress_function_params= */ 0,
  2353.    output_buffer, output_buffer_size,
  2354.    err, buffer_overflow_err, required_buffer_size);
  2355. }
  2357. void decode_identifier_styled(char      *id,
  2358.       int       act_like_gnu,
  2359.       int       suppress_function_params,
  2360.       char      *output_buffer,
  2361.       sizeof_t  output_buffer_size,
  2362.       a_boolean *err,
  2363.       a_boolean *buffer_overflow_err,
  2364.       sizeof_t  *required_buffer_size)
  2365. #endif
  2366. {
  2367.   char                       *end_ptr, *p;
  2368.   a_decode_control_block     control_block;
  2369.   a_decode_control_block_ptr dctl = &control_block;
  2371.   /* Set global variables. */
  2372.   dctl->input_id_len = strlen(id);
  2373.   dctl->output_id = output_buffer;
  2374.   dctl->output_id_len = 0;
  2375.   dctl->output_id_size = output_buffer_size;
  2376.   dctl->err_in_id = FALSE;
  2377.   dctl->output_overflow_err = FALSE;
  2378.   dctl->suppress_id_output = 0;
  2379.   dctl->end_of_constant = NULL;
  2380.   dctl->uncompressed_length = 0;
  2381. #ifndef WRS_ORIG /* WRS LOCAL */
  2382.   dctl->suppress_function_params = suppress_function_params ? TRUE : FALSE;
  2383.   dctl->suppress_return_types = act_like_gnu ? TRUE : FALSE;
  2384.   dctl->sourcelike_template_params = act_like_gnu ? TRUE : FALSE;
  2385. #endif
  2386.   if (start_of_id_is("__CPR", id)) {
  2387.     /* Uncompress a compressed name. */
  2388.     id = uncompress_mangled_name(id, dctl);
  2389.   }  /* if */
  2390.   /* Check for special cases. */
  2391.   if (dctl->output_overflow_err) {
  2392.     /* Previous error (not enough room in the buffer to uncompress). */
  2393.   } else if (start_of_id_is("__vtbl__", id)) {
  2394.     write_id_str("virtual function table for ", dctl);
  2395.     /* Note that if the first name is a base class name and it's not simple,
  2396.        this will produce output containing partially-mangled information.
  2397.        It's hard to do better given the cfront encoding form. */
  2398.     end_ptr = demangle_vtbl_class_name(id+8, dctl);
  2399.     if (start_of_id_is("__A", end_ptr)) {
  2400.       /* "__A" indicates an ambiguous base class. */
  2401.       write_id_str(" (ambiguous)", dctl);
  2402.       end_ptr += 3;
  2403.     }  /* if */
  2404.     if (start_of_id_is("__", end_ptr)) {
  2405.       /* Virtual function table for base class in derived class. */
  2406.       end_ptr += 2;
  2407.       write_id_str(" in ", dctl);
  2408.       end_ptr = demangle_vtbl_class_name(end_ptr, dctl);
  2409.     }  /* if */
  2410.     if (start_of_id_is("__", end_ptr)) {
  2411.       /* Further derived class. */
  2412.       end_ptr += 2;
  2413.       write_id_str(" in ", dctl);
  2414.       end_ptr = demangle_vtbl_class_name(end_ptr, dctl);
  2415.     }  /* if */
  2416.   } else if (start_of_id_is("__CBI__", id)) {
  2417.     write_id_str("can-be-instantiated flag for ", dctl);
  2418.     end_ptr = demangle_identifier(id+7, dctl);
  2419.   } else if (start_of_id_is("__DNI__", id)) {
  2420.     write_id_str("do-not-instantiate flag for ", dctl);
  2421.     end_ptr = demangle_identifier(id+7, dctl);
  2422.   } else if (start_of_id_is("__TIR__", id)) {
  2423.     write_id_str("template-instantiation-request flag for ", dctl);
  2424.     end_ptr = demangle_identifier(id+7, dctl);
  2425.   } else if (start_of_id_is("__LSG__", id)) {
  2426.     write_id_str("initialization guard variable for ", dctl);
  2427.     end_ptr = demangle_identifier(id+7, dctl);
  2428.   } else if (start_of_id_is("__TID_", id)) {
  2429.     write_id_str("type identifier for ", dctl);
  2430.     end_ptr = demangle_type(id+6, dctl);
  2431.   } else if (start_of_id_is("__T_", id)) {
  2432.     write_id_str("typeinfo for ", dctl);
  2433.     end_ptr = demangle_type(id+4, dctl);
  2434.   } else if (start_of_id_is("__VFE__", id)) {
  2435.     write_id_str("surrogate in class ", dctl);
  2436.     p = demangle_type(id+7, dctl);
  2437.     if (p[0] != '_' || p[1] != '_') {
  2438.       bad_mangled_name(dctl);
  2439.       end_ptr = p;
  2440.     } else {
  2441.       write_id_str(" for ", dctl);
  2442.       end_ptr = demangle_identifier(p+2, dctl);
  2443.     }  /* if */
  2444.   } else if (start_of_id_is("__Q", id)) {
  2445.     /* Nested class name. */
  2446.     end_ptr = demangle_type_name(id+2, dctl);
  2447.   } else if (start_of_id_is("__STV__", id)) {
  2448.     /* Static variable made external by addition of prefix "__STV__" and
  2449.        suffix of module id. */
  2450.     end_ptr = demangle_static_variable_name(id, dctl);
  2451.   } else if (start_of_id_is("__STF__", id)) {
  2452.     /* Static function made external by addition of prefix "__STF__" and
  2453.        suffix of module id. */
  2454.     end_ptr = demangle_static_function_name(id, dctl);
  2455.   } else if (start_of_id_is("__", id) && isdigit((unsigned char)id[2])) {
  2456.     /* Local variable mangled by the C-generating back end: __nn_mm_name,
  2457.        where "nn" and "mm" are decimal integers. */
  2458.     end_ptr = demangle_local_name(id, dctl);
  2459.   } else {
  2460.     /* Normal case: function name, static data member name, or
  2461.        name of type or variable promoted out of function. */
  2462.     end_ptr = demangle_identifier(id, dctl);
  2463.   }  /* if */
  2464.   if (dctl->output_overflow_err) {
  2465.     dctl->err_in_id = TRUE;
  2466.   } else {
  2467.     /* Add a terminating null. */
  2468.     dctl->output_id[dctl->output_id_len] = 0;
  2469.   }  /* if */
  2470.   /* Make sure the whole identifier was taken. */
  2471.   if (!dctl->err_in_id && *end_ptr != '') bad_mangled_name(dctl);
  2472.   *err = dctl->err_in_id;
  2473.   *buffer_overflow_err = dctl->output_overflow_err;
  2474.   *required_buffer_size = dctl->output_id_len + 1; /* +1 for final null. */
  2475.   /* If the name is compressed, we need room for the uncompressed
  2476.      form, and a null, in the buffer. */
  2477.   if (dctl->uncompressed_length != 0) {
  2478.     *required_buffer_size += dctl->uncompressed_length+1;
  2479.   }  /* if */
  2480. }  /* decode_identifier */
  2483. /******************************************************************************
  2484. *                                                               ___  /       *
  2485. *                                                               /            *
  2486. * Edison Design Group C++/C Front End                        - | ^/ | -      *
  2487. *                                                                  /         *
  2488. *                                                             /  | |         *
  2489. * Copyright 1996-1999 Edison Design Group Inc.                   [_]          *
  2490. *                                                                             *
  2491. ******************************************************************************/