/* YACC parser for C expressions, for GDB.
- Copyright (C) 1986-2021 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
static struct stoken typename_stoken (const char *);
static void check_parameter_typelist (std::vector<struct type *> *);
-#ifdef YYBISON
+#if defined(YYBISON) && YYBISON < 30800
static void c_print_token (FILE *file, int type, YYSTYPE value);
#define YYPRINT(FILE, TYPE, VALUE) c_print_token (FILE, TYPE, VALUE)
#endif
= lookup_symbol (copy.c_str (), $1,
VAR_DOMAIN, NULL).symbol;
- if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
+ if (!tem || tem->aclass () != LOC_BLOCK)
error (_("No function \"%s\" in specified context."),
copy.c_str ());
$$ = SYMBOL_BLOCK_VALUE (tem); }
variable: name_not_typename ENTRY
{ struct symbol *sym = $1.sym.symbol;
- if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
+ if (sym == NULL || !sym->is_argument ()
|| !symbol_read_needs_frame (sym))
error (_("@entry can be used only for function "
"parameters, not for \"%s\""),
if (symbol_read_needs_frame (sym.symbol))
pstate->block_tracker->update (sym);
- pstate->push_new<var_value_operation> (sym.symbol,
- sym.block);
+ pstate->push_new<var_value_operation> (sym);
}
;
= find_gnu_ifunc (sym.symbol);
if (resolver.minsym != NULL)
pstate->push_new<var_msym_value_operation>
- (resolver.minsym, resolver.objfile);
+ (resolver);
else
- pstate->push_new<var_value_operation>
- (sym.symbol, sym.block);
+ pstate->push_new<var_value_operation> (sym);
}
else if ($1.is_a_field_of_this)
{
? find_function_alias_target (msymbol)
: NULL);
if (alias_target != NULL)
- pstate->push_new<var_value_operation>
- (alias_target, SYMBOL_BLOCK_VALUE (alias_target));
+ {
+ block_symbol bsym { alias_target,
+ SYMBOL_BLOCK_VALUE (alias_target) };
+ pstate->push_new<var_value_operation> (bsym);
+ }
else
pstate->push_new<var_msym_value_operation>
- (msymbol.minsym, msymbol.objfile);
+ (msymbol);
}
}
;
cpstate->type_stack.insert (pstate,
copy_name ($2.stoken).c_str ());
}
+ | '@' UNKNOWN_CPP_NAME
+ {
+ cpstate->type_stack.insert (pstate,
+ copy_name ($2.stoken).c_str ());
+ }
;
qualifier_seq_noopt:
single_qualifier
- | qualifier_seq single_qualifier
+ | qualifier_seq_noopt single_qualifier
;
qualifier_seq:
| OPERATOR OBJC_LBRAC ']'
{ $$ = operator_stoken ("[]"); }
| OPERATOR conversion_type_id
- { string_file buf;
-
+ {
+ string_file buf;
c_print_type ($2, NULL, &buf, -1, 0,
&type_print_raw_options);
- std::string name = std::move (buf.string ());
+ std::string name = buf.release ();
/* This also needs canonicalization. */
gdb::unique_xmalloc_ptr<char> canon
|| type->code () == TYPE_CODE_UNION
|| type->code () == TYPE_CODE_NAMESPACE
|| (type->code () == TYPE_CODE_ENUM
- && TYPE_DECLARED_CLASS (type)));
+ && type->is_declared_class ()));
}
/* Validate a parameter typelist. */
{
{">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
{"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
- {"->*", ARROW_STAR, BINOP_END, FLAG_CXX},
- {"...", DOTDOTDOT, BINOP_END, 0}
+ {"->*", ARROW_STAR, OP_NULL, FLAG_CXX},
+ {"...", DOTDOTDOT, OP_NULL, 0}
};
static const struct token tokentab2[] =
{"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
{"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
{"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
- {"++", INCREMENT, BINOP_END, 0},
- {"--", DECREMENT, BINOP_END, 0},
- {"->", ARROW, BINOP_END, 0},
- {"&&", ANDAND, BINOP_END, 0},
- {"||", OROR, BINOP_END, 0},
+ {"++", INCREMENT, OP_NULL, 0},
+ {"--", DECREMENT, OP_NULL, 0},
+ {"->", ARROW, OP_NULL, 0},
+ {"&&", ANDAND, OP_NULL, 0},
+ {"||", OROR, OP_NULL, 0},
/* "::" is *not* only C++: gdb overrides its meaning in several
different ways, e.g., 'filename'::func, function::variable. */
- {"::", COLONCOLON, BINOP_END, 0},
- {"<<", LSH, BINOP_END, 0},
- {">>", RSH, BINOP_END, 0},
- {"==", EQUAL, BINOP_END, 0},
- {"!=", NOTEQUAL, BINOP_END, 0},
- {"<=", LEQ, BINOP_END, 0},
- {">=", GEQ, BINOP_END, 0},
- {".*", DOT_STAR, BINOP_END, FLAG_CXX}
+ {"::", COLONCOLON, OP_NULL, 0},
+ {"<<", LSH, OP_NULL, 0},
+ {">>", RSH, OP_NULL, 0},
+ {"==", EQUAL, OP_NULL, 0},
+ {"!=", NOTEQUAL, OP_NULL, 0},
+ {"<=", LEQ, OP_NULL, 0},
+ {">=", GEQ, OP_NULL, 0},
+ {".*", DOT_STAR, OP_NULL, FLAG_CXX}
};
/* Identifier-like tokens. Only type-specifiers than can appear in
{"delete", DELETE, OP_NULL, FLAG_CXX},
{"operator", OPERATOR, OP_NULL, FLAG_CXX},
- {"and", ANDAND, BINOP_END, FLAG_CXX},
+ {"and", ANDAND, OP_NULL, FLAG_CXX},
{"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX},
{"bitand", '&', OP_NULL, FLAG_CXX},
{"bitor", '|', OP_NULL, FLAG_CXX},
{"compl", '~', OP_NULL, FLAG_CXX},
{"not", '!', OP_NULL, FLAG_CXX},
- {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX},
- {"or", OROR, BINOP_END, FLAG_CXX},
+ {"not_eq", NOTEQUAL, OP_NULL, FLAG_CXX},
+ {"or", OROR, OP_NULL, FLAG_CXX},
{"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
{"xor", '^', OP_NULL, FLAG_CXX},
{"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
{
int c;
int namelen;
- unsigned int i;
const char *tokstart;
bool saw_structop = last_was_structop;
tokstart = pstate->lexptr;
/* See if it is a special token of length 3. */
- for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
- if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
+ for (const auto &token : tokentab3)
+ if (strncmp (tokstart, token.oper, 3) == 0)
{
- if ((tokentab3[i].flags & FLAG_CXX) != 0
+ if ((token.flags & FLAG_CXX) != 0
&& par_state->language ()->la_language != language_cplus)
break;
- gdb_assert ((tokentab3[i].flags & FLAG_C) == 0);
+ gdb_assert ((token.flags & FLAG_C) == 0);
pstate->lexptr += 3;
- yylval.opcode = tokentab3[i].opcode;
- return tokentab3[i].token;
+ yylval.opcode = token.opcode;
+ return token.token;
}
/* See if it is a special token of length 2. */
- for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
- if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
+ for (const auto &token : tokentab2)
+ if (strncmp (tokstart, token.oper, 2) == 0)
{
- if ((tokentab2[i].flags & FLAG_CXX) != 0
+ if ((token.flags & FLAG_CXX) != 0
&& par_state->language ()->la_language != language_cplus)
break;
- gdb_assert ((tokentab2[i].flags & FLAG_C) == 0);
+ gdb_assert ((token.flags & FLAG_C) == 0);
pstate->lexptr += 2;
- yylval.opcode = tokentab2[i].opcode;
- if (tokentab2[i].token == ARROW)
+ yylval.opcode = token.opcode;
+ if (token.token == ARROW)
last_was_structop = 1;
- return tokentab2[i].token;
+ return token.token;
}
switch (c = *tokstart)
/* Catch specific keywords. */
std::string copy = copy_name (yylval.sval);
- for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
- if (copy == ident_tokens[i].oper)
+ for (const auto &token : ident_tokens)
+ if (copy == token.oper)
{
- if ((ident_tokens[i].flags & FLAG_CXX) != 0
+ if ((token.flags & FLAG_CXX) != 0
&& par_state->language ()->la_language != language_cplus)
break;
- if ((ident_tokens[i].flags & FLAG_C) != 0
+ if ((token.flags & FLAG_C) != 0
&& par_state->language ()->la_language != language_c
&& par_state->language ()->la_language != language_objc)
break;
- if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
+ if ((token.flags & FLAG_SHADOW) != 0)
{
struct field_of_this_result is_a_field_of_this;
/* It is ok to always set this, even though we don't always
strictly need to. */
- yylval.opcode = ident_tokens[i].opcode;
- return ident_tokens[i].token;
+ yylval.opcode = token.opcode;
+ return token.token;
}
if (*tokstart == '$')
par_state->language ()->name_of_this ()
? &is_a_field_of_this : NULL);
- if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_BLOCK)
+ if (bsym.symbol && bsym.symbol->aclass () == LOC_BLOCK)
{
yylval.ssym.sym = bsym;
yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
&inner_is_a_field_of_this);
if (bsym.symbol != NULL)
{
- yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);
+ yylval.tsym.type = bsym.symbol->type ();
return TYPENAME;
}
}
symtab = lookup_symtab (copy.c_str ());
if (symtab)
{
- yylval.bval = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab),
+ yylval.bval = BLOCKVECTOR_BLOCK (symtab->blockvector (),
STATIC_BLOCK);
return FILENAME;
}
}
}
- if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_TYPEDEF)
+ if (bsym.symbol && bsym.symbol->aclass () == LOC_TYPEDEF)
{
- yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);
+ yylval.tsym.type = bsym.symbol->type ();
return TYPENAME;
}
sym = lookup_struct_typedef (copy.c_str (),
par_state->expression_context_block, 1);
if (sym)
- yylval.theclass.type = SYMBOL_TYPE (sym);
+ yylval.theclass.type = sym->type ();
return CLASSNAME;
}
}
return ERROR;
}
- switch (SYMBOL_CLASS (yylval.ssym.sym.symbol))
+ switch (yylval.ssym.sym.symbol->aclass ())
{
case LOC_BLOCK:
case LOC_LABEL:
return ERROR;
case LOC_TYPEDEF:
- yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
+ yylval.tsym.type = yylval.ssym.sym.symbol->type ();
return TYPENAME;
default:
return result;
}
-#ifdef YYBISON
+#if defined(YYBISON) && YYBISON < 30800
+
/* This is called via the YYPRINT macro when parser debugging is
enabled. It prints a token's value. */
projects / binutils-gdb.git / blobdiff