/* YACC parser for Ada expressions, for GDB.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 Free Software Foundation, Inc.
This file is part of GDB.
#define parse_type(ps) builtin_type (parse_gdbarch (ps))
-/* 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. 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. */
-
-/* NOTE: This is clumsy, especially since BISON and FLEX provide --prefix
- options. I presume we are maintaining it to accommodate systems
- without BISON? (PNH) */
-
-#define yymaxdepth ada_maxdepth
-/* ada_parse calls this after initialization */
-#define yyparse ada_parse_internal
-#define yylex ada_lex
-#define yyerror ada_error
-#define yylval ada_lval
-#define yychar ada_char
-#define yydebug ada_debug
-#define yypact ada_pact
-#define yyr1 ada_r1
-#define yyr2 ada_r2
-#define yydef ada_def
-#define yychk ada_chk
-#define yypgo ada_pgo
-#define yyact ada_act
-#define yyexca ada_exca
-#define yyerrflag ada_errflag
-#define yynerrs ada_nerrs
-#define yyps ada_ps
-#define yypv ada_pv
-#define yys ada_s
-#define yy_yys ada_yys
-#define yystate ada_state
-#define yytmp ada_tmp
-#define yyv ada_v
-#define yy_yyv ada_yyv
-#define yyval ada_val
-#define yylloc ada_lloc
-#define yyreds ada_reds /* With YYDEBUG defined */
-#define yytoks ada_toks /* With YYDEBUG defined */
-#define yyname ada_name /* With YYDEBUG defined */
-#define yyrule ada_rule /* With YYDEBUG defined */
-#define yyss ada_yyss
-#define yysslim ada_yysslim
-#define yyssp ada_yyssp
-#define yystacksize ada_yystacksize
-#define yyvs ada_yyvs
-#define yyvsp ada_yyvsp
-
-#ifndef YYDEBUG
-#define YYDEBUG 1 /* Default to yydebug support */
-#endif
-
-#define YYFPRINTF parser_fprintf
+/* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
+ etc). */
+#define GDB_YY_REMAP_PREFIX ada_
+#include "yy-remap.h"
struct name_info {
struct symbol *sym;
static int yylex (void);
-void yyerror (char *);
+void yyerror (const char *);
static void write_int (struct parser_state *, LONGEST, struct type *);
static struct type *type_long_long (struct parser_state *);
-static struct type *type_float (struct parser_state *);
-
-static struct type *type_double (struct parser_state *);
-
static struct type *type_long_double (struct parser_state *);
static struct type *type_char (struct parser_state *);
struct type *type;
} typed_val;
struct {
- DOUBLEST dval;
+ gdb_byte val[16];
struct type *type;
} typed_val_float;
struct type *tval;
;
primary : FLOAT
- { write_exp_elt_opcode (pstate, OP_DOUBLE);
+ { write_exp_elt_opcode (pstate, OP_FLOAT);
write_exp_elt_type (pstate, $1.type);
- write_exp_elt_dblcst (pstate, $1.dval);
- write_exp_elt_opcode (pstate, OP_DOUBLE);
+ write_exp_elt_floatcst (pstate, $1.val);
+ write_exp_elt_opcode (pstate, OP_FLOAT);
}
;
int
ada_parse (struct parser_state *par_state)
{
- int result;
- struct cleanup *c = make_cleanup_clear_parser_state (&pstate);
-
/* Setting up the parser state. */
+ scoped_restore pstate_restore = make_scoped_restore (&pstate);
gdb_assert (par_state != NULL);
pstate = par_state;
obstack_free (&temp_parse_space, NULL);
obstack_init (&temp_parse_space);
- result = yyparse ();
- do_cleanups (c);
- return result;
+ return yyparse ();
}
void
-yyerror (char *msg)
+yyerror (const char *msg)
{
error (_("Error in expression, near `%s'."), lexptr);
}
/* Emit expression to access an instance of SYM, in block BLOCK (if
- * non-NULL), and with :: qualification ORIG_LEFT_CONTEXT. */
+ non-NULL). */
+
static void
write_var_from_sym (struct parser_state *par_state,
- const struct block *orig_left_context,
const struct block *block,
struct symbol *sym)
{
- if (orig_left_context == NULL && symbol_read_needs_frame (sym))
- {
- if (innermost_block == 0
- || contained_in (block, innermost_block))
- innermost_block = block;
- }
+ if (symbol_read_needs_frame (sym))
+ innermost_block.update (block, INNERMOST_BLOCK_FOR_SYMBOLS);
write_exp_elt_opcode (par_state, OP_VAR_VALUE);
write_exp_elt_block (par_state, block);
&inner_renaming_expr))
{
case ADA_NOT_RENAMING:
- write_var_from_sym (par_state, orig_left_context, sym_info.block,
- sym_info.symbol);
+ write_var_from_sym (par_state, sym_info.block, sym_info.symbol);
break;
case ADA_OBJECT_RENAMING:
write_object_renaming (par_state, sym_info.block,
end - renaming_expr);
renaming_expr = end;
- ada_lookup_encoded_symbol (index_name, NULL, VAR_DOMAIN,
- &index_sym_info);
+ ada_lookup_encoded_symbol (index_name, orig_left_context,
+ VAR_DOMAIN, &index_sym_info);
if (index_sym_info.symbol == NULL)
error (_("Could not find %s"), index_name);
else if (SYMBOL_CLASS (index_sym_info.symbol) == LOC_TYPEDEF)
/* Index is an old-style renaming symbol. */
index_sym_info.block = orig_left_context;
- write_var_from_sym (par_state, NULL, index_sym_info.block,
+ write_var_from_sym (par_state, index_sym_info.block,
index_sym_info.symbol);
}
if (slice_state == SIMPLE_INDEX)
struct block_symbol *syms;
int nsyms;
struct symtab *symtab;
+ struct cleanup *old_chain;
+ const struct block *result = NULL;
if (raw_name[0] == '\'')
{
name = ada_encode (raw_name);
nsyms = ada_lookup_symbol_list (name, context, VAR_DOMAIN, &syms);
+ old_chain = make_cleanup (xfree, syms);
+
if (context == NULL
&& (nsyms == 0 || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK))
symtab = lookup_symtab (name);
symtab = NULL;
if (symtab != NULL)
- return BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), STATIC_BLOCK);
+ result = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), STATIC_BLOCK);
else if (nsyms == 0 || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK)
{
if (context == NULL)
{
if (nsyms > 1)
warning (_("Function name \"%s\" ambiguous here"), raw_name);
- return SYMBOL_BLOCK_VALUE (syms[0].symbol);
+ result = SYMBOL_BLOCK_VALUE (syms[0].symbol);
}
+
+ do_cleanups (old_chain);
+ return result;
}
static struct symbol*
int depth;
char *encoded_name;
int name_len;
+ struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
if (block == NULL)
block = expression_context_block;
encoded_name[tail_index] = '\0';
nsyms = ada_lookup_symbol_list (encoded_name, block,
VAR_DOMAIN, &syms);
+ make_cleanup (xfree, syms);
encoded_name[tail_index] = terminator;
/* A single symbol may rename a package or object. */
write_object_renaming (par_state, block, renaming, renaming_len,
renaming_expr, MAX_RENAMING_CHAIN_LENGTH);
write_selectors (par_state, encoded_name + tail_index);
+ do_cleanups (old_chain);
return NULL;
default:
internal_error (__FILE__, __LINE__,
struct type *field_type;
if (tail_index == name_len)
- return SYMBOL_TYPE (type_sym);
+ {
+ do_cleanups (old_chain);
+ return SYMBOL_TYPE (type_sym);
+ }
/* We have some extraneous characters after the type name.
If this is an expression "TYPE_NAME.FIELD0.[...].FIELDN",
field_type
= get_symbol_field_type (type_sym, encoded_name + tail_index);
if (field_type != NULL)
- return field_type;
+ {
+ do_cleanups (old_chain);
+ return field_type;
+ }
else
error (_("Invalid attempt to select from type: \"%s\"."),
name0.ptr);
encoded_name);
if (type != NULL)
- return type;
+ {
+ do_cleanups (old_chain);
+ return type;
+ }
}
if (nsyms == 1)
{
- write_var_from_sym (par_state, block, syms[0].block,
- syms[0].symbol);
+ write_var_from_sym (par_state, syms[0].block, syms[0].symbol);
write_selectors (par_state, encoded_name + tail_index);
+ do_cleanups (old_chain);
return NULL;
}
else if (nsyms == 0)
write_exp_msymbol (par_state, msym);
/* Maybe cause error here rather than later? FIXME? */
write_selectors (par_state, encoded_name + tail_index);
+ do_cleanups (old_chain);
return NULL;
}
write_ambiguous_var (par_state, block, encoded_name,
tail_index);
write_selectors (par_state, encoded_name + tail_index);
+ do_cleanups (old_chain);
return NULL;
}
}
struct block_symbol *syms;
int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block,
VAR_DOMAIN, &syms);
+ struct cleanup *old_chain = make_cleanup (xfree, syms);
if (nsyms != 1 || SYMBOL_CLASS (syms[0].symbol) == LOC_TYPEDEF)
write_exp_op_with_string (par_state, OP_NAME, name);
else
- write_var_from_sym (par_state, NULL, syms[0].block, syms[0].symbol);
+ write_var_from_sym (par_state, syms[0].block, syms[0].symbol);
+
+ do_cleanups (old_chain);
}
else
if (write_var_or_type (par_state, NULL, name) != NULL)
return parse_type (par_state)->builtin_long_long;
}
-static struct type *
-type_float (struct parser_state *par_state)
-{
- return parse_type (par_state)->builtin_float;
-}
-
-static struct type *
-type_double (struct parser_state *par_state)
-{
- return parse_type (par_state)->builtin_double;
-}
-
static struct type *
type_long_double (struct parser_state *par_state)
{
return type != NULL ? type : parse_type (par_state)->builtin_data_ptr;
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_ada_exp;
-
void
_initialize_ada_exp (void)
{