/* YACC parser for C expressions, for GDB.
- Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2003, 2004, 2006, 2007, 2008
- Free Software Foundation, Inc.
+ Copyright (C) 1986-2015 Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is 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.
-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.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Parse a C expression from text in a string,
and return the result as a struct expression pointer.
with include files (<malloc.h> and <stdlib.h> for example) just became
too messy, particularly when such includes can be inserted at random
times by the parser generator. */
-
+
%{
#include "defs.h"
-#include "gdb_string.h"
#include <ctype.h>
#include "expression.h"
#include "value.h"
#include "block.h"
#include "cp-support.h"
#include "dfp.h"
+#include "macroscope.h"
+#include "objc-lang.h"
+#include "typeprint.h"
+#include "cp-abi.h"
+
+#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
#define yygindex c_yygindex
#define yytable c_yytable
#define yycheck c_yycheck
+#define yyss c_yyss
+#define yysslim c_yysslim
+#define yyssp c_yyssp
+#define yystacksize c_yystacksize
+#define yyvs c_yyvs
+#define yyvsp c_yyvsp
#ifndef YYDEBUG
#define YYDEBUG 1 /* Default to yydebug support */
#define YYFPRINTF parser_fprintf
+/* The state of the parser, used internally when we are parsing the
+ expression. */
+
+static struct parser_state *pstate = NULL;
+
int yyparse (void);
static int yylex (void);
void yyerror (char *);
+static int type_aggregate_p (struct type *);
+
%}
/* Although the yacc "value" of an expression is not used,
gdb_byte val[16];
struct type *type;
} typed_val_decfloat;
- struct symbol *sym;
struct type *tval;
struct stoken sval;
+ struct typed_stoken tsval;
struct ttype tsym;
struct symtoken ssym;
int voidval;
- struct block *bval;
+ const struct block *bval;
enum exp_opcode opcode;
- struct internalvar *ivar;
- struct type **tvec;
- int *ivec;
+ struct stoken_vector svec;
+ VEC (type_ptr) *tvec;
+
+ struct type_stack *type_stack;
+
+ struct objc_class_str theclass;
}
%{
/* YYSTYPE gets defined by %union */
-static int parse_number (char *, int, int, YYSTYPE *);
+static int parse_number (struct parser_state *par_state,
+ const char *, int, int, YYSTYPE *);
+static struct stoken operator_stoken (const char *);
+static void check_parameter_typelist (VEC (type_ptr) *);
+static void write_destructor_name (struct parser_state *par_state,
+ struct stoken);
+
+#ifdef YYBISON
+static void c_print_token (FILE *file, int type, YYSTYPE value);
+#define YYPRINT(FILE, TYPE, VALUE) c_print_token (FILE, TYPE, VALUE)
+#endif
%}
%type <voidval> exp exp1 type_exp start variable qualified_name lcurly
%type <lval> rcurly
-%type <tval> type typebase qualified_type
-%type <tvec> nonempty_typelist
+%type <tval> type typebase
+%type <tvec> nonempty_typelist func_mod parameter_typelist
/* %type <bval> block */
/* Fancy type parsing. */
-%type <voidval> func_mod direct_abs_decl abs_decl
%type <tval> ptype
%type <lval> array_mod
+%type <tval> conversion_type_id
+
+%type <type_stack> ptr_operator_ts abs_decl direct_abs_decl
%token <typed_val_int> INT
%token <typed_val_float> FLOAT
Contexts where this distinction is not important can use the
nonterminal "name", which matches either NAME or TYPENAME. */
-%token <sval> STRING
+%token <tsval> STRING
+%token <sval> NSSTRING /* ObjC Foundation "NSString" literal */
+%token SELECTOR /* ObjC "@selector" pseudo-operator */
+%token <tsval> CHAR
%token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
+%token <ssym> UNKNOWN_CPP_NAME
%token <voidval> COMPLETE
%token <tsym> TYPENAME
+%token <theclass> CLASSNAME /* ObjC Class name */
%type <sval> name
+%type <svec> string_exp
%type <ssym> name_not_typename
-%type <tsym> typename
+%type <tsym> type_name
+
+ /* This is like a '[' token, but is only generated when parsing
+ Objective C. This lets us reuse the same parser without
+ erroneously parsing ObjC-specific expressions in C. */
+%token OBJC_LBRAC
/* A NAME_OR_INT is a symbol which is not known in the symbol table,
but which would parse as a valid number in the current input radix.
E.g. "c" when input_radix==16. Depending on the parse, it will be
turned into a name or into a number. */
-%token <ssym> NAME_OR_INT
+%token <ssym> NAME_OR_INT
+%token OPERATOR
%token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
%token TEMPLATE
%token ERROR
+%token NEW DELETE
+%type <sval> oper
+%token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST
+%token ENTRY
+%token TYPEOF
+%token DECLTYPE
+%token TYPEID
/* 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
-%token <voidval> VARIABLE
+%token <sval> VARIABLE
%token <opcode> ASSIGN_MODIFY
%left '+' '-'
%left '*' '/' '%'
%right UNARY INCREMENT DECREMENT
-%right ARROW '.' '[' '('
-%token <ssym> BLOCKNAME
+%right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '('
+%token <ssym> BLOCKNAME
%token <bval> FILENAME
%type <bval> block
%left COLONCOLON
+%token DOTDOTDOT
+
\f
%%
;
type_exp: type
- { write_exp_elt_opcode(OP_TYPE);
- write_exp_elt_type($1);
- write_exp_elt_opcode(OP_TYPE);}
+ { write_exp_elt_opcode(pstate, OP_TYPE);
+ write_exp_elt_type(pstate, $1);
+ write_exp_elt_opcode(pstate, OP_TYPE);}
+ | TYPEOF '(' exp ')'
+ {
+ write_exp_elt_opcode (pstate, OP_TYPEOF);
+ }
+ | TYPEOF '(' type ')'
+ {
+ write_exp_elt_opcode (pstate, OP_TYPE);
+ write_exp_elt_type (pstate, $3);
+ write_exp_elt_opcode (pstate, OP_TYPE);
+ }
+ | DECLTYPE '(' exp ')'
+ {
+ write_exp_elt_opcode (pstate, OP_DECLTYPE);
+ }
;
/* Expressions, including the comma operator. */
exp1 : exp
| exp1 ',' exp
- { write_exp_elt_opcode (BINOP_COMMA); }
+ { write_exp_elt_opcode (pstate, BINOP_COMMA); }
;
/* Expressions, not including the comma operator. */
exp : '*' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_IND); }
+ { write_exp_elt_opcode (pstate, UNOP_IND); }
;
exp : '&' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_ADDR); }
+ { write_exp_elt_opcode (pstate, UNOP_ADDR); }
;
exp : '-' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_NEG); }
+ { write_exp_elt_opcode (pstate, UNOP_NEG); }
;
exp : '+' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_PLUS); }
+ { write_exp_elt_opcode (pstate, UNOP_PLUS); }
;
exp : '!' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
+ { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
;
exp : '~' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_COMPLEMENT); }
+ { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
;
exp : INCREMENT exp %prec UNARY
- { write_exp_elt_opcode (UNOP_PREINCREMENT); }
+ { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
;
exp : DECREMENT exp %prec UNARY
- { write_exp_elt_opcode (UNOP_PREDECREMENT); }
+ { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
;
exp : exp INCREMENT %prec UNARY
- { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
+ { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
;
exp : exp DECREMENT %prec UNARY
- { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
+ { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
+ ;
+
+exp : TYPEID '(' exp ')' %prec UNARY
+ { write_exp_elt_opcode (pstate, OP_TYPEID); }
+ ;
+
+exp : TYPEID '(' type_exp ')' %prec UNARY
+ { write_exp_elt_opcode (pstate, OP_TYPEID); }
;
exp : SIZEOF exp %prec UNARY
- { write_exp_elt_opcode (UNOP_SIZEOF); }
+ { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
;
exp : exp ARROW name
- { write_exp_elt_opcode (STRUCTOP_PTR);
- write_exp_string ($3);
- write_exp_elt_opcode (STRUCTOP_PTR); }
+ { write_exp_elt_opcode (pstate, STRUCTOP_PTR);
+ write_exp_string (pstate, $3);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
;
exp : exp ARROW name COMPLETE
- { mark_struct_expression ();
- write_exp_elt_opcode (STRUCTOP_PTR);
- write_exp_string ($3);
- write_exp_elt_opcode (STRUCTOP_PTR); }
+ { mark_struct_expression (pstate);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR);
+ write_exp_string (pstate, $3);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
;
exp : exp ARROW COMPLETE
{ struct stoken s;
- mark_struct_expression ();
- write_exp_elt_opcode (STRUCTOP_PTR);
+ mark_struct_expression (pstate);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR);
s.ptr = "";
s.length = 0;
- write_exp_string (s);
- write_exp_elt_opcode (STRUCTOP_PTR); }
+ write_exp_string (pstate, s);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
+ ;
+
+exp : exp ARROW '~' name
+ { write_exp_elt_opcode (pstate, STRUCTOP_PTR);
+ write_destructor_name (pstate, $4);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
+ ;
+
+exp : exp ARROW '~' name COMPLETE
+ { mark_struct_expression (pstate);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR);
+ write_destructor_name (pstate, $4);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
;
exp : exp ARROW qualified_name
{ /* exp->type::name becomes exp->*(&type::name) */
/* Note: this doesn't work if name is a
static member! FIXME */
- write_exp_elt_opcode (UNOP_ADDR);
- write_exp_elt_opcode (STRUCTOP_MPTR); }
+ write_exp_elt_opcode (pstate, UNOP_ADDR);
+ write_exp_elt_opcode (pstate, STRUCTOP_MPTR); }
;
-exp : exp ARROW '*' exp
- { write_exp_elt_opcode (STRUCTOP_MPTR); }
+exp : exp ARROW_STAR exp
+ { write_exp_elt_opcode (pstate, STRUCTOP_MPTR); }
;
exp : exp '.' name
- { write_exp_elt_opcode (STRUCTOP_STRUCT);
- write_exp_string ($3);
- write_exp_elt_opcode (STRUCTOP_STRUCT); }
+ { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
+ write_exp_string (pstate, $3);
+ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
;
exp : exp '.' name COMPLETE
- { mark_struct_expression ();
- write_exp_elt_opcode (STRUCTOP_STRUCT);
- write_exp_string ($3);
- write_exp_elt_opcode (STRUCTOP_STRUCT); }
+ { mark_struct_expression (pstate);
+ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
+ write_exp_string (pstate, $3);
+ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
;
exp : exp '.' COMPLETE
{ struct stoken s;
- mark_struct_expression ();
- write_exp_elt_opcode (STRUCTOP_STRUCT);
+ mark_struct_expression (pstate);
+ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
s.ptr = "";
s.length = 0;
- write_exp_string (s);
- write_exp_elt_opcode (STRUCTOP_STRUCT); }
+ write_exp_string (pstate, s);
+ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
+ ;
+
+exp : exp '.' '~' name
+ { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
+ write_destructor_name (pstate, $4);
+ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
+ ;
+
+exp : exp '.' '~' name COMPLETE
+ { mark_struct_expression (pstate);
+ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
+ write_destructor_name (pstate, $4);
+ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
;
exp : exp '.' qualified_name
{ /* exp.type::name becomes exp.*(&type::name) */
/* Note: this doesn't work if name is a
static member! FIXME */
- write_exp_elt_opcode (UNOP_ADDR);
- write_exp_elt_opcode (STRUCTOP_MEMBER); }
+ write_exp_elt_opcode (pstate, UNOP_ADDR);
+ write_exp_elt_opcode (pstate, STRUCTOP_MEMBER); }
;
-exp : exp '.' '*' exp
- { write_exp_elt_opcode (STRUCTOP_MEMBER); }
+exp : exp DOT_STAR exp
+ { write_exp_elt_opcode (pstate, STRUCTOP_MEMBER); }
;
exp : exp '[' exp1 ']'
- { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
+ { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
+ ;
+
+exp : exp OBJC_LBRAC exp1 ']'
+ { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
+ ;
+
+/*
+ * The rules below parse ObjC message calls of the form:
+ * '[' target selector {':' argument}* ']'
+ */
+
+exp : OBJC_LBRAC TYPENAME
+ {
+ CORE_ADDR theclass;
+
+ theclass = lookup_objc_class (parse_gdbarch (pstate),
+ copy_name ($2.stoken));
+ if (theclass == 0)
+ error (_("%s is not an ObjC Class"),
+ copy_name ($2.stoken));
+ write_exp_elt_opcode (pstate, OP_LONG);
+ write_exp_elt_type (pstate,
+ parse_type (pstate)->builtin_int);
+ write_exp_elt_longcst (pstate, (LONGEST) theclass);
+ write_exp_elt_opcode (pstate, OP_LONG);
+ start_msglist();
+ }
+ msglist ']'
+ { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
+ end_msglist (pstate);
+ write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
+ }
+ ;
+
+exp : OBJC_LBRAC CLASSNAME
+ {
+ write_exp_elt_opcode (pstate, OP_LONG);
+ write_exp_elt_type (pstate,
+ parse_type (pstate)->builtin_int);
+ write_exp_elt_longcst (pstate, (LONGEST) $2.theclass);
+ write_exp_elt_opcode (pstate, OP_LONG);
+ start_msglist();
+ }
+ msglist ']'
+ { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
+ end_msglist (pstate);
+ write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
+ }
+ ;
+
+exp : OBJC_LBRAC exp
+ { start_msglist(); }
+ msglist ']'
+ { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
+ end_msglist (pstate);
+ write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
+ }
+ ;
+
+msglist : name
+ { add_msglist(&$1, 0); }
+ | msgarglist
;
-exp : exp '('
+msgarglist : msgarg
+ | msgarglist msgarg
+ ;
+
+msgarg : name ':' exp
+ { add_msglist(&$1, 1); }
+ | ':' exp /* Unnamed arg. */
+ { add_msglist(0, 1); }
+ | ',' exp /* Variable number of args. */
+ { add_msglist(0, 0); }
+ ;
+
+exp : exp '('
/* This is to save the value of arglist_len
being accumulated by an outer function call. */
{ start_arglist (); }
arglist ')' %prec ARROW
- { write_exp_elt_opcode (OP_FUNCALL);
- write_exp_elt_longcst ((LONGEST) end_arglist ());
- write_exp_elt_opcode (OP_FUNCALL); }
+ { write_exp_elt_opcode (pstate, OP_FUNCALL);
+ write_exp_elt_longcst (pstate,
+ (LONGEST) end_arglist ());
+ write_exp_elt_opcode (pstate, OP_FUNCALL); }
+ ;
+
+exp : UNKNOWN_CPP_NAME '('
+ {
+ /* This could potentially be a an argument defined
+ lookup function (Koenig). */
+ write_exp_elt_opcode (pstate, OP_ADL_FUNC);
+ write_exp_elt_block (pstate,
+ expression_context_block);
+ write_exp_elt_sym (pstate,
+ NULL); /* Placeholder. */
+ write_exp_string (pstate, $1.stoken);
+ write_exp_elt_opcode (pstate, OP_ADL_FUNC);
+
+ /* This is to save the value of arglist_len
+ being accumulated by an outer function call. */
+
+ start_arglist ();
+ }
+ arglist ')' %prec ARROW
+ {
+ write_exp_elt_opcode (pstate, OP_FUNCALL);
+ write_exp_elt_longcst (pstate,
+ (LONGEST) end_arglist ());
+ write_exp_elt_opcode (pstate, OP_FUNCALL);
+ }
;
lcurly : '{'
{ arglist_len++; }
;
+exp : exp '(' parameter_typelist ')' const_or_volatile
+ { int i;
+ VEC (type_ptr) *type_list = $3;
+ struct type *type_elt;
+ LONGEST len = VEC_length (type_ptr, type_list);
+
+ write_exp_elt_opcode (pstate, TYPE_INSTANCE);
+ write_exp_elt_longcst (pstate, len);
+ for (i = 0;
+ VEC_iterate (type_ptr, type_list, i, type_elt);
+ ++i)
+ write_exp_elt_type (pstate, type_elt);
+ write_exp_elt_longcst(pstate, len);
+ write_exp_elt_opcode (pstate, TYPE_INSTANCE);
+ VEC_free (type_ptr, type_list);
+ }
+ ;
+
rcurly : '}'
{ $$ = end_arglist () - 1; }
;
exp : lcurly arglist rcurly %prec ARROW
- { write_exp_elt_opcode (OP_ARRAY);
- write_exp_elt_longcst ((LONGEST) 0);
- write_exp_elt_longcst ((LONGEST) $3);
- write_exp_elt_opcode (OP_ARRAY); }
+ { write_exp_elt_opcode (pstate, OP_ARRAY);
+ write_exp_elt_longcst (pstate, (LONGEST) 0);
+ write_exp_elt_longcst (pstate, (LONGEST) $3);
+ write_exp_elt_opcode (pstate, OP_ARRAY); }
;
-exp : lcurly type rcurly exp %prec UNARY
- { write_exp_elt_opcode (UNOP_MEMVAL);
- write_exp_elt_type ($2);
- write_exp_elt_opcode (UNOP_MEMVAL); }
+exp : lcurly type_exp rcurly exp %prec UNARY
+ { write_exp_elt_opcode (pstate, UNOP_MEMVAL_TYPE); }
;
-exp : '(' type ')' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_CAST);
- write_exp_elt_type ($2);
- write_exp_elt_opcode (UNOP_CAST); }
+exp : '(' type_exp ')' exp %prec UNARY
+ { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }
;
exp : '(' exp1 ')'
/* Binary operators in order of decreasing precedence. */
exp : exp '@' exp
- { write_exp_elt_opcode (BINOP_REPEAT); }
+ { write_exp_elt_opcode (pstate, BINOP_REPEAT); }
;
exp : exp '*' exp
- { write_exp_elt_opcode (BINOP_MUL); }
+ { write_exp_elt_opcode (pstate, BINOP_MUL); }
;
exp : exp '/' exp
- { write_exp_elt_opcode (BINOP_DIV); }
+ { write_exp_elt_opcode (pstate, BINOP_DIV); }
;
exp : exp '%' exp
- { write_exp_elt_opcode (BINOP_REM); }
+ { write_exp_elt_opcode (pstate, BINOP_REM); }
;
exp : exp '+' exp
- { write_exp_elt_opcode (BINOP_ADD); }
+ { write_exp_elt_opcode (pstate, BINOP_ADD); }
;
exp : exp '-' exp
- { write_exp_elt_opcode (BINOP_SUB); }
+ { write_exp_elt_opcode (pstate, BINOP_SUB); }
;
exp : exp LSH exp
- { write_exp_elt_opcode (BINOP_LSH); }
+ { write_exp_elt_opcode (pstate, BINOP_LSH); }
;
exp : exp RSH exp
- { write_exp_elt_opcode (BINOP_RSH); }
+ { write_exp_elt_opcode (pstate, BINOP_RSH); }
;
exp : exp EQUAL exp
- { write_exp_elt_opcode (BINOP_EQUAL); }
+ { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
;
exp : exp NOTEQUAL exp
- { write_exp_elt_opcode (BINOP_NOTEQUAL); }
+ { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
;
exp : exp LEQ exp
- { write_exp_elt_opcode (BINOP_LEQ); }
+ { write_exp_elt_opcode (pstate, BINOP_LEQ); }
;
exp : exp GEQ exp
- { write_exp_elt_opcode (BINOP_GEQ); }
+ { write_exp_elt_opcode (pstate, BINOP_GEQ); }
;
exp : exp '<' exp
- { write_exp_elt_opcode (BINOP_LESS); }
+ { write_exp_elt_opcode (pstate, BINOP_LESS); }
;
exp : exp '>' exp
- { write_exp_elt_opcode (BINOP_GTR); }
+ { write_exp_elt_opcode (pstate, BINOP_GTR); }
;
exp : exp '&' exp
- { write_exp_elt_opcode (BINOP_BITWISE_AND); }
+ { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
;
exp : exp '^' exp
- { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
+ { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
;
exp : exp '|' exp
- { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
+ { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
;
exp : exp ANDAND exp
- { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
+ { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
;
exp : exp OROR exp
- { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
+ { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
;
exp : exp '?' exp ':' exp %prec '?'
- { write_exp_elt_opcode (TERNOP_COND); }
+ { write_exp_elt_opcode (pstate, TERNOP_COND); }
;
-
+
exp : exp '=' exp
- { write_exp_elt_opcode (BINOP_ASSIGN); }
+ { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
;
exp : exp ASSIGN_MODIFY exp
- { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
- write_exp_elt_opcode ($2);
- write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
+ { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
+ write_exp_elt_opcode (pstate, $2);
+ write_exp_elt_opcode (pstate,
+ BINOP_ASSIGN_MODIFY); }
;
exp : INT
- { write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type ($1.type);
- write_exp_elt_longcst ((LONGEST)($1.val));
- write_exp_elt_opcode (OP_LONG); }
+ { write_exp_elt_opcode (pstate, OP_LONG);
+ write_exp_elt_type (pstate, $1.type);
+ write_exp_elt_longcst (pstate, (LONGEST) ($1.val));
+ write_exp_elt_opcode (pstate, OP_LONG); }
+ ;
+
+exp : CHAR
+ {
+ struct stoken_vector vec;
+ vec.len = 1;
+ vec.tokens = &$1;
+ write_exp_string_vector (pstate, $1.type, &vec);
+ }
;
exp : NAME_OR_INT
{ YYSTYPE val;
- parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
- write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (val.typed_val_int.type);
- write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
- write_exp_elt_opcode (OP_LONG);
+ parse_number (pstate, $1.stoken.ptr,
+ $1.stoken.length, 0, &val);
+ write_exp_elt_opcode (pstate, OP_LONG);
+ write_exp_elt_type (pstate, val.typed_val_int.type);
+ write_exp_elt_longcst (pstate,
+ (LONGEST) val.typed_val_int.val);
+ write_exp_elt_opcode (pstate, OP_LONG);
}
;
exp : FLOAT
- { write_exp_elt_opcode (OP_DOUBLE);
- write_exp_elt_type ($1.type);
- write_exp_elt_dblcst ($1.dval);
- write_exp_elt_opcode (OP_DOUBLE); }
+ { write_exp_elt_opcode (pstate, OP_DOUBLE);
+ write_exp_elt_type (pstate, $1.type);
+ write_exp_elt_dblcst (pstate, $1.dval);
+ write_exp_elt_opcode (pstate, OP_DOUBLE); }
;
exp : DECFLOAT
- { write_exp_elt_opcode (OP_DECFLOAT);
- write_exp_elt_type ($1.type);
- write_exp_elt_decfloatcst ($1.val);
- write_exp_elt_opcode (OP_DECFLOAT); }
+ { write_exp_elt_opcode (pstate, OP_DECFLOAT);
+ write_exp_elt_type (pstate, $1.type);
+ write_exp_elt_decfloatcst (pstate, $1.val);
+ write_exp_elt_opcode (pstate, OP_DECFLOAT); }
;
exp : variable
;
exp : VARIABLE
- /* Already written by write_dollar_variable. */
+ {
+ write_dollar_variable (pstate, $1);
+ }
+ ;
+
+exp : SELECTOR '(' name ')'
+ {
+ write_exp_elt_opcode (pstate, OP_OBJC_SELECTOR);
+ write_exp_string (pstate, $3);
+ write_exp_elt_opcode (pstate, OP_OBJC_SELECTOR); }
;
exp : SIZEOF '(' type ')' %prec UNARY
- { write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type (current_gdbarch)->builtin_int);
- CHECK_TYPEDEF ($3);
- write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
- write_exp_elt_opcode (OP_LONG); }
- ;
-
-exp : STRING
- { /* C strings are converted into array constants with
- an explicit null byte added at the end. Thus
- the array upper bound is the string length.
- There is no such thing in C as a completely empty
- string. */
- char *sp = $1.ptr; int count = $1.length;
- while (count-- > 0)
+ { struct type *type = $3;
+ write_exp_elt_opcode (pstate, OP_LONG);
+ write_exp_elt_type (pstate, lookup_signed_typename
+ (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "int"));
+ type = check_typedef (type);
+
+ /* $5.3.3/2 of the C++ Standard (n3290 draft)
+ says of sizeof: "When applied to a reference
+ or a reference type, the result is the size of
+ the referenced type." */
+ if (TYPE_CODE (type) == TYPE_CODE_REF)
+ type = check_typedef (TYPE_TARGET_TYPE (type));
+ write_exp_elt_longcst (pstate,
+ (LONGEST) TYPE_LENGTH (type));
+ write_exp_elt_opcode (pstate, OP_LONG); }
+ ;
+
+exp : REINTERPRET_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
+ { write_exp_elt_opcode (pstate,
+ UNOP_REINTERPRET_CAST); }
+ ;
+
+exp : STATIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
+ { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }
+ ;
+
+exp : DYNAMIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
+ { write_exp_elt_opcode (pstate, UNOP_DYNAMIC_CAST); }
+ ;
+
+exp : CONST_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
+ { /* We could do more error checking here, but
+ it doesn't seem worthwhile. */
+ write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }
+ ;
+
+string_exp:
+ STRING
+ {
+ /* We copy the string here, and not in the
+ lexer, to guarantee that we do not leak a
+ string. Note that we follow the
+ NUL-termination convention of the
+ lexer. */
+ struct typed_stoken *vec = XNEW (struct typed_stoken);
+ $$.len = 1;
+ $$.tokens = vec;
+
+ vec->type = $1.type;
+ vec->length = $1.length;
+ vec->ptr = malloc ($1.length + 1);
+ memcpy (vec->ptr, $1.ptr, $1.length + 1);
+ }
+
+ | string_exp STRING
+ {
+ /* Note that we NUL-terminate here, but just
+ for convenience. */
+ char *p;
+ ++$$.len;
+ $$.tokens = realloc ($$.tokens,
+ $$.len * sizeof (struct typed_stoken));
+
+ p = malloc ($2.length + 1);
+ memcpy (p, $2.ptr, $2.length + 1);
+
+ $$.tokens[$$.len - 1].type = $2.type;
+ $$.tokens[$$.len - 1].length = $2.length;
+ $$.tokens[$$.len - 1].ptr = p;
+ }
+ ;
+
+exp : string_exp
+ {
+ int i;
+ enum c_string_type type = C_STRING;
+
+ for (i = 0; i < $1.len; ++i)
{
- write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
- write_exp_elt_longcst ((LONGEST)(*sp++));
- write_exp_elt_opcode (OP_LONG);
+ switch ($1.tokens[i].type)
+ {
+ case C_STRING:
+ break;
+ case C_WIDE_STRING:
+ case C_STRING_16:
+ case C_STRING_32:
+ if (type != C_STRING
+ && type != $1.tokens[i].type)
+ error (_("Undefined string concatenation."));
+ type = $1.tokens[i].type;
+ break;
+ default:
+ /* internal error */
+ internal_error (__FILE__, __LINE__,
+ "unrecognized type in string concatenation");
+ }
}
- write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
- write_exp_elt_longcst ((LONGEST)'\0');
- write_exp_elt_opcode (OP_LONG);
- write_exp_elt_opcode (OP_ARRAY);
- write_exp_elt_longcst ((LONGEST) 0);
- write_exp_elt_longcst ((LONGEST) ($1.length));
- write_exp_elt_opcode (OP_ARRAY); }
+
+ write_exp_string_vector (pstate, type, &$1);
+ for (i = 0; i < $1.len; ++i)
+ free ($1.tokens[i].ptr);
+ free ($1.tokens);
+ }
+ ;
+
+exp : NSSTRING /* ObjC NextStep NSString constant
+ * of the form '@' '"' string '"'.
+ */
+ { write_exp_elt_opcode (pstate, OP_OBJC_NSSTRING);
+ write_exp_string (pstate, $1);
+ write_exp_elt_opcode (pstate, OP_OBJC_NSSTRING); }
;
/* C++. */
-exp : TRUEKEYWORD
- { write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
- write_exp_elt_longcst ((LONGEST) 1);
- write_exp_elt_opcode (OP_LONG); }
+exp : TRUEKEYWORD
+ { write_exp_elt_opcode (pstate, OP_LONG);
+ write_exp_elt_type (pstate,
+ parse_type (pstate)->builtin_bool);
+ write_exp_elt_longcst (pstate, (LONGEST) 1);
+ write_exp_elt_opcode (pstate, OP_LONG); }
;
-exp : FALSEKEYWORD
- { write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
- write_exp_elt_longcst ((LONGEST) 0);
- write_exp_elt_opcode (OP_LONG); }
+exp : FALSEKEYWORD
+ { write_exp_elt_opcode (pstate, OP_LONG);
+ write_exp_elt_type (pstate,
+ parse_type (pstate)->builtin_bool);
+ write_exp_elt_longcst (pstate, (LONGEST) 0);
+ write_exp_elt_opcode (pstate, OP_LONG); }
;
/* end of C++. */
if ($1.sym)
$$ = SYMBOL_BLOCK_VALUE ($1.sym);
else
- error ("No file or function \"%s\".",
+ error (_("No file or function \"%s\"."),
copy_name ($1.stoken));
}
| FILENAME
block : block COLONCOLON name
{ struct symbol *tem
= lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL);
+ VAR_DOMAIN, NULL);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
- error ("No function \"%s\" in specified context.",
+ error (_("No function \"%s\" in specified context."),
copy_name ($3));
$$ = SYMBOL_BLOCK_VALUE (tem); }
;
+variable: name_not_typename ENTRY
+ { struct symbol *sym = $1.sym;
+
+ if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
+ || !symbol_read_needs_frame (sym))
+ error (_("@entry can be used only for function "
+ "parameters, not for \"%s\""),
+ copy_name ($1.stoken));
+
+ write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE);
+ write_exp_elt_sym (pstate, sym);
+ write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE);
+ }
+ ;
+
variable: block COLONCOLON name
{ struct symbol *sym;
sym = lookup_symbol (copy_name ($3), $1,
- VAR_DOMAIN, (int *) NULL);
+ VAR_DOMAIN, NULL);
if (sym == 0)
- error ("No symbol \"%s\" in specified context.",
+ error (_("No symbol \"%s\" in specified context."),
copy_name ($3));
+ if (symbol_read_needs_frame (sym))
+ {
+ if (innermost_block == 0
+ || contained_in (block_found,
+ innermost_block))
+ innermost_block = block_found;
+ }
- write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_opcode (pstate, OP_VAR_VALUE);
/* block_found is set by lookup_symbol. */
- write_exp_elt_block (block_found);
- write_exp_elt_sym (sym);
- write_exp_elt_opcode (OP_VAR_VALUE); }
+ write_exp_elt_block (pstate, block_found);
+ write_exp_elt_sym (pstate, sym);
+ write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
;
-qualified_name: typebase COLONCOLON name
+qualified_name: TYPENAME COLONCOLON name
{
- struct type *type = $1;
- if (TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_UNION
- && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
- error ("`%s' is not defined as an aggregate type.",
- TYPE_NAME (type));
-
- write_exp_elt_opcode (OP_SCOPE);
- write_exp_elt_type (type);
- write_exp_string ($3);
- write_exp_elt_opcode (OP_SCOPE);
+ struct type *type = $1.type;
+ type = check_typedef (type);
+ if (!type_aggregate_p (type))
+ error (_("`%s' is not defined as an aggregate type."),
+ TYPE_SAFE_NAME (type));
+
+ write_exp_elt_opcode (pstate, OP_SCOPE);
+ write_exp_elt_type (pstate, type);
+ write_exp_string (pstate, $3);
+ write_exp_elt_opcode (pstate, OP_SCOPE);
}
- | typebase COLONCOLON '~' name
+ | TYPENAME COLONCOLON '~' name
{
- struct type *type = $1;
+ struct type *type = $1.type;
struct stoken tmp_token;
- if (TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_UNION
- && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
- error ("`%s' is not defined as an aggregate type.",
- TYPE_NAME (type));
-
- tmp_token.ptr = (char*) alloca ($4.length + 2);
+ char *buf;
+
+ type = check_typedef (type);
+ if (!type_aggregate_p (type))
+ error (_("`%s' is not defined as an aggregate type."),
+ TYPE_SAFE_NAME (type));
+ buf = alloca ($4.length + 2);
+ tmp_token.ptr = buf;
tmp_token.length = $4.length + 1;
- tmp_token.ptr[0] = '~';
- memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
- tmp_token.ptr[tmp_token.length] = 0;
+ buf[0] = '~';
+ memcpy (buf+1, $4.ptr, $4.length);
+ buf[tmp_token.length] = 0;
/* Check for valid destructor name. */
- destructor_name_p (tmp_token.ptr, type);
- write_exp_elt_opcode (OP_SCOPE);
- write_exp_elt_type (type);
- write_exp_string (tmp_token);
- write_exp_elt_opcode (OP_SCOPE);
+ destructor_name_p (tmp_token.ptr, $1.type);
+ write_exp_elt_opcode (pstate, OP_SCOPE);
+ write_exp_elt_type (pstate, type);
+ write_exp_string (pstate, tmp_token);
+ write_exp_elt_opcode (pstate, OP_SCOPE);
+ }
+ | TYPENAME COLONCOLON name COLONCOLON name
+ {
+ char *copy = copy_name ($3);
+ error (_("No type \"%s\" within class "
+ "or namespace \"%s\"."),
+ copy, TYPE_SAFE_NAME ($1.type));
}
;
variable: qualified_name
- | COLONCOLON name
+ | COLONCOLON name_not_typename
{
- char *name = copy_name ($2);
+ char *name = copy_name ($2.stoken);
struct symbol *sym;
- struct minimal_symbol *msymbol;
+ struct bound_minimal_symbol msymbol;
sym =
lookup_symbol (name, (const struct block *) NULL,
- VAR_DOMAIN, (int *) NULL);
+ VAR_DOMAIN, NULL);
if (sym)
{
- write_exp_elt_opcode (OP_VAR_VALUE);
- write_exp_elt_block (NULL);
- write_exp_elt_sym (sym);
- write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_opcode (pstate, OP_VAR_VALUE);
+ write_exp_elt_block (pstate, NULL);
+ write_exp_elt_sym (pstate, sym);
+ write_exp_elt_opcode (pstate, OP_VAR_VALUE);
break;
}
- msymbol = lookup_minimal_symbol (name, NULL, NULL);
- if (msymbol != NULL)
- {
- write_exp_msymbol (msymbol,
- lookup_function_type (builtin_type (current_gdbarch)->builtin_int),
- builtin_type (current_gdbarch)->builtin_int);
- }
+ msymbol = lookup_bound_minimal_symbol (name);
+ 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 \"file\" command."));
else
- if (!have_full_symbols () && !have_partial_symbols ())
- error ("No symbol table is loaded. Use the \"file\" command.");
- else
- error ("No symbol \"%s\" in current context.", name);
+ error (_("No symbol \"%s\" in current context."), name);
}
;
{
if (symbol_read_needs_frame (sym))
{
- if (innermost_block == 0 ||
- contained_in (block_found,
- innermost_block))
+ if (innermost_block == 0
+ || contained_in (block_found,
+ innermost_block))
innermost_block = block_found;
}
- write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_opcode (pstate, OP_VAR_VALUE);
/* We want to use the selected frame, not
another more inner frame which happens to
be in the same block. */
- write_exp_elt_block (NULL);
- write_exp_elt_sym (sym);
- write_exp_elt_opcode (OP_VAR_VALUE);
+ write_exp_elt_block (pstate, NULL);
+ write_exp_elt_sym (pstate, sym);
+ write_exp_elt_opcode (pstate, OP_VAR_VALUE);
}
else if ($1.is_a_field_of_this)
{
/* C++: it hangs off of `this'. Must
not inadvertently convert from a method call
to data ref. */
- if (innermost_block == 0 ||
- contained_in (block_found, innermost_block))
+ if (innermost_block == 0
+ || contained_in (block_found,
+ innermost_block))
innermost_block = block_found;
- write_exp_elt_opcode (OP_THIS);
- write_exp_elt_opcode (OP_THIS);
- write_exp_elt_opcode (STRUCTOP_PTR);
- write_exp_string ($1.stoken);
- write_exp_elt_opcode (STRUCTOP_PTR);
+ write_exp_elt_opcode (pstate, OP_THIS);
+ write_exp_elt_opcode (pstate, OP_THIS);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR);
+ write_exp_string (pstate, $1.stoken);
+ write_exp_elt_opcode (pstate, STRUCTOP_PTR);
}
else
{
- struct minimal_symbol *msymbol;
+ struct bound_minimal_symbol msymbol;
char *arg = copy_name ($1.stoken);
msymbol =
- lookup_minimal_symbol (arg, NULL, NULL);
- if (msymbol != NULL)
- {
- write_exp_msymbol (msymbol,
- lookup_function_type (builtin_type (current_gdbarch)->builtin_int),
- builtin_type (current_gdbarch)->builtin_int);
- }
+ lookup_bound_minimal_symbol (arg);
+ 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 \"file\" command.");
+ error (_("No symbol table is loaded. Use the \"file\" command."));
else
- error ("No symbol \"%s\" in current context.",
+ error (_("No symbol \"%s\" in current context."),
copy_name ($1.stoken));
}
}
;
space_identifier : '@' NAME
- { push_type_address_space (copy_name ($2.stoken));
- push_type (tp_space_identifier);
- }
+ { insert_type_address_space (pstate, copy_name ($2.stoken)); }
;
const_or_volatile: const_or_volatile_noopt
;
const_or_volatile_or_space_identifier_noopt: cv_with_space_id
- | const_or_volatile_noopt
+ | const_or_volatile_noopt
;
-const_or_volatile_or_space_identifier:
+const_or_volatile_or_space_identifier:
const_or_volatile_or_space_identifier_noopt
|
;
-abs_decl: '*'
- { push_type (tp_pointer); $$ = 0; }
- | '*' abs_decl
- { push_type (tp_pointer); $$ = $2; }
+ptr_operator:
+ ptr_operator '*'
+ { insert_type (tp_pointer); }
+ const_or_volatile_or_space_identifier
+ | '*'
+ { insert_type (tp_pointer); }
+ const_or_volatile_or_space_identifier
| '&'
- { push_type (tp_reference); $$ = 0; }
- | '&' abs_decl
- { push_type (tp_reference); $$ = $2; }
+ { insert_type (tp_reference); }
+ | '&' ptr_operator
+ { insert_type (tp_reference); }
+ ;
+
+ptr_operator_ts: ptr_operator
+ {
+ $$ = get_type_stack ();
+ /* This cleanup is eventually run by
+ c_parse. */
+ make_cleanup (type_stack_cleanup, $$);
+ }
+ ;
+
+abs_decl: ptr_operator_ts direct_abs_decl
+ { $$ = append_type_stack ($2, $1); }
+ | ptr_operator_ts
| direct_abs_decl
;
{ $$ = $2; }
| direct_abs_decl array_mod
{
+ push_type_stack ($1);
push_type_int ($2);
push_type (tp_array);
+ $$ = get_type_stack ();
}
| array_mod
{
push_type_int ($1);
push_type (tp_array);
- $$ = 0;
+ $$ = get_type_stack ();
}
| direct_abs_decl func_mod
- { push_type (tp_function); }
+ {
+ push_type_stack ($1);
+ push_typelist ($2);
+ $$ = get_type_stack ();
+ }
| func_mod
- { push_type (tp_function); }
+ {
+ push_typelist ($1);
+ $$ = get_type_stack ();
+ }
;
array_mod: '[' ']'
{ $$ = -1; }
+ | OBJC_LBRAC ']'
+ { $$ = -1; }
| '[' INT ']'
{ $$ = $2.val; }
+ | OBJC_LBRAC INT ']'
+ { $$ = $2.val; }
;
func_mod: '(' ')'
- { $$ = 0; }
- | '(' nonempty_typelist ')'
- { free ($2); $$ = 0; }
+ { $$ = NULL; }
+ | '(' parameter_typelist ')'
+ { $$ = $2; }
;
/* We used to try to recognize pointer to member types here, but
: TYPENAME
{ $$ = $1.type; }
| INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_int; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "int"); }
| LONG
- { $$ = builtin_type (current_gdbarch)->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long"); }
| SHORT
- { $$ = builtin_type (current_gdbarch)->builtin_short; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "short"); }
| LONG INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long"); }
| LONG SIGNED_KEYWORD INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long"); }
| LONG SIGNED_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long"); }
| SIGNED_KEYWORD LONG INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long"); }
| UNSIGNED LONG INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long"); }
| LONG UNSIGNED INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long"); }
| LONG UNSIGNED
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long"); }
| LONG LONG
- { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| LONG LONG INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| LONG LONG SIGNED_KEYWORD INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| LONG LONG SIGNED_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| SIGNED_KEYWORD LONG LONG
- { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| SIGNED_KEYWORD LONG LONG INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| UNSIGNED LONG LONG
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| UNSIGNED LONG LONG INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| LONG LONG UNSIGNED
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| LONG LONG UNSIGNED INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long long"); }
| SHORT INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_short; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "short"); }
| SHORT SIGNED_KEYWORD INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_short; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "short"); }
| SHORT SIGNED_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_short; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "short"); }
| UNSIGNED SHORT INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
- | SHORT UNSIGNED
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "short"); }
+ | SHORT UNSIGNED
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "short"); }
| SHORT UNSIGNED INT_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "short"); }
| DOUBLE_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_double; }
+ { $$ = lookup_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "double",
+ (struct block *) NULL,
+ 0); }
| LONG DOUBLE_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_long_double; }
+ { $$ = lookup_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long double",
+ (struct block *) NULL,
+ 0); }
| STRUCT name
{ $$ = lookup_struct (copy_name ($2),
expression_context_block); }
+ | STRUCT COMPLETE
+ {
+ mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
+ $$ = NULL;
+ }
+ | STRUCT name COMPLETE
+ {
+ mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr,
+ $2.length);
+ $$ = NULL;
+ }
| CLASS name
{ $$ = lookup_struct (copy_name ($2),
expression_context_block); }
+ | CLASS COMPLETE
+ {
+ mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
+ $$ = NULL;
+ }
+ | CLASS name COMPLETE
+ {
+ mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr,
+ $2.length);
+ $$ = NULL;
+ }
| UNION name
{ $$ = lookup_union (copy_name ($2),
expression_context_block); }
+ | UNION COMPLETE
+ {
+ mark_completion_tag (TYPE_CODE_UNION, "", 0);
+ $$ = NULL;
+ }
+ | UNION name COMPLETE
+ {
+ mark_completion_tag (TYPE_CODE_UNION, $2.ptr,
+ $2.length);
+ $$ = NULL;
+ }
| ENUM name
{ $$ = lookup_enum (copy_name ($2),
expression_context_block); }
- | UNSIGNED typename
- { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
+ | ENUM COMPLETE
+ {
+ mark_completion_tag (TYPE_CODE_ENUM, "", 0);
+ $$ = NULL;
+ }
+ | ENUM name COMPLETE
+ {
+ mark_completion_tag (TYPE_CODE_ENUM, $2.ptr,
+ $2.length);
+ $$ = NULL;
+ }
+ | UNSIGNED type_name
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ TYPE_NAME($2.type)); }
| UNSIGNED
- { $$ = builtin_type (current_gdbarch)->builtin_unsigned_int; }
- | SIGNED_KEYWORD typename
- { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
+ { $$ = lookup_unsigned_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "int"); }
+ | SIGNED_KEYWORD type_name
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ TYPE_NAME($2.type)); }
| SIGNED_KEYWORD
- { $$ = builtin_type (current_gdbarch)->builtin_int; }
+ { $$ = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "int"); }
/* It appears that this rule for templates is never
reduced; template recognition happens by lookahead
- in the token processing code in yylex. */
+ in the token processing code in yylex. */
| TEMPLATE name '<' type '>'
{ $$ = lookup_template_type(copy_name($2), $4,
expression_context_block);
}
- | const_or_volatile_or_space_identifier_noopt typebase
+ | const_or_volatile_or_space_identifier_noopt typebase
{ $$ = follow_types ($2); }
- | typebase const_or_volatile_or_space_identifier_noopt
+ | typebase const_or_volatile_or_space_identifier_noopt
{ $$ = follow_types ($1); }
- | qualified_type
- ;
-
-/* FIXME: carlton/2003-09-25: This next bit leads to lots of
- reduce-reduce conflicts, because the parser doesn't know whether or
- not to use qualified_name or qualified_type: the rules are
- identical. If the parser is parsing 'A::B::x', then, when it sees
- the second '::', it knows that the expression to the left of it has
- to be a type, so it uses qualified_type. But if it is parsing just
- 'A::B', then it doesn't have any way of knowing which rule to use,
- so there's a reduce-reduce conflict; it picks qualified_name, since
- that occurs earlier in this file than qualified_type.
-
- There's no good way to fix this with the grammar as it stands; as
- far as I can tell, some of the problems arise from ambiguities that
- GDB introduces ('start' can be either an expression or a type), but
- some of it is inherent to the nature of C++ (you want to treat the
- input "(FOO)" fairly differently depending on whether FOO is an
- expression or a type, and if FOO is a complex expression, this can
- be hard to determine at the right time). Fortunately, it works
- pretty well in most cases. For example, if you do 'ptype A::B',
- where A::B is a nested type, then the parser will mistakenly
- misidentify it as an expression; but evaluate_subexp will get
- called with 'noside' set to EVAL_AVOID_SIDE_EFFECTS, and everything
- will work out anyways. But there are situations where the parser
- will get confused: the most common one that I've run into is when
- you want to do
-
- print *((A::B *) x)"
-
- where the parser doesn't realize that A::B has to be a type until
- it hits the first right paren, at which point it's too late. (The
- workaround is to type "print *(('A::B' *) x)" instead.) (And
- another solution is to fix our symbol-handling code so that the
- user never wants to type something like that in the first place,
- because we get all the types right without the user's help!)
-
- Perhaps we could fix this by making the lexer smarter. Some of
- this functionality used to be in the lexer, but in a way that
- worked even less well than the current solution: that attempt
- involved having the parser sometimes handle '::' and having the
- lexer sometimes handle it, and without a clear division of
- responsibility, it quickly degenerated into a big mess. Probably
- the eventual correct solution will give more of a role to the lexer
- (ideally via code that is shared between the lexer and
- decode_line_1), but I'm not holding my breath waiting for somebody
- to get around to cleaning this up... */
-
-qualified_type: typebase COLONCOLON name
- {
- struct type *type = $1;
- struct type *new_type;
- char *ncopy = alloca ($3.length + 1);
-
- memcpy (ncopy, $3.ptr, $3.length);
- ncopy[$3.length] = '\0';
-
- if (TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_UNION
- && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
- error ("`%s' is not defined as an aggregate type.",
- TYPE_NAME (type));
-
- new_type = cp_lookup_nested_type (type, ncopy,
- expression_context_block);
- if (new_type == NULL)
- error ("No type \"%s\" within class or namespace \"%s\".",
- ncopy, TYPE_NAME (type));
-
- $$ = new_type;
- }
;
-typename: TYPENAME
+type_name: TYPENAME
| INT_KEYWORD
{
$$.stoken.ptr = "int";
$$.stoken.length = 3;
- $$.type = builtin_type (current_gdbarch)->builtin_int;
+ $$.type = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "int");
}
| LONG
{
$$.stoken.ptr = "long";
$$.stoken.length = 4;
- $$.type = builtin_type (current_gdbarch)->builtin_long;
+ $$.type = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "long");
}
| SHORT
{
$$.stoken.ptr = "short";
$$.stoken.length = 5;
- $$.type = builtin_type (current_gdbarch)->builtin_short;
+ $$.type = lookup_signed_typename (parse_language (pstate),
+ parse_gdbarch (pstate),
+ "short");
}
;
+parameter_typelist:
+ nonempty_typelist
+ { check_parameter_typelist ($1); }
+ | nonempty_typelist ',' DOTDOTDOT
+ {
+ VEC_safe_push (type_ptr, $1, NULL);
+ check_parameter_typelist ($1);
+ $$ = $1;
+ }
+ ;
+
nonempty_typelist
: type
- { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
- $<ivec>$[0] = 1; /* Number of types in vector */
- $$[1] = $1;
+ {
+ VEC (type_ptr) *typelist = NULL;
+ VEC_safe_push (type_ptr, typelist, $1);
+ $$ = typelist;
}
| nonempty_typelist ',' type
- { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
- $$ = (struct type **) realloc ((char *) $1, len);
- $$[$<ivec>$[0]] = $3;
+ {
+ VEC_safe_push (type_ptr, $1, $3);
+ $$ = $1;
}
;
ptype : typebase
- | ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
+ | ptype abs_decl
+ {
+ push_type_stack ($2);
+ $$ = follow_types ($1);
+ }
+ ;
+
+conversion_type_id: typebase conversion_declarator
{ $$ = follow_types ($1); }
;
+conversion_declarator: /* Nothing. */
+ | ptr_operator conversion_declarator
+ ;
+
const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
| VOLATILE_KEYWORD CONST_KEYWORD
;
-const_or_volatile_noopt: const_and_volatile
- { push_type (tp_const);
- push_type (tp_volatile);
+const_or_volatile_noopt: const_and_volatile
+ { insert_type (tp_const);
+ insert_type (tp_volatile);
}
| CONST_KEYWORD
- { push_type (tp_const); }
+ { insert_type (tp_const); }
| VOLATILE_KEYWORD
- { push_type (tp_volatile); }
+ { insert_type (tp_volatile); }
+ ;
+
+oper: OPERATOR NEW
+ { $$ = operator_stoken (" new"); }
+ | OPERATOR DELETE
+ { $$ = operator_stoken (" delete"); }
+ | OPERATOR NEW '[' ']'
+ { $$ = operator_stoken (" new[]"); }
+ | OPERATOR DELETE '[' ']'
+ { $$ = operator_stoken (" delete[]"); }
+ | OPERATOR NEW OBJC_LBRAC ']'
+ { $$ = operator_stoken (" new[]"); }
+ | OPERATOR DELETE OBJC_LBRAC ']'
+ { $$ = operator_stoken (" delete[]"); }
+ | OPERATOR '+'
+ { $$ = operator_stoken ("+"); }
+ | OPERATOR '-'
+ { $$ = operator_stoken ("-"); }
+ | OPERATOR '*'
+ { $$ = operator_stoken ("*"); }
+ | OPERATOR '/'
+ { $$ = operator_stoken ("/"); }
+ | OPERATOR '%'
+ { $$ = operator_stoken ("%"); }
+ | OPERATOR '^'
+ { $$ = operator_stoken ("^"); }
+ | OPERATOR '&'
+ { $$ = operator_stoken ("&"); }
+ | OPERATOR '|'
+ { $$ = operator_stoken ("|"); }
+ | OPERATOR '~'
+ { $$ = operator_stoken ("~"); }
+ | OPERATOR '!'
+ { $$ = operator_stoken ("!"); }
+ | OPERATOR '='
+ { $$ = operator_stoken ("="); }
+ | OPERATOR '<'
+ { $$ = operator_stoken ("<"); }
+ | OPERATOR '>'
+ { $$ = operator_stoken (">"); }
+ | OPERATOR ASSIGN_MODIFY
+ { const char *op = "unknown";
+ switch ($2)
+ {
+ case BINOP_RSH:
+ op = ">>=";
+ break;
+ case BINOP_LSH:
+ op = "<<=";
+ break;
+ case BINOP_ADD:
+ op = "+=";
+ break;
+ case BINOP_SUB:
+ op = "-=";
+ break;
+ case BINOP_MUL:
+ op = "*=";
+ break;
+ case BINOP_DIV:
+ op = "/=";
+ break;
+ case BINOP_REM:
+ op = "%=";
+ break;
+ case BINOP_BITWISE_IOR:
+ op = "|=";
+ break;
+ case BINOP_BITWISE_AND:
+ op = "&=";
+ break;
+ case BINOP_BITWISE_XOR:
+ op = "^=";
+ break;
+ default:
+ break;
+ }
+
+ $$ = operator_stoken (op);
+ }
+ | OPERATOR LSH
+ { $$ = operator_stoken ("<<"); }
+ | OPERATOR RSH
+ { $$ = operator_stoken (">>"); }
+ | OPERATOR EQUAL
+ { $$ = operator_stoken ("=="); }
+ | OPERATOR NOTEQUAL
+ { $$ = operator_stoken ("!="); }
+ | OPERATOR LEQ
+ { $$ = operator_stoken ("<="); }
+ | OPERATOR GEQ
+ { $$ = operator_stoken (">="); }
+ | OPERATOR ANDAND
+ { $$ = operator_stoken ("&&"); }
+ | OPERATOR OROR
+ { $$ = operator_stoken ("||"); }
+ | OPERATOR INCREMENT
+ { $$ = operator_stoken ("++"); }
+ | OPERATOR DECREMENT
+ { $$ = operator_stoken ("--"); }
+ | OPERATOR ','
+ { $$ = operator_stoken (","); }
+ | OPERATOR ARROW_STAR
+ { $$ = operator_stoken ("->*"); }
+ | OPERATOR ARROW
+ { $$ = operator_stoken ("->"); }
+ | OPERATOR '(' ')'
+ { $$ = operator_stoken ("()"); }
+ | OPERATOR '[' ']'
+ { $$ = operator_stoken ("[]"); }
+ | OPERATOR OBJC_LBRAC ']'
+ { $$ = operator_stoken ("[]"); }
+ | OPERATOR conversion_type_id
+ { char *name;
+ long length;
+ struct ui_file *buf = mem_fileopen ();
+
+ c_print_type ($2, NULL, buf, -1, 0,
+ &type_print_raw_options);
+ name = ui_file_xstrdup (buf, &length);
+ ui_file_delete (buf);
+ $$ = operator_stoken (name);
+ free (name);
+ }
;
+
+
name : NAME { $$ = $1.stoken; }
| BLOCKNAME { $$ = $1.stoken; }
| TYPENAME { $$ = $1.stoken; }
| NAME_OR_INT { $$ = $1.stoken; }
+ | UNKNOWN_CPP_NAME { $$ = $1.stoken; }
+ | oper { $$ = $1; }
;
name_not_typename : NAME
context where only a name could occur, this might be useful.
| NAME_OR_INT
*/
+ | oper
+ {
+ struct field_of_this_result is_a_field_of_this;
+
+ $$.stoken = $1;
+ $$.sym = lookup_symbol ($1.ptr,
+ expression_context_block,
+ VAR_DOMAIN,
+ &is_a_field_of_this);
+ $$.is_a_field_of_this
+ = is_a_field_of_this.type != NULL;
+ }
+ | UNKNOWN_CPP_NAME
;
%%
+/* Like write_exp_string, but prepends a '~'. */
+
+static void
+write_destructor_name (struct parser_state *par_state, struct stoken token)
+{
+ char *copy = alloca (token.length + 1);
+
+ copy[0] = '~';
+ memcpy (©[1], token.ptr, token.length);
+
+ token.ptr = copy;
+ ++token.length;
+
+ write_exp_string (par_state, token);
+}
+
+/* Returns a stoken of the operator name given by OP (which does not
+ include the string "operator"). */
+
+static struct stoken
+operator_stoken (const char *op)
+{
+ static const char *operator_string = "operator";
+ struct stoken st = { NULL, 0 };
+ char *buf;
+
+ st.length = strlen (operator_string) + strlen (op);
+ buf = malloc (st.length + 1);
+ strcpy (buf, operator_string);
+ strcat (buf, op);
+ st.ptr = buf;
+
+ /* The toplevel (c_parse) will free the memory allocated here. */
+ make_cleanup (free, buf);
+ return st;
+};
+
+/* Return true if the type is aggregate-like. */
+
+static int
+type_aggregate_p (struct type *type)
+{
+ return (TYPE_CODE (type) == TYPE_CODE_STRUCT
+ || TYPE_CODE (type) == TYPE_CODE_UNION
+ || TYPE_CODE (type) == TYPE_CODE_NAMESPACE
+ || (TYPE_CODE (type) == TYPE_CODE_ENUM
+ && TYPE_DECLARED_CLASS (type)));
+}
+
+/* Validate a parameter typelist. */
+
+static void
+check_parameter_typelist (VEC (type_ptr) *params)
+{
+ struct type *type;
+ int ix;
+
+ for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix)
+ {
+ if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
+ {
+ if (ix == 0)
+ {
+ if (VEC_length (type_ptr, params) == 1)
+ {
+ /* Ok. */
+ break;
+ }
+ VEC_free (type_ptr, params);
+ error (_("parameter types following 'void'"));
+ }
+ else
+ {
+ VEC_free (type_ptr, params);
+ error (_("'void' invalid as parameter type"));
+ }
+ }
+ }
+}
+
/* Take care of parsing a number (anything that starts with a digit).
Set yylval and return the token type; update lexptr.
LEN is the number of characters in it. */
/*** Needs some error checking for the float case ***/
static int
-parse_number (p, len, parsed_float, putithere)
- char *p;
- int len;
- int parsed_float;
- YYSTYPE *putithere;
+parse_number (struct parser_state *par_state,
+ const char *buf, int len, int parsed_float, YYSTYPE *putithere)
{
/* FIXME: Shouldn't these be unsigned? We don't deal with negative values
here, and we do kind of silly things like cast to unsigned. */
ULONGEST high_bit;
struct type *signed_type;
struct type *unsigned_type;
+ char *p;
+
+ p = alloca (len);
+ memcpy (p, buf, len);
if (parsed_float)
{
- /* It's a float since it contains a point or an exponent. */
- char *s = malloc (len);
- int num = 0; /* number of tokens scanned by scanf */
- char saved_char = p[len];
-
- p[len] = 0; /* null-terminate the token */
-
/* If it ends at "df", "dd" or "dl", take it as type of decimal floating
point. Return DECFLOAT. */
- if (p[len - 2] == 'd' && p[len - 1] == 'f')
+ if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
{
p[len - 2] = '\0';
putithere->typed_val_decfloat.type
- = builtin_type (current_gdbarch)->builtin_decfloat;
- decimal_from_string (putithere->typed_val_decfloat.val, 4, p);
- p[len] = saved_char;
- return (DECFLOAT);
+ = parse_type (par_state)->builtin_decfloat;
+ decimal_from_string (putithere->typed_val_decfloat.val, 4,
+ gdbarch_byte_order (parse_gdbarch (par_state)),
+ p);
+ p[len - 2] = 'd';
+ return DECFLOAT;
}
- if (p[len - 2] == 'd' && p[len - 1] == 'd')
+ if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
{
p[len - 2] = '\0';
putithere->typed_val_decfloat.type
- = builtin_type (current_gdbarch)->builtin_decdouble;
- decimal_from_string (putithere->typed_val_decfloat.val, 8, p);
- p[len] = saved_char;
- return (DECFLOAT);
+ = parse_type (par_state)->builtin_decdouble;
+ decimal_from_string (putithere->typed_val_decfloat.val, 8,
+ gdbarch_byte_order (parse_gdbarch (par_state)),
+ p);
+ p[len - 2] = 'd';
+ return DECFLOAT;
}
- if (p[len - 2] == 'd' && p[len - 1] == 'l')
+ if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
{
p[len - 2] = '\0';
putithere->typed_val_decfloat.type
- = builtin_type (current_gdbarch)->builtin_declong;
- decimal_from_string (putithere->typed_val_decfloat.val, 16, p);
- p[len] = saved_char;
- return (DECFLOAT);
- }
-
- num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%s",
- &putithere->typed_val_float.dval, s);
- p[len] = saved_char; /* restore the input stream */
-
- if (num == 1)
- putithere->typed_val_float.type =
- builtin_type (current_gdbarch)->builtin_double;
-
- if (num == 2 )
- {
- /* See if it has any float suffix: 'f' for float, 'l' for long
- double. */
- if (!strcasecmp (s, "f"))
- putithere->typed_val_float.type =
- builtin_type (current_gdbarch)->builtin_float;
- else if (!strcasecmp (s, "l"))
- putithere->typed_val_float.type =
- builtin_type (current_gdbarch)->builtin_long_double;
- else
- {
- free (s);
- return ERROR;
- }
+ = parse_type (par_state)->builtin_declong;
+ decimal_from_string (putithere->typed_val_decfloat.val, 16,
+ gdbarch_byte_order (parse_gdbarch (par_state)),
+ p);
+ p[len - 2] = 'd';
+ return DECFLOAT;
}
- free (s);
+ if (! parse_c_float (parse_gdbarch (par_state), p, len,
+ &putithere->typed_val_float.dval,
+ &putithere->typed_val_float.type))
+ return ERROR;
return FLOAT;
}
/* Handle base-switching prefixes 0x, 0t, 0d, 0 */
- if (p[0] == '0')
+ if (p[0] == '0' && len > 1)
switch (p[1])
{
case 'x':
}
break;
+ case 'b':
+ case 'B':
+ if (len >= 3)
+ {
+ p += 2;
+ base = 2;
+ len -= 2;
+ }
+ break;
+
case 't':
case 'T':
case 'd':
if (c != 'l' && c != 'u' && n != 0)
{
if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
- error ("Numeric constant too large.");
+ error (_("Numeric constant too large."));
}
prevn = n;
}
un = (ULONGEST)n >> 2;
if (long_p == 0
- && (un >> (gdbarch_int_bit (current_gdbarch) - 2)) == 0)
+ && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0)
{
- high_bit = ((ULONGEST)1) << (gdbarch_int_bit (current_gdbarch) - 1);
+ high_bit
+ = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
/* A large decimal (not hex or octal) constant (between INT_MAX
and UINT_MAX) is a long or unsigned long, according to ANSI,
int. This probably should be fixed. GCC gives a warning on
such constants. */
- unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_int;
- signed_type = builtin_type (current_gdbarch)->builtin_int;
+ unsigned_type = parse_type (par_state)->builtin_unsigned_int;
+ signed_type = parse_type (par_state)->builtin_int;
}
else if (long_p <= 1
- && (un >> (gdbarch_long_bit (current_gdbarch) - 2)) == 0)
+ && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0)
{
- high_bit = ((ULONGEST)1) << (gdbarch_long_bit (current_gdbarch) - 1);
- unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long;
- signed_type = builtin_type (current_gdbarch)->builtin_long;
+ high_bit
+ = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1);
+ unsigned_type = parse_type (par_state)->builtin_unsigned_long;
+ signed_type = parse_type (par_state)->builtin_long;
}
else
{
int shift;
- if (sizeof (ULONGEST) * HOST_CHAR_BIT
- < gdbarch_long_long_bit (current_gdbarch))
+ if (sizeof (ULONGEST) * HOST_CHAR_BIT
+ < gdbarch_long_long_bit (parse_gdbarch (par_state)))
/* A long long does not fit in a LONGEST. */
shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
else
- shift = (gdbarch_long_long_bit (current_gdbarch) - 1);
+ shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1);
high_bit = (ULONGEST) 1 << shift;
- unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long_long;
- signed_type = builtin_type (current_gdbarch)->builtin_long_long;
+ unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
+ signed_type = parse_type (par_state)->builtin_long_long;
}
putithere->typed_val_int.val = n;
/* If the high bit of the worked out type is set then this number
has to be unsigned. */
- if (unsigned_p || (n & high_bit))
+ if (unsigned_p || (n & high_bit))
{
putithere->typed_val_int.type = unsigned_type;
}
- else
+ else
{
putithere->typed_val_int.type = signed_type;
}
return INT;
}
-struct token
-{
- char *operator;
- int token;
- enum exp_opcode opcode;
-};
-
-static const struct token tokentab3[] =
- {
- {">>=", ASSIGN_MODIFY, BINOP_RSH},
- {"<<=", ASSIGN_MODIFY, BINOP_LSH}
- };
+/* Temporary obstack used for holding strings. */
+static struct obstack tempbuf;
+static int tempbuf_init;
-static const struct token tokentab2[] =
- {
- {"+=", ASSIGN_MODIFY, BINOP_ADD},
- {"-=", ASSIGN_MODIFY, BINOP_SUB},
- {"*=", ASSIGN_MODIFY, BINOP_MUL},
- {"/=", ASSIGN_MODIFY, BINOP_DIV},
- {"%=", ASSIGN_MODIFY, BINOP_REM},
- {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
- {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
- {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
- {"++", INCREMENT, BINOP_END},
- {"--", DECREMENT, BINOP_END},
- {"->", ARROW, BINOP_END},
- {"&&", ANDAND, BINOP_END},
- {"||", OROR, BINOP_END},
- {"::", COLONCOLON, BINOP_END},
- {"<<", LSH, BINOP_END},
- {">>", RSH, BINOP_END},
- {"==", EQUAL, BINOP_END},
- {"!=", NOTEQUAL, BINOP_END},
- {"<=", LEQ, BINOP_END},
- {">=", GEQ, BINOP_END}
- };
+/* Parse a C escape sequence. The initial backslash of the sequence
+ is at (*PTR)[-1]. *PTR will be updated to point to just after the
+ last character of the sequence. If OUTPUT is not NULL, the
+ translated form of the escape sequence will be written there. If
+ OUTPUT is NULL, no output is written and the call will only affect
+ *PTR. If an escape sequence is expressed in target bytes, then the
+ entire sequence will simply be copied to OUTPUT. Return 1 if any
+ character was emitted, 0 otherwise. */
-/* This is set if a NAME token appeared at the very end of the input
- string, with no whitespace separating the name from the EOF. This
- is used only when parsing to do field name completion. */
-static int saw_name_at_eof;
+int
+c_parse_escape (const char **ptr, struct obstack *output)
+{
+ const char *tokptr = *ptr;
+ int result = 1;
-/* This is set if the previously-returned token was a structure
+ /* Some escape sequences undergo character set conversion. Those we
+ translate here. */
+ switch (*tokptr)
+ {
+ /* Hex escapes do not undergo character set conversion, so keep
+ the escape sequence for later. */
+ case 'x':
+ if (output)
+ obstack_grow_str (output, "\\x");
+ ++tokptr;
+ if (!isxdigit (*tokptr))
+ error (_("\\x escape without a following hex digit"));
+ while (isxdigit (*tokptr))
+ {
+ if (output)
+ obstack_1grow (output, *tokptr);
+ ++tokptr;
+ }
+ break;
+
+ /* Octal escapes do not undergo character set conversion, so
+ keep the escape sequence for later. */
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ {
+ int i;
+ if (output)
+ obstack_grow_str (output, "\\");
+ for (i = 0;
+ i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
+ ++i)
+ {
+ if (output)
+ obstack_1grow (output, *tokptr);
+ ++tokptr;
+ }
+ }
+ break;
+
+ /* We handle UCNs later. We could handle them here, but that
+ would mean a spurious error in the case where the UCN could
+ be converted to the target charset but not the host
+ charset. */
+ case 'u':
+ case 'U':
+ {
+ char c = *tokptr;
+ int i, len = c == 'U' ? 8 : 4;
+ if (output)
+ {
+ obstack_1grow (output, '\\');
+ obstack_1grow (output, *tokptr);
+ }
+ ++tokptr;
+ if (!isxdigit (*tokptr))
+ error (_("\\%c escape without a following hex digit"), c);
+ for (i = 0; i < len && isxdigit (*tokptr); ++i)
+ {
+ if (output)
+ obstack_1grow (output, *tokptr);
+ ++tokptr;
+ }
+ }
+ break;
+
+ /* We must pass backslash through so that it does not
+ cause quoting during the second expansion. */
+ case '\\':
+ if (output)
+ obstack_grow_str (output, "\\\\");
+ ++tokptr;
+ break;
+
+ /* Escapes which undergo conversion. */
+ case 'a':
+ if (output)
+ obstack_1grow (output, '\a');
+ ++tokptr;
+ break;
+ case 'b':
+ if (output)
+ obstack_1grow (output, '\b');
+ ++tokptr;
+ break;
+ case 'f':
+ if (output)
+ obstack_1grow (output, '\f');
+ ++tokptr;
+ break;
+ case 'n':
+ if (output)
+ obstack_1grow (output, '\n');
+ ++tokptr;
+ break;
+ case 'r':
+ if (output)
+ obstack_1grow (output, '\r');
+ ++tokptr;
+ break;
+ case 't':
+ if (output)
+ obstack_1grow (output, '\t');
+ ++tokptr;
+ break;
+ case 'v':
+ if (output)
+ obstack_1grow (output, '\v');
+ ++tokptr;
+ break;
+
+ /* GCC extension. */
+ case 'e':
+ if (output)
+ obstack_1grow (output, HOST_ESCAPE_CHAR);
+ ++tokptr;
+ break;
+
+ /* Backslash-newline expands to nothing at all. */
+ case '\n':
+ ++tokptr;
+ result = 0;
+ break;
+
+ /* A few escapes just expand to the character itself. */
+ case '\'':
+ case '\"':
+ case '?':
+ /* GCC extensions. */
+ case '(':
+ case '{':
+ case '[':
+ case '%':
+ /* Unrecognized escapes turn into the character itself. */
+ default:
+ if (output)
+ obstack_1grow (output, *tokptr);
+ ++tokptr;
+ break;
+ }
+ *ptr = tokptr;
+ return result;
+}
+
+/* Parse a string or character literal from TOKPTR. The string or
+ character may be wide or unicode. *OUTPTR is set to just after the
+ end of the literal in the input string. The resulting token is
+ stored in VALUE. This returns a token value, either STRING or
+ CHAR, depending on what was parsed. *HOST_CHARS is set to the
+ number of host characters in the literal. */
+
+static int
+parse_string_or_char (const char *tokptr, const char **outptr,
+ struct typed_stoken *value, int *host_chars)
+{
+ int quote;
+ enum c_string_type type;
+ int is_objc = 0;
+
+ /* Build the gdb internal form of the input string in tempbuf. Note
+ that the buffer is null byte terminated *only* for the
+ convenience of debugging gdb itself and printing the buffer
+ contents when the buffer contains no embedded nulls. Gdb does
+ not depend upon the buffer being null byte terminated, it uses
+ the length string instead. This allows gdb to handle C strings
+ (as well as strings in other languages) with embedded null
+ bytes */
+
+ if (!tempbuf_init)
+ tempbuf_init = 1;
+ else
+ obstack_free (&tempbuf, NULL);
+ obstack_init (&tempbuf);
+
+ /* Record the string type. */
+ if (*tokptr == 'L')
+ {
+ type = C_WIDE_STRING;
+ ++tokptr;
+ }
+ else if (*tokptr == 'u')
+ {
+ type = C_STRING_16;
+ ++tokptr;
+ }
+ else if (*tokptr == 'U')
+ {
+ type = C_STRING_32;
+ ++tokptr;
+ }
+ else if (*tokptr == '@')
+ {
+ /* An Objective C string. */
+ is_objc = 1;
+ type = C_STRING;
+ ++tokptr;
+ }
+ else
+ type = C_STRING;
+
+ /* Skip the quote. */
+ quote = *tokptr;
+ if (quote == '\'')
+ type |= C_CHAR;
+ ++tokptr;
+
+ *host_chars = 0;
+
+ while (*tokptr)
+ {
+ char c = *tokptr;
+ if (c == '\\')
+ {
+ ++tokptr;
+ *host_chars += c_parse_escape (&tokptr, &tempbuf);
+ }
+ else if (c == quote)
+ break;
+ else
+ {
+ obstack_1grow (&tempbuf, c);
+ ++tokptr;
+ /* FIXME: this does the wrong thing with multi-byte host
+ characters. We could use mbrlen here, but that would
+ make "set host-charset" a bit less useful. */
+ ++*host_chars;
+ }
+ }
+
+ if (*tokptr != quote)
+ {
+ if (quote == '"')
+ error (_("Unterminated string in expression."));
+ else
+ error (_("Unmatched single quote."));
+ }
+ ++tokptr;
+
+ value->type = type;
+ value->ptr = obstack_base (&tempbuf);
+ value->length = obstack_object_size (&tempbuf);
+
+ *outptr = tokptr;
+
+ return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR;
+}
+
+/* This is used to associate some attributes with a token. */
+
+enum token_flags
+{
+ /* If this bit is set, the token is C++-only. */
+
+ FLAG_CXX = 1,
+
+ /* If this bit is set, the token is conditional: if there is a
+ symbol of the same name, then the token is a symbol; otherwise,
+ the token is a keyword. */
+
+ FLAG_SHADOW = 2
+};
+
+struct token
+{
+ char *oper;
+ int token;
+ enum exp_opcode opcode;
+ enum token_flags flags;
+};
+
+static const struct token tokentab3[] =
+ {
+ {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
+ {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
+ {"->*", ARROW_STAR, BINOP_END, FLAG_CXX},
+ {"...", DOTDOTDOT, BINOP_END, 0}
+ };
+
+static const struct token tokentab2[] =
+ {
+ {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
+ {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
+ {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
+ {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
+ {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
+ {"|=", 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},
+ /* "::" 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}
+ };
+
+/* Identifier-like tokens. */
+static const struct token ident_tokens[] =
+ {
+ {"unsigned", UNSIGNED, OP_NULL, 0},
+ {"template", TEMPLATE, OP_NULL, FLAG_CXX},
+ {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
+ {"struct", STRUCT, OP_NULL, 0},
+ {"signed", SIGNED_KEYWORD, OP_NULL, 0},
+ {"sizeof", SIZEOF, OP_NULL, 0},
+ {"double", DOUBLE_KEYWORD, OP_NULL, 0},
+ {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
+ {"class", CLASS, OP_NULL, FLAG_CXX},
+ {"union", UNION, OP_NULL, 0},
+ {"short", SHORT, OP_NULL, 0},
+ {"const", CONST_KEYWORD, OP_NULL, 0},
+ {"enum", ENUM, OP_NULL, 0},
+ {"long", LONG, OP_NULL, 0},
+ {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
+ {"int", INT_KEYWORD, OP_NULL, 0},
+ {"new", NEW, OP_NULL, FLAG_CXX},
+ {"delete", DELETE, OP_NULL, FLAG_CXX},
+ {"operator", OPERATOR, OP_NULL, FLAG_CXX},
+
+ {"and", ANDAND, BINOP_END, 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},
+ {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
+ {"xor", '^', OP_NULL, FLAG_CXX},
+ {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
+
+ {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX },
+ {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX },
+ {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX },
+ {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX },
+
+ {"__typeof__", TYPEOF, OP_TYPEOF, 0 },
+ {"__typeof", TYPEOF, OP_TYPEOF, 0 },
+ {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
+ {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
+ {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW },
+
+ {"typeid", TYPEID, OP_TYPEID, FLAG_CXX}
+ };
+
+/* When we find that lexptr (the global var defined in parse.c) is
+ pointing at a macro invocation, we expand the invocation, and call
+ scan_macro_expansion to save the old lexptr here and point lexptr
+ into the expanded text. When we reach the end of that, we call
+ end_macro_expansion to pop back to the value we saved here. The
+ macro expansion code promises to return only fully-expanded text,
+ so we don't need to "push" more than one level.
+
+ This is disgusting, of course. It would be cleaner to do all macro
+ expansion beforehand, and then hand that to lexptr. But we don't
+ really know where the expression ends. Remember, in a command like
+
+ (gdb) break *ADDRESS if CONDITION
+
+ we evaluate ADDRESS in the scope of the current frame, but we
+ evaluate CONDITION in the scope of the breakpoint's location. So
+ it's simply wrong to try to macro-expand the whole thing at once. */
+static const char *macro_original_text;
+
+/* We save all intermediate macro expansions on this obstack for the
+ duration of a single parse. The expansion text may sometimes have
+ to live past the end of the expansion, due to yacc lookahead.
+ Rather than try to be clever about saving the data for a single
+ token, we simply keep it all and delete it after parsing has
+ completed. */
+static struct obstack expansion_obstack;
+
+static void
+scan_macro_expansion (char *expansion)
+{
+ char *copy;
+
+ /* We'd better not be trying to push the stack twice. */
+ gdb_assert (! macro_original_text);
+
+ /* Copy to the obstack, and then free the intermediate
+ expansion. */
+ copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
+ xfree (expansion);
+
+ /* Save the old lexptr value, so we can return to it when we're done
+ parsing the expanded text. */
+ macro_original_text = lexptr;
+ lexptr = copy;
+}
+
+static int
+scanning_macro_expansion (void)
+{
+ return macro_original_text != 0;
+}
+
+static void
+finished_macro_expansion (void)
+{
+ /* There'd better be something to pop back to. */
+ gdb_assert (macro_original_text);
+
+ /* Pop back to the original text. */
+ lexptr = macro_original_text;
+ macro_original_text = 0;
+}
+
+static void
+scan_macro_cleanup (void *dummy)
+{
+ if (macro_original_text)
+ finished_macro_expansion ();
+
+ obstack_free (&expansion_obstack, NULL);
+}
+
+/* Return true iff the token represents a C++ cast operator. */
+
+static int
+is_cast_operator (const char *token, int len)
+{
+ return (! strncmp (token, "dynamic_cast", len)
+ || ! strncmp (token, "static_cast", len)
+ || ! strncmp (token, "reinterpret_cast", len)
+ || ! strncmp (token, "const_cast", len));
+}
+
+/* The scope used for macro expansion. */
+static struct macro_scope *expression_macro_scope;
+
+/* This is set if a NAME token appeared at the very end of the input
+ string, with no whitespace separating the name from the EOF. This
+ is used only when parsing to do field name completion. */
+static int saw_name_at_eof;
+
+/* This is set if the previously-returned token was a structure
operator -- either '.' or ARROW. This is used only when parsing to
do field name completion. */
static int last_was_structop;
/* Read one token, getting characters through lexptr. */
static int
-yylex ()
+lex_one_token (struct parser_state *par_state, int *is_quoted_name)
{
int c;
int namelen;
unsigned int i;
- char *tokstart;
- char *tokptr;
- int tempbufindex;
- static char *tempbuf;
- static int tempbufsize;
- char * token_string = NULL;
- int class_prefix = 0;
+ const char *tokstart;
int saw_structop = last_was_structop;
+ char *copy;
last_was_structop = 0;
+ *is_quoted_name = 0;
retry:
if (! scanning_macro_expansion ())
{
char *expanded = macro_expand_next (&lexptr,
- expression_macro_lookup_func,
- expression_macro_lookup_baton);
+ standard_macro_lookup,
+ expression_macro_scope);
if (expanded)
scan_macro_expansion (expanded);
tokstart = 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].operator, 3) == 0)
+ if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
{
+ if ((tokentab3[i].flags & FLAG_CXX) != 0
+ && parse_language (par_state)->la_language != language_cplus)
+ break;
+
lexptr += 3;
yylval.opcode = tokentab3[i].opcode;
return tokentab3[i].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].operator, 2) == 0)
+ if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
{
+ if ((tokentab2[i].flags & FLAG_CXX) != 0
+ && parse_language (par_state)->la_language != language_cplus)
+ break;
+
lexptr += 2;
yylval.opcode = tokentab2[i].opcode;
- if (in_parse_field && tokentab2[i].opcode == ARROW)
+ if (parse_completion && tokentab2[i].token == ARROW)
last_was_structop = 1;
return tokentab2[i].token;
}
lexptr++;
goto retry;
- case '\'':
- /* We either have a character constant ('0' or '\177' for example)
- or we have a quoted symbol reference ('foo(int,int)' in C++
- for example). */
- lexptr++;
- c = *lexptr++;
- if (c == '\\')
- c = parse_escape (&lexptr);
- else if (c == '\'')
- error ("Empty character constant.");
- else if (! host_char_to_target (c, &c))
- {
- int toklen = lexptr - tokstart + 1;
- char *tok = alloca (toklen + 1);
- memcpy (tok, tokstart, toklen);
- tok[toklen] = '\0';
- error ("There is no character corresponding to %s in the target "
- "character set `%s'.", tok, target_charset ());
- }
-
- yylval.typed_val_int.val = c;
- yylval.typed_val_int.type = builtin_type (current_gdbarch)->builtin_char;
-
- c = *lexptr++;
- if (c != '\'')
- {
- namelen = skip_quoted (tokstart) - tokstart;
- if (namelen > 2)
- {
- lexptr = tokstart + namelen;
- if (lexptr[-1] != '\'')
- error ("Unmatched single quote.");
- namelen -= 2;
- tokstart++;
- goto tryname;
- }
- error ("Invalid character constant.");
- }
- return INT;
-
+ case '[':
case '(':
paren_depth++;
lexptr++;
+ if (parse_language (par_state)->la_language == language_objc
+ && c == '[')
+ return OBJC_LBRAC;
return c;
+ case ']':
case ')':
if (paren_depth == 0)
return 0;
/* Might be a floating point number. */
if (lexptr[1] < '0' || lexptr[1] > '9')
{
- if (in_parse_field)
+ if (parse_completion)
last_was_structop = 1;
goto symbol; /* Nope, must be a symbol. */
}
{
/* It's a number. */
int got_dot = 0, got_e = 0, toktype;
- char *p = tokstart;
+ const char *p = tokstart;
int hex = input_radix > 10;
if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
&& (*p < 'A' || *p > 'Z')))
break;
}
- toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
+ toktype = parse_number (par_state, tokstart, p - tokstart,
+ got_dot|got_e, &yylval);
if (toktype == ERROR)
{
char *err_copy = (char *) alloca (p - tokstart + 1);
memcpy (err_copy, tokstart, p - tokstart);
err_copy[p - tokstart] = 0;
- error ("Invalid number \"%s\".", err_copy);
+ error (_("Invalid number \"%s\"."), err_copy);
}
lexptr = p;
return toktype;
}
+ case '@':
+ {
+ const char *p = &tokstart[1];
+ size_t len = strlen ("entry");
+
+ if (parse_language (par_state)->la_language == language_objc)
+ {
+ size_t len = strlen ("selector");
+
+ if (strncmp (p, "selector", len) == 0
+ && (p[len] == '\0' || isspace (p[len])))
+ {
+ lexptr = p + len;
+ return SELECTOR;
+ }
+ else if (*p == '"')
+ goto parse_string;
+ }
+
+ while (isspace (*p))
+ p++;
+ if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
+ && p[len] != '_')
+ {
+ lexptr = &p[len];
+ return ENTRY;
+ }
+ }
+ /* FALLTHRU */
case '+':
case '-':
case '*':
case '^':
case '~':
case '!':
- case '@':
case '<':
case '>':
- case '[':
- case ']':
case '?':
case ':':
case '=':
lexptr++;
return c;
+ case 'L':
+ case 'u':
+ case 'U':
+ if (tokstart[1] != '"' && tokstart[1] != '\'')
+ break;
+ /* Fall through. */
+ case '\'':
case '"':
- /* Build the gdb internal form of the input string in tempbuf,
- translating any standard C escape forms seen. Note that the
- buffer is null byte terminated *only* for the convenience of
- debugging gdb itself and printing the buffer contents when
- the buffer contains no embedded nulls. Gdb does not depend
- upon the buffer being null byte terminated, it uses the length
- string instead. This allows gdb to handle C strings (as well
- as strings in other languages) with embedded null bytes */
-
- tokptr = ++tokstart;
- tempbufindex = 0;
-
- do {
- char *char_start_pos = tokptr;
-
- /* Grow the static temp buffer if necessary, including allocating
- the first one on demand. */
- if (tempbufindex + 1 >= tempbufsize)
- {
- tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
- }
- switch (*tokptr)
+ parse_string:
+ {
+ int host_len;
+ int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
+ &host_len);
+ if (result == CHAR)
{
- case '\0':
- case '"':
- /* Do nothing, loop will terminate. */
- break;
- case '\\':
- tokptr++;
- c = parse_escape (&tokptr);
- if (c == -1)
+ if (host_len == 0)
+ error (_("Empty character constant."));
+ else if (host_len > 2 && c == '\'')
{
- continue;
+ ++tokstart;
+ namelen = lexptr - tokstart - 1;
+ *is_quoted_name = 1;
+
+ goto tryname;
}
- tempbuf[tempbufindex++] = c;
- break;
- default:
- c = *tokptr++;
- if (! host_char_to_target (c, &c))
- {
- int len = tokptr - char_start_pos;
- char *copy = alloca (len + 1);
- memcpy (copy, char_start_pos, len);
- copy[len] = '\0';
-
- error ("There is no character corresponding to `%s' "
- "in the target character set `%s'.",
- copy, target_charset ());
- }
- tempbuf[tempbufindex++] = c;
- break;
+ else if (host_len > 1)
+ error (_("Invalid character constant."));
}
- } while ((*tokptr != '"') && (*tokptr != '\0'));
- if (*tokptr++ != '"')
- {
- error ("Unterminated string in expression.");
- }
- tempbuf[tempbufindex] = '\0'; /* See note above */
- yylval.sval.ptr = tempbuf;
- yylval.sval.length = tempbufindex;
- lexptr = tokptr;
- return (STRING);
+ return result;
+ }
}
if (!(c == '_' || c == '$'
|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
/* We must have come across a bad character (e.g. ';'). */
- error ("Invalid character '%c' in expression.", c);
+ error (_("Invalid character '%c' in expression."), c);
/* It's a name. See how long it is. */
namelen = 0;
FIXME: This mishandles `print $a<4&&$a>3'. */
if (c == '<')
- {
- /* Scan ahead to get rest of the template specification. Note
- that we look ahead only when the '<' adjoins non-whitespace
- characters; for comparison expressions, e.g. "a < b > c",
- there must be spaces before the '<', etc. */
-
- char * p = find_template_name_end (tokstart + namelen);
- if (p)
- namelen = p - tokstart;
- break;
+ {
+ if (! is_cast_operator (tokstart, namelen))
+ {
+ /* Scan ahead to get rest of the template specification. Note
+ that we look ahead only when the '<' adjoins non-whitespace
+ characters; for comparison expressions, e.g. "a < b > c",
+ there must be spaces before the '<', etc. */
+ const char *p = find_template_name_end (tokstart + namelen);
+
+ if (p)
+ namelen = p - tokstart;
+ }
+ break;
}
c = tokstart[++namelen];
}
return 0;
}
+ /* For the same reason (breakpoint conditions), "thread N"
+ terminates the expression. "thread" could be an identifier, but
+ an identifier is never followed by a number without intervening
+ punctuation. "task" is similar. Handle abbreviations of these,
+ similarly to breakpoint.c:find_condition_and_thread. */
+ if (namelen >= 1
+ && (strncmp (tokstart, "thread", namelen) == 0
+ || strncmp (tokstart, "task", namelen) == 0)
+ && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
+ && ! scanning_macro_expansion ())
+ {
+ const char *p = tokstart + namelen + 1;
+
+ while (*p == ' ' || *p == '\t')
+ p++;
+ if (*p >= '0' && *p <= '9')
+ return 0;
+ }
+
lexptr += namelen;
tryname:
- /* Catch specific keywords. Should be done with a data structure. */
- switch (namelen)
- {
- case 8:
- if (strncmp (tokstart, "unsigned", 8) == 0)
- return UNSIGNED;
- if (current_language->la_language == language_cplus
- && strncmp (tokstart, "template", 8) == 0)
- return TEMPLATE;
- if (strncmp (tokstart, "volatile", 8) == 0)
- return VOLATILE_KEYWORD;
- break;
- case 6:
- 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:
- if (current_language->la_language == language_cplus)
- {
- 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, "short", 5) == 0)
- return SHORT;
- if (strncmp (tokstart, "const", 5) == 0)
- return CONST_KEYWORD;
- break;
- case 4:
- if (strncmp (tokstart, "enum", 4) == 0)
- return ENUM;
- if (strncmp (tokstart, "long", 4) == 0)
- return LONG;
- if (current_language->la_language == language_cplus)
- {
- if (strncmp (tokstart, "true", 4) == 0)
- return TRUEKEYWORD;
- }
- break;
- case 3:
- if (strncmp (tokstart, "int", 3) == 0)
- return INT_KEYWORD;
- break;
- default:
- break;
- }
-
yylval.sval.ptr = tokstart;
yylval.sval.length = namelen;
- if (*tokstart == '$')
- {
- write_dollar_variable (yylval.sval);
- return VARIABLE;
- }
-
- /* Use token-type BLOCKNAME for symbols that happen to be defined as
- functions or symtabs. If this is not so, then ...
- Use token-type TYPENAME for symbols that happen to be defined
- 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);
- struct symbol *sym;
- int is_a_field_of_this = 0;
- int hextype;
-
- sym = lookup_symbol (tmp, expression_context_block,
- VAR_DOMAIN,
- current_language->la_language == language_cplus
- ? &is_a_field_of_this : (int *) NULL);
- /* Call lookup_symtab, not lookup_partial_symtab, in case there are
- no psymtabs (coff, xcoff, or some future change to blow away the
- psymtabs once once symbols are read). */
- if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ /* Catch specific keywords. */
+ copy = copy_name (yylval.sval);
+ for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
+ if (strcmp (copy, ident_tokens[i].oper) == 0)
{
- yylval.ssym.sym = sym;
- yylval.ssym.is_a_field_of_this = is_a_field_of_this;
- return BLOCKNAME;
- }
- else if (!sym)
- { /* See if it's a file name. */
- struct symtab *symtab;
+ if ((ident_tokens[i].flags & FLAG_CXX) != 0
+ && parse_language (par_state)->la_language != language_cplus)
+ break;
- symtab = lookup_symtab (tmp);
-
- if (symtab)
+ if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
{
- yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
- return FILENAME;
+ struct field_of_this_result is_a_field_of_this;
+
+ if (lookup_symbol (copy, expression_context_block,
+ VAR_DOMAIN,
+ (parse_language (par_state)->la_language
+ == language_cplus ? &is_a_field_of_this
+ : NULL))
+ != NULL)
+ {
+ /* The keyword is shadowed. */
+ break;
+ }
}
+
+ /* 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;
}
- if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
- {
- /* NOTE: carlton/2003-09-25: There used to be code here to
- handle nested types. It didn't work very well. See the
- comment before qualified_type for more info. */
- yylval.tsym.type = SYMBOL_TYPE (sym);
- return TYPENAME;
- }
- yylval.tsym.type
- = language_lookup_primitive_type_by_name (current_language,
- current_gdbarch, tmp);
- if (yylval.tsym.type != NULL)
+ if (*tokstart == '$')
+ return VARIABLE;
+
+ if (parse_completion && *lexptr == '\0')
+ saw_name_at_eof = 1;
+
+ yylval.ssym.stoken = yylval.sval;
+ yylval.ssym.sym = NULL;
+ yylval.ssym.is_a_field_of_this = 0;
+ return NAME;
+}
+
+/* An object of this type is pushed on a FIFO by the "outer" lexer. */
+typedef struct
+{
+ int token;
+ YYSTYPE value;
+} token_and_value;
+
+DEF_VEC_O (token_and_value);
+
+/* A FIFO of tokens that have been read but not yet returned to the
+ parser. */
+static VEC (token_and_value) *token_fifo;
+
+/* Non-zero if the lexer should return tokens from the FIFO. */
+static int popping;
+
+/* Temporary storage for c_lex; this holds symbol names as they are
+ built up. */
+static struct obstack name_obstack;
+
+/* Classify a NAME token. The contents of the token are in `yylval'.
+ Updates yylval and returns the new token type. BLOCK is the block
+ in which lookups start; this can be NULL to mean the global scope.
+ IS_QUOTED_NAME is non-zero if the name token was originally quoted
+ in single quotes. */
+
+static int
+classify_name (struct parser_state *par_state, const struct block *block,
+ int is_quoted_name)
+{
+ struct symbol *sym;
+ char *copy;
+ struct field_of_this_result is_a_field_of_this;
+
+ copy = copy_name (yylval.sval);
+
+ /* Initialize this in case we *don't* use it in this call; that way
+ we can refer to it unconditionally below. */
+ memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
+
+ sym = lookup_symbol (copy, block, VAR_DOMAIN,
+ parse_language (par_state)->la_name_of_this
+ ? &is_a_field_of_this : NULL);
+
+ if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ {
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
+ return BLOCKNAME;
+ }
+ else if (!sym)
+ {
+ /* If we found a field of 'this', we might have erroneously
+ found a constructor where we wanted a type name. Handle this
+ case by noticing that we found a constructor and then look up
+ the type tag instead. */
+ if (is_a_field_of_this.type != NULL
+ && is_a_field_of_this.fn_field != NULL
+ && TYPE_FN_FIELD_CONSTRUCTOR (is_a_field_of_this.fn_field->fn_fields,
+ 0))
+ {
+ struct field_of_this_result inner_is_a_field_of_this;
+
+ sym = lookup_symbol (copy, block, STRUCT_DOMAIN,
+ &inner_is_a_field_of_this);
+ if (sym != NULL)
+ {
+ yylval.tsym.type = SYMBOL_TYPE (sym);
+ return TYPENAME;
+ }
+ }
+
+ /* If we found a field, then we want to prefer it over a
+ filename. However, if the name was quoted, then it is better
+ to check for a filename or a block, since this is the only
+ way the user has of requiring the extension to be used. */
+ if (is_a_field_of_this.type == NULL || is_quoted_name)
+ {
+ /* See if it's a file name. */
+ struct symtab *symtab;
+
+ symtab = lookup_symtab (copy);
+ if (symtab)
+ {
+ yylval.bval = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab),
+ STATIC_BLOCK);
+ return FILENAME;
+ }
+ }
+ }
+
+ if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ {
+ yylval.tsym.type = SYMBOL_TYPE (sym);
return TYPENAME;
+ }
+
+ /* See if it's an ObjC classname. */
+ if (parse_language (par_state)->la_language == language_objc && !sym)
+ {
+ CORE_ADDR Class = lookup_objc_class (parse_gdbarch (par_state), copy);
+ if (Class)
+ {
+ yylval.theclass.theclass = Class;
+ sym = lookup_struct_typedef (copy, expression_context_block, 1);
+ if (sym)
+ yylval.theclass.type = SYMBOL_TYPE (sym);
+ return CLASSNAME;
+ }
+ }
+
+ /* Input names that aren't symbols but ARE valid hex numbers, when
+ the input radix permits them, can be names or numbers depending
+ on the parse. Note we support radixes > 16 here. */
+ if (!sym
+ && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
+ || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
+ {
+ YYSTYPE newlval; /* Its value is ignored. */
+ int hextype = parse_number (par_state, copy, yylval.sval.length,
+ 0, &newlval);
+ if (hextype == INT)
+ {
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
+ return NAME_OR_INT;
+ }
+ }
+
+ /* Any other kind of symbol */
+ yylval.ssym.sym = sym;
+ yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
+
+ if (sym == NULL
+ && parse_language (par_state)->la_language == language_cplus
+ && is_a_field_of_this.type == NULL
+ && lookup_minimal_symbol (copy, NULL, NULL).minsym == NULL)
+ return UNKNOWN_CPP_NAME;
+
+ return NAME;
+}
+
+/* Like classify_name, but used by the inner loop of the lexer, when a
+ name might have already been seen. CONTEXT is the context type, or
+ NULL if this is the first component of a name. */
+
+static int
+classify_inner_name (struct parser_state *par_state,
+ const struct block *block, struct type *context)
+{
+ struct type *type;
+ char *copy;
+
+ if (context == NULL)
+ return classify_name (par_state, block, 0);
- /* Input names that aren't symbols but ARE valid hex numbers,
- when the input radix permits them, can be names or numbers
- depending on the parse. Note we support radixes > 16 here. */
- if (!sym &&
- ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
- (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
+ type = check_typedef (context);
+ if (!type_aggregate_p (type))
+ return ERROR;
+
+ copy = copy_name (yylval.ssym.stoken);
+ /* N.B. We assume the symbol can only be in VAR_DOMAIN. */
+ yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block, VAR_DOMAIN);
+
+ /* If no symbol was found, search for a matching base class named
+ COPY. This will allow users to enter qualified names of class members
+ relative to the `this' pointer. */
+ if (yylval.ssym.sym == NULL)
+ {
+ struct type *base_type = cp_find_type_baseclass_by_name (type, copy);
+
+ if (base_type != NULL)
+ {
+ yylval.tsym.type = base_type;
+ return TYPENAME;
+ }
+
+ return ERROR;
+ }
+
+ switch (SYMBOL_CLASS (yylval.ssym.sym))
+ {
+ case LOC_BLOCK:
+ case LOC_LABEL:
+ /* cp_lookup_nested_symbol might have accidentally found a constructor
+ named COPY when we really wanted a base class of the same name.
+ Double-check this case by looking for a base class. */
{
- YYSTYPE newlval; /* Its value is ignored. */
- hextype = parse_number (tokstart, namelen, 0, &newlval);
- if (hextype == INT)
+ struct type *base_type = cp_find_type_baseclass_by_name (type, copy);
+
+ if (base_type != NULL)
{
- yylval.ssym.sym = sym;
- yylval.ssym.is_a_field_of_this = is_a_field_of_this;
- return NAME_OR_INT;
+ yylval.tsym.type = base_type;
+ return TYPENAME;
}
}
+ return ERROR;
- /* Any other kind of symbol */
- yylval.ssym.sym = sym;
- yylval.ssym.is_a_field_of_this = is_a_field_of_this;
- if (in_parse_field && *lexptr == '\0')
- saw_name_at_eof = 1;
- return NAME;
- }
+ case LOC_TYPEDEF:
+ yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);
+ return TYPENAME;
+
+ default:
+ return NAME;
+ }
+ internal_error (__FILE__, __LINE__, _("not reached"));
+}
+
+/* The outer level of a two-level lexer. This calls the inner lexer
+ to return tokens. It then either returns these tokens, or
+ aggregates them into a larger token. This lets us work around a
+ problem in our parsing approach, where the parser could not
+ distinguish between qualified names and qualified types at the
+ right point.
+
+ This approach is still not ideal, because it mishandles template
+ types. See the comment in lex_one_token for an example. However,
+ this is still an improvement over the earlier approach, and will
+ suffice until we move to better parsing technology. */
+
+static int
+yylex (void)
+{
+ token_and_value current;
+ int first_was_coloncolon, last_was_coloncolon;
+ struct type *context_type = NULL;
+ int last_to_examine, next_to_examine, checkpoint;
+ const struct block *search_block;
+ int is_quoted_name;
+
+ if (popping && !VEC_empty (token_and_value, token_fifo))
+ goto do_pop;
+ popping = 0;
+
+ /* Read the first token and decide what to do. Most of the
+ subsequent code is C++-only; but also depends on seeing a "::" or
+ name-like token. */
+ current.token = lex_one_token (pstate, &is_quoted_name);
+ if (current.token == NAME)
+ current.token = classify_name (pstate, expression_context_block,
+ is_quoted_name);
+ if (parse_language (pstate)->la_language != language_cplus
+ || (current.token != TYPENAME && current.token != COLONCOLON
+ && current.token != FILENAME))
+ return current.token;
+
+ /* Read any sequence of alternating "::" and name-like tokens into
+ the token FIFO. */
+ current.value = yylval;
+ VEC_safe_push (token_and_value, token_fifo, ¤t);
+ last_was_coloncolon = current.token == COLONCOLON;
+ while (1)
+ {
+ int ignore;
+
+ /* We ignore quoted names other than the very first one.
+ Subsequent ones do not have any special meaning. */
+ current.token = lex_one_token (pstate, &ignore);
+ current.value = yylval;
+ VEC_safe_push (token_and_value, token_fifo, ¤t);
+
+ if ((last_was_coloncolon && current.token != NAME)
+ || (!last_was_coloncolon && current.token != COLONCOLON))
+ break;
+ last_was_coloncolon = !last_was_coloncolon;
+ }
+ popping = 1;
+
+ /* We always read one extra token, so compute the number of tokens
+ to examine accordingly. */
+ last_to_examine = VEC_length (token_and_value, token_fifo) - 2;
+ next_to_examine = 0;
+
+ current = *VEC_index (token_and_value, token_fifo, next_to_examine);
+ ++next_to_examine;
+
+ obstack_free (&name_obstack, obstack_base (&name_obstack));
+ checkpoint = 0;
+ if (current.token == FILENAME)
+ search_block = current.value.bval;
+ else if (current.token == COLONCOLON)
+ search_block = NULL;
+ else
+ {
+ gdb_assert (current.token == TYPENAME);
+ search_block = expression_context_block;
+ obstack_grow (&name_obstack, current.value.sval.ptr,
+ current.value.sval.length);
+ context_type = current.value.tsym.type;
+ checkpoint = 1;
+ }
+
+ first_was_coloncolon = current.token == COLONCOLON;
+ last_was_coloncolon = first_was_coloncolon;
+
+ while (next_to_examine <= last_to_examine)
+ {
+ token_and_value *next;
+
+ next = VEC_index (token_and_value, token_fifo, next_to_examine);
+ ++next_to_examine;
+
+ if (next->token == NAME && last_was_coloncolon)
+ {
+ int classification;
+
+ yylval = next->value;
+ classification = classify_inner_name (pstate, search_block,
+ context_type);
+ /* We keep going until we either run out of names, or until
+ we have a qualified name which is not a type. */
+ if (classification != TYPENAME && classification != NAME)
+ break;
+
+ /* Accept up to this token. */
+ checkpoint = next_to_examine;
+
+ /* Update the partial name we are constructing. */
+ if (context_type != NULL)
+ {
+ /* We don't want to put a leading "::" into the name. */
+ obstack_grow_str (&name_obstack, "::");
+ }
+ obstack_grow (&name_obstack, next->value.sval.ptr,
+ next->value.sval.length);
+
+ yylval.sval.ptr = obstack_base (&name_obstack);
+ yylval.sval.length = obstack_object_size (&name_obstack);
+ current.value = yylval;
+ current.token = classification;
+
+ last_was_coloncolon = 0;
+
+ if (classification == NAME)
+ break;
+
+ context_type = yylval.tsym.type;
+ }
+ else if (next->token == COLONCOLON && !last_was_coloncolon)
+ last_was_coloncolon = 1;
+ else
+ {
+ /* We've reached the end of the name. */
+ break;
+ }
+ }
+
+ /* If we have a replacement token, install it as the first token in
+ the FIFO, and delete the other constituent tokens. */
+ if (checkpoint > 0)
+ {
+ current.value.sval.ptr = obstack_copy0 (&expansion_obstack,
+ current.value.sval.ptr,
+ current.value.sval.length);
+
+ VEC_replace (token_and_value, token_fifo, 0, ¤t);
+ if (checkpoint > 1)
+ VEC_block_remove (token_and_value, token_fifo, 1, checkpoint - 1);
+ }
+
+ do_pop:
+ current = *VEC_index (token_and_value, token_fifo, 0);
+ VEC_ordered_remove (token_and_value, token_fifo, 0);
+ yylval = current.value;
+ return current.token;
}
int
-c_parse (void)
+c_parse (struct parser_state *par_state)
{
+ int result;
+ struct cleanup *back_to;
+
+ /* Setting up the parser state. */
+ gdb_assert (par_state != NULL);
+ pstate = par_state;
+
+ back_to = make_cleanup (free_current_contents, &expression_macro_scope);
+ make_cleanup_clear_parser_state (&pstate);
+
+ /* Set up the scope for macro expansion. */
+ expression_macro_scope = NULL;
+
+ if (expression_context_block)
+ expression_macro_scope
+ = sal_macro_scope (find_pc_line (expression_context_pc, 0));
+ else
+ expression_macro_scope = default_macro_scope ();
+ if (! expression_macro_scope)
+ expression_macro_scope = user_macro_scope ();
+
+ /* Initialize macro expansion code. */
+ obstack_init (&expansion_obstack);
+ gdb_assert (! macro_original_text);
+ make_cleanup (scan_macro_cleanup, 0);
+
+ make_cleanup_restore_integer (&yydebug);
+ yydebug = parser_debug;
+
+ /* Initialize some state used by the lexer. */
last_was_structop = 0;
saw_name_at_eof = 0;
- return yyparse ();
+
+ VEC_free (token_and_value, token_fifo);
+ popping = 0;
+ obstack_init (&name_obstack);
+ make_cleanup_obstack_free (&name_obstack);
+
+ result = yyparse ();
+ do_cleanups (back_to);
+
+ return result;
+}
+
+#ifdef YYBISON
+
+/* This is called via the YYPRINT macro when parser debugging is
+ enabled. It prints a token's value. */
+
+static void
+c_print_token (FILE *file, int type, YYSTYPE value)
+{
+ switch (type)
+ {
+ case INT:
+ fprintf (file, "typed_val_int<%s, %s>",
+ TYPE_SAFE_NAME (value.typed_val_int.type),
+ pulongest (value.typed_val_int.val));
+ break;
+
+ case CHAR:
+ case STRING:
+ {
+ char *copy = alloca (value.tsval.length + 1);
+
+ memcpy (copy, value.tsval.ptr, value.tsval.length);
+ copy[value.tsval.length] = '\0';
+
+ fprintf (file, "tsval<type=%d, %s>", value.tsval.type, copy);
+ }
+ break;
+
+ case NSSTRING:
+ case VARIABLE:
+ fprintf (file, "sval<%s>", copy_name (value.sval));
+ break;
+
+ case TYPENAME:
+ fprintf (file, "tsym<type=%s, name=%s>",
+ TYPE_SAFE_NAME (value.tsym.type),
+ copy_name (value.tsym.stoken));
+ break;
+
+ case NAME:
+ case UNKNOWN_CPP_NAME:
+ case NAME_OR_INT:
+ case BLOCKNAME:
+ fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
+ copy_name (value.ssym.stoken),
+ (value.ssym.sym == NULL
+ ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym)),
+ value.ssym.is_a_field_of_this);
+ break;
+
+ case FILENAME:
+ fprintf (file, "bval<%s>", host_address_to_string (value.bval));
+ break;
+ }
}
+#endif
+
void
-yyerror (msg)
- char *msg;
+yyerror (char *msg)
{
if (prev_lexptr)
lexptr = prev_lexptr;
- error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
+ error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
}