diff options
Diffstat (limited to 'gdb/cp-name-parser.y')
-rw-r--r-- | gdb/cp-name-parser.y | 2132 |
1 files changed, 2132 insertions, 0 deletions
diff --git a/gdb/cp-name-parser.y b/gdb/cp-name-parser.y new file mode 100644 index 0000000..889ef91 --- /dev/null +++ b/gdb/cp-name-parser.y @@ -0,0 +1,2132 @@ +/* YACC parser for C++ names, for GDB. + + Copyright 2003, 2004, 2005 + Free Software Foundation, Inc. + + Parts of the lexer are based on c-exp.y from GDB. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* Note that malloc's and realloc's in this file are transformed to + xmalloc and xrealloc respectively by the same sed command in the + makefile that remaps any other malloc/realloc inserted by the parser + generator. Doing this with #defines and trying to control the interaction + with include files (<malloc.h> and <stdlib.h> for example) just became + too messy, particularly when such includes can be inserted at random + times by the parser generator. */ + +%{ + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> + +#include "safe-ctype.h" +#include "libiberty.h" +#include "demangle.h" + +/* Bison does not make it easy to create a parser without global + state, unfortunately. Here are all the global variables used + in this parser. */ + +/* LEXPTR is the current pointer into our lex buffer. PREV_LEXPTR + is the start of the last token lexed, only used for diagnostics. + ERROR_LEXPTR is the first place an error occurred. GLOBAL_ERRMSG + is the first error message encountered. */ + +static const char *lexptr, *prev_lexptr, *error_lexptr, *global_errmsg; + +/* The components built by the parser are allocated ahead of time, + and cached in this structure. */ + +struct demangle_info { + int used; + struct demangle_component comps[1]; +}; + +static struct demangle_info *demangle_info; +#define d_grab() (&demangle_info->comps[demangle_info->used++]) + +/* The parse tree created by the parser is stored here after a successful + parse. */ + +static struct demangle_component *global_result; + +/* Prototypes for helper functions used when constructing the parse + tree. */ + +static struct demangle_component *d_qualify (struct demangle_component *, int, + int); + +static struct demangle_component *d_int_type (int); + +static struct demangle_component *d_unary (const char *, + struct demangle_component *); +static struct demangle_component *d_binary (const char *, + struct demangle_component *, + struct demangle_component *); + +/* Flags passed to d_qualify. */ + +#define QUAL_CONST 1 +#define QUAL_RESTRICT 2 +#define QUAL_VOLATILE 4 + +/* Flags passed to d_int_type. */ + +#define INT_CHAR (1 << 0) +#define INT_SHORT (1 << 1) +#define INT_LONG (1 << 2) +#define INT_LLONG (1 << 3) + +#define INT_SIGNED (1 << 4) +#define INT_UNSIGNED (1 << 5) + +/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), + as well as gratuitiously global symbol names, so we can have multiple + yacc generated parsers in gdb. Note that these are only the variables + produced by yacc. If other parser generators (bison, byacc, etc) produce + additional global names that conflict at link time, then those parser + generators need to be fixed instead of adding those names to this list. */ + +#define yymaxdepth cpname_maxdepth +#define yyparse cpname_parse +#define yylex cpname_lex +#define yyerror cpname_error +#define yylval cpname_lval +#define yychar cpname_char +#define yydebug cpname_debug +#define yypact cpname_pact +#define yyr1 cpname_r1 +#define yyr2 cpname_r2 +#define yydef cpname_def +#define yychk cpname_chk +#define yypgo cpname_pgo +#define yyact cpname_act +#define yyexca cpname_exca +#define yyerrflag cpname_errflag +#define yynerrs cpname_nerrs +#define yyps cpname_ps +#define yypv cpname_pv +#define yys cpname_s +#define yy_yys cpname_yys +#define yystate cpname_state +#define yytmp cpname_tmp +#define yyv cpname_v +#define yy_yyv cpname_yyv +#define yyval cpname_val +#define yylloc cpname_lloc +#define yyreds cpname_reds /* With YYDEBUG defined */ +#define yytoks cpname_toks /* With YYDEBUG defined */ +#define yyname cpname_name /* With YYDEBUG defined */ +#define yyrule cpname_rule /* With YYDEBUG defined */ +#define yylhs cpname_yylhs +#define yylen cpname_yylen +#define yydefred cpname_yydefred +#define yydgoto cpname_yydgoto +#define yysindex cpname_yysindex +#define yyrindex cpname_yyrindex +#define yygindex cpname_yygindex +#define yytable cpname_yytable +#define yycheck cpname_yycheck + +int yyparse (void); +static int yylex (void); +static void yyerror (char *); + +/* Enable yydebug for the stand-alone parser. */ +#ifdef TEST_CPNAMES +# define YYDEBUG 1 +#endif + +/* Helper functions. These wrap the demangler tree interface, handle + allocation from our global store, and return the allocated component. */ + +static struct demangle_component * +fill_comp (enum demangle_component_type d_type, struct demangle_component *lhs, + struct demangle_component *rhs) +{ + struct demangle_component *ret = d_grab (); + cplus_demangle_fill_component (ret, d_type, lhs, rhs); + return ret; +} + +static struct demangle_component * +make_empty (enum demangle_component_type d_type) +{ + struct demangle_component *ret = d_grab (); + ret->type = d_type; + return ret; +} + +static struct demangle_component * +make_operator (const char *name, int args) +{ + struct demangle_component *ret = d_grab (); + cplus_demangle_fill_operator (ret, name, args); + return ret; +} + +static struct demangle_component * +make_dtor (enum gnu_v3_dtor_kinds kind, struct demangle_component *name) +{ + struct demangle_component *ret = d_grab (); + cplus_demangle_fill_dtor (ret, kind, name); + return ret; +} + +static struct demangle_component * +make_builtin_type (const char *name) +{ + struct demangle_component *ret = d_grab (); + cplus_demangle_fill_builtin_type (ret, name); + return ret; +} + +static struct demangle_component * +make_name (const char *name, int len) +{ + struct demangle_component *ret = d_grab (); + cplus_demangle_fill_name (ret, name, len); + return ret; +} + +#define d_left(dc) (dc)->u.s_binary.left +#define d_right(dc) (dc)->u.s_binary.right + +%} + +%union + { + struct demangle_component *comp; + struct nested { + struct demangle_component *comp; + struct demangle_component **last; + } nested; + struct { + struct demangle_component *comp, *last; + } nested1; + struct { + struct demangle_component *comp, **last; + struct nested fn; + struct demangle_component *start; + int fold_flag; + } abstract; + int lval; + struct { + int val; + struct demangle_component *type; + } typed_val_int; + const char *opname; + } + +%type <comp> exp exp1 type start start_opt operator colon_name +%type <comp> unqualified_name colon_ext_name +%type <comp> template template_arg +%type <comp> builtin_type +%type <comp> typespec_2 array_indicator +%type <comp> colon_ext_only ext_only_name + +%type <comp> demangler_special function conversion_op +%type <nested> conversion_op_name + +%type <abstract> abstract_declarator direct_abstract_declarator +%type <abstract> abstract_declarator_fn +%type <nested> declarator direct_declarator function_arglist + +%type <nested> declarator_1 direct_declarator_1 + +%type <nested> template_params function_args +%type <nested> ptr_operator + +%type <nested1> nested_name + +%type <lval> qualifier qualifiers qualifiers_opt + +%type <lval> int_part int_seq + +%token <comp> INT +%token <comp> FLOAT + +%token <comp> NAME +%type <comp> name + +%token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON +%token TEMPLATE +%token ERROR +%token NEW DELETE OPERATOR +%token STATIC_CAST REINTERPRET_CAST DYNAMIC_CAST + +/* Special type cases, put in to allow the parser to distinguish different + legal basetypes. */ +%token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD BOOL +%token ELLIPSIS RESTRICT VOID FLOAT_KEYWORD CHAR WCHAR_T + +%token <opname> ASSIGN_MODIFY + +/* C++ */ +%token TRUEKEYWORD +%token FALSEKEYWORD + +/* Non-C++ things we get from the demangler. */ +%token <lval> DEMANGLER_SPECIAL +%token CONSTRUCTION_VTABLE CONSTRUCTION_IN +%token <typed_val_int> GLOBAL + +%{ +enum { + GLOBAL_CONSTRUCTORS = DEMANGLE_COMPONENT_LITERAL + 20, + GLOBAL_DESTRUCTORS = DEMANGLE_COMPONENT_LITERAL + 21 +}; +%} + +/* Precedence declarations. */ + +/* Give NAME lower precedence than COLONCOLON, so that nested_name will + associate greedily. */ +%nonassoc NAME + +/* Give NEW and DELETE lower precedence than ']', because we can not + have an array of type operator new. This causes NEW '[' to be + parsed as operator new[]. */ +%nonassoc NEW DELETE + +/* Give VOID higher precedence than NAME. Then we can use %prec NAME + to prefer (VOID) to (function_args). */ +%nonassoc VOID + +/* Give VOID lower precedence than ')' for similar reasons. */ +%nonassoc ')' + +%left ',' +%right '=' ASSIGN_MODIFY +%right '?' +%left OROR +%left ANDAND +%left '|' +%left '^' +%left '&' +%left EQUAL NOTEQUAL +%left '<' '>' LEQ GEQ +%left LSH RSH +%left '@' +%left '+' '-' +%left '*' '/' '%' +%right UNARY INCREMENT DECREMENT + +/* We don't need a precedence for '(' in this reduced grammar, and it + can mask some unpleasant bugs, so disable it for now. */ + +%right ARROW '.' '[' /* '(' */ +%left COLONCOLON + + +%% + +result : start + { global_result = $1; } + ; + +start : type + + | demangler_special + + | function + + ; + +start_opt : /* */ + { $$ = NULL; } + | COLONCOLON start + { $$ = $2; } + ; + +function + /* Function with a return type. declarator_1 is used to prevent + ambiguity with the next rule. */ + : typespec_2 declarator_1 + { $$ = $2.comp; + *$2.last = $1; + } + + /* Function without a return type. We need to use typespec_2 + to prevent conflicts from qualifiers_opt - harmless. The + start_opt is used to handle "function-local" variables and + types. */ + | typespec_2 function_arglist start_opt + { $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp); + if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); } + | colon_ext_only function_arglist start_opt + { $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp); + if ($3) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); } + + | conversion_op_name start_opt + { $$ = $1.comp; + if ($2) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2); } + | conversion_op_name abstract_declarator_fn + { if ($2.last) + { + /* First complete the abstract_declarator's type using + the typespec from the conversion_op_name. */ + *$2.last = *$1.last; + /* Then complete the conversion_op_name with the type. */ + *$1.last = $2.comp; + } + /* If we have an arglist, build a function type. */ + if ($2.fn.comp) + $$ = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1.comp, $2.fn.comp); + else + $$ = $1.comp; + if ($2.start) $$ = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2.start); + } + ; + +demangler_special + : DEMANGLER_SPECIAL start + { $$ = make_empty ($1); + d_left ($$) = $2; + d_right ($$) = NULL; } + | CONSTRUCTION_VTABLE start CONSTRUCTION_IN start + { $$ = fill_comp (DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, $2, $4); } + | GLOBAL + { $$ = make_empty ($1.val); + d_left ($$) = $1.type; + d_right ($$) = NULL; } + ; + +operator : OPERATOR NEW + { $$ = make_operator ("new", 1); } + | OPERATOR DELETE + { $$ = make_operator ("delete", 1); } + | OPERATOR NEW '[' ']' + { $$ = make_operator ("new[]", 1); } + | OPERATOR DELETE '[' ']' + { $$ = make_operator ("delete[]", 1); } + | OPERATOR '+' + { $$ = make_operator ("+", 2); } + | OPERATOR '-' + { $$ = make_operator ("-", 2); } + | OPERATOR '*' + { $$ = make_operator ("*", 2); } + | OPERATOR '/' + { $$ = make_operator ("/", 2); } + | OPERATOR '%' + { $$ = make_operator ("%", 2); } + | OPERATOR '^' + { $$ = make_operator ("^", 2); } + | OPERATOR '&' + { $$ = make_operator ("&", 2); } + | OPERATOR '|' + { $$ = make_operator ("|", 2); } + | OPERATOR '~' + { $$ = make_operator ("~", 1); } + | OPERATOR '!' + { $$ = make_operator ("!", 1); } + | OPERATOR '=' + { $$ = make_operator ("=", 2); } + | OPERATOR '<' + { $$ = make_operator ("<", 2); } + | OPERATOR '>' + { $$ = make_operator (">", 2); } + | OPERATOR ASSIGN_MODIFY + { $$ = make_operator ($2, 2); } + | OPERATOR LSH + { $$ = make_operator ("<<", 2); } + | OPERATOR RSH + { $$ = make_operator (">>", 2); } + | OPERATOR EQUAL + { $$ = make_operator ("==", 2); } + | OPERATOR NOTEQUAL + { $$ = make_operator ("!=", 2); } + | OPERATOR LEQ + { $$ = make_operator ("<=", 2); } + | OPERATOR GEQ + { $$ = make_operator (">=", 2); } + | OPERATOR ANDAND + { $$ = make_operator ("&&", 2); } + | OPERATOR OROR + { $$ = make_operator ("||", 2); } + | OPERATOR INCREMENT + { $$ = make_operator ("++", 1); } + | OPERATOR DECREMENT + { $$ = make_operator ("--", 1); } + | OPERATOR ',' + { $$ = make_operator (",", 2); } + | OPERATOR ARROW '*' + { $$ = make_operator ("->*", 2); } + | OPERATOR ARROW + { $$ = make_operator ("->", 2); } + | OPERATOR '(' ')' + { $$ = make_operator ("()", 0); } + | OPERATOR '[' ']' + { $$ = make_operator ("[]", 2); } + ; + + /* Conversion operators. We don't try to handle some of + the wackier demangler output for function pointers, + since it's not clear that it's parseable. */ +conversion_op + : OPERATOR typespec_2 + { $$ = fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL); } + ; + +conversion_op_name + : nested_name conversion_op + { $$.comp = $1.comp; + d_right ($1.last) = $2; + $$.last = &d_left ($2); + } + | conversion_op + { $$.comp = $1; + $$.last = &d_left ($1); + } + | COLONCOLON nested_name conversion_op + { $$.comp = $2.comp; + d_right ($2.last) = $3; + $$.last = &d_left ($3); + } + | COLONCOLON conversion_op + { $$.comp = $2; + $$.last = &d_left ($2); + } + ; + +/* DEMANGLE_COMPONENT_NAME */ +/* This accepts certain invalid placements of '~'. */ +unqualified_name: operator + | operator '<' template_params '>' + { $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); } + | '~' NAME + { $$ = make_dtor (gnu_v3_complete_object_dtor, $2); } + ; + +/* This rule is used in name and nested_name, and expanded inline there + for efficiency. */ +/* +scope_id : NAME + | template + ; +*/ + +colon_name : name + | COLONCOLON name + { $$ = $2; } + ; + +/* DEMANGLE_COMPONENT_QUAL_NAME */ +/* DEMANGLE_COMPONENT_CTOR / DEMANGLE_COMPONENT_DTOR ? */ +name : nested_name NAME %prec NAME + { $$ = $1.comp; d_right ($1.last) = $2; } + | NAME %prec NAME + | nested_name template %prec NAME + { $$ = $1.comp; d_right ($1.last) = $2; } + | template %prec NAME + ; + +colon_ext_name : colon_name + | colon_ext_only + ; + +colon_ext_only : ext_only_name + | COLONCOLON ext_only_name + { $$ = $2; } + ; + +ext_only_name : nested_name unqualified_name + { $$ = $1.comp; d_right ($1.last) = $2; } + | unqualified_name + ; + +nested_name : NAME COLONCOLON + { $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME); + d_left ($$.comp) = $1; + d_right ($$.comp) = NULL; + $$.last = $$.comp; + } + | nested_name NAME COLONCOLON + { $$.comp = $1.comp; + d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME); + $$.last = d_right ($1.last); + d_left ($$.last) = $2; + d_right ($$.last) = NULL; + } + | template COLONCOLON + { $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME); + d_left ($$.comp) = $1; + d_right ($$.comp) = NULL; + $$.last = $$.comp; + } + | nested_name template COLONCOLON + { $$.comp = $1.comp; + d_right ($1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME); + $$.last = d_right ($1.last); + d_left ($$.last) = $2; + d_right ($$.last) = NULL; + } + ; + +/* DEMANGLE_COMPONENT_TEMPLATE */ +/* DEMANGLE_COMPONENT_TEMPLATE_ARGLIST */ +template : NAME '<' template_params '>' + { $$ = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); } + ; + +template_params : template_arg + { $$.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $1, NULL); + $$.last = &d_right ($$.comp); } + | template_params ',' template_arg + { $$.comp = $1.comp; + *$1.last = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $3, NULL); + $$.last = &d_right (*$1.last); + } + ; + +/* "type" is inlined into template_arg and function_args. */ + +/* Also an integral constant-expression of integral type, and a + pointer to member (?) */ +template_arg : typespec_2 + | typespec_2 abstract_declarator + { $$ = $2.comp; + *$2.last = $1; + } + | '&' start + { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); } + | '&' '(' start ')' + { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $3); } + | exp + ; + +function_args : typespec_2 + { $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $1, NULL); + $$.last = &d_right ($$.comp); + } + | typespec_2 abstract_declarator + { *$2.last = $1; + $$.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $2.comp, NULL); + $$.last = &d_right ($$.comp); + } + | function_args ',' typespec_2 + { *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $3, NULL); + $$.comp = $1.comp; + $$.last = &d_right (*$1.last); + } + | function_args ',' typespec_2 abstract_declarator + { *$4.last = $3; + *$1.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, $4.comp, NULL); + $$.comp = $1.comp; + $$.last = &d_right (*$1.last); + } + | function_args ',' ELLIPSIS + { *$1.last + = fill_comp (DEMANGLE_COMPONENT_ARGLIST, + make_builtin_type ("..."), + NULL); + $$.comp = $1.comp; + $$.last = &d_right (*$1.last); + } + ; + +function_arglist: '(' function_args ')' qualifiers_opt %prec NAME + { $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, $2.comp); + $$.last = &d_left ($$.comp); + $$.comp = d_qualify ($$.comp, $4, 1); } + | '(' VOID ')' qualifiers_opt + { $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL); + $$.last = &d_left ($$.comp); + $$.comp = d_qualify ($$.comp, $4, 1); } + | '(' ')' qualifiers_opt + { $$.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL); + $$.last = &d_left ($$.comp); + $$.comp = d_qualify ($$.comp, $3, 1); } + ; + +/* Should do something about DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL */ +qualifiers_opt : /* epsilon */ + { $$ = 0; } + | qualifiers + ; + +qualifier : RESTRICT + { $$ = QUAL_RESTRICT; } + | VOLATILE_KEYWORD + { $$ = QUAL_VOLATILE; } + | CONST_KEYWORD + { $$ = QUAL_CONST; } + ; + +qualifiers : qualifier + | qualifier qualifiers + { $$ = $1 | $2; } + ; + +/* This accepts all sorts of invalid constructions and produces + invalid output for them - an error would be better. */ + +int_part : INT_KEYWORD + { $$ = 0; } + | SIGNED_KEYWORD + { $$ = INT_SIGNED; } + | UNSIGNED + { $$ = INT_UNSIGNED; } + | CHAR + { $$ = INT_CHAR; } + | LONG + { $$ = INT_LONG; } + | SHORT + { $$ = INT_SHORT; } + ; + +int_seq : int_part + | int_seq int_part + { $$ = $1 | $2; if ($1 & $2 & INT_LONG) $$ = $1 | INT_LLONG; } + ; + +builtin_type : int_seq + { $$ = d_int_type ($1); } + | FLOAT_KEYWORD + { $$ = make_builtin_type ("float"); } + | DOUBLE_KEYWORD + { $$ = make_builtin_type ("double"); } + | LONG DOUBLE_KEYWORD + { $$ = make_builtin_type ("long double"); } + | BOOL + { $$ = make_builtin_type ("bool"); } + | WCHAR_T + { $$ = make_builtin_type ("wchar_t"); } + | VOID + { $$ = make_builtin_type ("void"); } + ; + +ptr_operator : '*' qualifiers_opt + { $$.comp = make_empty (DEMANGLE_COMPONENT_POINTER); + $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL; + $$.last = &d_left ($$.comp); + $$.comp = d_qualify ($$.comp, $2, 0); } + /* g++ seems to allow qualifiers after the reference? */ + | '&' + { $$.comp = make_empty (DEMANGLE_COMPONENT_REFERENCE); + $$.comp->u.s_binary.left = $$.comp->u.s_binary.right = NULL; + $$.last = &d_left ($$.comp); } + | nested_name '*' qualifiers_opt + { $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE); + $$.comp->u.s_binary.left = $1.comp; + /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */ + *$1.last = *d_left ($1.last); + $$.comp->u.s_binary.right = NULL; + $$.last = &d_right ($$.comp); + $$.comp = d_qualify ($$.comp, $3, 0); } + | COLONCOLON nested_name '*' qualifiers_opt + { $$.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE); + $$.comp->u.s_binary.left = $2.comp; + /* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */ + *$2.last = *d_left ($2.last); + $$.comp->u.s_binary.right = NULL; + $$.last = &d_right ($$.comp); + $$.comp = d_qualify ($$.comp, $4, 0); } + ; + +array_indicator : '[' ']' + { $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE); + d_left ($$) = NULL; + } + | '[' INT ']' + { $$ = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE); + d_left ($$) = $2; + } + ; + +/* Details of this approach inspired by the G++ < 3.4 parser. */ + +/* This rule is only used in typespec_2, and expanded inline there for + efficiency. */ +/* +typespec : builtin_type + | colon_name + ; +*/ + +typespec_2 : builtin_type qualifiers + { $$ = d_qualify ($1, $2, 0); } + | builtin_type + | qualifiers builtin_type qualifiers + { $$ = d_qualify ($2, $1 | $3, 0); } + | qualifiers builtin_type + { $$ = d_qualify ($2, $1, 0); } + + | name qualifiers + { $$ = d_qualify ($1, $2, 0); } + | name + | qualifiers name qualifiers + { $$ = d_qualify ($2, $1 | $3, 0); } + | qualifiers name + { $$ = d_qualify ($2, $1, 0); } + + | COLONCOLON name qualifiers + { $$ = d_qualify ($2, $3, 0); } + | COLONCOLON name + { $$ = $2; } + | qualifiers COLONCOLON name qualifiers + { $$ = d_qualify ($3, $1 | $4, 0); } + | qualifiers COLONCOLON name + { $$ = d_qualify ($3, $1, 0); } + ; + +abstract_declarator + : ptr_operator + { $$.comp = $1.comp; $$.last = $1.last; + $$.fn.comp = NULL; $$.fn.last = NULL; } + | ptr_operator abstract_declarator + { $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL; + if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; } + *$$.last = $1.comp; + $$.last = $1.last; } + | direct_abstract_declarator + { $$.fn.comp = NULL; $$.fn.last = NULL; + if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; } + } + ; + +direct_abstract_declarator + : '(' abstract_declarator ')' + { $$ = $2; $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 1; + if ($2.fn.comp) { $$.last = $2.fn.last; *$2.last = $2.fn.comp; } + } + | direct_abstract_declarator function_arglist + { $$.fold_flag = 0; + if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; } + if ($1.fold_flag) + { + *$$.last = $2.comp; + $$.last = $2.last; + } + else + $$.fn = $2; + } + | direct_abstract_declarator array_indicator + { $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0; + if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; } + *$1.last = $2; + $$.last = &d_right ($2); + } + | array_indicator + { $$.fn.comp = NULL; $$.fn.last = NULL; $$.fold_flag = 0; + $$.comp = $1; + $$.last = &d_right ($1); + } + /* G++ has the following except for () and (type). Then + (type) is handled in regcast_or_absdcl and () is handled + in fcast_or_absdcl. + + However, this is only useful for function types, and + generates reduce/reduce conflicts with direct_declarator. + We're interested in pointer-to-function types, and in + functions, but not in function types - so leave this + out. */ + /* | function_arglist */ + ; + +abstract_declarator_fn + : ptr_operator + { $$.comp = $1.comp; $$.last = $1.last; + $$.fn.comp = NULL; $$.fn.last = NULL; $$.start = NULL; } + | ptr_operator abstract_declarator_fn + { $$ = $2; + if ($2.last) + *$$.last = $1.comp; + else + $$.comp = $1.comp; + $$.last = $1.last; + } + | direct_abstract_declarator + { $$.comp = $1.comp; $$.last = $1.last; $$.fn = $1.fn; $$.start = NULL; } + | direct_abstract_declarator function_arglist COLONCOLON start + { $$.start = $4; + if ($1.fn.comp) { $$.last = $1.fn.last; *$1.last = $1.fn.comp; } + if ($1.fold_flag) + { + *$$.last = $2.comp; + $$.last = $2.last; + } + else + $$.fn = $2; + } + | function_arglist start_opt + { $$.fn = $1; + $$.start = $2; + $$.comp = NULL; $$.last = NULL; + } + ; + +type : typespec_2 + | typespec_2 abstract_declarator + { $$ = $2.comp; + *$2.last = $1; + } + ; + +declarator : ptr_operator declarator + { $$.comp = $2.comp; + $$.last = $1.last; + *$2.last = $1.comp; } + | direct_declarator + ; + +direct_declarator + : '(' declarator ')' + { $$ = $2; } + | direct_declarator function_arglist + { $$.comp = $1.comp; + *$1.last = $2.comp; + $$.last = $2.last; + } + | direct_declarator array_indicator + { $$.comp = $1.comp; + *$1.last = $2; + $$.last = &d_right ($2); + } + | colon_ext_name + { $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME); + d_left ($$.comp) = $1; + $$.last = &d_right ($$.comp); + } + ; + +/* These are similar to declarator and direct_declarator except that they + do not permit ( colon_ext_name ), which is ambiguous with a function + argument list. They also don't permit a few other forms with redundant + parentheses around the colon_ext_name; any colon_ext_name in parentheses + must be followed by an argument list or an array indicator, or preceded + by a pointer. */ +declarator_1 : ptr_operator declarator_1 + { $$.comp = $2.comp; + $$.last = $1.last; + *$2.last = $1.comp; } + | colon_ext_name + { $$.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME); + d_left ($$.comp) = $1; + $$.last = &d_right ($$.comp); + } + | direct_declarator_1 + + /* Function local variable or type. The typespec to + our left is the type of the containing function. + This should be OK, because function local types + can not be templates, so the return types of their + members will not be mangled. If they are hopefully + they'll end up to the right of the ::. */ + | colon_ext_name function_arglist COLONCOLON start + { $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp); + $$.last = $2.last; + $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4); + } + | direct_declarator_1 function_arglist COLONCOLON start + { $$.comp = $1.comp; + *$1.last = $2.comp; + $$.last = $2.last; + $$.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4); + } + ; + +direct_declarator_1 + : '(' ptr_operator declarator ')' + { $$.comp = $3.comp; + $$.last = $2.last; + *$3.last = $2.comp; } + | direct_declarator_1 function_arglist + { $$.comp = $1.comp; + *$1.last = $2.comp; + $$.last = $2.last; + } + | direct_declarator_1 array_indicator + { $$.comp = $1.comp; + *$1.last = $2; + $$.last = &d_right ($2); + } + | colon_ext_name function_arglist + { $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp); + $$.last = $2.last; + } + | colon_ext_name array_indicator + { $$.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2); + $$.last = &d_right ($2); + } + ; + +exp : '(' exp1 ')' + { $$ = $2; } + ; + +/* Silly trick. Only allow '>' when parenthesized, in order to + handle conflict with templates. */ +exp1 : exp + ; + +exp1 : exp '>' exp + { $$ = d_binary (">", $1, $3); } + ; + +/* References. Not allowed everywhere in template parameters, only + at the top level, but treat them as expressions in case they are wrapped + in parentheses. */ +exp1 : '&' start + { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $2); } + ; + +/* Expressions, not including the comma operator. */ +exp : '-' exp %prec UNARY + { $$ = d_unary ("-", $2); } + ; + +exp : '!' exp %prec UNARY + { $$ = d_unary ("!", $2); } + ; + +exp : '~' exp %prec UNARY + { $$ = d_unary ("~", $2); } + ; + +/* Casts. First your normal C-style cast. If exp is a LITERAL, just change + its type. */ + +exp : '(' type ')' exp %prec UNARY + { if ($4->type == DEMANGLE_COMPONENT_LITERAL + || $4->type == DEMANGLE_COMPONENT_LITERAL_NEG) + { + $$ = $4; + d_left ($4) = $2; + } + else + $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, + fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL), + $4); + } + ; + +/* Mangling does not differentiate between these, so we don't need to + either. */ +exp : STATIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY + { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, + fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL), + $6); + } + ; + +exp : DYNAMIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY + { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, + fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL), + $6); + } + ; + +exp : REINTERPRET_CAST '<' type '>' '(' exp1 ')' %prec UNARY + { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, + fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL), + $6); + } + ; + +/* Another form of C++-style cast. "type ( exp1 )" is not allowed (it's too + ambiguous), but "name ( exp1 )" is. Because we don't need to support + function types, we can handle this unambiguously (the use of typespec_2 + prevents a silly, harmless conflict with qualifiers_opt). This does not + appear in demangler output so it's not a great loss if we need to + disable it. */ +exp : typespec_2 '(' exp1 ')' %prec UNARY + { $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, + fill_comp (DEMANGLE_COMPONENT_CAST, $1, NULL), + $3); + } + ; + +/* TO INVESTIGATE: ._0 style anonymous names; anonymous namespaces */ + +/* Binary operators in order of decreasing precedence. */ + +exp : exp '*' exp + { $$ = d_binary ("*", $1, $3); } + ; + +exp : exp '/' exp + { $$ = d_binary ("/", $1, $3); } + ; + +exp : exp '%' exp + { $$ = d_binary ("%", $1, $3); } + ; + +exp : exp '+' exp + { $$ = d_binary ("+", $1, $3); } + ; + +exp : exp '-' exp + { $$ = d_binary ("-", $1, $3); } + ; + +exp : exp LSH exp + { $$ = d_binary ("<<", $1, $3); } + ; + +exp : exp RSH exp + { $$ = d_binary (">>", $1, $3); } + ; + +exp : exp EQUAL exp + { $$ = d_binary ("==", $1, $3); } + ; + +exp : exp NOTEQUAL exp + { $$ = d_binary ("!=", $1, $3); } + ; + +exp : exp LEQ exp + { $$ = d_binary ("<=", $1, $3); } + ; + +exp : exp GEQ exp + { $$ = d_binary (">=", $1, $3); } + ; + +exp : exp '<' exp + { $$ = d_binary ("<", $1, $3); } + ; + +exp : exp '&' exp + { $$ = d_binary ("&", $1, $3); } + ; + +exp : exp '^' exp + { $$ = d_binary ("^", $1, $3); } + ; + +exp : exp '|' exp + { $$ = d_binary ("|", $1, $3); } + ; + +exp : exp ANDAND exp + { $$ = d_binary ("&&", $1, $3); } + ; + +exp : exp OROR exp + { $$ = d_binary ("||", $1, $3); } + ; + +/* Not 100% sure these are necessary, but they're harmless. */ +exp : exp ARROW NAME + { $$ = d_binary ("->", $1, $3); } + ; + +exp : exp '.' NAME + { $$ = d_binary (".", $1, $3); } + ; + +exp : exp '?' exp ':' exp %prec '?' + { $$ = fill_comp (DEMANGLE_COMPONENT_TRINARY, make_operator ("?", 3), + fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG1, $1, + fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG2, $3, $5))); + } + ; + +exp : INT + ; + +/* Not generally allowed. */ +exp : FLOAT + ; + +exp : SIZEOF '(' type ')' %prec UNARY + { $$ = d_unary ("sizeof", $3); } + ; + +/* C++. */ +exp : TRUEKEYWORD + { struct demangle_component *i; + i = make_name ("1", 1); + $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL, + make_builtin_type ("bool"), + i); + } + ; + +exp : FALSEKEYWORD + { struct demangle_component *i; + i = make_name ("0", 1); + $$ = fill_comp (DEMANGLE_COMPONENT_LITERAL, + make_builtin_type ("bool"), + i); + } + ; + +/* end of C++. */ + +%% + +/* Apply QUALIFIERS to LHS and return a qualified component. IS_METHOD + is set if LHS is a method, in which case the qualifiers are logically + applied to "this". We apply qualifiers in a consistent order; LHS + may already be qualified; duplicate qualifiers are not created. */ + +struct demangle_component * +d_qualify (struct demangle_component *lhs, int qualifiers, int is_method) +{ + struct demangle_component **inner_p; + enum demangle_component_type type; + + /* For now the order is CONST (innermost), VOLATILE, RESTRICT. */ + +#define HANDLE_QUAL(TYPE, MTYPE, QUAL) \ + if ((qualifiers & QUAL) && (type != TYPE) && (type != MTYPE)) \ + { \ + *inner_p = fill_comp (is_method ? MTYPE : TYPE, \ + *inner_p, NULL); \ + inner_p = &d_left (*inner_p); \ + type = (*inner_p)->type; \ + } \ + else if (type == TYPE || type == MTYPE) \ + { \ + inner_p = &d_left (*inner_p); \ + type = (*inner_p)->type; \ + } + + inner_p = &lhs; + + type = (*inner_p)->type; + + HANDLE_QUAL (DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RESTRICT_THIS, QUAL_RESTRICT); + HANDLE_QUAL (DEMANGLE_COMPONENT_VOLATILE, DEMANGLE_COMPONENT_VOLATILE_THIS, QUAL_VOLATILE); + HANDLE_QUAL (DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_CONST_THIS, QUAL_CONST); + + return lhs; +} + +/* Return a builtin type corresponding to FLAGS. */ + +static struct demangle_component * +d_int_type (int flags) +{ + const char *name; + + switch (flags) + { + case INT_SIGNED | INT_CHAR: + name = "signed char"; + break; + case INT_CHAR: + name = "char"; + break; + case INT_UNSIGNED | INT_CHAR: + name = "unsigned char"; + break; + case 0: + case INT_SIGNED: + name = "int"; + break; + case INT_UNSIGNED: + name = "unsigned int"; + break; + case INT_LONG: + case INT_SIGNED | INT_LONG: + name = "long"; + break; + case INT_UNSIGNED | INT_LONG: + name = "unsigned long"; + break; + case INT_SHORT: + case INT_SIGNED | INT_SHORT: + name = "short"; + break; + case INT_UNSIGNED | INT_SHORT: + name = "unsigned short"; + break; + case INT_LLONG | INT_LONG: + case INT_SIGNED | INT_LLONG | INT_LONG: + name = "long long"; + break; + case INT_UNSIGNED | INT_LLONG | INT_LONG: + name = "unsigned long long"; + break; + default: + return NULL; + } + + return make_builtin_type (name); +} + +/* Wrapper to create a unary operation. */ + +static struct demangle_component * +d_unary (const char *name, struct demangle_component *lhs) +{ + return fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator (name, 1), lhs); +} + +/* Wrapper to create a binary operation. */ + +static struct demangle_component * +d_binary (const char *name, struct demangle_component *lhs, struct demangle_component *rhs) +{ + return fill_comp (DEMANGLE_COMPONENT_BINARY, make_operator (name, 2), + fill_comp (DEMANGLE_COMPONENT_BINARY_ARGS, lhs, rhs)); +} + +/* Find the end of a symbol name starting at LEXPTR. */ + +static const char * +symbol_end (const char *lexptr) +{ + const char *p = lexptr; + + while (*p && (ISALNUM (*p) || *p == '_' || *p == '$' || *p == '.')) + p++; + + return p; +} + +/* Take care of parsing a number (anything that starts with a digit). + The number starts at P and contains LEN characters. Store the result in + YYLVAL. */ + +static int +parse_number (const char *p, int len, int parsed_float) +{ + int unsigned_p = 0; + + /* Number of "L" suffixes encountered. */ + int long_p = 0; + + struct demangle_component *signed_type; + struct demangle_component *unsigned_type; + struct demangle_component *type, *name; + enum demangle_component_type literal_type; + + if (p[0] == '-') + { + literal_type = DEMANGLE_COMPONENT_LITERAL_NEG; + p++; + len--; + } + else + literal_type = DEMANGLE_COMPONENT_LITERAL; + + if (parsed_float) + { + /* It's a float since it contains a point or an exponent. */ + char c; + + /* The GDB lexer checks the result of scanf at this point. Not doing + this leaves our error checking slightly weaker but only for invalid + data. */ + + /* See if it has `f' or `l' suffix (float or long double). */ + + c = TOLOWER (p[len - 1]); + + if (c == 'f') + { + len--; + type = make_builtin_type ("float"); + } + else if (c == 'l') + { + len--; + type = make_builtin_type ("long double"); + } + else if (ISDIGIT (c) || c == '.') + type = make_builtin_type ("double"); + else + return ERROR; + + name = make_name (p, len); + yylval.comp = fill_comp (literal_type, type, name); + + return FLOAT; + } + + /* This treats 0x1 and 1 as different literals. We also do not + automatically generate unsigned types. */ + + long_p = 0; + unsigned_p = 0; + while (len > 0) + { + if (p[len - 1] == 'l' || p[len - 1] == 'L') + { + len--; + long_p++; + continue; + } + if (p[len - 1] == 'u' || p[len - 1] == 'U') + { + len--; + unsigned_p++; + continue; + } + break; + } + + if (long_p == 0) + { + unsigned_type = make_builtin_type ("unsigned int"); + signed_type = make_builtin_type ("int"); + } + else if (long_p == 1) + { + unsigned_type = make_builtin_type ("unsigned long"); + signed_type = make_builtin_type ("long"); + } + else + { + unsigned_type = make_builtin_type ("unsigned long long"); + signed_type = make_builtin_type ("long long"); + } + + if (unsigned_p) + type = unsigned_type; + else + type = signed_type; + + name = make_name (p, len); + yylval.comp = fill_comp (literal_type, type, name); + + return INT; +} + +static char backslashable[] = "abefnrtv"; +static char represented[] = "\a\b\e\f\n\r\t\v"; + +/* Translate the backslash the way we would in the host character set. */ +static int +c_parse_backslash (int host_char, int *target_char) +{ + const char *ix; + ix = strchr (backslashable, host_char); + if (! ix) + return 0; + else + *target_char = represented[ix - backslashable]; + return 1; +} + +/* Parse a C escape sequence. STRING_PTR points to a variable + containing a pointer to the string to parse. That pointer + should point to the character after the \. That pointer + is updated past the characters we use. The value of the + escape sequence is returned. + + A negative value means the sequence \ newline was seen, + which is supposed to be equivalent to nothing at all. + + If \ is followed by a null character, we return a negative + value and leave the string pointer pointing at the null character. + + If \ is followed by 000, we return 0 and leave the string pointer + after the zeros. A value of 0 does not mean end of string. */ + +static int +parse_escape (const char **string_ptr) +{ + int target_char; + int c = *(*string_ptr)++; + if (c_parse_backslash (c, &target_char)) + return target_char; + else + switch (c) + { + case '\n': + return -2; + case 0: + (*string_ptr)--; + return 0; + case '^': + { + c = *(*string_ptr)++; + + if (c == '?') + return 0177; + else if (c == '\\') + target_char = parse_escape (string_ptr); + else + target_char = c; + + /* Now target_char is something like `c', and we want to find + its control-character equivalent. */ + target_char = target_char & 037; + + return target_char; + } + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + int i = c - '0'; + int count = 0; + while (++count < 3) + { + c = (**string_ptr); + if (c >= '0' && c <= '7') + { + (*string_ptr)++; + i *= 8; + i += c - '0'; + } + else + { + break; + } + } + return i; + } + default: + return target_char; + } +} + +#define HANDLE_SPECIAL(string, comp) \ + if (strncmp (tokstart, string, sizeof (string) - 1) == 0) \ + { \ + lexptr = tokstart + sizeof (string) - 1; \ + yylval.lval = comp; \ + return DEMANGLER_SPECIAL; \ + } + +#define HANDLE_TOKEN2(string, token) \ + if (lexptr[1] == string[1]) \ + { \ + lexptr += 2; \ + yylval.opname = string; \ + return token; \ + } + +#define HANDLE_TOKEN3(string, token) \ + if (lexptr[1] == string[1] && lexptr[2] == string[2]) \ + { \ + lexptr += 3; \ + yylval.opname = string; \ + return token; \ + } + +/* Read one token, getting characters through LEXPTR. */ + +static int +yylex (void) +{ + int c; + int namelen; + const char *tokstart, *tokptr; + + retry: + prev_lexptr = lexptr; + tokstart = lexptr; + + switch (c = *tokstart) + { + case 0: + return 0; + + case ' ': + case '\t': + case '\n': + lexptr++; + goto retry; + + case '\'': + /* We either have a character constant ('0' or '\177' for example) + or we have a quoted symbol reference ('foo(int,int)' in C++ + for example). */ + lexptr++; + c = *lexptr++; + if (c == '\\') + c = parse_escape (&lexptr); + else if (c == '\'') + { + yyerror ("empty character constant"); + return ERROR; + } + + c = *lexptr++; + if (c != '\'') + { + yyerror ("invalid character constant"); + return ERROR; + } + + /* FIXME: We should refer to a canonical form of the character, + presumably the same one that appears in manglings - the decimal + representation. But if that isn't in our input then we have to + allocate memory for it somewhere. */ + yylval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL, + make_builtin_type ("char"), + make_name (tokstart, lexptr - tokstart)); + + return INT; + + case '(': + if (strncmp (tokstart, "(anonymous namespace)", 21) == 0) + { + lexptr += 21; + yylval.comp = make_name ("(anonymous namespace)", + sizeof "(anonymous namespace)" - 1); + return NAME; + } + /* FALL THROUGH */ + + case ')': + case ',': + lexptr++; + return c; + + case '.': + if (lexptr[1] == '.' && lexptr[2] == '.') + { + lexptr += 3; + return ELLIPSIS; + } + + /* Might be a floating point number. */ + if (lexptr[1] < '0' || lexptr[1] > '9') + goto symbol; /* Nope, must be a symbol. */ + + goto try_number; + + case '-': + HANDLE_TOKEN2 ("-=", ASSIGN_MODIFY); + HANDLE_TOKEN2 ("--", DECREMENT); + HANDLE_TOKEN2 ("->", ARROW); + + /* For construction vtables. This is kind of hokey. */ + if (strncmp (tokstart, "-in-", 4) == 0) + { + lexptr += 4; + return CONSTRUCTION_IN; + } + + if (lexptr[1] < '0' || lexptr[1] > '9') + { + lexptr++; + return '-'; + } + /* FALL THRU into number case. */ + + try_number: + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + /* It's a number. */ + int got_dot = 0, got_e = 0, toktype; + const char *p = tokstart; + int hex = 0; + + if (c == '-') + p++; + + if (c == '0' && (p[1] == 'x' || p[1] == 'X')) + { + p += 2; + hex = 1; + } + else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) + { + p += 2; + hex = 0; + } + + for (;; ++p) + { + /* This test includes !hex because 'e' is a valid hex digit + and thus does not indicate a floating point number when + the radix is hex. */ + if (!hex && !got_e && (*p == 'e' || *p == 'E')) + got_dot = got_e = 1; + /* This test does not include !hex, because a '.' always indicates + a decimal floating point number regardless of the radix. + + NOTE drow/2005-03-09: This comment is not accurate in C99; + however, it's not clear that all the floating point support + in this file is doing any good here. */ + else if (!got_dot && *p == '.') + got_dot = 1; + else if (got_e && (p[-1] == 'e' || p[-1] == 'E') + && (*p == '-' || *p == '+')) + /* This is the sign of the exponent, not the end of the + number. */ + continue; + /* We will take any letters or digits. parse_number will + complain if past the radix, or if L or U are not final. */ + else if (! ISALNUM (*p)) + break; + } + toktype = parse_number (tokstart, p - tokstart, got_dot|got_e); + if (toktype == ERROR) + { + char *err_copy = (char *) alloca (p - tokstart + 1); + + memcpy (err_copy, tokstart, p - tokstart); + err_copy[p - tokstart] = 0; + yyerror ("invalid number"); + return ERROR; + } + lexptr = p; + return toktype; + } + + case '+': + HANDLE_TOKEN2 ("+=", ASSIGN_MODIFY); + HANDLE_TOKEN2 ("++", INCREMENT); + lexptr++; + return c; + case '*': + HANDLE_TOKEN2 ("*=", ASSIGN_MODIFY); + lexptr++; + return c; + case '/': + HANDLE_TOKEN2 ("/=", ASSIGN_MODIFY); + lexptr++; + return c; + case '%': + HANDLE_TOKEN2 ("%=", ASSIGN_MODIFY); + lexptr++; + return c; + case '|': + HANDLE_TOKEN2 ("|=", ASSIGN_MODIFY); + HANDLE_TOKEN2 ("||", OROR); + lexptr++; + return c; + case '&': + HANDLE_TOKEN2 ("&=", ASSIGN_MODIFY); + HANDLE_TOKEN2 ("&&", ANDAND); + lexptr++; + return c; + case '^': + HANDLE_TOKEN2 ("^=", ASSIGN_MODIFY); + lexptr++; + return c; + case '!': + HANDLE_TOKEN2 ("!=", NOTEQUAL); + lexptr++; + return c; + case '<': + HANDLE_TOKEN3 ("<<=", ASSIGN_MODIFY); + HANDLE_TOKEN2 ("<=", LEQ); + HANDLE_TOKEN2 ("<<", LSH); + lexptr++; + return c; + case '>': + HANDLE_TOKEN3 (">>=", ASSIGN_MODIFY); + HANDLE_TOKEN2 (">=", GEQ); + HANDLE_TOKEN2 (">>", RSH); + lexptr++; + return c; + case '=': + HANDLE_TOKEN2 ("==", EQUAL); + lexptr++; + return c; + case ':': + HANDLE_TOKEN2 ("::", COLONCOLON); + lexptr++; + return c; + + case '[': + case ']': + case '?': + case '@': + case '~': + case '{': + case '}': + symbol: + lexptr++; + return c; + + case '"': + /* These can't occur in C++ names. */ + yyerror ("unexpected string literal"); + return ERROR; + } + + if (!(c == '_' || c == '$' || ISALPHA (c))) + { + /* We must have come across a bad character (e.g. ';'). */ + yyerror ("invalid character"); + return ERROR; + } + + /* It's a name. See how long it is. */ + namelen = 0; + do + c = tokstart[++namelen]; + while (ISALNUM (c) || c == '_' || c == '$'); + + lexptr += namelen; + + /* Catch specific keywords. Notice that some of the keywords contain + spaces, and are sorted by the length of the first word. They must + all include a trailing space in the string comparison. */ + switch (namelen) + { + case 16: + if (strncmp (tokstart, "reinterpret_cast", 16) == 0) + return REINTERPRET_CAST; + break; + case 12: + if (strncmp (tokstart, "construction vtable for ", 24) == 0) + { + lexptr = tokstart + 24; + return CONSTRUCTION_VTABLE; + } + if (strncmp (tokstart, "dynamic_cast", 12) == 0) + return DYNAMIC_CAST; + break; + case 11: + if (strncmp (tokstart, "static_cast", 11) == 0) + return STATIC_CAST; + break; + case 9: + HANDLE_SPECIAL ("covariant return thunk to ", DEMANGLE_COMPONENT_COVARIANT_THUNK); + HANDLE_SPECIAL ("reference temporary for ", DEMANGLE_COMPONENT_REFTEMP); + break; + case 8: + HANDLE_SPECIAL ("typeinfo for ", DEMANGLE_COMPONENT_TYPEINFO); + HANDLE_SPECIAL ("typeinfo fn for ", DEMANGLE_COMPONENT_TYPEINFO_FN); + HANDLE_SPECIAL ("typeinfo name for ", DEMANGLE_COMPONENT_TYPEINFO_NAME); + if (strncmp (tokstart, "operator", 8) == 0) + return OPERATOR; + if (strncmp (tokstart, "restrict", 8) == 0) + return RESTRICT; + if (strncmp (tokstart, "unsigned", 8) == 0) + return UNSIGNED; + if (strncmp (tokstart, "template", 8) == 0) + return TEMPLATE; + if (strncmp (tokstart, "volatile", 8) == 0) + return VOLATILE_KEYWORD; + break; + case 7: + HANDLE_SPECIAL ("virtual thunk to ", DEMANGLE_COMPONENT_VIRTUAL_THUNK); + if (strncmp (tokstart, "wchar_t", 7) == 0) + return WCHAR_T; + break; + case 6: + if (strncmp (tokstart, "global constructors keyed to ", 29) == 0) + { + const char *p; + lexptr = tokstart + 29; + yylval.typed_val_int.val = GLOBAL_CONSTRUCTORS; + /* Find the end of the symbol. */ + p = symbol_end (lexptr); + yylval.typed_val_int.type = make_name (lexptr, p - lexptr); + lexptr = p; + return GLOBAL; + } + if (strncmp (tokstart, "global destructors keyed to ", 28) == 0) + { + const char *p; + lexptr = tokstart + 28; + yylval.typed_val_int.val = GLOBAL_DESTRUCTORS; + /* Find the end of the symbol. */ + p = symbol_end (lexptr); + yylval.typed_val_int.type = make_name (lexptr, p - lexptr); + lexptr = p; + return GLOBAL; + } + + HANDLE_SPECIAL ("vtable for ", DEMANGLE_COMPONENT_VTABLE); + if (strncmp (tokstart, "delete", 6) == 0) + return DELETE; + if (strncmp (tokstart, "struct", 6) == 0) + return STRUCT; + if (strncmp (tokstart, "signed", 6) == 0) + return SIGNED_KEYWORD; + if (strncmp (tokstart, "sizeof", 6) == 0) + return SIZEOF; + if (strncmp (tokstart, "double", 6) == 0) + return DOUBLE_KEYWORD; + break; + case 5: + HANDLE_SPECIAL ("guard variable for ", DEMANGLE_COMPONENT_GUARD); + if (strncmp (tokstart, "false", 5) == 0) + return FALSEKEYWORD; + if (strncmp (tokstart, "class", 5) == 0) + return CLASS; + if (strncmp (tokstart, "union", 5) == 0) + return UNION; + if (strncmp (tokstart, "float", 5) == 0) + return FLOAT_KEYWORD; + if (strncmp (tokstart, "short", 5) == 0) + return SHORT; + if (strncmp (tokstart, "const", 5) == 0) + return CONST_KEYWORD; + break; + case 4: + if (strncmp (tokstart, "void", 4) == 0) + return VOID; + if (strncmp (tokstart, "bool", 4) == 0) + return BOOL; + if (strncmp (tokstart, "char", 4) == 0) + return CHAR; + if (strncmp (tokstart, "enum", 4) == 0) + return ENUM; + if (strncmp (tokstart, "long", 4) == 0) + return LONG; + if (strncmp (tokstart, "true", 4) == 0) + return TRUEKEYWORD; + break; + case 3: + HANDLE_SPECIAL ("VTT for ", DEMANGLE_COMPONENT_VTT); + HANDLE_SPECIAL ("non-virtual thunk to ", DEMANGLE_COMPONENT_THUNK); + if (strncmp (tokstart, "new", 3) == 0) + return NEW; + if (strncmp (tokstart, "int", 3) == 0) + return INT_KEYWORD; + break; + default: + break; + } + + yylval.comp = make_name (tokstart, namelen); + return NAME; +} + +static void +yyerror (char *msg) +{ + if (global_errmsg) + return; + + error_lexptr = prev_lexptr; + global_errmsg = msg ? msg : "parse error"; +} + +/* Allocate all the components we'll need to build a tree. We generally + allocate too many components, but the extra memory usage doesn't hurt + because the trees are temporary. If we start keeping the trees for + a longer lifetime we'll need to be cleverer. */ +static struct demangle_info * +allocate_info (int comps) +{ + struct demangle_info *ret; + + ret = malloc (sizeof (struct demangle_info) + + sizeof (struct demangle_component) * (comps - 1)); + ret->used = 0; + return ret; +} + +/* Convert RESULT to a string. The return value is allocated + using xmalloc. ESTIMATED_LEN is used only as a guide to the + length of the result. This functions handles a few cases that + cplus_demangle_print does not, specifically the global destructor + and constructor labels. */ + +char * +cp_comp_to_string (struct demangle_component *result, int estimated_len) +{ + char *str, *prefix = NULL, *buf; + size_t err = 0; + + if (result->type == GLOBAL_DESTRUCTORS) + { + result = d_left (result); + prefix = "global destructors keyed to "; + } + else if (result->type == GLOBAL_CONSTRUCTORS) + { + result = d_left (result); + prefix = "global constructors keyed to "; + } + + str = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, estimated_len, &err); + if (str == NULL) + return NULL; + + if (prefix == NULL) + return str; + + buf = malloc (strlen (str) + strlen (prefix) + 1); + strcpy (buf, prefix); + strcat (buf, str); + free (str); + return (buf); +} + +/* Convert a demangled name to a demangle_component tree. *MEMORY is set to the + block of used memory that should be freed when finished with the + tree. On error, NULL is returned, and an error message will be + set in *ERRMSG (which does not need to be freed). */ + +struct demangle_component * +cp_demangled_name_to_comp (const char *demangled_name, void **memory, + const char **errmsg) +{ + static char errbuf[60]; + struct demangle_component *result; + + int len = strlen (demangled_name); + + len = len + len / 8; + prev_lexptr = lexptr = demangled_name; + error_lexptr = NULL; + global_errmsg = NULL; + + demangle_info = allocate_info (len); + + if (yyparse ()) + { + if (global_errmsg && errmsg) + { + snprintf (errbuf, sizeof (errbuf) - 2, "%s, near `%s", + global_errmsg, error_lexptr); + strcat (errbuf, "'"); + *errmsg = errbuf; + } + free (demangle_info); + return NULL; + } + + *memory = demangle_info; + result = global_result; + global_result = NULL; + + return result; +} + +#ifdef TEST_CPNAMES + +static void +cp_print (struct demangle_component *result) +{ + char *str; + size_t err = 0; + + if (result->type == GLOBAL_DESTRUCTORS) + { + result = d_left (result); + fputs ("global destructors keyed to ", stdout); + } + else if (result->type == GLOBAL_CONSTRUCTORS) + { + result = d_left (result); + fputs ("global constructors keyed to ", stdout); + } + + str = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, 64, &err); + if (str == NULL) + return; + + fputs (str, stdout); + + free (str); +} + +static char +trim_chars (char *lexptr, char **extra_chars) +{ + char *p = (char *) symbol_end (lexptr); + char c = 0; + + if (*p) + { + c = *p; + *p = 0; + *extra_chars = p + 1; + } + + return c; +} + +int +main (int argc, char **argv) +{ + char *str2, *extra_chars, c; + char buf[65536]; + int arg; + const char *errmsg; + void *memory; + struct demangle_component *result; + + arg = 1; + if (argv[arg] && strcmp (argv[arg], "--debug") == 0) + { + yydebug = 1; + arg++; + } + + if (argv[arg] == NULL) + while (fgets (buf, 65536, stdin) != NULL) + { + int len; + buf[strlen (buf) - 1] = 0; + /* Use DMGL_VERBOSE to get expanded standard substitutions. */ + c = trim_chars (buf, &extra_chars); + str2 = cplus_demangle (buf, DMGL_PARAMS | DMGL_ANSI | DMGL_VERBOSE); + if (str2 == NULL) + { + /* printf ("Demangling error\n"); */ + if (c) + printf ("%s%c%s\n", buf, c, extra_chars); + else + printf ("%s\n", buf); + continue; + } + result = cp_demangled_name_to_comp (str2, &memory, &errmsg); + if (result == NULL) + { + fputs (errmsg, stderr); + fputc ('\n', stderr); + continue; + } + + cp_print (result); + free (memory); + + free (str2); + if (c) + { + putchar (c); + fputs (extra_chars, stdout); + } + putchar ('\n'); + } + else + { + result = cp_demangled_name_to_comp (argv[arg], &memory, &errmsg); + if (result == NULL) + { + fputs (errmsg, stderr); + fputc ('\n', stderr); + return 0; + } + cp_print (result); + putchar ('\n'); + free (memory); + } + return 0; +} + +#endif |