1: /* Internal demangler interface for g++ V3 ABI.
    2:    Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
    3:    Written by Ian Lance Taylor <ian@wasabisystems.com>.
    4: 
    5:    This file is part of the libiberty library, which is part of GCC.
    6: 
    7:    This file is free software; you can redistribute it and/or modify
    8:    it under the terms of the GNU General Public License as published by
    9:    the Free Software Foundation; either version 2 of the License, or
   10:    (at your option) any later version.
   11: 
   12:    In addition to the permissions in the GNU General Public License, the
   13:    Free Software Foundation gives you unlimited permission to link the
   14:    compiled version of this file into combinations with other programs,
   15:    and to distribute those combinations without any restriction coming
   16:    from the use of this file.  (The General Public License restrictions
   17:    do apply in other respects; for example, they cover modification of
   18:    the file, and distribution when not linked into a combined
   19:    executable.)
   20: 
   21:    This program is distributed in the hope that it will be useful,
   22:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   23:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   24:    GNU General Public License for more details.
   25: 
   26:    You should have received a copy of the GNU General Public License
   27:    along with this program; if not, write to the Free Software
   28:    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. 
   29: */
   30: 
   31: /* This file provides some definitions shared by cp-demangle.c and
   32:    cp-demint.c.  It should not be included by any other files.  */
   33: 
   34: /* Information we keep for operators.  */
   35: 
   36: struct demangle_operator_info
   37: {
   38:   /* Mangled name.  */
   39:   const char *code;
   40:   /* Real name.  */
   41:   const char *name;
   42:   /* Length of real name.  */
   43:   int len;
   44:   /* Number of arguments.  */
   45:   int args;
   46: };
   47: 
   48: /* How to print the value of a builtin type.  */
   49: 
   50: enum d_builtin_type_print
   51: {
   52:   /* Print as (type)val.  */
   53:   D_PRINT_DEFAULT,
   54:   /* Print as integer.  */
   55:   D_PRINT_INT,
   56:   /* Print as unsigned integer, with trailing "u".  */
   57:   D_PRINT_UNSIGNED,
   58:   /* Print as long, with trailing "l".  */
   59:   D_PRINT_LONG,
   60:   /* Print as unsigned long, with trailing "ul".  */
   61:   D_PRINT_UNSIGNED_LONG,
   62:   /* Print as long long, with trailing "ll".  */
   63:   D_PRINT_LONG_LONG,
   64:   /* Print as unsigned long long, with trailing "ull".  */
   65:   D_PRINT_UNSIGNED_LONG_LONG,
   66:   /* Print as bool.  */
   67:   D_PRINT_BOOL,
   68:   /* Print as float--put value in square brackets.  */
   69:   D_PRINT_FLOAT,
   70:   /* Print in usual way, but here to detect void.  */
   71:   D_PRINT_VOID
   72: };
   73: 
   74: /* Information we keep for a builtin type.  */
   75: 
   76: struct demangle_builtin_type_info
   77: {
   78:   /* Type name.  */
   79:   const char *name;
   80:   /* Length of type name.  */
   81:   int len;
   82:   /* Type name when using Java.  */
   83:   const char *java_name;
   84:   /* Length of java name.  */
   85:   int java_len;
   86:   /* How to print a value of this type.  */
   87:   enum d_builtin_type_print print;
   88: };
   89: 
   90: /* The information structure we pass around.  */
   91: 
   92: struct d_info
   93: {
   94:   /* The string we are demangling.  */
   95:   const char *s;
   96:   /* The end of the string we are demangling.  */
   97:   const char *send;
   98:   /* The options passed to the demangler.  */
   99:   int options;
  100:   /* The next character in the string to consider.  */
  101:   const char *n;
  102:   /* The array of components.  */
  103:   struct demangle_component *comps;
  104:   /* The index of the next available component.  */
  105:   int next_comp;
  106:   /* The number of available component structures.  */
  107:   int num_comps;
  108:   /* The array of substitutions.  */
  109:   struct demangle_component **subs;
  110:   /* The index of the next substitution.  */
  111:   int next_sub;
  112:   /* The number of available entries in the subs array.  */
  113:   int num_subs;
  114:   /* The number of substitutions which we actually made from the subs
  115:      array, plus the number of template parameter references we
  116:      saw.  */
  117:   int did_subs;
  118:   /* The last name we saw, for constructors and destructors.  */
  119:   struct demangle_component *last_name;
  120:   /* A running total of the length of large expansions from the
  121:      mangled name to the demangled name, such as standard
  122:      substitutions and builtin types.  */
  123:   int expansion;
  124: };
  125: 
  126: /* To avoid running past the ending '\0', don't:
  127:    - call d_peek_next_char if d_peek_char returned '\0'
  128:    - call d_advance with an 'i' that is too large
  129:    - call d_check_char(di, '\0')
  130:    Everything else is safe.  */
  131: #define d_peek_char(di) (*((di)->n))
  132: #define d_peek_next_char(di) ((di)->n[1])
  133: #define d_advance(di, i) ((di)->n += (i))
  134: #define d_check_char(di, c) (d_peek_char(di) == c ? ((di)->n++, 1) : 0)
  135: #define d_next_char(di) (d_peek_char(di) == '\0' ? '\0' : *((di)->n++))
  136: #define d_str(di) ((di)->n)
  137: 
  138: /* Functions and arrays in cp-demangle.c which are referenced by
  139:    functions in cp-demint.c.  */
  140: #ifdef IN_GLIBCPP_V3
  141: #define CP_STATIC_IF_GLIBCPP_V3 static
  142: #else
  143: #define CP_STATIC_IF_GLIBCPP_V3 extern
  144: #endif
  145: 
  146: #ifndef IN_GLIBCPP_V3
  147: extern const struct demangle_operator_info cplus_demangle_operators[];
  148: #endif
  149: 
  150: #define D_BUILTIN_TYPE_COUNT (26)
  151: 
  152: CP_STATIC_IF_GLIBCPP_V3
  153: const struct demangle_builtin_type_info
  154: cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT];
  155: 
  156: CP_STATIC_IF_GLIBCPP_V3
  157: struct demangle_component *
  158: cplus_demangle_mangled_name (struct d_info *, int);
  159: 
  160: CP_STATIC_IF_GLIBCPP_V3
  161: struct demangle_component *
  162: cplus_demangle_type (struct d_info *);
  163: 
  164: extern void
  165: cplus_demangle_init_info (const char *, int, size_t, struct d_info *);
  166: 
  167: /* cp-demangle.c needs to define this a little differently */
  168: #undef CP_STATIC_IF_GLIBCPP_V3