/* YACC grammar for Modula-2 expressions, for GDB.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
Generated from expread.y (now c-exp.y) and contributed by the Department
of Computer Science at the State University of New York at Buffalo, 1991.
#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
#include "block.h"
-#define parse_type(ps) builtin_type (parse_gdbarch (ps))
-#define parse_m2_type(ps) builtin_m2_type (parse_gdbarch (ps))
+#define parse_type(ps) builtin_type (ps->gdbarch ())
+#define parse_m2_type(ps) builtin_m2_type (ps->gdbarch ())
/* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
etc). */
static int yylex (void);
-void yyerror (const char *);
+static void yyerror (const char *);
static int parse_number (int);
/* The GDB scope operator */
%token COLONCOLON
-%token <voidval> INTERNAL_VAR
+%token <voidval> DOLLAR_VARIABLE
/* M2 tokens */
%left ','
/* This function just saves the number of arguments
that follow in the list. It is *not* specific to
function types */
- { start_arglist(); }
+ { pstate->start_arglist(); }
non_empty_arglist ']' %prec DOT
{ write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
write_exp_elt_longcst (pstate,
- (LONGEST) end_arglist());
+ pstate->end_arglist());
write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT); }
;
exp : exp '('
/* This is to save the value of arglist_len
being accumulated by an outer function call. */
- { start_arglist (); }
+ { pstate->start_arglist (); }
arglist ')' %prec DOT
{ write_exp_elt_opcode (pstate, OP_FUNCALL);
write_exp_elt_longcst (pstate,
- (LONGEST) end_arglist ());
+ pstate->end_arglist ());
write_exp_elt_opcode (pstate, OP_FUNCALL); }
;
;
arglist : exp
- { arglist_len = 1; }
+ { pstate->arglist_len = 1; }
;
arglist : arglist ',' exp %prec ABOVE_COMMA
- { arglist_len++; }
+ { pstate->arglist_len++; }
;
non_empty_arglist
: exp
- { arglist_len = 1; }
+ { pstate->arglist_len = 1; }
;
non_empty_arglist
: non_empty_arglist ',' exp %prec ABOVE_COMMA
- { arglist_len++; }
+ { pstate->arglist_len++; }
;
/* GDB construct */
fblock : BLOCKNAME
{ struct symbol *sym
- = lookup_symbol (copy_name ($1),
- expression_context_block,
+ = lookup_symbol (copy_name ($1).c_str (),
+ pstate->expression_context_block,
VAR_DOMAIN, 0).symbol;
$$ = sym;}
;
/* GDB scope operator */
fblock : block COLONCOLON BLOCKNAME
{ struct symbol *tem
- = lookup_symbol (copy_name ($3), $1,
+ = lookup_symbol (copy_name ($3).c_str (), $1,
VAR_DOMAIN, 0).symbol;
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error (_("No function \"%s\" in specified context."),
- copy_name ($3));
+ copy_name ($3).c_str ());
$$ = tem;
}
;
;
/* GDB internal ($foo) variable */
-variable: INTERNAL_VAR
+variable: DOLLAR_VARIABLE
;
/* GDB scope operator */
variable: block COLONCOLON NAME
{ struct block_symbol sym
- = lookup_symbol (copy_name ($3), $1,
+ = lookup_symbol (copy_name ($3).c_str (), $1,
VAR_DOMAIN, 0);
if (sym.symbol == 0)
error (_("No symbol \"%s\" in specified context."),
- copy_name ($3));
+ copy_name ($3).c_str ());
if (symbol_read_needs_frame (sym.symbol))
- innermost_block.update (sym);
+ pstate->block_tracker->update (sym);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
write_exp_elt_block (pstate, sym.block);
{ struct block_symbol sym;
struct field_of_this_result is_a_field_of_this;
- sym = lookup_symbol (copy_name ($1),
- expression_context_block,
- VAR_DOMAIN,
- &is_a_field_of_this);
+ sym
+ = lookup_symbol (copy_name ($1).c_str (),
+ pstate->expression_context_block,
+ VAR_DOMAIN,
+ &is_a_field_of_this);
if (sym.symbol)
{
if (symbol_read_needs_frame (sym.symbol))
- innermost_block.update (sym);
+ pstate->block_tracker->update (sym);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
write_exp_elt_block (pstate, sym.block);
else
{
struct bound_minimal_symbol msymbol;
- char *arg = copy_name ($1);
+ std::string arg = copy_name ($1);
msymbol =
- lookup_bound_minimal_symbol (arg);
+ lookup_bound_minimal_symbol (arg.c_str ());
if (msymbol.minsym != NULL)
write_exp_msymbol (pstate, msymbol);
else if (!have_full_symbols () && !have_partial_symbols ())
error (_("No symbol table is loaded. Use the \"symbol-file\" command."));
else
error (_("No symbol \"%s\" in current context."),
- copy_name ($1));
+ arg.c_str ());
}
}
;
type
: TYPENAME
- { $$ = lookup_typename (parse_language (pstate),
- parse_gdbarch (pstate),
- copy_name ($1),
- expression_context_block, 0); }
+ { $$
+ = lookup_typename (pstate->language (),
+ copy_name ($1).c_str (),
+ pstate->expression_context_block,
+ 0);
+ }
;
static int
parse_number (int olen)
{
- const char *p = lexptr;
+ const char *p = pstate->lexptr;
LONGEST n = 0;
LONGEST prevn = 0;
int c,i,ischar=0;
yylval.val))
return ERROR;
- lexptr += len;
+ pstate->lexptr += len;
return FLOAT;
}
if (p[c] == '.' && base != 10)
prevn=n;
}
- lexptr = p;
+ pstate->lexptr = p;
if(*p == 'B' || *p == 'C' || *p == 'H')
- lexptr++; /* Advance past B,C or H */
+ pstate->lexptr++; /* Advance past B,C or H */
if (ischar)
{
};
+/* Depth of parentheses. */
+static int paren_depth;
+
/* Read one token, getting characters through lexptr. */
/* This is where we will check to make sure that the language and the
retry:
- prev_lexptr = lexptr;
+ pstate->prev_lexptr = pstate->lexptr;
- tokstart = lexptr;
+ tokstart = pstate->lexptr;
/* See if it is a special token of length 2 */
for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)
if (strncmp (tokentab2[i].name, tokstart, 2) == 0)
{
- lexptr += 2;
+ pstate->lexptr += 2;
return tokentab2[i].token;
}
case ' ':
case '\t':
case '\n':
- lexptr++;
+ pstate->lexptr++;
goto retry;
case '(':
paren_depth++;
- lexptr++;
+ pstate->lexptr++;
return c;
case ')':
if (paren_depth == 0)
return 0;
paren_depth--;
- lexptr++;
+ pstate->lexptr++;
return c;
case ',':
- if (comma_terminates && paren_depth == 0)
+ if (pstate->comma_terminates && paren_depth == 0)
return 0;
- lexptr++;
+ pstate->lexptr++;
return c;
case '.':
/* Might be a floating point number. */
- if (lexptr[1] >= '0' && lexptr[1] <= '9')
+ if (pstate->lexptr[1] >= '0' && pstate->lexptr[1] <= '9')
break; /* Falls into number code. */
else
{
- lexptr++;
+ pstate->lexptr++;
return DOT;
}
case '@':
case '~':
case '&':
- lexptr++;
+ pstate->lexptr++;
return c;
case '\'' :
error (_("Unterminated string or character constant."));
yylval.sval.ptr = tokstart + 1;
yylval.sval.length = namelen - 1;
- lexptr += namelen + 1;
+ pstate->lexptr += namelen + 1;
if(namelen == 2) /* Single character */
{
err_copy[p - tokstart] = 0;
error (_("Invalid number \"%s\"."), err_copy);
}
- lexptr = p;
+ pstate->lexptr = p;
return toktype;
}
return 0;
}
- lexptr += namelen;
+ pstate->lexptr += namelen;
/* Lookup special keywords */
for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)
if (*tokstart == '$')
{
write_dollar_variable (pstate, yylval.sval);
- return INTERNAL_VAR;
+ return DOLLAR_VARIABLE;
}
/* Use token-type BLOCKNAME for symbols that happen to be defined as
currently as names of types; NAME for other symbols.
The caller is not constrained to care about the distinction. */
{
-
-
- char *tmp = copy_name (yylval.sval);
+ std::string tmp = copy_name (yylval.sval);
struct symbol *sym;
- if (lookup_symtab (tmp))
+ if (lookup_symtab (tmp.c_str ()))
return BLOCKNAME;
- sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0).symbol;
+ sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
+ VAR_DOMAIN, 0).symbol;
if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
return BLOCKNAME;
- if (lookup_typename (parse_language (pstate), parse_gdbarch (pstate),
- copy_name (yylval.sval),
- expression_context_block, 1))
+ if (lookup_typename (pstate->language (),
+ tmp.c_str (), pstate->expression_context_block, 1))
return TYPENAME;
if(sym)
scoped_restore pstate_restore = make_scoped_restore (&pstate);
gdb_assert (par_state != NULL);
pstate = par_state;
+ paren_depth = 0;
return yyparse ();
}
-void
+static void
yyerror (const char *msg)
{
- if (prev_lexptr)
- lexptr = prev_lexptr;
+ if (pstate->prev_lexptr)
+ pstate->lexptr = pstate->prev_lexptr;
- error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
+ error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);
}
projects / deliverable / binutils-gdb.git / blobdiff