2005-03-11 03:24:23 +01:00
|
|
|
|
/* YACC parser for C++ names, for GDB.
|
|
|
|
|
|
2015-01-01 10:32:14 +01:00
|
|
|
|
Copyright (C) 2003-2015 Free Software Foundation, Inc.
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
Parts of the lexer are based on c-exp.y from GDB.
|
|
|
|
|
|
2009-03-18 09:51:11 +01:00
|
|
|
|
This file is part of GDB.
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
2009-03-18 09:51:11 +01:00
|
|
|
|
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 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
2009-03-18 09:51:11 +01:00
|
|
|
|
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.
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
2009-03-18 09:51:11 +01:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
|
|
|
|
|
|
%{
|
|
|
|
|
|
2008-10-27 20:28:52 +01:00
|
|
|
|
#include "defs.h"
|
2008-08-25 23:50:25 +02:00
|
|
|
|
|
2005-03-11 03:24:23 +01:00
|
|
|
|
#include <unistd.h>
|
|
|
|
|
#include "safe-ctype.h"
|
|
|
|
|
#include "demangle.h"
|
2008-02-21 Pedro Alves <pedro@codesorcery.com>
Silence a few -Wmissing-prototypes warnings.
PR build/9877:
* amd64-nat.c: Include "amd64-nat.h".
* fork-child.c (_initialize_fork_child): Ditto.
* gcore.c (_initialize_gcore): Ditto.
* inf-ptrace.c: Include "inf-ptrace.h".
(inf_ptrace_store_registers): Make it static.
* linux-nat.c (linux_nat_terminal_ours): Make it static.
(_initialize_linux_nat): Declare before definition.
* linux-tdep.c: Include "linux-tdep.h".
* linux-thread-db.c (_initialize_thread_db): Declare before
definition.
* proc-service.c (_initialize_proc_service): Ditto.
* remote.c (remote_send_printf): Make it static.
* solib.c: Include "solib.h".
* symfile-mem.c (_initialize_symfile_mem): Declare before
definition.
* ada-lang.c (ada_la_decode, ada_match_name)
(ada_suppress_symbol_printing, ada_is_array_type)
(ada_value_ptr_subscript, ada_array_length)
(ada_to_static_fixed_value): Make them static.
(_initialize_ada_language): Declare before definition.
* ada-tasks.c (ada_get_task_number, ada_get_environment_task)
(ada_task_list_changed, ada_new_objfile_observer): Make them
static.
(_initialize_tasks): Declare before definition.
* addrmap.c (_initialize_addrmap): Declare before definition.
* auxv.c (default_auxv_parse): Make it static.
* bfd-target.c (target_bfd_xfer_partial, target_bfd_xclose): Make
them static.
* breakpoint.c (remove_sal): Add line break.
(expand_line_sal_maybe): Make it static.
* cp-name-parser.y: Include "cp-support.h".
* cp-valprint.c (cp_find_class_member): Make it static.
* eval.c (value_f90_subarray): Ditto.
* exceptions.c (print_any_exception): Ditto.
* findcmd.c (_initialize_mem_search): Declare before definition.
* frame.c (frame_observer_target_changed): Make it static.
* gnu-v3-abi.c (gnuv3_find_method_in): Make it static.
* inf-child.c: Include "inf-child.h".
* inferior.h (valid_inferior_id): Rename to ...
(valid_gdb_inferior_id): ... this.
* infrun.c (infrun_thread_stop_requested, siginfo_make_value):
Make them static.
* jv-lang.c (java_language_arch_info): Make it static.
* m2-typeprint.c (m2_get_discrete_bounds): Ditto.
* osdata.c (info_osdata_command): Make it static.
* regcache.c (regcache_observer_target_changed): Make it static.
* reverse.c (_initialize_reverse): Declare before definition.
* stabsread.c (cleanup_undefined_types_noname)
(cleanup_undefined_types_1): Make them static.
* symfile.c (place_section): Make it static.
* symtab.c (find_pc_sect_psymtab_closer): Make it static.
* target-descriptions.c (_initialize_target_descriptions): Declare
before definition.
* target.c (default_get_ada_task_ptid, find_default_can_async_p)
(find_default_is_async_p, find_default_supports_non_stop): Make
them static.
(target_supports_non_stop): Add prototype.
(dummy_pid_to_str): Make it static.
* utils.c (_initialize_utils): Declare before definition.
* ada-exp.y (_initialize_ada_exp): Declare before definition.
* solib-svr4.c (HAS_LM_DYNAMIC_FROM_LINK_MAP): Add a prototype.
* target.h (struct target_ops): Add a prototype to the
to_can_execute_reverse callback.
* macroscope.c (_initialize_macroscope): Declare before definition.
* cp-namespace.c (_initialize_cp_namespace): Declare before definition.
* python/python.c (_initialize_python): Declare before definition.
* tui/tui-command.c: Include "tui/tui-command.h".
* tui/tui-data.c (init_content_element, init_win_info): Make them
static.
* tui/tui-disasm.c: Include "tui/tui-disasm.h".
* tui/tui-interp.c (_initialize_tui_interp): Declare before
definition.
* tui/tui-layout.c: Include "tui/tui-layout.h".
(_initialize_tui_layout): Declare before definition.
* tui/tui-regs.c: Include "tui/tui-regs.h".
(tui_display_reg_element_at_line): Make it static.
(_initialize_tui_regs): Declare before definition.
* tui/tui-stack.c (_initialize_tui_stack): Declare before
definition.
* tui/tui-win.c: Include "tui/tui-win.h".
(_initialize_tui_win): Declare before definition.
(tui_sigwinch_handler): Make it static. Wrap in ifdef SIGWINCH.
* tui/tui-win.h (tui_sigwinch_handler): Delete declaration.
(tui_get_cmd_list): Add a prototype.
* tui/tui-windata.c: Include tui-windata.h.
* tui/tui-wingeneral.c (box_win): Make it static.
* cli/cli-logging.c (show_logging_command): Make it static.
(_initialize_cli_logging): Declare before definition.
* mi/mi-common.c (_initialize_gdb_mi_common): Declare before
definition.
2009-02-21 17:14:50 +01:00
|
|
|
|
#include "cp-support.h"
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
|
|
2007-10-22 16:37:36 +02:00
|
|
|
|
#define ALLOC_CHUNK 100
|
|
|
|
|
|
2005-03-11 03:24:23 +01:00
|
|
|
|
struct demangle_info {
|
|
|
|
|
int used;
|
2011-08-18 18:17:39 +02:00
|
|
|
|
struct demangle_info *next;
|
2007-10-22 16:37:36 +02:00
|
|
|
|
struct demangle_component comps[ALLOC_CHUNK];
|
2005-03-11 03:24:23 +01:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct demangle_info *demangle_info;
|
2007-10-22 16:37:36 +02:00
|
|
|
|
|
|
|
|
|
static struct demangle_component *
|
|
|
|
|
d_grab (void)
|
|
|
|
|
{
|
|
|
|
|
struct demangle_info *more;
|
|
|
|
|
|
|
|
|
|
if (demangle_info->used >= ALLOC_CHUNK)
|
|
|
|
|
{
|
|
|
|
|
if (demangle_info->next == NULL)
|
|
|
|
|
{
|
|
|
|
|
more = malloc (sizeof (struct demangle_info));
|
|
|
|
|
more->next = NULL;
|
|
|
|
|
demangle_info->next = more;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
more = demangle_info->next;
|
|
|
|
|
|
|
|
|
|
more->used = 0;
|
|
|
|
|
demangle_info = more;
|
|
|
|
|
}
|
|
|
|
|
return &demangle_info->comps[demangle_info->used++];
|
|
|
|
|
}
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
/* 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
|
* ada-exp.y (yyss, yysslim, yyssp, yystacksize, yyvs, yyvsp): New
defines.
* c-exp.y (yyss, yysslim, yyssp, yystacksize, yyvs, yyvsp): New
defines.
* cp-name-parser.y (yyss, yysslim, yyssp, yystacksize, yyvs)
(yyvsp): New defines.
* f-exp.y (yyss, yysslim, yyssp, yystacksize, yyvs, yyvsp): New
defines.
* jv-exp.y (yyss, yysslim, yyssp, yystacksize, yyvs, yyvsp): New
defines.
* m2-exp.y (yyss, yysslim, yyssp, yystacksize, yyvs, yyvsp): New
defines.
* objc-exp.y (yyss, yysslim, yyssp, yystacksize, yyvs, yyvsp): New
defines.
* p-exp.y (yyss, yysslim, yyssp, yystacksize, yyvs, yyvsp): New
defines.
2012-04-09 19:07:43 +02:00
|
|
|
|
#define yyss cpname_yyss
|
|
|
|
|
#define yysslim cpname_yysslim
|
|
|
|
|
#define yyssp cpname_yyssp
|
|
|
|
|
#define yystacksize cpname_yystacksize
|
|
|
|
|
#define yyvs cpname_yyvs
|
|
|
|
|
#define yyvsp cpname_yyvsp
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
2005-03-20 17:26:44 +01:00
|
|
|
|
int yyparse (void);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
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 ();
|
2012-01-10 20:29:12 +01:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
i = cplus_demangle_fill_component (ret, d_type, lhs, rhs);
|
|
|
|
|
gdb_assert (i);
|
|
|
|
|
|
2005-03-11 03:24:23 +01:00
|
|
|
|
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 ();
|
2012-01-10 20:29:12 +01:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
i = cplus_demangle_fill_operator (ret, name, args);
|
|
|
|
|
gdb_assert (i);
|
|
|
|
|
|
2005-03-11 03:24:23 +01:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct demangle_component *
|
|
|
|
|
make_dtor (enum gnu_v3_dtor_kinds kind, struct demangle_component *name)
|
|
|
|
|
{
|
|
|
|
|
struct demangle_component *ret = d_grab ();
|
2012-01-10 20:29:12 +01:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
i = cplus_demangle_fill_dtor (ret, kind, name);
|
|
|
|
|
gdb_assert (i);
|
|
|
|
|
|
2005-03-11 03:24:23 +01:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct demangle_component *
|
|
|
|
|
make_builtin_type (const char *name)
|
|
|
|
|
{
|
|
|
|
|
struct demangle_component *ret = d_grab ();
|
2012-01-10 20:29:12 +01:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
i = cplus_demangle_fill_builtin_type (ret, name);
|
|
|
|
|
gdb_assert (i);
|
|
|
|
|
|
2005-03-11 03:24:23 +01:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct demangle_component *
|
|
|
|
|
make_name (const char *name, int len)
|
|
|
|
|
{
|
|
|
|
|
struct demangle_component *ret = d_grab ();
|
2012-01-10 20:29:12 +01:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
i = cplus_demangle_fill_name (ret, name, len);
|
|
|
|
|
gdb_assert (i);
|
|
|
|
|
|
2005-03-11 03:24:23 +01:00
|
|
|
|
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;
|
|
|
|
|
const char *opname;
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-27 17:33:07 +01:00
|
|
|
|
%type <comp> exp exp1 type start start_opt oper colon_name
|
2005-03-11 03:24:23 +01:00
|
|
|
|
%type <comp> unqualified_name colon_ext_name
|
2015-02-27 17:33:07 +01:00
|
|
|
|
%type <comp> templ template_arg
|
2005-03-11 03:24:23 +01:00
|
|
|
|
%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
|
|
|
|
|
|
|
|
|
|
/* 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); }
|
|
|
|
|
;
|
|
|
|
|
|
2015-02-27 17:33:07 +01:00
|
|
|
|
oper : OPERATOR NEW
|
2012-09-21 22:01:12 +02:00
|
|
|
|
{
|
|
|
|
|
/* Match the whitespacing of cplus_demangle_operators.
|
|
|
|
|
It would abort on unrecognized string otherwise. */
|
|
|
|
|
$$ = make_operator ("new", 3);
|
|
|
|
|
}
|
2005-03-11 03:24:23 +01:00
|
|
|
|
| OPERATOR DELETE
|
2012-09-21 22:01:12 +02:00
|
|
|
|
{
|
|
|
|
|
/* Match the whitespacing of cplus_demangle_operators.
|
|
|
|
|
It would abort on unrecognized string otherwise. */
|
|
|
|
|
$$ = make_operator ("delete ", 1);
|
|
|
|
|
}
|
2005-03-11 03:24:23 +01:00
|
|
|
|
| OPERATOR NEW '[' ']'
|
2012-09-21 22:01:12 +02:00
|
|
|
|
{
|
|
|
|
|
/* Match the whitespacing of cplus_demangle_operators.
|
|
|
|
|
It would abort on unrecognized string otherwise. */
|
|
|
|
|
$$ = make_operator ("new[]", 3);
|
|
|
|
|
}
|
2005-03-11 03:24:23 +01:00
|
|
|
|
| OPERATOR DELETE '[' ']'
|
2012-09-21 22:01:12 +02:00
|
|
|
|
{
|
|
|
|
|
/* Match the whitespacing of cplus_demangle_operators.
|
|
|
|
|
It would abort on unrecognized string otherwise. */
|
|
|
|
|
$$ = make_operator ("delete[] ", 1);
|
|
|
|
|
}
|
2005-03-11 03:24:23 +01:00
|
|
|
|
| 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 '(' ')'
|
2009-03-31 22:21:08 +02:00
|
|
|
|
{ $$ = make_operator ("()", 2); }
|
2005-03-11 03:24:23 +01:00
|
|
|
|
| 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 '~'. */
|
2015-02-27 17:33:07 +01:00
|
|
|
|
unqualified_name: oper
|
|
|
|
|
| oper '<' template_params '>'
|
2005-03-11 03:24:23 +01:00
|
|
|
|
{ $$ = 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
|
2015-02-27 17:33:07 +01:00
|
|
|
|
| nested_name templ %prec NAME
|
2005-03-11 03:24:23 +01:00
|
|
|
|
{ $$ = $1.comp; d_right ($1.last) = $2; }
|
2015-02-27 17:33:07 +01:00
|
|
|
|
| templ %prec NAME
|
2005-03-11 03:24:23 +01:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
2015-02-27 17:33:07 +01:00
|
|
|
|
| templ COLONCOLON
|
2005-03-11 03:24:23 +01:00
|
|
|
|
{ $$.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
|
|
|
|
|
d_left ($$.comp) = $1;
|
|
|
|
|
d_right ($$.comp) = NULL;
|
|
|
|
|
$$.last = $$.comp;
|
|
|
|
|
}
|
2015-02-27 17:33:07 +01:00
|
|
|
|
| nested_name templ COLONCOLON
|
2005-03-11 03:24:23 +01:00
|
|
|
|
{ $$.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 */
|
2015-02-27 17:33:07 +01:00
|
|
|
|
templ : NAME '<' template_params '>'
|
2005-03-11 03:24:23 +01:00
|
|
|
|
{ $$ = 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); }
|
2007-10-22 18:07:13 +02:00
|
|
|
|
| '&' '(' start ')'
|
|
|
|
|
{ $$ = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), $3); }
|
2005-03-11 03:24:23 +01:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
}
|
|
|
|
|
;
|
|
|
|
|
|
2007-10-22 18:07:13 +02:00
|
|
|
|
/* Another form of C++-style cast is "type ( exp1 )". This creates too many
|
|
|
|
|
conflicts to support. For a while we supported the simpler
|
|
|
|
|
"typespec_2 ( exp1 )", but that conflicts with "& ( start )" as a
|
|
|
|
|
reference, deep within the wilderness of abstract declarators:
|
|
|
|
|
Qux<int(&(*))> vs Qux<int(&(var))>, a shift-reduce conflict at the
|
|
|
|
|
innermost left parenthesis. So we do not support function-like casts.
|
|
|
|
|
Fortunately they never appear in demangler output. */
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
/* 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
|
2012-09-21 22:01:12 +02:00
|
|
|
|
{
|
|
|
|
|
/* Match the whitespacing of cplus_demangle_operators.
|
|
|
|
|
It would abort on unrecognized string otherwise. */
|
|
|
|
|
$$ = d_unary ("sizeof ", $3);
|
|
|
|
|
}
|
2005-03-11 03:24:23 +01:00
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
/* 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
|
2008-10-27 20:28:52 +01:00
|
|
|
|
cp_parse_escape (const char **string_ptr)
|
2005-03-11 03:24:23 +01:00
|
|
|
|
{
|
2005-05-28 18:48:58 +02:00
|
|
|
|
int target_char;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
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 == '\\')
|
2008-10-27 20:28:52 +01:00
|
|
|
|
target_char = cp_parse_escape (string_ptr);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
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:
|
2005-05-28 18:48:58 +02:00
|
|
|
|
return c;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#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;
|
2010-05-06 02:08:44 +02:00
|
|
|
|
const char *tokstart;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
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 == '\\')
|
2008-10-27 20:28:52 +01:00
|
|
|
|
c = cp_parse_escape (&lexptr);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
else if (c == '\'')
|
|
|
|
|
{
|
2011-03-18 14:51:41 +01:00
|
|
|
|
yyerror (_("empty character constant"));
|
2005-03-11 03:24:23 +01:00
|
|
|
|
return ERROR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
c = *lexptr++;
|
|
|
|
|
if (c != '\'')
|
|
|
|
|
{
|
2011-03-18 14:51:41 +01:00
|
|
|
|
yyerror (_("invalid character constant"));
|
2005-03-11 03:24:23 +01:00
|
|
|
|
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;
|
2011-03-18 14:51:41 +01:00
|
|
|
|
yyerror (_("invalid number"));
|
2005-03-11 03:24:23 +01:00
|
|
|
|
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. */
|
2011-03-18 14:51:41 +01:00
|
|
|
|
yyerror (_("unexpected string literal"));
|
2005-03-11 03:24:23 +01:00
|
|
|
|
return ERROR;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!(c == '_' || c == '$' || ISALPHA (c)))
|
|
|
|
|
{
|
|
|
|
|
/* We must have come across a bad character (e.g. ';'). */
|
2011-03-18 14:51:41 +01:00
|
|
|
|
yyerror (_("invalid character"));
|
2005-03-11 03:24:23 +01:00
|
|
|
|
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;
|
2009-07-29 20:44:28 +02:00
|
|
|
|
yylval.lval = DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
/* Find the end of the symbol. */
|
|
|
|
|
p = symbol_end (lexptr);
|
2009-07-29 20:44:28 +02:00
|
|
|
|
yylval.comp = make_name (lexptr, p - lexptr);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
lexptr = p;
|
2009-07-29 20:44:28 +02:00
|
|
|
|
return DEMANGLER_SPECIAL;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
}
|
|
|
|
|
if (strncmp (tokstart, "global destructors keyed to ", 28) == 0)
|
|
|
|
|
{
|
|
|
|
|
const char *p;
|
|
|
|
|
lexptr = tokstart + 28;
|
2009-07-29 20:44:28 +02:00
|
|
|
|
yylval.lval = DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
/* Find the end of the symbol. */
|
|
|
|
|
p = symbol_end (lexptr);
|
2009-07-29 20:44:28 +02:00
|
|
|
|
yylval.comp = make_name (lexptr, p - lexptr);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
lexptr = p;
|
2009-07-29 20:44:28 +02:00
|
|
|
|
return DEMANGLER_SPECIAL;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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";
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-22 16:37:36 +02:00
|
|
|
|
/* Allocate a chunk of 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 and the storage is
|
|
|
|
|
reused. More may be allocated later, by d_grab. */
|
2011-08-18 18:17:39 +02:00
|
|
|
|
static struct demangle_info *
|
2007-10-22 16:37:36 +02:00
|
|
|
|
allocate_info (void)
|
2005-03-11 03:24:23 +01:00
|
|
|
|
{
|
2011-08-18 18:17:39 +02:00
|
|
|
|
struct demangle_info *info = malloc (sizeof (struct demangle_info));
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
2011-08-18 18:17:39 +02:00
|
|
|
|
info->next = NULL;
|
|
|
|
|
info->used = 0;
|
|
|
|
|
return info;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
|
{
|
2009-07-29 20:44:28 +02:00
|
|
|
|
size_t err;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
2009-07-29 20:44:28 +02:00
|
|
|
|
return cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, result, estimated_len,
|
|
|
|
|
&err);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
}
|
|
|
|
|
|
2011-08-18 18:17:39 +02:00
|
|
|
|
/* A convenience function to allocate and initialize a new struct
|
|
|
|
|
demangled_parse_info. */
|
|
|
|
|
|
|
|
|
|
struct demangle_parse_info *
|
|
|
|
|
cp_new_demangle_parse_info (void)
|
|
|
|
|
{
|
|
|
|
|
struct demangle_parse_info *info;
|
|
|
|
|
|
|
|
|
|
info = malloc (sizeof (struct demangle_parse_info));
|
|
|
|
|
info->info = NULL;
|
|
|
|
|
info->tree = NULL;
|
|
|
|
|
obstack_init (&info->obstack);
|
|
|
|
|
|
|
|
|
|
return info;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Free any memory associated with the given PARSE_INFO. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
cp_demangled_name_parse_free (struct demangle_parse_info *parse_info)
|
|
|
|
|
{
|
|
|
|
|
struct demangle_info *info = parse_info->info;
|
|
|
|
|
|
|
|
|
|
/* Free any allocated chunks of memory for the parse. */
|
|
|
|
|
while (info != NULL)
|
|
|
|
|
{
|
|
|
|
|
struct demangle_info *next = info->next;
|
|
|
|
|
|
|
|
|
|
free (info);
|
|
|
|
|
info = next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Free any memory allocated during typedef replacement. */
|
|
|
|
|
obstack_free (&parse_info->obstack, NULL);
|
|
|
|
|
|
|
|
|
|
/* Free the parser info. */
|
|
|
|
|
free (parse_info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Merge the two parse trees given by DEST and SRC. The parse tree
|
|
|
|
|
in SRC is attached to DEST at the node represented by TARGET.
|
|
|
|
|
SRC is then freed.
|
|
|
|
|
|
|
|
|
|
NOTE 1: Since there is no API to merge obstacks, this function does
|
|
|
|
|
even attempt to try it. Fortunately, we do not (yet?) need this ability.
|
|
|
|
|
The code will assert if SRC->obstack is not empty.
|
|
|
|
|
|
|
|
|
|
NOTE 2: The string from which SRC was parsed must not be freed, since
|
|
|
|
|
this function will place pointers to that string into DEST. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
cp_merge_demangle_parse_infos (struct demangle_parse_info *dest,
|
|
|
|
|
struct demangle_component *target,
|
|
|
|
|
struct demangle_parse_info *src)
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
struct demangle_info *di;
|
|
|
|
|
|
|
|
|
|
/* Copy the SRC's parse data into DEST. */
|
|
|
|
|
*target = *src->tree;
|
|
|
|
|
di = dest->info;
|
|
|
|
|
while (di->next != NULL)
|
|
|
|
|
di = di->next;
|
|
|
|
|
di->next = src->info;
|
|
|
|
|
|
|
|
|
|
/* Clear the (pointer to) SRC's parse data so that it is not freed when
|
|
|
|
|
cp_demangled_parse_info_free is called. */
|
|
|
|
|
src->info = NULL;
|
|
|
|
|
|
|
|
|
|
/* Free SRC. */
|
|
|
|
|
cp_demangled_name_parse_free (src);
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-22 16:37:36 +02:00
|
|
|
|
/* Convert a demangled name to a demangle_component tree. On success,
|
2011-08-18 18:17:39 +02:00
|
|
|
|
a structure containing the root of the new tree is returned; it must
|
|
|
|
|
be freed by calling cp_demangled_name_parse_free. On error, NULL is
|
2007-10-22 16:37:36 +02:00
|
|
|
|
returned, and an error message will be set in *ERRMSG (which does
|
|
|
|
|
not need to be freed). */
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
2011-08-18 18:17:39 +02:00
|
|
|
|
struct demangle_parse_info *
|
2007-10-22 16:37:36 +02:00
|
|
|
|
cp_demangled_name_to_comp (const char *demangled_name, const char **errmsg)
|
2005-03-11 03:24:23 +01:00
|
|
|
|
{
|
|
|
|
|
static char errbuf[60];
|
2011-08-18 18:17:39 +02:00
|
|
|
|
struct demangle_parse_info *result;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
prev_lexptr = lexptr = demangled_name;
|
|
|
|
|
error_lexptr = NULL;
|
|
|
|
|
global_errmsg = NULL;
|
|
|
|
|
|
2011-08-18 18:17:39 +02:00
|
|
|
|
demangle_info = allocate_info ();
|
|
|
|
|
|
|
|
|
|
result = cp_new_demangle_parse_info ();
|
|
|
|
|
result->info = demangle_info;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
if (yyparse ())
|
|
|
|
|
{
|
|
|
|
|
if (global_errmsg && errmsg)
|
|
|
|
|
{
|
|
|
|
|
snprintf (errbuf, sizeof (errbuf) - 2, "%s, near `%s",
|
|
|
|
|
global_errmsg, error_lexptr);
|
|
|
|
|
strcat (errbuf, "'");
|
|
|
|
|
*errmsg = errbuf;
|
|
|
|
|
}
|
2011-08-18 18:17:39 +02:00
|
|
|
|
cp_demangled_name_parse_free (result);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-18 18:17:39 +02:00
|
|
|
|
result->tree = global_result;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
global_result = NULL;
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef TEST_CPNAMES
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
cp_print (struct demangle_component *result)
|
|
|
|
|
{
|
|
|
|
|
char *str;
|
|
|
|
|
size_t err = 0;
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-27 20:28:52 +01:00
|
|
|
|
/* When this file is built as a standalone program, xmalloc comes from
|
|
|
|
|
libiberty --- in which case we have to provide xfree ourselves. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
xfree (void *ptr)
|
|
|
|
|
{
|
|
|
|
|
if (ptr != NULL)
|
2011-08-06 16:13:49 +02:00
|
|
|
|
{
|
|
|
|
|
/* Literal `free' would get translated back to xfree again. */
|
|
|
|
|
CONCAT2 (fr,ee) (ptr);
|
|
|
|
|
}
|
2008-10-27 20:28:52 +01:00
|
|
|
|
}
|
|
|
|
|
|
2011-08-18 18:17:39 +02:00
|
|
|
|
/* GDB normally defines internal_error itself, but when this file is built
|
|
|
|
|
as a standalone program, we must also provide an implementation. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
internal_error (const char *file, int line, const char *fmt, ...)
|
|
|
|
|
{
|
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
|
|
va_start (ap, fmt);
|
|
|
|
|
fprintf (stderr, "%s:%d: internal error: ", file, line);
|
|
|
|
|
vfprintf (stderr, fmt, ap);
|
|
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
|
2005-03-11 03:24:23 +01:00
|
|
|
|
int
|
|
|
|
|
main (int argc, char **argv)
|
|
|
|
|
{
|
2007-10-22 16:37:36 +02:00
|
|
|
|
char *str2, *extra_chars = "", c;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
char buf[65536];
|
|
|
|
|
int arg;
|
|
|
|
|
const char *errmsg;
|
2011-08-18 18:17:39 +02:00
|
|
|
|
struct demangle_parse_info *result;
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
2011-08-06 16:13:49 +02:00
|
|
|
|
printf ("Demangling error\n");
|
2005-03-11 03:24:23 +01:00
|
|
|
|
if (c)
|
|
|
|
|
printf ("%s%c%s\n", buf, c, extra_chars);
|
|
|
|
|
else
|
|
|
|
|
printf ("%s\n", buf);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2007-10-22 16:37:36 +02:00
|
|
|
|
result = cp_demangled_name_to_comp (str2, &errmsg);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
if (result == NULL)
|
|
|
|
|
{
|
|
|
|
|
fputs (errmsg, stderr);
|
|
|
|
|
fputc ('\n', stderr);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-18 18:17:39 +02:00
|
|
|
|
cp_print (result->tree);
|
|
|
|
|
cp_demangled_name_parse_free (result);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
|
|
|
|
|
free (str2);
|
|
|
|
|
if (c)
|
|
|
|
|
{
|
|
|
|
|
putchar (c);
|
|
|
|
|
fputs (extra_chars, stdout);
|
|
|
|
|
}
|
|
|
|
|
putchar ('\n');
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2007-10-22 16:37:36 +02:00
|
|
|
|
result = cp_demangled_name_to_comp (argv[arg], &errmsg);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
if (result == NULL)
|
|
|
|
|
{
|
|
|
|
|
fputs (errmsg, stderr);
|
|
|
|
|
fputc ('\n', stderr);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2011-08-18 18:17:39 +02:00
|
|
|
|
cp_print (result->tree);
|
|
|
|
|
cp_demangled_name_parse_free (result);
|
2005-03-11 03:24:23 +01:00
|
|
|
|
putchar ('\n');
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|