Mercurial > hg > CbC > CbC_gcc
annotate libiberty/cp-demangle.h @ 131:84e7813d76e9
gcc-8.2
| author | mir3636 |
|---|---|
| date | Thu, 25 Oct 2018 07:37:49 +0900 |
| parents | 04ced10e8804 |
| children | 1830386684a0 |
| rev | line source |
|---|---|
| 0 | 1 /* Internal demangler interface for g++ V3 ABI. |
| 131 | 2 Copyright (C) 2003-2018 Free Software Foundation, Inc. |
| 0 | 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 last name we saw, for constructors and destructors. */ | |
| 115 struct demangle_component *last_name; | |
| 116 /* A running total of the length of large expansions from the | |
| 117 mangled name to the demangled name, such as standard | |
| 118 substitutions and builtin types. */ | |
| 119 int expansion; | |
| 111 | 120 /* Non-zero if we are parsing an expression. */ |
| 121 int is_expression; | |
| 122 /* Non-zero if we are parsing the type operand of a conversion | |
| 123 operator, but not when in an expression. */ | |
| 124 int is_conversion; | |
| 0 | 125 }; |
| 126 | |
| 127 /* To avoid running past the ending '\0', don't: | |
| 128 - call d_peek_next_char if d_peek_char returned '\0' | |
| 129 - call d_advance with an 'i' that is too large | |
| 130 - call d_check_char(di, '\0') | |
| 131 Everything else is safe. */ | |
| 132 #define d_peek_char(di) (*((di)->n)) | |
| 111 | 133 #ifndef CHECK_DEMANGLER |
| 134 # define d_peek_next_char(di) ((di)->n[1]) | |
| 135 # define d_advance(di, i) ((di)->n += (i)) | |
| 136 #endif | |
| 0 | 137 #define d_check_char(di, c) (d_peek_char(di) == c ? ((di)->n++, 1) : 0) |
| 138 #define d_next_char(di) (d_peek_char(di) == '\0' ? '\0' : *((di)->n++)) | |
| 139 #define d_str(di) ((di)->n) | |
| 140 | |
| 111 | 141 #ifdef CHECK_DEMANGLER |
| 142 static inline char | |
| 143 d_peek_next_char (const struct d_info *di) | |
| 144 { | |
| 145 if (!di->n[0]) | |
| 146 abort (); | |
| 147 return di->n[1]; | |
| 148 } | |
| 149 | |
| 150 static inline void | |
| 151 d_advance (struct d_info *di, int i) | |
| 152 { | |
| 153 if (i < 0) | |
| 154 abort (); | |
| 155 while (i--) | |
| 156 { | |
| 157 if (!di->n[0]) | |
| 158 abort (); | |
| 159 di->n++; | |
| 160 } | |
| 161 } | |
| 162 #endif | |
| 163 | |
| 0 | 164 /* Functions and arrays in cp-demangle.c which are referenced by |
| 165 functions in cp-demint.c. */ | |
| 166 #ifdef IN_GLIBCPP_V3 | |
| 167 #define CP_STATIC_IF_GLIBCPP_V3 static | |
| 168 #else | |
| 169 #define CP_STATIC_IF_GLIBCPP_V3 extern | |
| 170 #endif | |
| 171 | |
| 172 #ifndef IN_GLIBCPP_V3 | |
| 173 extern const struct demangle_operator_info cplus_demangle_operators[]; | |
| 174 #endif | |
| 175 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
176 #define D_BUILTIN_TYPE_COUNT (33) |
| 0 | 177 |
| 178 CP_STATIC_IF_GLIBCPP_V3 | |
| 179 const struct demangle_builtin_type_info | |
| 180 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT]; | |
| 181 | |
| 182 CP_STATIC_IF_GLIBCPP_V3 | |
| 183 struct demangle_component * | |
| 184 cplus_demangle_mangled_name (struct d_info *, int); | |
| 185 | |
| 186 CP_STATIC_IF_GLIBCPP_V3 | |
| 187 struct demangle_component * | |
| 188 cplus_demangle_type (struct d_info *); | |
| 189 | |
| 190 extern void | |
| 191 cplus_demangle_init_info (const char *, int, size_t, struct d_info *); | |
| 192 | |
| 193 /* cp-demangle.c needs to define this a little differently */ | |
| 194 #undef CP_STATIC_IF_GLIBCPP_V3 |