AArch64: Revert setting of elf class in linker stub.

[deliverable/binutils-gdb.git] / gdb / c-exp.y

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index f6659d47fbec9423bc32207ac67508ef43d64f61..3403a857a8396190b039dd2ae595e258f3c96990 100644 (file)
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -1,5 +1,5 @@
 /* YACC parser for C expressions, for GDB.
 /* YACC parser for C expressions, for GDB.

-   Copyright (C) 1986-2013 Free Software Foundation, Inc.
+   Copyright (C) 1986-2020 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -32,97 +32,95 @@
    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.  */
    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 "defs.h"

-#include "gdb_string.h"

 #include <ctype.h>
 #include "expression.h"
 #include "value.h"
 #include "parser-defs.h"
 #include "language.h"
 #include "c-lang.h"
 #include <ctype.h>
 #include "expression.h"
 #include "value.h"
 #include "parser-defs.h"
 #include "language.h"
 #include "c-lang.h"

+#include "c-support.h"

 #include "bfd.h" /* Required by objfiles.h.  */
 #include "symfile.h" /* Required by objfiles.h.  */
 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
 #include "charset.h"
 #include "block.h"
 #include "cp-support.h"
 #include "bfd.h" /* Required by objfiles.h.  */
 #include "symfile.h" /* Required by objfiles.h.  */
 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
 #include "charset.h"
 #include "block.h"
 #include "cp-support.h"

-#include "dfp.h"
-#include "gdb_assert.h"

 #include "macroscope.h"
 #include "objc-lang.h"
 #include "typeprint.h"
 #include "cp-abi.h"
 #include "macroscope.h"
 #include "objc-lang.h"
 #include "typeprint.h"
 #include "cp-abi.h"

+#include "type-stack.h"

 
 

-#define parse_type builtin_type (parse_gdbarch)
-
-/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
-   as well as gratuitiously global symbol names, so we can have multiple
-   yacc generated parsers in gdb.  Note that these are only the variables
-   produced by yacc.  If other parser generators (bison, byacc, etc) produce
-   additional global names that conflict at link time, then those parser
-   generators need to be fixed instead of adding those names to this list. */
-
-#define        yymaxdepth c_maxdepth
-#define        yyparse c_parse_internal
-#define        yylex   c_lex
-#define        yyerror c_error
-#define        yylval  c_lval
-#define        yychar  c_char
-#define        yydebug c_debug
-#define        yypact  c_pact  
-#define        yyr1    c_r1                    
-#define        yyr2    c_r2                    
-#define        yydef   c_def           
-#define        yychk   c_chk           
-#define        yypgo   c_pgo           
-#define        yyact   c_act           
-#define        yyexca  c_exca
-#define yyerrflag c_errflag
-#define yynerrs        c_nerrs
-#define        yyps    c_ps
-#define        yypv    c_pv
-#define        yys     c_s
-#define        yy_yys  c_yys
-#define        yystate c_state
-#define        yytmp   c_tmp
-#define        yyv     c_v
-#define        yy_yyv  c_yyv
-#define        yyval   c_val
-#define        yylloc  c_lloc
-#define yyreds c_reds          /* With YYDEBUG defined */
-#define yytoks c_toks          /* With YYDEBUG defined */
-#define yyname c_name          /* With YYDEBUG defined */
-#define yyrule c_rule          /* With YYDEBUG defined */
-#define yylhs  c_yylhs
-#define yylen  c_yylen
-#define yydefred c_yydefred
-#define yydgoto        c_yydgoto
-#define yysindex c_yysindex
-#define yyrindex c_yyrindex
-#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 */
-#endif
+#define parse_type(ps) builtin_type (ps->gdbarch ())
+
+/* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
+   etc).  */
+#define GDB_YY_REMAP_PREFIX c_
+#include "yy-remap.h"
+
+/* The state of the parser, used internally when we are parsing the
+   expression.  */

 
 

-#define YYFPRINTF parser_fprintf
+static struct parser_state *pstate = NULL;
+
+/* Data that must be held for the duration of a parse.  */
+
+struct c_parse_state
+{
+  /* These are used to hold type lists and type stacks that are
+     allocated during the parse.  */
+  std::vector<std::unique_ptr<std::vector<struct type *>>> type_lists;
+  std::vector<std::unique_ptr<struct type_stack>> type_stacks;
+
+  /* Storage for some strings allocated during the parse.  */
+  std::vector<gdb::unique_xmalloc_ptr<char>> strings;
+
+  /* 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.  */
+  const char *macro_original_text = nullptr;
+
+  /* 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.  */
+  auto_obstack expansion_obstack;
+
+  /* The type stack.  */
+  struct type_stack type_stack;
+};
+
+/* This is set and cleared in c_parse.  */
+
+static struct c_parse_state *cpstate;

 
 int yyparse (void);
 
 static int yylex (void);
 
 
 int yyparse (void);
 
 static int yylex (void);
 

-void yyerror (char *);
+static void yyerror (const char *);
+
+static int type_aggregate_p (struct type *);

 
 %}
 
 
 %}
 


@@ -137,42 +135,44 @@ void yyerror (char *);
       LONGEST val;
       struct type *type;
     } typed_val_int;
       LONGEST val;
       struct type *type;
     } typed_val_int;

-    struct {
-      DOUBLEST dval;
-      struct type *type;
-    } typed_val_float;

     struct {
       gdb_byte val[16];
       struct type *type;
     struct {
       gdb_byte val[16];
       struct type *type;

-    } typed_val_decfloat;
-    struct symbol *sym;
+    } typed_val_float;

     struct type *tval;
     struct stoken sval;
     struct typed_stoken tsval;
     struct ttype tsym;
     struct symtoken ssym;
     int voidval;
     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;
     enum exp_opcode opcode;

-    struct internalvar *ivar;

 
     struct stoken_vector svec;
 
     struct stoken_vector svec;

-    VEC (type_ptr) *tvec;
-    int *ivec;
+    std::vector<struct type *> *tvec;

 
     struct type_stack *type_stack;
 
 
     struct type_stack *type_stack;
 

-    struct objc_class_str class;
+    struct objc_class_str theclass;

   }
 
 %{
 /* YYSTYPE gets defined by %union */
   }
 
 %{
 /* 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 struct stoken operator_stoken (const char *);

-static void check_parameter_typelist (VEC (type_ptr) *);
+static struct stoken typename_stoken (const char *);
+static void check_parameter_typelist (std::vector<struct type *> *);
+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 <voidval> exp exp1 type_exp start variable qualified_name lcurly function_method

 %type <lval> rcurly
 %type <tval> type typebase
 %type <tvec> nonempty_typelist func_mod parameter_typelist
 %type <lval> rcurly
 %type <tval> type typebase
 %type <tvec> nonempty_typelist func_mod parameter_typelist


@@ -187,7 +187,6 @@ static void check_parameter_typelist (VEC (type_ptr) *);
 
 %token <typed_val_int> INT
 %token <typed_val_float> FLOAT
 
 %token <typed_val_int> INT
 %token <typed_val_float> FLOAT

-%token <typed_val_decfloat> DECFLOAT

 
 /* Both NAME and TYPENAME tokens represent symbols in the input,
    and both convey their data as strings.
 
 /* Both NAME and TYPENAME tokens represent symbols in the input,
    and both convey their data as strings.


@@ -205,11 +204,11 @@ static void check_parameter_typelist (VEC (type_ptr) *);
 %token <ssym> UNKNOWN_CPP_NAME
 %token <voidval> COMPLETE
 %token <tsym> TYPENAME
 %token <ssym> UNKNOWN_CPP_NAME
 %token <voidval> COMPLETE
 %token <tsym> TYPENAME

-%token <class> CLASSNAME       /* ObjC Class name */
-%type <sval> name
+%token <theclass> CLASSNAME    /* ObjC Class name */
+%type <sval> name field_name

 %type <svec> string_exp
 %type <ssym> name_not_typename
 %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
 
  /* This is like a '[' token, but is only generated when parsing
     Objective C.  This lets us reuse the same parser without


@@ -221,24 +220,25 @@ static void check_parameter_typelist (VEC (type_ptr) *);
    E.g. "c" when input_radix==16.  Depending on the parse, it will be
    turned into a name or into a number.  */
 
    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 OPERATOR

-%token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
+%token STRUCT CLASS UNION ENUM SIZEOF ALIGNOF UNSIGNED COLONCOLON

 %token TEMPLATE
 %token ERROR
 %token NEW DELETE
 %token TEMPLATE
 %token ERROR
 %token NEW DELETE

-%type <sval> operator
+%type <sval> oper

 %token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST
 %token ENTRY
 %token TYPEOF
 %token DECLTYPE
 %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
 
 
 /* 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 <sval> VARIABLE
+%token <sval> DOLLAR_VARIABLE

 
 %token <opcode> ASSIGN_MODIFY
 
 
 %token <opcode> ASSIGN_MODIFY
 


@@ -264,7 +264,7 @@ static void check_parameter_typelist (VEC (type_ptr) *);
 %left '*' '/' '%'
 %right UNARY INCREMENT DECREMENT
 %right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '('
 %left '*' '/' '%'
 %right UNARY INCREMENT DECREMENT
 %right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '('

-%token <ssym> BLOCKNAME 
+%token <ssym> BLOCKNAME

 %token <bval> FILENAME
 %type <bval> block
 %left COLONCOLON
 %token <bval> FILENAME
 %type <bval> block
 %left COLONCOLON


@@ -279,152 +279,190 @@ start   :       exp1
        ;
 
 type_exp:      type
        ;
 
 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 ')'
                        {
        |       TYPEOF '(' exp ')'
                        {

-                         write_exp_elt_opcode (OP_TYPEOF);
+                         write_exp_elt_opcode (pstate, OP_TYPEOF);

                        }
        |       TYPEOF '(' type ')'
                        {
                        }
        |       TYPEOF '(' type ')'
                        {

-                         write_exp_elt_opcode (OP_TYPE);
-                         write_exp_elt_type ($3);
-                         write_exp_elt_opcode (OP_TYPE);
+                         write_exp_elt_opcode (pstate, OP_TYPE);
+                         write_exp_elt_type (pstate, $3);
+                         write_exp_elt_opcode (pstate, OP_TYPE);

                        }
        |       DECLTYPE '(' exp ')'
                        {
                        }
        |       DECLTYPE '(' exp ')'
                        {

-                         write_exp_elt_opcode (OP_DECLTYPE);
+                         write_exp_elt_opcode (pstate, OP_DECLTYPE);

                        }
        ;
 
 /* Expressions, including the comma operator.  */
 exp1   :       exp
        |       exp1 ',' exp
                        }
        ;
 
 /* 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
        ;
 
 /* 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
        ;
 
 exp    :       '&' exp    %prec UNARY

-                       { write_exp_elt_opcode (UNOP_ADDR); }
+                       { write_exp_elt_opcode (pstate, UNOP_ADDR); }

        ;
 
 exp    :       '-' exp    %prec UNARY
        ;
 
 exp    :       '-' exp    %prec UNARY

-                       { write_exp_elt_opcode (UNOP_NEG); }
+                       { write_exp_elt_opcode (pstate, UNOP_NEG); }

        ;
 
 exp    :       '+' exp    %prec UNARY
        ;
 
 exp    :       '+' exp    %prec UNARY

-                       { write_exp_elt_opcode (UNOP_PLUS); }
+                       { write_exp_elt_opcode (pstate, UNOP_PLUS); }

        ;
 
 exp    :       '!' exp    %prec UNARY
        ;
 
 exp    :       '!' exp    %prec UNARY

-                       { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
+                       { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }

        ;
 
 exp    :       '~' exp    %prec UNARY
        ;
 
 exp    :       '~' exp    %prec UNARY

-                       { write_exp_elt_opcode (UNOP_COMPLEMENT); }
+                       { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }

        ;
 
 exp    :       INCREMENT exp    %prec UNARY
        ;
 
 exp    :       INCREMENT exp    %prec UNARY

-                       { write_exp_elt_opcode (UNOP_PREINCREMENT); }
+                       { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }

        ;
 
 exp    :       DECREMENT exp    %prec UNARY
        ;
 
 exp    :       DECREMENT exp    %prec UNARY

-                       { write_exp_elt_opcode (UNOP_PREDECREMENT); }
+                       { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }

        ;
 
 exp    :       exp INCREMENT    %prec UNARY
        ;
 
 exp    :       exp INCREMENT    %prec UNARY

-                       { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
+                       { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }

        ;
 
 exp    :       exp DECREMENT    %prec UNARY
        ;
 
 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
        ;
 
 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); }
+exp    :       ALIGNOF '(' type_exp ')'        %prec UNARY
+                       { write_exp_elt_opcode (pstate, UNOP_ALIGNOF); }

        ;
 
        ;
 

-exp    :       exp ARROW name COMPLETE
-                       { mark_struct_expression ();
-                         write_exp_elt_opcode (STRUCTOP_PTR);
-                         write_exp_string ($3);
-                         write_exp_elt_opcode (STRUCTOP_PTR); }
+exp    :       exp ARROW field_name
+                       { write_exp_elt_opcode (pstate, STRUCTOP_PTR);
+                         write_exp_string (pstate, $3);
+                         write_exp_elt_opcode (pstate, STRUCTOP_PTR); }
+       ;
+
+exp    :       exp ARROW field_name COMPLETE
+                       { pstate->mark_struct_expression ();
+                         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;
        ;
 
 exp    :       exp ARROW COMPLETE
                        { struct stoken s;

-                         mark_struct_expression ();
-                         write_exp_elt_opcode (STRUCTOP_PTR);
+                         pstate->mark_struct_expression ();
+                         write_exp_elt_opcode (pstate, STRUCTOP_PTR);

                          s.ptr = "";
                          s.length = 0;
                          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
+                       { pstate->mark_struct_expression ();
+                         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 */
        ;
 
 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_STAR exp
        ;
 
 exp    :       exp ARROW_STAR exp

-                       { write_exp_elt_opcode (STRUCTOP_MPTR); }
+                       { 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); }
+exp    :       exp '.' field_name
+                       { 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); }
+exp    :       exp '.' field_name COMPLETE
+                       { pstate->mark_struct_expression ();
+                         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;
        ;
 
 exp    :       exp '.' COMPLETE
                        { struct stoken s;

-                         mark_struct_expression ();
-                         write_exp_elt_opcode (STRUCTOP_STRUCT);
+                         pstate->mark_struct_expression ();
+                         write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);

                          s.ptr = "";
                          s.length = 0;
                          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
+                       { pstate->mark_struct_expression ();
+                         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 */
        ;
 
 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 DOT_STAR exp
        ;
 
 exp    :       exp DOT_STAR exp

-                       { write_exp_elt_opcode (STRUCTOP_MEMBER); }
+                       { write_exp_elt_opcode (pstate, STRUCTOP_MEMBER); }

        ;
 
 exp    :       exp '[' exp1 ']'
        ;
 
 exp    :       exp '[' exp1 ']'

-                       { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
+                       { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }

        ;
 
 exp    :       exp OBJC_LBRAC exp1 ']'
        ;
 
 exp    :       exp OBJC_LBRAC exp1 ']'

-                       { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
+                       { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }

        ;
 
 /*
        ;
 
 /*


@@ -434,47 +472,50 @@ exp       :       exp OBJC_LBRAC exp1 ']'
 
 exp    :       OBJC_LBRAC TYPENAME
                        {
 
 exp    :       OBJC_LBRAC TYPENAME
                        {

-                         CORE_ADDR class;
+                         CORE_ADDR theclass;

 
 

-                         class = lookup_objc_class (parse_gdbarch,
-                                                    copy_name ($2.stoken));
-                         if (class == 0)
+                         std::string copy = copy_name ($2.stoken);
+                         theclass = lookup_objc_class (pstate->gdbarch (),
+                                                       copy.c_str ());
+                         if (theclass == 0)

                            error (_("%s is not an ObjC Class"),
                            error (_("%s is not an ObjC Class"),

-                                  copy_name ($2.stoken));
-                         write_exp_elt_opcode (OP_LONG);
-                         write_exp_elt_type (parse_type->builtin_int);
-                         write_exp_elt_longcst ((LONGEST) class);
-                         write_exp_elt_opcode (OP_LONG);
+                                  copy.c_str ());
+                         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 ']'
                          start_msglist();
                        }
                msglist ']'

-                       { write_exp_elt_opcode (OP_OBJC_MSGCALL);
-                         end_msglist();
-                         write_exp_elt_opcode (OP_OBJC_MSGCALL);
+                       { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
+                         end_msglist (pstate);
+                         write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);

                        }
        ;
 
 exp    :       OBJC_LBRAC CLASSNAME
                        {
                        }
        ;
 
 exp    :       OBJC_LBRAC CLASSNAME
                        {

-                         write_exp_elt_opcode (OP_LONG);
-                         write_exp_elt_type (parse_type->builtin_int);
-                         write_exp_elt_longcst ((LONGEST) $2.class);
-                         write_exp_elt_opcode (OP_LONG);
+                         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 ']'
                          start_msglist();
                        }
                msglist ']'

-                       { write_exp_elt_opcode (OP_OBJC_MSGCALL);
-                         end_msglist();
-                         write_exp_elt_opcode (OP_OBJC_MSGCALL);
+                       { 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 ']'
                        }
        ;
 
 exp    :       OBJC_LBRAC exp
                        { start_msglist(); }
                msglist ']'

-                       { write_exp_elt_opcode (OP_OBJC_MSGCALL);
-                         end_msglist();
-                         write_exp_elt_opcode (OP_OBJC_MSGCALL);
+                       { write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);
+                         end_msglist (pstate);
+                         write_exp_elt_opcode (pstate, OP_OBJC_MSGCALL);

                        }
        ;
 
                        }
        ;
 


@@ -495,88 +536,138 @@ msgarg   :       name ':' exp
                        { add_msglist(0, 0);   }
        ;
 
                        { add_msglist(0, 0);   }
        ;
 

-exp    :       exp '(' 
+exp    :       exp '('

                        /* This is to save the value of arglist_len
                           being accumulated by an outer function call.  */
                        /* This is to save the value of arglist_len
                           being accumulated by an outer function call.  */

-                       { start_arglist (); }
+                       { pstate->start_arglist (); }

                arglist ')'     %prec ARROW
                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,
+                                                pstate->end_arglist ());
+                         write_exp_elt_opcode (pstate, OP_FUNCALL); }
+       ;
+
+/* This is here to disambiguate with the production for
+   "func()::static_var" further below, which uses
+   function_method_void.  */
+exp    :       exp '(' ')' %prec ARROW
+                       { pstate->start_arglist ();
+                         write_exp_elt_opcode (pstate, OP_FUNCALL);
+                         write_exp_elt_longcst (pstate,
+                                                pstate->end_arglist ());
+                         write_exp_elt_opcode (pstate, OP_FUNCALL); }

        ;
 
        ;
 

+

 exp    :       UNKNOWN_CPP_NAME '('
                        {
                          /* This could potentially be a an argument defined
                             lookup function (Koenig).  */
 exp    :       UNKNOWN_CPP_NAME '('
                        {
                          /* This could potentially be a an argument defined
                             lookup function (Koenig).  */

-                         write_exp_elt_opcode (OP_ADL_FUNC);
-                         write_exp_elt_block (expression_context_block);
-                         write_exp_elt_sym (NULL); /* Placeholder.  */
-                         write_exp_string ($1.stoken);
-                         write_exp_elt_opcode (OP_ADL_FUNC);
+                         write_exp_elt_opcode (pstate, OP_ADL_FUNC);
+                         write_exp_elt_block
+                           (pstate, 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.  */
 
 
                        /* This is to save the value of arglist_len
                           being accumulated by an outer function call.  */
 

-                         start_arglist ();
+                         pstate->start_arglist ();

                        }
                arglist ')'     %prec ARROW
                        {
                        }
                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,
+                                                pstate->end_arglist ());
+                         write_exp_elt_opcode (pstate, OP_FUNCALL);

                        }
        ;
 
 lcurly :       '{'
                        }
        ;
 
 lcurly :       '{'

-                       { start_arglist (); }
+                       { pstate->start_arglist (); }

        ;
 
 arglist        :
        ;
 
 arglist        :       exp
        ;
 
 arglist        :
        ;
 
 arglist        :       exp

-                       { arglist_len = 1; }
+                       { pstate->arglist_len = 1; }

        ;
 
 arglist        :       arglist ',' exp   %prec ABOVE_COMMA
        ;
 
 arglist        :       arglist ',' exp   %prec ABOVE_COMMA

-                       { 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 (TYPE_INSTANCE);
-                         write_exp_elt_longcst (len);
-                         for (i = 0;
-                              VEC_iterate (type_ptr, type_list, i, type_elt);
-                              ++i)
-                           write_exp_elt_type (type_elt);
-                         write_exp_elt_longcst(len);
-                         write_exp_elt_opcode (TYPE_INSTANCE);
-                         VEC_free (type_ptr, type_list);
+                       { pstate->arglist_len++; }
+       ;
+
+function_method:       exp '(' parameter_typelist ')' const_or_volatile
+                       {
+                         std::vector<struct type *> *type_list = $3;
+                         LONGEST len = type_list->size ();
+
+                         write_exp_elt_opcode (pstate, TYPE_INSTANCE);
+                         /* Save the const/volatile qualifiers as
+                            recorded by the const_or_volatile
+                            production's actions.  */
+                         write_exp_elt_longcst
+                           (pstate,
+                            (cpstate->type_stack
+                             .follow_type_instance_flags ()));
+                         write_exp_elt_longcst (pstate, len);
+                         for (type *type_elt : *type_list)
+                           write_exp_elt_type (pstate, type_elt);
+                         write_exp_elt_longcst(pstate, len);
+                         write_exp_elt_opcode (pstate, TYPE_INSTANCE);
+                       }
+       ;
+
+function_method_void:      exp '(' ')' const_or_volatile
+                      { write_exp_elt_opcode (pstate, TYPE_INSTANCE);
+                        /* See above.  */
+                        write_exp_elt_longcst
+                          (pstate,
+                           cpstate->type_stack.follow_type_instance_flags ());
+                        write_exp_elt_longcst (pstate, 0);
+                        write_exp_elt_longcst (pstate, 0);
+                        write_exp_elt_opcode (pstate, TYPE_INSTANCE);
+                      }
+       ;
+
+exp     :       function_method
+       ;
+
+/* Normally we must interpret "func()" as a function call, instead of
+   a type.  The user needs to write func(void) to disambiguate.
+   However, in the "func()::static_var" case, there's no
+   ambiguity.  */
+function_method_void_or_typelist: function_method
+       |               function_method_void
+       ;
+
+exp     :       function_method_void_or_typelist COLONCOLON name
+                       {
+                         write_exp_elt_opcode (pstate, OP_FUNC_STATIC_VAR);
+                         write_exp_string (pstate, $3);
+                         write_exp_elt_opcode (pstate, OP_FUNC_STATIC_VAR);

                        }
        ;
 
 rcurly :       '}'
                        }
        ;
 
 rcurly :       '}'

-                       { $$ = end_arglist () - 1; }
+                       { $$ = pstate->end_arglist () - 1; }

        ;
 exp    :       lcurly arglist rcurly   %prec ARROW
        ;
 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_exp rcurly exp  %prec UNARY
        ;
 
 exp    :       lcurly type_exp rcurly exp  %prec UNARY

-                       { write_exp_elt_opcode (UNOP_MEMVAL_TYPE); }
+                       { write_exp_elt_opcode (pstate, UNOP_MEMVAL_TYPE); }

        ;
 
 exp    :       '(' type_exp ')' exp  %prec UNARY
        ;
 
 exp    :       '(' type_exp ')' exp  %prec UNARY

-                       { write_exp_elt_opcode (UNOP_CAST_TYPE); }
+                       { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }

        ;
 
 exp    :       '(' exp1 ')'
        ;
 
 exp    :       '(' exp1 ')'


@@ -586,100 +677,101 @@ exp     :       '(' exp1 ')'
 /* Binary operators in order of decreasing precedence.  */
 
 exp    :       exp '@' exp
 /* 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
        ;
 
 exp    :       exp '*' exp

-                       { write_exp_elt_opcode (BINOP_MUL); }
+                       { write_exp_elt_opcode (pstate, BINOP_MUL); }

        ;
 
 exp    :       exp '/' exp
        ;
 
 exp    :       exp '/' exp

-                       { write_exp_elt_opcode (BINOP_DIV); }
+                       { write_exp_elt_opcode (pstate, BINOP_DIV); }

        ;
 
 exp    :       exp '%' exp
        ;
 
 exp    :       exp '%' exp

-                       { write_exp_elt_opcode (BINOP_REM); }
+                       { write_exp_elt_opcode (pstate, BINOP_REM); }

        ;
 
 exp    :       exp '+' exp
        ;
 
 exp    :       exp '+' exp

-                       { write_exp_elt_opcode (BINOP_ADD); }
+                       { write_exp_elt_opcode (pstate, BINOP_ADD); }

        ;
 
 exp    :       exp '-' exp
        ;
 
 exp    :       exp '-' exp

-                       { write_exp_elt_opcode (BINOP_SUB); }
+                       { write_exp_elt_opcode (pstate, BINOP_SUB); }

        ;
 
 exp    :       exp LSH exp
        ;
 
 exp    :       exp LSH exp

-                       { write_exp_elt_opcode (BINOP_LSH); }
+                       { write_exp_elt_opcode (pstate, BINOP_LSH); }

        ;
 
 exp    :       exp RSH exp
        ;
 
 exp    :       exp RSH exp

-                       { write_exp_elt_opcode (BINOP_RSH); }
+                       { write_exp_elt_opcode (pstate, BINOP_RSH); }

        ;
 
 exp    :       exp EQUAL exp
        ;
 
 exp    :       exp EQUAL exp

-                       { write_exp_elt_opcode (BINOP_EQUAL); }
+                       { write_exp_elt_opcode (pstate, BINOP_EQUAL); }

        ;
 
 exp    :       exp NOTEQUAL exp
        ;
 
 exp    :       exp NOTEQUAL exp

-                       { write_exp_elt_opcode (BINOP_NOTEQUAL); }
+                       { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }

        ;
 
 exp    :       exp LEQ exp
        ;
 
 exp    :       exp LEQ exp

-                       { write_exp_elt_opcode (BINOP_LEQ); }
+                       { write_exp_elt_opcode (pstate, BINOP_LEQ); }

        ;
 
 exp    :       exp GEQ exp
        ;
 
 exp    :       exp GEQ exp

-                       { write_exp_elt_opcode (BINOP_GEQ); }
+                       { write_exp_elt_opcode (pstate, BINOP_GEQ); }

        ;
 
 exp    :       exp '<' exp
        ;
 
 exp    :       exp '<' exp

-                       { write_exp_elt_opcode (BINOP_LESS); }
+                       { write_exp_elt_opcode (pstate, BINOP_LESS); }

        ;
 
 exp    :       exp '>' exp
        ;
 
 exp    :       exp '>' exp

-                       { write_exp_elt_opcode (BINOP_GTR); }
+                       { write_exp_elt_opcode (pstate, BINOP_GTR); }

        ;
 
 exp    :       exp '&' exp
        ;
 
 exp    :       exp '&' exp

-                       { write_exp_elt_opcode (BINOP_BITWISE_AND); }
+                       { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }

        ;
 
 exp    :       exp '^' exp
        ;
 
 exp    :       exp '^' exp

-                       { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
+                       { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }

        ;
 
 exp    :       exp '|' exp
        ;
 
 exp    :       exp '|' exp

-                       { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
+                       { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }

        ;
 
 exp    :       exp ANDAND exp
        ;
 
 exp    :       exp ANDAND exp

-                       { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
+                       { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }

        ;
 
 exp    :       exp OROR exp
        ;
 
 exp    :       exp OROR exp

-                       { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
+                       { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }

        ;
 
 exp    :       exp '?' exp ':' exp     %prec '?'
        ;
 
 exp    :       exp '?' exp ':' exp     %prec '?'

-                       { write_exp_elt_opcode (TERNOP_COND); }
+                       { write_exp_elt_opcode (pstate, TERNOP_COND); }

        ;
        ;

-                         
+

 exp    :       exp '=' exp
 exp    :       exp '=' exp

-                       { write_exp_elt_opcode (BINOP_ASSIGN); }
+                       { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }

        ;
 
 exp    :       exp ASSIGN_MODIFY exp
        ;
 
 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
        ;
 
 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
        ;
 
 exp    :       CHAR


@@ -687,77 +779,82 @@ exp       :       CHAR
                          struct stoken_vector vec;
                          vec.len = 1;
                          vec.tokens = &$1;
                          struct stoken_vector vec;
                          vec.len = 1;
                          vec.tokens = &$1;

-                         write_exp_string_vector ($1.type, &vec);
+                         write_exp_string_vector (pstate, $1.type, &vec);

                        }
        ;
 
 exp    :       NAME_OR_INT
                        { YYSTYPE val;
                        }
        ;
 
 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
                        }
        ;
 
 
 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); }
-       ;
-
-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_FLOAT);
+                         write_exp_elt_type (pstate, $1.type);
+                         write_exp_elt_floatcst (pstate, $1.val);
+                         write_exp_elt_opcode (pstate, OP_FLOAT); }

        ;
 
 exp    :       variable
        ;
 
        ;
 
 exp    :       variable
        ;
 

-exp    :       VARIABLE
+exp    :       DOLLAR_VARIABLE

                        {
                        {

-                         write_dollar_variable ($1);
+                         write_dollar_variable (pstate, $1);

                        }
        ;
 
 exp    :       SELECTOR '(' name ')'
                        {
                        }
        ;
 
 exp    :       SELECTOR '(' name ')'
                        {

-                         write_exp_elt_opcode (OP_OBJC_SELECTOR);
-                         write_exp_string ($3);
-                         write_exp_elt_opcode (OP_OBJC_SELECTOR); }
+                         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
        ;
 
 exp    :       SIZEOF '(' type ')'     %prec UNARY

-                       { write_exp_elt_opcode (OP_LONG);
-                         write_exp_elt_type (lookup_signed_typename
-                                             (parse_language, parse_gdbarch,
+                       { struct type *type = $3;
+                         write_exp_elt_opcode (pstate, OP_LONG);
+                         write_exp_elt_type (pstate, lookup_signed_typename
+                                             (pstate->language (),

                                               "int"));
                                               "int"));

-                         CHECK_TYPEDEF ($3);
-                         write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
-                         write_exp_elt_opcode (OP_LONG); }
+                         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_IS_REFERENCE (type))
+                           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
        ;
 
 exp    :       REINTERPRET_CAST '<' type_exp '>' '(' exp ')' %prec UNARY

-                       { write_exp_elt_opcode (UNOP_REINTERPRET_CAST); }
+                       { write_exp_elt_opcode (pstate,
+                                               UNOP_REINTERPRET_CAST); }

        ;
 
 exp    :       STATIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
        ;
 
 exp    :       STATIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY

-                       { write_exp_elt_opcode (UNOP_CAST_TYPE); }
+                       { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }

        ;
 
 exp    :       DYNAMIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
        ;
 
 exp    :       DYNAMIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY

-                       { write_exp_elt_opcode (UNOP_DYNAMIC_CAST); }
+                       { 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.  */
        ;
 
 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 (UNOP_CAST_TYPE); }
+                         write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); }

        ;
 
 string_exp:
        ;
 
 string_exp:


@@ -774,7 +871,7 @@ string_exp:
 
                          vec->type = $1.type;
                          vec->length = $1.length;
 
                          vec->type = $1.type;
                          vec->length = $1.length;

-                         vec->ptr = malloc ($1.length + 1);
+                         vec->ptr = (char *) malloc ($1.length + 1);

                          memcpy (vec->ptr, $1.ptr, $1.length + 1);
                        }
 
                          memcpy (vec->ptr, $1.ptr, $1.length + 1);
                        }
 


@@ -784,10 +881,10 @@ string_exp:
                             for convenience.  */
                          char *p;
                          ++$$.len;
                             for convenience.  */
                          char *p;
                          ++$$.len;

-                         $$.tokens = realloc ($$.tokens,
-                                              $$.len * sizeof (struct typed_stoken));
+                         $$.tokens = XRESIZEVEC (struct typed_stoken,
+                                                 $$.tokens, $$.len);

 
 

-                         p = malloc ($2.length + 1);
+                         p = (char *) malloc ($2.length + 1);

                          memcpy (p, $2.ptr, $2.length + 1);
 
                          $$.tokens[$$.len - 1].type = $2.type;
                          memcpy (p, $2.ptr, $2.length + 1);
 
                          $$.tokens[$$.len - 1].type = $2.type;


@@ -799,7 +896,7 @@ string_exp:
 exp    :       string_exp
                        {
                          int i;
 exp    :       string_exp
                        {
                          int i;

-                         enum c_string_type type = C_STRING;
+                         c_string_type type = C_STRING;

 
                          for (i = 0; i < $1.len; ++i)
                            {
 
                          for (i = 0; i < $1.len; ++i)
                            {


@@ -813,7 +910,7 @@ exp :       string_exp
                                  if (type != C_STRING
                                      && type != $1.tokens[i].type)
                                    error (_("Undefined string concatenation."));
                                  if (type != C_STRING
                                      && type != $1.tokens[i].type)
                                    error (_("Undefined string concatenation."));

-                                 type = $1.tokens[i].type;
+                                 type = (enum c_string_type_values) $1.tokens[i].type;

                                  break;
                                default:
                                  /* internal error */
                                  break;
                                default:
                                  /* internal error */


@@ -822,7 +919,7 @@ exp :       string_exp
                                }
                            }
 
                                }
                            }
 

-                         write_exp_string_vector (type, &$1);
+                         write_exp_string_vector (pstate, type, &$1);

                          for (i = 0; i < $1.len; ++i)
                            free ($1.tokens[i].ptr);
                          free ($1.tokens);
                          for (i = 0; i < $1.len; ++i)
                            free ($1.tokens[i].ptr);
                          free ($1.tokens);


@@ -832,35 +929,37 @@ exp       :       string_exp
 exp     :      NSSTRING        /* ObjC NextStep NSString constant
                                 * of the form '@' '"' string '"'.
                                 */
 exp     :      NSSTRING        /* ObjC NextStep NSString constant
                                 * of the form '@' '"' string '"'.
                                 */

-                       { write_exp_elt_opcode (OP_OBJC_NSSTRING);
-                         write_exp_string ($1);
-                         write_exp_elt_opcode (OP_OBJC_NSSTRING); }
+                       { write_exp_elt_opcode (pstate, OP_OBJC_NSSTRING);
+                         write_exp_string (pstate, $1);
+                         write_exp_elt_opcode (pstate, OP_OBJC_NSSTRING); }

        ;
 
 /* C++.  */
        ;
 
 /* C++.  */

-exp     :       TRUEKEYWORD    
-                        { write_exp_elt_opcode (OP_LONG);
-                          write_exp_elt_type (parse_type->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 (parse_type->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++.  */
 
 block  :       BLOCKNAME
                        {
        ;
 
 /* end of C++.  */
 
 block  :       BLOCKNAME
                        {

-                         if ($1.sym)
-                           $$ = SYMBOL_BLOCK_VALUE ($1.sym);
+                         if ($1.sym.symbol)
+                           $$ = SYMBOL_BLOCK_VALUE ($1.sym.symbol);

                          else
                            error (_("No file or function \"%s\"."),
                          else
                            error (_("No file or function \"%s\"."),

-                                  copy_name ($1.stoken));
+                                  copy_name ($1.stoken).c_str ());

                        }
        |       FILENAME
                        {
                        }
        |       FILENAME
                        {


@@ -869,185 +968,212 @@ block   :       BLOCKNAME
        ;
 
 block  :       block COLONCOLON name
        ;
 
 block  :       block COLONCOLON name

-                       { struct symbol *tem
-                           = lookup_symbol (copy_name ($3), $1,
-                                            VAR_DOMAIN, NULL);
+                       {
+                         std::string copy = copy_name ($3);
+                         struct symbol *tem
+                           = lookup_symbol (copy.c_str (), $1,
+                                            VAR_DOMAIN, NULL).symbol;
+

                          if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
                            error (_("No function \"%s\" in specified context."),
                          if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
                            error (_("No function \"%s\" in specified context."),

-                                  copy_name ($3));
+                                  copy.c_str ());

                          $$ = SYMBOL_BLOCK_VALUE (tem); }
        ;
 
 variable:      name_not_typename ENTRY
                          $$ = SYMBOL_BLOCK_VALUE (tem); }
        ;
 
 variable:      name_not_typename ENTRY

-                       { struct symbol *sym = $1.sym;
+                       { struct symbol *sym = $1.sym.symbol;

 
                          if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
                              || !symbol_read_needs_frame (sym))
                            error (_("@entry can be used only for function "
                                     "parameters, not for \"%s\""),
 
                          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));
+                                  copy_name ($1.stoken).c_str ());

 
 

-                         write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
-                         write_exp_elt_sym (sym);
-                         write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
+                         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
                        }
        ;
 
 variable:      block COLONCOLON name

-                       { struct symbol *sym;
-                         sym = lookup_symbol (copy_name ($3), $1,
-                                              VAR_DOMAIN, NULL);
-                         if (sym == 0)
+                       {
+                         std::string copy = copy_name ($3);
+                         struct block_symbol sym
+                           = lookup_symbol (copy.c_str (), $1,
+                                            VAR_DOMAIN, NULL);
+
+                         if (sym.symbol == 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;
-                           }
+                                  copy.c_str ());
+                         if (symbol_read_needs_frame (sym.symbol))
+                           pstate->block_tracker->update (sym);

 
 

-                         write_exp_elt_opcode (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_opcode (pstate, OP_VAR_VALUE);
+                         write_exp_elt_block (pstate, sym.block);
+                         write_exp_elt_sym (pstate, sym.symbol);
+                         write_exp_elt_opcode (pstate, OP_VAR_VALUE); }

        ;
 
 qualified_name:        TYPENAME COLONCOLON name
                        {
                          struct type *type = $1.type;
        ;
 
 qualified_name:        TYPENAME COLONCOLON name
                        {
                          struct type *type = $1.type;

-                         CHECK_TYPEDEF (type);
-                         if (TYPE_CODE (type) != TYPE_CODE_STRUCT
-                             && TYPE_CODE (type) != TYPE_CODE_UNION
-                             && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
+                         type = check_typedef (type);
+                         if (!type_aggregate_p (type))

                            error (_("`%s' is not defined as an aggregate type."),
                                   TYPE_SAFE_NAME (type));
 
                            error (_("`%s' is not defined as an aggregate type."),
                                   TYPE_SAFE_NAME (type));
 

-                         write_exp_elt_opcode (OP_SCOPE);
-                         write_exp_elt_type (type);
-                         write_exp_string ($3);
-                         write_exp_elt_opcode (OP_SCOPE);
+                         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);

                        }
        |       TYPENAME COLONCOLON '~' name
                        {
                          struct type *type = $1.type;
                          struct stoken tmp_token;
                        }
        |       TYPENAME COLONCOLON '~' name
                        {
                          struct type *type = $1.type;
                          struct stoken tmp_token;

-                         CHECK_TYPEDEF (type);
-                         if (TYPE_CODE (type) != TYPE_CODE_STRUCT
-                             && TYPE_CODE (type) != TYPE_CODE_UNION
-                             && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
+                         char *buf;
+
+                         type = check_typedef (type);
+                         if (!type_aggregate_p (type))

                            error (_("`%s' is not defined as an aggregate type."),
                                   TYPE_SAFE_NAME (type));
                            error (_("`%s' is not defined as an aggregate type."),
                                   TYPE_SAFE_NAME (type));

-
-                         tmp_token.ptr = (char*) alloca ($4.length + 2);
+                         buf = (char *) alloca ($4.length + 2);
+                         tmp_token.ptr = buf;

                          tmp_token.length = $4.length + 1;
                          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, $1.type);
 
                          /* Check for valid destructor name.  */
                          destructor_name_p (tmp_token.ptr, $1.type);

-                         write_exp_elt_opcode (OP_SCOPE);
-                         write_exp_elt_type (type);
-                         write_exp_string (tmp_token);
-                         write_exp_elt_opcode (OP_SCOPE);
+                         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
                        {
                        }
        |       TYPENAME COLONCOLON name COLONCOLON name
                        {

-                         char *copy = copy_name ($3);
+                         std::string copy = copy_name ($3);

                          error (_("No type \"%s\" within class "
                                   "or namespace \"%s\"."),
                          error (_("No type \"%s\" within class "
                                   "or namespace \"%s\"."),

-                                copy, TYPE_SAFE_NAME ($1.type));
+                                copy.c_str (), TYPE_SAFE_NAME ($1.type));

                        }
        ;
 
 variable:      qualified_name
        |       COLONCOLON name_not_typename
                        {
                        }
        ;
 
 variable:      qualified_name
        |       COLONCOLON name_not_typename
                        {

-                         char *name = copy_name ($2.stoken);
+                         std::string name = copy_name ($2.stoken);

                          struct symbol *sym;
                          struct symbol *sym;

-                         struct minimal_symbol *msymbol;
+                         struct bound_minimal_symbol msymbol;

 
 

-                         sym =
-                           lookup_symbol (name, (const struct block *) NULL,
-                                          VAR_DOMAIN, NULL);
+                         sym
+                           = lookup_symbol (name.c_str (),
+                                            (const struct block *) NULL,
+                                            VAR_DOMAIN, NULL).symbol;

                          if (sym)
                            {
                          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;
                            }
 
                              break;
                            }
 

-                         msymbol = lookup_minimal_symbol (name, NULL, NULL);
-                         if (msymbol != NULL)
-                           write_exp_msymbol (msymbol);
+                         msymbol = lookup_bound_minimal_symbol (name.c_str ());
+                         if (msymbol.minsym != NULL)
+                           write_exp_msymbol (pstate, msymbol);

                          else if (!have_full_symbols () && !have_partial_symbols ())
                            error (_("No symbol table is loaded.  Use the \"file\" command."));
                          else
                          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.c_str ());

                        }
        ;
 
 variable:      name_not_typename
                        }
        ;
 
 variable:      name_not_typename

-                       { struct symbol *sym = $1.sym;
+                       { struct block_symbol sym = $1.sym;

 
 

-                         if (sym)
+                         if (sym.symbol)

                            {
                            {

-                             if (symbol_read_needs_frame (sym))
+                             if (symbol_read_needs_frame (sym.symbol))
+                               pstate->block_tracker->update (sym);
+
+                             /* If we found a function, see if it's
+                                an ifunc resolver that has the same
+                                address as the ifunc symbol itself.
+                                If so, prefer the ifunc symbol.  */
+
+                             bound_minimal_symbol resolver
+                               = find_gnu_ifunc (sym.symbol);
+                             if (resolver.minsym != NULL)
+                               write_exp_msymbol (pstate, resolver);
+                             else

                                {
                                {

-                                 if (innermost_block == 0
-                                     || contained_in (block_found, 
-                                                      innermost_block))
-                                   innermost_block = block_found;
+                                 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
+                                 write_exp_elt_block (pstate, sym.block);
+                                 write_exp_elt_sym (pstate, sym.symbol);
+                                 write_exp_elt_opcode (pstate, OP_VAR_VALUE);

                                }
                                }

-
-                             write_exp_elt_opcode (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);

                            }
                          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.  */
                            }
                          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))
-                               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);
+                             pstate->block_tracker->update (sym);
+                             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
                            {
                            }
                          else
                            {

-                             struct minimal_symbol *msymbol;
-                             char *arg = copy_name ($1.stoken);
-
-                             msymbol =
-                               lookup_minimal_symbol (arg, NULL, NULL);
-                             if (msymbol != NULL)
-                               write_exp_msymbol (msymbol);
-                             else if (!have_full_symbols () && !have_partial_symbols ())
-                               error (_("No symbol table is loaded.  Use the \"file\" command."));
+                             std::string arg = copy_name ($1.stoken);
+
+                             bound_minimal_symbol msymbol
+                               = lookup_bound_minimal_symbol (arg.c_str ());
+                             if (msymbol.minsym == NULL)
+                               {
+                                 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."),
+                                          arg.c_str ());
+                               }
+
+                             /* This minsym might be an alias for
+                                another function.  See if we can find
+                                the debug symbol for the target, and
+                                if so, use it instead, since it has
+                                return type / prototype info.  This
+                                is important for example for "p
+                                *__errno_location()".  */
+                             symbol *alias_target
+                               = ((msymbol.minsym->type != mst_text_gnu_ifunc
+                                   && msymbol.minsym->type != mst_data_gnu_ifunc)
+                                  ? find_function_alias_target (msymbol)
+                                  : NULL);
+                             if (alias_target != NULL)
+                               {
+                                 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
+                                 write_exp_elt_block
+                                   (pstate, SYMBOL_BLOCK_VALUE (alias_target));
+                                 write_exp_elt_sym (pstate, alias_target);
+                                 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
+                               }

                              else
                              else

-                               error (_("No symbol \"%s\" in current context."),
-                                      copy_name ($1.stoken));
+                               write_exp_msymbol (pstate, msymbol);

                            }
                        }
        ;
 
 space_identifier : '@' NAME
                            }
                        }
        ;
 
 space_identifier : '@' NAME

-               { insert_type_address_space (copy_name ($2.stoken)); }
+               {
+                 cpstate->type_stack.insert (pstate,
+                                             copy_name ($2.stoken).c_str ());
+               }

        ;
 
 const_or_volatile: const_or_volatile_noopt
        ;
 
 const_or_volatile: const_or_volatile_noopt


@@ -1058,39 +1184,41 @@ cv_with_space_id : const_or_volatile space_identifier const_or_volatile
        ;
 
 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
        ;
 
 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
        |
        ;
 
 ptr_operator:
                ptr_operator '*'
                const_or_volatile_or_space_identifier_noopt
        |
        ;
 
 ptr_operator:
                ptr_operator '*'

-                       { insert_type (tp_pointer); }
+                       { cpstate->type_stack.insert (tp_pointer); }

                const_or_volatile_or_space_identifier
                const_or_volatile_or_space_identifier

-       |       '*' 
-                       { insert_type (tp_pointer); }
+       |       '*'
+                       { cpstate->type_stack.insert (tp_pointer); }

                const_or_volatile_or_space_identifier
        |       '&'
                const_or_volatile_or_space_identifier
        |       '&'

-                       { insert_type (tp_reference); }
+                       { cpstate->type_stack.insert (tp_reference); }

        |       '&' ptr_operator
        |       '&' ptr_operator

-                       { insert_type (tp_reference); }
+                       { cpstate->type_stack.insert (tp_reference); }
+       |       ANDAND
+                       { cpstate->type_stack.insert (tp_rvalue_reference); }
+       |       ANDAND ptr_operator
+                       { cpstate->type_stack.insert (tp_rvalue_reference); }

        ;
 
 ptr_operator_ts: ptr_operator
                        {
        ;
 
 ptr_operator_ts: ptr_operator
                        {

-                         $$ = get_type_stack ();
-                         /* This cleanup is eventually run by
-                            c_parse.  */
-                         make_cleanup (type_stack_cleanup, $$);
+                         $$ = cpstate->type_stack.create ();
+                         cpstate->type_stacks.emplace_back ($$);

                        }
        ;
 
 abs_decl:      ptr_operator_ts direct_abs_decl
                        }
        ;
 
 abs_decl:      ptr_operator_ts direct_abs_decl

-                       { $$ = append_type_stack ($2, $1); }
-       |       ptr_operator_ts 
+                       { $$ = $2->append ($1); }
+       |       ptr_operator_ts

        |       direct_abs_decl
        ;
 
        |       direct_abs_decl
        ;
 


@@ -1098,28 +1226,32 @@ direct_abs_decl: '(' abs_decl ')'
                        { $$ = $2; }
        |       direct_abs_decl array_mod
                        {
                        { $$ = $2; }
        |       direct_abs_decl array_mod
                        {

-                         push_type_stack ($1);
-                         push_type_int ($2);
-                         push_type (tp_array);
-                         $$ = get_type_stack ();
+                         cpstate->type_stack.push ($1);
+                         cpstate->type_stack.push ($2);
+                         cpstate->type_stack.push (tp_array);
+                         $$ = cpstate->type_stack.create ();
+                         cpstate->type_stacks.emplace_back ($$);

                        }
        |       array_mod
                        {
                        }
        |       array_mod
                        {

-                         push_type_int ($1);
-                         push_type (tp_array);
-                         $$ = get_type_stack ();
+                         cpstate->type_stack.push ($1);
+                         cpstate->type_stack.push (tp_array);
+                         $$ = cpstate->type_stack.create ();
+                         cpstate->type_stacks.emplace_back ($$);

                        }
 
        |       direct_abs_decl func_mod
                        {
                        }
 
        |       direct_abs_decl func_mod
                        {

-                         push_type_stack ($1);
-                         push_typelist ($2);
-                         $$ = get_type_stack ();
+                         cpstate->type_stack.push ($1);
+                         cpstate->type_stack.push ($2);
+                         $$ = cpstate->type_stack.create ();
+                         cpstate->type_stacks.emplace_back ($$);

                        }
        |       func_mod
                        {
                        }
        |       func_mod
                        {

-                         push_typelist ($1);
-                         $$ = get_type_stack ();
+                         cpstate->type_stack.push ($1);
+                         $$ = cpstate->type_stack.create ();
+                         cpstate->type_stacks.emplace_back ($$);

                        }
        ;
 
                        }
        ;
 


@@ -1134,7 +1266,10 @@ array_mod:       '[' ']'
        ;
 
 func_mod:      '(' ')'
        ;
 
 func_mod:      '(' ')'

-                       { $$ = NULL; }
+                       {
+                         $$ = new std::vector<struct type *>;
+                         cpstate->type_lists.emplace_back ($$);
+                       }

        |       '(' parameter_typelist ')'
                        { $$ = $2; }
        ;
        |       '(' parameter_typelist ')'
                        { $$ = $2; }
        ;


@@ -1150,229 +1285,219 @@ func_mod:     '(' ')'
 type   :       ptype
        ;
 
 type   :       ptype
        ;
 

-typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
+/* Implements (approximately): (type-qualifier)* type-specifier.
+
+   When type-specifier is only ever a single word, like 'float' then these
+   arrive as pre-built TYPENAME tokens thanks to the classify_name
+   function.  However, when a type-specifier can contain multiple words,
+   for example 'double' can appear as just 'double' or 'long double', and
+   similarly 'long' can appear as just 'long' or in 'long double', then
+   these type-specifiers are parsed into their own tokens in the function
+   lex_one_token and the ident_tokens array.  These separate tokens are all
+   recognised here.  */
+typebase

        :       TYPENAME
                        { $$ = $1.type; }
        |       INT_KEYWORD
        :       TYPENAME
                        { $$ = $1.type; }
        |       INT_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "int"); }
        |       LONG
                                                       "int"); }
        |       LONG

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long"); }
        |       SHORT
                                                       "long"); }
        |       SHORT

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "short"); }
        |       LONG INT_KEYWORD
                                                       "short"); }
        |       LONG INT_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long"); }
        |       LONG SIGNED_KEYWORD INT_KEYWORD
                                                       "long"); }
        |       LONG SIGNED_KEYWORD INT_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long"); }
        |       LONG SIGNED_KEYWORD
                                                       "long"); }
        |       LONG SIGNED_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long"); }
        |       SIGNED_KEYWORD LONG INT_KEYWORD
                                                       "long"); }
        |       SIGNED_KEYWORD LONG INT_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long"); }
        |       UNSIGNED LONG INT_KEYWORD
                                                       "long"); }
        |       UNSIGNED LONG INT_KEYWORD

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "long"); }
        |       LONG UNSIGNED INT_KEYWORD
                                                         "long"); }
        |       LONG UNSIGNED INT_KEYWORD

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "long"); }
        |       LONG UNSIGNED
                                                         "long"); }
        |       LONG UNSIGNED

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "long"); }
        |       LONG LONG
                                                         "long"); }
        |       LONG LONG

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long long"); }
        |       LONG LONG INT_KEYWORD
                                                       "long long"); }
        |       LONG LONG INT_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long long"); }
        |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
                                                       "long long"); }
        |       LONG LONG SIGNED_KEYWORD INT_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long long"); }
        |       LONG LONG SIGNED_KEYWORD
                                                       "long long"); }
        |       LONG LONG SIGNED_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long long"); }
        |       SIGNED_KEYWORD LONG LONG
                                                       "long long"); }
        |       SIGNED_KEYWORD LONG LONG

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long long"); }
        |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
                                                       "long long"); }
        |       SIGNED_KEYWORD LONG LONG INT_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "long long"); }
        |       UNSIGNED LONG LONG
                                                       "long long"); }
        |       UNSIGNED LONG LONG

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "long long"); }
        |       UNSIGNED LONG LONG INT_KEYWORD
                                                         "long long"); }
        |       UNSIGNED LONG LONG INT_KEYWORD

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "long long"); }
        |       LONG LONG UNSIGNED
                                                         "long long"); }
        |       LONG LONG UNSIGNED

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "long long"); }
        |       LONG LONG UNSIGNED INT_KEYWORD
                                                         "long long"); }
        |       LONG LONG UNSIGNED INT_KEYWORD

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "long long"); }
        |       SHORT INT_KEYWORD
                                                         "long long"); }
        |       SHORT INT_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "short"); }
        |       SHORT SIGNED_KEYWORD INT_KEYWORD
                                                       "short"); }
        |       SHORT SIGNED_KEYWORD INT_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "short"); }
        |       SHORT SIGNED_KEYWORD
                                                       "short"); }
        |       SHORT SIGNED_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "short"); }
        |       UNSIGNED SHORT INT_KEYWORD
                                                       "short"); }
        |       UNSIGNED SHORT INT_KEYWORD

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "short"); }
                                                         "short"); }

-       |       SHORT UNSIGNED 
-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+       |       SHORT UNSIGNED
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "short"); }
        |       SHORT UNSIGNED INT_KEYWORD
                                                         "short"); }
        |       SHORT UNSIGNED INT_KEYWORD

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "short"); }
        |       DOUBLE_KEYWORD
                                                         "short"); }
        |       DOUBLE_KEYWORD

-                       { $$ = lookup_typename (parse_language, parse_gdbarch,
-                                               "double", (struct block *) NULL,
+                       { $$ = lookup_typename (pstate->language (),
+                                               "double",
+                                               NULL,

                                                0); }
        |       LONG DOUBLE_KEYWORD
                                                0); }
        |       LONG DOUBLE_KEYWORD

-                       { $$ = lookup_typename (parse_language, parse_gdbarch,
+                       { $$ = lookup_typename (pstate->language (),

                                                "long double",
                                                "long double",

-                                               (struct block *) NULL, 0); }
+                                               NULL,
+                                               0); }

        |       STRUCT name
        |       STRUCT name

-                       { $$ = lookup_struct (copy_name ($2),
-                                             expression_context_block); }
+                       { $$
+                           = lookup_struct (copy_name ($2).c_str (),
+                                            pstate->expression_context_block);
+                       }

        |       STRUCT COMPLETE
                        {
        |       STRUCT COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
+                         pstate->mark_completion_tag (TYPE_CODE_STRUCT,
+                                                      "", 0);

                          $$ = NULL;
                        }
        |       STRUCT name COMPLETE
                        {
                          $$ = NULL;
                        }
        |       STRUCT name COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr,
-                                              $2.length);
+                         pstate->mark_completion_tag (TYPE_CODE_STRUCT,
+                                                      $2.ptr, $2.length);

                          $$ = NULL;
                        }
        |       CLASS name
                          $$ = NULL;
                        }
        |       CLASS name

-                       { $$ = lookup_struct (copy_name ($2),
-                                             expression_context_block); }
+                       { $$ = lookup_struct
+                           (copy_name ($2).c_str (),
+                            pstate->expression_context_block);
+                       }

        |       CLASS COMPLETE
                        {
        |       CLASS COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_CLASS, "", 0);
+                         pstate->mark_completion_tag (TYPE_CODE_STRUCT,
+                                                      "", 0);

                          $$ = NULL;
                        }
        |       CLASS name COMPLETE
                        {
                          $$ = NULL;
                        }
        |       CLASS name COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_CLASS, $2.ptr,
-                                              $2.length);
+                         pstate->mark_completion_tag (TYPE_CODE_STRUCT,
+                                                      $2.ptr, $2.length);

                          $$ = NULL;
                        }
        |       UNION name
                          $$ = NULL;
                        }
        |       UNION name

-                       { $$ = lookup_union (copy_name ($2),
-                                            expression_context_block); }
+                       { $$
+                           = lookup_union (copy_name ($2).c_str (),
+                                           pstate->expression_context_block);
+                       }

        |       UNION COMPLETE
                        {
        |       UNION COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_UNION, "", 0);
+                         pstate->mark_completion_tag (TYPE_CODE_UNION,
+                                                      "", 0);

                          $$ = NULL;
                        }
        |       UNION name COMPLETE
                        {
                          $$ = NULL;
                        }
        |       UNION name COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_UNION, $2.ptr,
-                                              $2.length);
+                         pstate->mark_completion_tag (TYPE_CODE_UNION,
+                                                      $2.ptr, $2.length);

                          $$ = NULL;
                        }
        |       ENUM name
                          $$ = NULL;
                        }
        |       ENUM name

-                       { $$ = lookup_enum (copy_name ($2),
-                                           expression_context_block); }
+                       { $$ = lookup_enum (copy_name ($2).c_str (),
+                                           pstate->expression_context_block);
+                       }

        |       ENUM COMPLETE
                        {
        |       ENUM COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_ENUM, "", 0);
+                         pstate->mark_completion_tag (TYPE_CODE_ENUM, "", 0);

                          $$ = NULL;
                        }
        |       ENUM name COMPLETE
                        {
                          $$ = NULL;
                        }
        |       ENUM name COMPLETE
                        {

-                         mark_completion_tag (TYPE_CODE_ENUM, $2.ptr,
-                                              $2.length);
+                         pstate->mark_completion_tag (TYPE_CODE_ENUM, $2.ptr,
+                                                      $2.length);

                          $$ = NULL;
                        }
                          $$ = NULL;
                        }

-       |       UNSIGNED typename
-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+       |       UNSIGNED type_name
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         TYPE_NAME($2.type)); }
        |       UNSIGNED
                                                         TYPE_NAME($2.type)); }
        |       UNSIGNED

-                       { $$ = lookup_unsigned_typename (parse_language,
-                                                        parse_gdbarch,
+                       { $$ = lookup_unsigned_typename (pstate->language (),

                                                         "int"); }
                                                         "int"); }

-       |       SIGNED_KEYWORD typename
-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+       |       SIGNED_KEYWORD type_name
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       TYPE_NAME($2.type)); }
        |       SIGNED_KEYWORD
                                                       TYPE_NAME($2.type)); }
        |       SIGNED_KEYWORD

-                       { $$ = lookup_signed_typename (parse_language,
-                                                      parse_gdbarch,
+                       { $$ = lookup_signed_typename (pstate->language (),

                                                       "int"); }
                 /* It appears that this rule for templates is never
                    reduced; template recognition happens by lookahead
                                                       "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 '>'
        |       TEMPLATE name '<' type '>'

-                       { $$ = lookup_template_type(copy_name($2), $4,
-                                                   expression_context_block);
+                       { $$ = lookup_template_type
+                           (copy_name($2).c_str (), $4,
+                            pstate->expression_context_block);

                        }
                        }

-       | const_or_volatile_or_space_identifier_noopt typebase 
-                       { $$ = follow_types ($2); }
-       | typebase const_or_volatile_or_space_identifier_noopt 
-                       { $$ = follow_types ($1); }
+       | const_or_volatile_or_space_identifier_noopt typebase
+                       { $$ = cpstate->type_stack.follow_types ($2); }
+       | typebase const_or_volatile_or_space_identifier_noopt
+                       { $$ = cpstate->type_stack.follow_types ($1); }

        ;
 
        ;
 

-typename:      TYPENAME
+type_name:     TYPENAME

        |       INT_KEYWORD
                {
                  $$.stoken.ptr = "int";
                  $$.stoken.length = 3;
        |       INT_KEYWORD
                {
                  $$.stoken.ptr = "int";
                  $$.stoken.length = 3;

-                 $$.type = lookup_signed_typename (parse_language,
-                                                   parse_gdbarch,
+                 $$.type = lookup_signed_typename (pstate->language (),

                                                    "int");
                }
        |       LONG
                {
                  $$.stoken.ptr = "long";
                  $$.stoken.length = 4;
                                                    "int");
                }
        |       LONG
                {
                  $$.stoken.ptr = "long";
                  $$.stoken.length = 4;

-                 $$.type = lookup_signed_typename (parse_language,
-                                                   parse_gdbarch,
+                 $$.type = lookup_signed_typename (pstate->language (),

                                                    "long");
                }
        |       SHORT
                {
                  $$.stoken.ptr = "short";
                  $$.stoken.length = 5;
                                                    "long");
                }
        |       SHORT
                {
                  $$.stoken.ptr = "short";
                  $$.stoken.length = 5;

-                 $$.type = lookup_signed_typename (parse_language,
-                                                   parse_gdbarch,
+                 $$.type = lookup_signed_typename (pstate->language (),

                                                    "short");
                }
        ;
                                                    "short");
                }
        ;


@@ -1382,7 +1507,7 @@ parameter_typelist:
                        { check_parameter_typelist ($1); }
        |       nonempty_typelist ',' DOTDOTDOT
                        {
                        { check_parameter_typelist ($1); }
        |       nonempty_typelist ',' DOTDOTDOT
                        {

-                         VEC_safe_push (type_ptr, $1, NULL);
+                         $1->push_back (NULL);

                          check_parameter_typelist ($1);
                          $$ = $1;
                        }
                          check_parameter_typelist ($1);
                          $$ = $1;
                        }


@@ -1391,13 +1516,16 @@ parameter_typelist:
 nonempty_typelist
        :       type
                {
 nonempty_typelist
        :       type
                {

-                 VEC (type_ptr) *typelist = NULL;
-                 VEC_safe_push (type_ptr, typelist, $1);
+                 std::vector<struct type *> *typelist
+                   = new std::vector<struct type *>;
+                 cpstate->type_lists.emplace_back (typelist);
+
+                 typelist->push_back ($1);

                  $$ = typelist;
                }
        |       nonempty_typelist ',' type
                {
                  $$ = typelist;
                }
        |       nonempty_typelist ',' type
                {

-                 VEC_safe_push (type_ptr, $1, $3);
+                 $1->push_back ($3);

                  $$ = $1;
                }
        ;
                  $$ = $1;
                }
        ;


@@ -1405,13 +1533,13 @@ nonempty_typelist
 ptype  :       typebase
        |       ptype abs_decl
                {
 ptype  :       typebase
        |       ptype abs_decl
                {

-                 push_type_stack ($2);
-                 $$ = follow_types ($1);
+                 cpstate->type_stack.push ($2);
+                 $$ = cpstate->type_stack.follow_types ($1);

                }
        ;
 
 conversion_type_id: typebase conversion_declarator
                }
        ;
 
 conversion_type_id: typebase conversion_declarator

-               { $$ = follow_types ($1); }
+               { $$ = cpstate->type_stack.follow_types ($1); }

        ;
 
 conversion_declarator:  /* Nothing.  */
        ;
 
 conversion_declarator:  /* Nothing.  */


@@ -1422,17 +1550,17 @@ const_and_volatile:     CONST_KEYWORD VOLATILE_KEYWORD
        |               VOLATILE_KEYWORD CONST_KEYWORD
        ;
 
        |               VOLATILE_KEYWORD CONST_KEYWORD
        ;
 

-const_or_volatile_noopt:       const_and_volatile 
-                       { insert_type (tp_const);
-                         insert_type (tp_volatile); 
+const_or_volatile_noopt:       const_and_volatile
+                       { cpstate->type_stack.insert (tp_const);
+                         cpstate->type_stack.insert (tp_volatile);

                        }
        |               CONST_KEYWORD
                        }
        |               CONST_KEYWORD

-                       { insert_type (tp_const); }
+                       { cpstate->type_stack.insert (tp_const); }

        |               VOLATILE_KEYWORD
        |               VOLATILE_KEYWORD

-                       { insert_type (tp_volatile); }
+                       { cpstate->type_stack.insert (tp_volatile); }

        ;
 
        ;
 

-operator:      OPERATOR NEW
+oper:  OPERATOR NEW

                        { $$ = operator_stoken (" new"); }
        |       OPERATOR DELETE
                        { $$ = operator_stoken (" delete"); }
                        { $$ = operator_stoken (" new"); }
        |       OPERATOR DELETE
                        { $$ = operator_stoken (" delete"); }


@@ -1471,7 +1599,7 @@ operator: OPERATOR NEW
        |       OPERATOR '>'
                        { $$ = operator_stoken (">"); }
        |       OPERATOR ASSIGN_MODIFY
        |       OPERATOR '>'
                        { $$ = operator_stoken (">"); }
        |       OPERATOR ASSIGN_MODIFY

-                       { const char *op = "unknown";
+                       { const char *op = " unknown";

                          switch ($2)
                            {
                            case BINOP_RSH:
                          switch ($2)
                            {
                            case BINOP_RSH:


@@ -1543,27 +1671,43 @@ operator:       OPERATOR NEW
        |       OPERATOR OBJC_LBRAC ']'
                        { $$ = operator_stoken ("[]"); }
        |       OPERATOR conversion_type_id
        |       OPERATOR OBJC_LBRAC ']'
                        { $$ = operator_stoken ("[]"); }
        |       OPERATOR conversion_type_id

-                       { char *name;
-                         long length;
-                         struct ui_file *buf = mem_fileopen ();
+                       { string_file buf;

 
 

-                         c_print_type ($2, NULL, buf, -1, 0,
+                         c_print_type ($2, NULL, &buf, -1, 0,

                                        &type_print_raw_options);
                                        &type_print_raw_options);

-                         name = ui_file_xstrdup (buf, &length);
-                         ui_file_delete (buf);
-                         $$ = operator_stoken (name);
-                         free (name);
+
+                         /* This also needs canonicalization.  */
+                         std::string canon
+                           = cp_canonicalize_string (buf.c_str ());
+                         if (canon.empty ())
+                           canon = std::move (buf.string ());
+                         $$ = operator_stoken ((" " + canon).c_str ());

                        }
        ;
 
                        }
        ;
 

-
+/* This rule exists in order to allow some tokens that would not normally
+   match the 'name' rule to appear as fields within a struct.  The example
+   that initially motivated this was the RISC-V target which models the
+   floating point registers as a union with fields called 'float' and
+   'double'.  The 'float' string becomes a TYPENAME token and can appear
+   anywhere a 'name' can, however 'double' is its own token,
+   DOUBLE_KEYWORD, and doesn't match the 'name' rule.*/
+field_name
+       :       name
+       |       DOUBLE_KEYWORD { $$ = typename_stoken ("double"); }
+       |       INT_KEYWORD { $$ = typename_stoken ("int"); }
+       |       LONG { $$ = typename_stoken ("long"); }
+       |       SHORT { $$ = typename_stoken ("short"); }
+       |       SIGNED_KEYWORD { $$ = typename_stoken ("signed"); }
+       |       UNSIGNED { $$ = typename_stoken ("unsigned"); }
+       ;

 
 name   :       NAME { $$ = $1.stoken; }
        |       BLOCKNAME { $$ = $1.stoken; }
        |       TYPENAME { $$ = $1.stoken; }
        |       NAME_OR_INT  { $$ = $1.stoken; }
        |       UNKNOWN_CPP_NAME  { $$ = $1.stoken; }
 
 name   :       NAME { $$ = $1.stoken; }
        |       BLOCKNAME { $$ = $1.stoken; }
        |       TYPENAME { $$ = $1.stoken; }
        |       NAME_OR_INT  { $$ = $1.stoken; }
        |       UNKNOWN_CPP_NAME  { $$ = $1.stoken; }

-       |       operator { $$ = $1; }
+       |       oper { $$ = $1; }

        ;
 
 name_not_typename :    NAME
        ;
 
 name_not_typename :    NAME


@@ -1575,15 +1719,16 @@ name_not_typename :     NAME
    context where only a name could occur, this might be useful.
        |       NAME_OR_INT
  */
    context where only a name could occur, this might be useful.
        |       NAME_OR_INT
  */

-       |       operator
+       |       oper

                        {
                          struct field_of_this_result is_a_field_of_this;
 
                          $$.stoken = $1;
                        {
                          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);
+                         $$.sym
+                           = lookup_symbol ($1.ptr,
+                                            pstate->expression_context_block,
+                                            VAR_DOMAIN,
+                                            &is_a_field_of_this);

                          $$.is_a_field_of_this
                            = is_a_field_of_this.type != NULL;
                        }
                          $$.is_a_field_of_this
                            = is_a_field_of_this.type != NULL;
                        }


@@ -1592,50 +1737,88 @@ name_not_typename :     NAME
 
 %%
 
 
 %%
 

+/* Like write_exp_string, but prepends a '~'.  */
+
+static void
+write_destructor_name (struct parser_state *par_state, struct stoken token)
+{
+  char *copy = (char *) alloca (token.length + 1);
+
+  copy[0] = '~';
+  memcpy (&copy[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
 /* Returns a stoken of the operator name given by OP (which does not

-   include the string "operator").  */ 
+   include the string "operator").  */
+

 static struct stoken
 operator_stoken (const char *op)
 {
 static struct stoken
 operator_stoken (const char *op)
 {

-  static const char *operator_string = "operator";

   struct stoken st = { NULL, 0 };
   struct stoken st = { NULL, 0 };

-  st.length = strlen (operator_string) + strlen (op);
-  st.ptr = malloc (st.length + 1);
-  strcpy (st.ptr, operator_string);
-  strcat (st.ptr, op);
+  char *buf;
+
+  st.length = CP_OPERATOR_LEN + strlen (op);
+  buf = (char *) malloc (st.length + 1);
+  strcpy (buf, CP_OPERATOR_STR);
+  strcat (buf, op);
+  st.ptr = buf;

 
   /* The toplevel (c_parse) will free the memory allocated here.  */
 
   /* The toplevel (c_parse) will free the memory allocated here.  */

-  make_cleanup (free, st.ptr);
+  cpstate->strings.emplace_back (buf);

   return st;
 };
 
   return st;
 };
 

+/* Returns a stoken of the type named TYPE.  */
+
+static struct stoken
+typename_stoken (const char *type)
+{
+  struct stoken st = { type, 0 };
+  st.length = strlen (type);
+  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
 /* Validate a parameter typelist.  */
 
 static void

-check_parameter_typelist (VEC (type_ptr) *params)
+check_parameter_typelist (std::vector<struct type *> *params)

 {
   struct type *type;
   int ix;
 
 {
   struct type *type;
   int ix;
 

-  for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix)
+  for (ix = 0; ix < params->size (); ++ix)

     {
     {

+      type = (*params)[ix];

       if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
        {
          if (ix == 0)
            {
       if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
        {
          if (ix == 0)
            {

-             if (VEC_length (type_ptr, params) == 1)
+             if (params->size () == 1)

                {
                  /* Ok.  */
                  break;
                }
                {
                  /* Ok.  */
                  break;
                }

-             VEC_free (type_ptr, params);

              error (_("parameter types following 'void'"));
            }
          else
              error (_("parameter types following 'void'"));
            }
          else

-           {
-             VEC_free (type_ptr, params);
-             error (_("'void' invalid as parameter type"));
-           }
+           error (_("'void' invalid as parameter type"));

        }
     }
 }
        }
     }
 }


@@ -1647,12 +1830,11 @@ check_parameter_typelist (VEC (type_ptr) *params)
 /*** Needs some error checking for the float case ***/
 
 static int
 /*** Needs some error checking for the float case ***/
 
 static int

-parse_number (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.  */
-  LONGEST n = 0;
-  LONGEST prevn = 0;
+  ULONGEST n = 0;
+  ULONGEST prevn = 0;

   ULONGEST un;
 
   int i = 0;
   ULONGEST un;
 
   int i = 0;


@@ -1669,54 +1851,61 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
   ULONGEST high_bit;
   struct type *signed_type;
   struct type *unsigned_type;
   ULONGEST high_bit;
   struct type *signed_type;
   struct type *unsigned_type;

+  char *p;
+
+  p = (char *) alloca (len);
+  memcpy (p, buf, len);

 
   if (parsed_float)
     {
 
   if (parsed_float)
     {

-      /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
-         point.  Return DECFLOAT.  */
-
+      /* Handle suffixes for decimal floating-point: "df", "dd" or "dl".  */

       if (len >= 2 && 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
-           = parse_type->builtin_decfloat;
-         decimal_from_string (putithere->typed_val_decfloat.val, 4,
-                              gdbarch_byte_order (parse_gdbarch), p);
-         p[len - 2] = 'd';
-         return DECFLOAT;
+         putithere->typed_val_float.type
+           = parse_type (par_state)->builtin_decfloat;
+         len -= 2;

        }
        }

-
-      if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
+      else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')

        {
        {

-         p[len - 2] = '\0';
-         putithere->typed_val_decfloat.type
-           = parse_type->builtin_decdouble;
-         decimal_from_string (putithere->typed_val_decfloat.val, 8,
-                              gdbarch_byte_order (parse_gdbarch), p);
-         p[len - 2] = 'd';
-         return DECFLOAT;
+         putithere->typed_val_float.type
+           = parse_type (par_state)->builtin_decdouble;
+         len -= 2;

        }
        }

-
-      if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
+      else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
+       {
+         putithere->typed_val_float.type
+           = parse_type (par_state)->builtin_declong;
+         len -= 2;
+       }
+      /* Handle suffixes: 'f' for float, 'l' for long double.  */
+      else if (len >= 1 && TOLOWER (p[len - 1]) == 'f')
+       {
+         putithere->typed_val_float.type
+           = parse_type (par_state)->builtin_float;
+         len -= 1;
+       }
+      else if (len >= 1 && TOLOWER (p[len - 1]) == 'l')
+       {
+         putithere->typed_val_float.type
+           = parse_type (par_state)->builtin_long_double;
+         len -= 1;
+       }
+      /* Default type for floating-point literals is double.  */
+      else

        {
        {

-         p[len - 2] = '\0';
-         putithere->typed_val_decfloat.type
-           = parse_type->builtin_declong;
-         decimal_from_string (putithere->typed_val_decfloat.val, 16,
-                              gdbarch_byte_order (parse_gdbarch), p);
-         p[len - 2] = 'd';
-         return DECFLOAT;
+         putithere->typed_val_float.type
+           = parse_type (par_state)->builtin_double;

        }
 
        }
 

-      if (! parse_c_float (parse_gdbarch, p, len,
-                          &putithere->typed_val_float.dval,
-                          &putithere->typed_val_float.type))
-       return ERROR;
+      if (!parse_float (p, len,
+                       putithere->typed_val_float.type,
+                       putithere->typed_val_float.val))
+        return ERROR;

       return FLOAT;
     }
 
   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
       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':
     switch (p[1])
       {
       case 'x':


@@ -1804,7 +1993,7 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
         on 0x123456789 when LONGEST is 32 bits.  */
       if (c != 'l' && c != 'u' && n != 0)
        {       
         on 0x123456789 when LONGEST is 32 bits.  */
       if (c != 'l' && c != 'u' && n != 0)
        {       

-         if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
+         if (unsigned_p && prevn >= n)

            error (_("Numeric constant too large."));
        }
       prevn = n;
            error (_("Numeric constant too large."));
        }
       prevn = n;


@@ -1822,11 +2011,12 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
      the case where it is we just always shift the value more than
      once, with fewer bits each time.  */
 
      the case where it is we just always shift the value more than
      once, with fewer bits each time.  */
 

-  un = (ULONGEST)n >> 2;
+  un = n >> 2;

   if (long_p == 0
   if (long_p == 0

-      && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
+      && (un >> (gdbarch_int_bit (par_state->gdbarch ()) - 2)) == 0)

     {
     {

-      high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
+      high_bit
+       = ((ULONGEST)1) << (gdbarch_int_bit (par_state->gdbarch ()) - 1);

 
       /* A large decimal (not hex or octal) constant (between INT_MAX
         and UINT_MAX) is a long or unsigned long, according to ANSI,
 
       /* A large decimal (not hex or octal) constant (between INT_MAX
         and UINT_MAX) is a long or unsigned long, according to ANSI,


@@ -1834,28 +2024,29 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
         int.  This probably should be fixed.  GCC gives a warning on
         such constants.  */
 
         int.  This probably should be fixed.  GCC gives a warning on
         such constants.  */
 

-      unsigned_type = parse_type->builtin_unsigned_int;
-      signed_type = parse_type->builtin_int;
+      unsigned_type = parse_type (par_state)->builtin_unsigned_int;
+      signed_type = parse_type (par_state)->builtin_int;

     }
   else if (long_p <= 1
     }
   else if (long_p <= 1

-          && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
+          && (un >> (gdbarch_long_bit (par_state->gdbarch ()) - 2)) == 0)

     {
     {

-      high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
-      unsigned_type = parse_type->builtin_unsigned_long;
-      signed_type = parse_type->builtin_long;
+      high_bit
+       = ((ULONGEST)1) << (gdbarch_long_bit (par_state->gdbarch ()) - 1);
+      unsigned_type = parse_type (par_state)->builtin_unsigned_long;
+      signed_type = parse_type (par_state)->builtin_long;

     }
   else
     {
       int shift;
     }
   else
     {
       int shift;

-      if (sizeof (ULONGEST) * HOST_CHAR_BIT 
-         < gdbarch_long_long_bit (parse_gdbarch))
+      if (sizeof (ULONGEST) * HOST_CHAR_BIT
+         < gdbarch_long_long_bit (par_state->gdbarch ()))

        /* A long long does not fit in a LONGEST.  */
        shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
       else
        /* A long long does not fit in a LONGEST.  */
        shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
       else

-       shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
+       shift = (gdbarch_long_long_bit (par_state->gdbarch ()) - 1);

       high_bit = (ULONGEST) 1 << shift;
       high_bit = (ULONGEST) 1 << shift;

-      unsigned_type = parse_type->builtin_unsigned_long_long;
-      signed_type = parse_type->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;
     }
 
    putithere->typed_val_int.val = n;


@@ -1863,11 +2054,11 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
    /* If the high bit of the worked out type is set then this number
       has to be unsigned. */
 
    /* 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;
      }
      {
        putithere->typed_val_int.type = unsigned_type;
      }

-   else 
+   else

      {
        putithere->typed_val_int.type = signed_type;
      }
      {
        putithere->typed_val_int.type = signed_type;
      }


@@ -1889,9 +2080,9 @@ static int tempbuf_init;
    character was emitted, 0 otherwise.  */
 
 int
    character was emitted, 0 otherwise.  */
 
 int

-c_parse_escape (char **ptr, struct obstack *output)
+c_parse_escape (const char **ptr, struct obstack *output)

 {
 {

-  char *tokptr = *ptr;
+  const char *tokptr = *ptr;

   int result = 1;
 
   /* Some escape sequences undergo character set conversion.  Those we
   int result = 1;
 
   /* Some escape sequences undergo character set conversion.  Those we


@@ -1904,9 +2095,9 @@ c_parse_escape (char **ptr, struct obstack *output)
       if (output)
        obstack_grow_str (output, "\\x");
       ++tokptr;
       if (output)
        obstack_grow_str (output, "\\x");
       ++tokptr;

-      if (!isxdigit (*tokptr))
+      if (!ISXDIGIT (*tokptr))

        error (_("\\x escape without a following hex digit"));
        error (_("\\x escape without a following hex digit"));

-      while (isxdigit (*tokptr))
+      while (ISXDIGIT (*tokptr))

        {
          if (output)
            obstack_1grow (output, *tokptr);
        {
          if (output)
            obstack_1grow (output, *tokptr);


@@ -1929,7 +2120,7 @@ c_parse_escape (char **ptr, struct obstack *output)
        if (output)
          obstack_grow_str (output, "\\");
        for (i = 0;
        if (output)
          obstack_grow_str (output, "\\");
        for (i = 0;

-            i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
+            i < 3 && ISDIGIT (*tokptr) && *tokptr != '8' && *tokptr != '9';

             ++i)
          {
            if (output)
             ++i)
          {
            if (output)


@@ -1954,9 +2145,9 @@ c_parse_escape (char **ptr, struct obstack *output)
            obstack_1grow (output, *tokptr);
          }
        ++tokptr;
            obstack_1grow (output, *tokptr);
          }
        ++tokptr;

-       if (!isxdigit (*tokptr))
+       if (!ISXDIGIT (*tokptr))

          error (_("\\%c escape without a following hex digit"), c);
          error (_("\\%c escape without a following hex digit"), c);

-       for (i = 0; i < len && isxdigit (*tokptr); ++i)
+       for (i = 0; i < len && ISXDIGIT (*tokptr); ++i)

          {
            if (output)
              obstack_1grow (output, *tokptr);
          {
            if (output)
              obstack_1grow (output, *tokptr);


@@ -2049,12 +2240,13 @@ c_parse_escape (char **ptr, struct obstack *output)
    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.  */
    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
 static int

-parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
-                     int *host_chars)
+parse_string_or_char (const char *tokptr, const char **outptr,
+                     struct typed_stoken *value, int *host_chars)

 {
   int quote;
 {
   int quote;

-  enum c_string_type type;
+  c_string_type type;

   int is_objc = 0;
 
   /* Build the gdb internal form of the input string in tempbuf.  Note
   int is_objc = 0;
 
   /* Build the gdb internal form of the input string in tempbuf.  Note


@@ -2137,7 +2329,7 @@ parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
   ++tokptr;
 
   value->type = type;
   ++tokptr;
 
   value->type = type;

-  value->ptr = obstack_base (&tempbuf);
+  value->ptr = (char *) obstack_base (&tempbuf);

   value->length = obstack_object_size (&tempbuf);
 
   *outptr = tokptr;
   value->length = obstack_object_size (&tempbuf);
 
   *outptr = tokptr;


@@ -2147,7 +2339,7 @@ parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
 
 /* This is used to associate some attributes with a token.  */
 
 
 /* This is used to associate some attributes with a token.  */
 

-enum token_flags
+enum token_flag

 {
   /* If this bit is set, the token is C++-only.  */
 
 {
   /* If this bit is set, the token is C++-only.  */
 


@@ -2159,13 +2351,14 @@ enum token_flags
 
   FLAG_SHADOW = 2
 };
 
   FLAG_SHADOW = 2
 };

+DEF_ENUM_FLAGS_TYPE (enum token_flag, token_flags);

 
 struct token
 {
 
 struct token
 {

-  char *operator;
+  const char *oper;

   int token;
   enum exp_opcode opcode;
   int token;
   enum exp_opcode opcode;

-  enum token_flags flags;
+  token_flags flags;

 };
 
 static const struct token tokentab3[] =
 };
 
 static const struct token tokentab3[] =


@@ -2203,7 +2396,10 @@ static const struct token tokentab2[] =
     {".*", DOT_STAR, BINOP_END, FLAG_CXX}
   };
 
     {".*", DOT_STAR, BINOP_END, FLAG_CXX}
   };
 

-/* Identifier-like tokens.  */
+/* Identifier-like tokens.  Only type-specifiers than can appear in
+   multi-word type names (for example 'double' can appear in 'long
+   double') need to be listed here.  type-specifiers that are only ever
+   single word (like 'float') are handled by the classify_name function.  */

 static const struct token ident_tokens[] =
   {
     {"unsigned", UNSIGNED, OP_NULL, 0},
 static const struct token ident_tokens[] =
   {
     {"unsigned", UNSIGNED, OP_NULL, 0},


@@ -2212,6 +2408,8 @@ static const struct token ident_tokens[] =
     {"struct", STRUCT, OP_NULL, 0},
     {"signed", SIGNED_KEYWORD, OP_NULL, 0},
     {"sizeof", SIZEOF, OP_NULL, 0},
     {"struct", STRUCT, OP_NULL, 0},
     {"signed", SIGNED_KEYWORD, OP_NULL, 0},
     {"sizeof", SIZEOF, OP_NULL, 0},

+    {"_Alignof", ALIGNOF, OP_NULL, 0},
+    {"alignof", ALIGNOF, OP_NULL, FLAG_CXX},

     {"double", DOUBLE_KEYWORD, OP_NULL, 0},
     {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
     {"class", CLASS, OP_NULL, FLAG_CXX},
     {"double", DOUBLE_KEYWORD, OP_NULL, 0},
     {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
     {"class", CLASS, OP_NULL, FLAG_CXX},


@@ -2247,82 +2445,46 @@ static const struct token ident_tokens[] =
     {"__typeof", TYPEOF, OP_TYPEOF, 0 },
     {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
     {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
     {"__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 }
-  };
-
-/* 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
+    {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW },

 
 

-   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 char *macro_original_text;
+    {"typeid", TYPEID, OP_TYPEID, FLAG_CXX}
+  };

 
 

-/* 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)
 {
 
 static void
 scan_macro_expansion (char *expansion)
 {

-  char *copy;
+  const char *copy;

 
   /* We'd better not be trying to push the stack twice.  */
 
   /* We'd better not be trying to push the stack twice.  */

-  gdb_assert (! macro_original_text);
+  gdb_assert (! cpstate->macro_original_text);

 
   /* Copy to the obstack, and then free the intermediate
      expansion.  */
 
   /* Copy to the obstack, and then free the intermediate
      expansion.  */

-  copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
+  copy = obstack_strdup (&cpstate->expansion_obstack, expansion);

   xfree (expansion);
 
   /* Save the old lexptr value, so we can return to it when we're done
      parsing the expanded text.  */
   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;
+  cpstate->macro_original_text = pstate->lexptr;
+  pstate->lexptr = copy;

 }
 
 }
 

-

 static int
 scanning_macro_expansion (void)
 {
 static int
 scanning_macro_expansion (void)
 {

-  return macro_original_text != 0;
+  return cpstate->macro_original_text != 0;

 }
 
 }
 

-
-static void 
+static void

 finished_macro_expansion (void)
 {
   /* There'd better be something to pop back to.  */
 finished_macro_expansion (void)
 {
   /* There'd better be something to pop back to.  */

-  gdb_assert (macro_original_text);
+  gdb_assert (cpstate->macro_original_text);

 
   /* Pop back to the 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);
+  pstate->lexptr = cpstate->macro_original_text;
+  cpstate->macro_original_text = 0;

 }
 
 /* Return true iff the token represents a C++ cast operator.  */
 }
 
 /* Return true iff the token represents a C++ cast operator.  */


@@ -2345,30 +2507,32 @@ static struct macro_scope *expression_macro_scope;
 static int saw_name_at_eof;
 
 /* This is set if the previously-returned token was a structure
 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;
+   operator -- either '.' or ARROW.  */
+static bool last_was_structop;
+
+/* Depth of parentheses.  */
+static int paren_depth;

 
 /* Read one token, getting characters through lexptr.  */
 
 static int
 
 /* Read one token, getting characters through lexptr.  */
 
 static int

-lex_one_token (void)
+lex_one_token (struct parser_state *par_state, bool *is_quoted_name)

 {
   int c;
   int namelen;
   unsigned int i;
 {
   int c;
   int namelen;
   unsigned int i;

-  char *tokstart;
-  int saw_structop = last_was_structop;
-  char *copy;
+  const char *tokstart;
+  bool saw_structop = last_was_structop;

 
 

-  last_was_structop = 0;
+  last_was_structop = false;
+  *is_quoted_name = false;

 
  retry:
 
   /* Check if this is a macro invocation that we need to expand.  */
   if (! scanning_macro_expansion ())
     {
 
  retry:
 
   /* Check if this is a macro invocation that we need to expand.  */
   if (! scanning_macro_expansion ())
     {

-      char *expanded = macro_expand_next (&lexptr,
+      char *expanded = macro_expand_next (&pstate->lexptr,

                                           standard_macro_lookup,
                                           expression_macro_scope);
 
                                           standard_macro_lookup,
                                           expression_macro_scope);
 


@@ -2376,33 +2540,33 @@ lex_one_token (void)
         scan_macro_expansion (expanded);
     }
 
         scan_macro_expansion (expanded);
     }
 

-  prev_lexptr = lexptr;
+  pstate->prev_lexptr = pstate->lexptr;

 
 

-  tokstart = lexptr;
+  tokstart = pstate->lexptr;

   /* See if it is a special token of length 3.  */
   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
   /* 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
       {
        if ((tokentab3[i].flags & FLAG_CXX) != 0

-           && parse_language->la_language != language_cplus)
+           && par_state->language ()->la_language != language_cplus)

          break;
 
          break;
 

-       lexptr += 3;
+       pstate->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++)
        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
       {
        if ((tokentab2[i].flags & FLAG_CXX) != 0

-           && parse_language->la_language != language_cplus)
+           && par_state->language ()->la_language != language_cplus)

          break;
 
          break;
 

-       lexptr += 2;
+       pstate->lexptr += 2;

        yylval.opcode = tokentab2[i].opcode;
        yylval.opcode = tokentab2[i].opcode;

-       if (parse_completion && tokentab2[i].token == ARROW)
+       if (tokentab2[i].token == ARROW)

          last_was_structop = 1;
        return tokentab2[i].token;
       }
          last_was_structop = 1;
        return tokentab2[i].token;
       }


@@ -2426,7 +2590,7 @@ lex_one_token (void)
          saw_name_at_eof = 0;
          return COMPLETE;
        }
          saw_name_at_eof = 0;
          return COMPLETE;
        }

-      else if (saw_structop)
+      else if (par_state->parse_completion && saw_structop)

        return COMPLETE;
       else
         return 0;
        return COMPLETE;
       else
         return 0;


@@ -2434,14 +2598,15 @@ lex_one_token (void)
     case ' ':
     case '\t':
     case '\n':
     case ' ':
     case '\t':
     case '\n':

-      lexptr++;
+      pstate->lexptr++;

       goto retry;
 
     case '[':
     case '(':
       paren_depth++;
       goto retry;
 
     case '[':
     case '(':
       paren_depth++;

-      lexptr++;
-      if (parse_language->la_language == language_objc && c == '[')
+      pstate->lexptr++;
+      if (par_state->language ()->la_language == language_objc
+         && c == '[')

        return OBJC_LBRAC;
       return c;
 
        return OBJC_LBRAC;
       return c;
 


@@ -2450,26 +2615,25 @@ lex_one_token (void)
       if (paren_depth == 0)
        return 0;
       paren_depth--;
       if (paren_depth == 0)
        return 0;
       paren_depth--;

-      lexptr++;
+      pstate->lexptr++;

       return c;
 
     case ',':
       return c;
 
     case ',':

-      if (comma_terminates
+      if (pstate->comma_terminates

           && paren_depth == 0
           && ! scanning_macro_expansion ())
        return 0;
           && paren_depth == 0
           && ! scanning_macro_expansion ())
        return 0;

-      lexptr++;
+      pstate->lexptr++;

       return c;
 
     case '.':
       /* Might be a floating point number.  */
       return c;
 
     case '.':
       /* Might be a floating point number.  */

-      if (lexptr[1] < '0' || lexptr[1] > '9')
+      if (pstate->lexptr[1] < '0' || pstate->lexptr[1] > '9')

        {
        {

-         if (parse_completion)
-           last_was_structop = 1;
+         last_was_structop = true;

          goto symbol;          /* Nope, must be a symbol. */
        }
          goto symbol;          /* Nope, must be a symbol. */
        }

-      /* FALL THRU into number case.  */
+      /* FALL THRU.  */

 
     case '0':
     case '1':
 
     case '0':
     case '1':


@@ -2484,7 +2648,7 @@ lex_one_token (void)
       {
        /* It's a number.  */
        int got_dot = 0, got_e = 0, toktype;
       {
        /* 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'))
        int hex = input_radix > 10;
 
        if (c == '0' && (p[1] == 'x' || p[1] == 'X'))


@@ -2521,7 +2685,8 @@ lex_one_token (void)
                                  && (*p < 'A' || *p > 'Z')))
              break;
          }
                                  && (*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);
         if (toktype == ERROR)
          {
            char *err_copy = (char *) alloca (p - tokstart + 1);


@@ -2530,35 +2695,35 @@ lex_one_token (void)
            err_copy[p - tokstart] = 0;
            error (_("Invalid number \"%s\"."), err_copy);
          }
            err_copy[p - tokstart] = 0;
            error (_("Invalid number \"%s\"."), err_copy);
          }

-       lexptr = p;
+       pstate->lexptr = p;

        return toktype;
       }
 
     case '@':
       {
        return toktype;
       }
 
     case '@':
       {

-       char *p = &tokstart[1];
-       size_t len = strlen ("entry");
+       const char *p = &tokstart[1];

 
 

-       if (parse_language->la_language == language_objc)
+       if (par_state->language ()->la_language == language_objc)

          {
            size_t len = strlen ("selector");
 
            if (strncmp (p, "selector", len) == 0
          {
            size_t len = strlen ("selector");
 
            if (strncmp (p, "selector", len) == 0

-               && (p[len] == '\0' || isspace (p[len])))
+               && (p[len] == '\0' || ISSPACE (p[len])))

              {
              {

-               lexptr = p + len;
+               pstate->lexptr = p + len;

                return SELECTOR;
              }
            else if (*p == '"')
              goto parse_string;
          }
 
                return SELECTOR;
              }
            else if (*p == '"')
              goto parse_string;
          }
 

-       while (isspace (*p))
+       while (ISSPACE (*p))

          p++;
          p++;

-       if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
+       size_t len = strlen ("entry");
+       if (strncmp (p, "entry", len) == 0 && !c_ident_is_alnum (p[len])

            && p[len] != '_')
          {
            && p[len] != '_')
          {

-           lexptr = &p[len];
+           pstate->lexptr = &p[len];

            return ENTRY;
          }
       }
            return ENTRY;
          }
       }


@@ -2581,7 +2746,7 @@ lex_one_token (void)
     case '{':
     case '}':
     symbol:
     case '{':
     case '}':
     symbol:

-      lexptr++;
+      pstate->lexptr++;

       return c;
 
     case 'L':
       return c;
 
     case 'L':


@@ -2596,8 +2761,8 @@ lex_one_token (void)
     parse_string:
       {
        int host_len;
     parse_string:
       {
        int host_len;

-       int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
-                                          &host_len);
+       int result = parse_string_or_char (tokstart, &pstate->lexptr,
+                                          &yylval.tsval, &host_len);

        if (result == CHAR)
          {
            if (host_len == 0)
        if (result == CHAR)
          {
            if (host_len == 0)


@@ -2605,7 +2770,9 @@ lex_one_token (void)
            else if (host_len > 2 && c == '\'')
              {
                ++tokstart;
            else if (host_len > 2 && c == '\'')
              {
                ++tokstart;

-               namelen = lexptr - tokstart - 1;
+               namelen = pstate->lexptr - tokstart - 1;
+               *is_quoted_name = true;
+

                goto tryname;
              }
            else if (host_len > 1)
                goto tryname;
              }
            else if (host_len > 1)


@@ -2615,16 +2782,14 @@ lex_one_token (void)
       }
     }
 
       }
     }
 

-  if (!(c == '_' || c == '$'
-       || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
+  if (!(c == '_' || c == '$' || c_ident_is_alpha (c)))

     /* We must have come across a bad character (e.g. ';').  */
     error (_("Invalid character '%c' in expression."), c);
 
   /* It's a name.  See how long it is.  */
   namelen = 0;
   for (c = tokstart[namelen];
     /* We must have come across a bad character (e.g. ';').  */
     error (_("Invalid character '%c' in expression."), c);
 
   /* It's a name.  See how long it is.  */
   namelen = 0;
   for (c = tokstart[namelen];

-       (c == '_' || c == '$' || (c >= '0' && c <= '9')
-       || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
+       (c == '_' || c == '$' || c_ident_is_alnum (c) || c == '<');)

     {
       /* Template parameter lists are part of the name.
         FIXME: This mishandles `print $a<4&&$a>3'.  */
     {
       /* Template parameter lists are part of the name.
         FIXME: This mishandles `print $a<4&&$a>3'.  */


@@ -2637,8 +2802,8 @@ lex_one_token (void)
                 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. */
                 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);
+             const char *p = find_template_name_end (tokstart + namelen);
+

              if (p)
                namelen = p - tokstart;
            }
              if (p)
                namelen = p - tokstart;
            }


@@ -2669,14 +2834,15 @@ lex_one_token (void)
       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
       && ! scanning_macro_expansion ())
     {
       && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
       && ! scanning_macro_expansion ())
     {

-      char *p = tokstart + namelen + 1;
+      const char *p = tokstart + namelen + 1;
+

       while (*p == ' ' || *p == '\t')
        p++;
       if (*p >= '0' && *p <= '9')
        return 0;
     }
 
       while (*p == ' ' || *p == '\t')
        p++;
       if (*p >= '0' && *p <= '9')
        return 0;
     }
 

-  lexptr += namelen;
+  pstate->lexptr += namelen;

 
   tryname:
 
 
   tryname:
 


@@ -2684,23 +2850,24 @@ lex_one_token (void)
   yylval.sval.length = namelen;
 
   /* Catch specific keywords.  */
   yylval.sval.length = namelen;
 
   /* Catch specific keywords.  */

-  copy = copy_name (yylval.sval);
+  std::string copy = copy_name (yylval.sval);

   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
   for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)

-    if (strcmp (copy, ident_tokens[i].operator) == 0)
+    if (copy == ident_tokens[i].oper)

       {
        if ((ident_tokens[i].flags & FLAG_CXX) != 0
       {
        if ((ident_tokens[i].flags & FLAG_CXX) != 0

-           && parse_language->la_language != language_cplus)
+           && par_state->language ()->la_language != language_cplus)

          break;
 
        if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
          {
            struct field_of_this_result is_a_field_of_this;
 
          break;
 
        if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
          {
            struct field_of_this_result is_a_field_of_this;
 

-           if (lookup_symbol (copy, expression_context_block,
+           if (lookup_symbol (copy.c_str (),
+                              pstate->expression_context_block,

                               VAR_DOMAIN,
                               VAR_DOMAIN,

-                              (parse_language->la_language == language_cplus
-                               ? &is_a_field_of_this
-                               : NULL))
+                              (par_state->language ()->la_language
+                               == language_cplus ? &is_a_field_of_this
+                               : NULL)).symbol

                != NULL)
              {
                /* The keyword is shadowed.  */
                != NULL)
              {
                /* The keyword is shadowed.  */


@@ -2715,76 +2882,68 @@ lex_one_token (void)
       }
 
   if (*tokstart == '$')
       }
 
   if (*tokstart == '$')

-    return VARIABLE;
+    return DOLLAR_VARIABLE;

 
 

-  if (parse_completion && *lexptr == '\0')
+  if (pstate->parse_completion && *pstate->lexptr == '\0')

     saw_name_at_eof = 1;
 
   yylval.ssym.stoken = yylval.sval;
     saw_name_at_eof = 1;
 
   yylval.ssym.stoken = yylval.sval;

-  yylval.ssym.sym = NULL;
+  yylval.ssym.sym.symbol = NULL;
+  yylval.ssym.sym.block = 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.  */
   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
+struct token_and_value

 {
   int token;
   YYSTYPE value;
 {
   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.  */
 
 /* A FIFO of tokens that have been read but not yet returned to the
    parser.  */

-static VEC (token_and_value) *token_fifo;
+static std::vector<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.  */
 
 /* 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;
+auto_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
 
 /* 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.  */
+   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.  IS_AFTER_STRUCTOP is true if this name follows
+   a structure operator -- either '.' or ARROW  */
+

 static int
 static int

-classify_name (const struct block *block)
+classify_name (struct parser_state *par_state, const struct block *block,
+              bool is_quoted_name, bool is_after_structop)

 {
 {

-  struct symbol *sym;
-  char *copy;
+  struct block_symbol bsym;

   struct field_of_this_result is_a_field_of_this;
 
   struct field_of_this_result is_a_field_of_this;
 

-  copy = copy_name (yylval.sval);
+  std::string 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));
 
 
   /* 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->la_name_of_this
-                      ? &is_a_field_of_this : NULL);
+  bsym = lookup_symbol (copy.c_str (), block, VAR_DOMAIN,
+                       par_state->language ()->la_name_of_this
+                       ? &is_a_field_of_this : NULL);

 
 

-  if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
+  if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_BLOCK)

     {
     {

-      yylval.ssym.sym = sym;
+      yylval.ssym.sym = bsym;

       yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
       return BLOCKNAME;
     }
       yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
       return BLOCKNAME;
     }

-  else if (!sym)
+  else if (!bsym.symbol)

     {
     {

-      /* See if it's a file name. */
-      struct symtab *symtab;
-
-      symtab = lookup_symtab (copy);
-      if (symtab)
-       {
-         yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
-         return FILENAME;
-       }
-

       /* 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
       /* 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


@@ -2796,38 +2955,56 @@ classify_name (const struct block *block)
        {
          struct field_of_this_result inner_is_a_field_of_this;
 
        {
          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)
+         bsym = lookup_symbol (copy.c_str (), block, STRUCT_DOMAIN,
+                               &inner_is_a_field_of_this);
+         if (bsym.symbol != NULL)

            {
            {

-             yylval.tsym.type = SYMBOL_TYPE (sym);
+             yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);

              return TYPENAME;
            }
        }
              return TYPENAME;
            }
        }

+
+      /* If we found a field on the "this" object, or we are looking
+        up a field on a struct, 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_after_structop) 
+         || is_quoted_name)
+       {
+         /* See if it's a file name. */
+         struct symtab *symtab;
+
+         symtab = lookup_symtab (copy.c_str ());
+         if (symtab)
+           {
+             yylval.bval = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab),
+                                              STATIC_BLOCK);
+             return FILENAME;
+           }
+       }

     }
 
     }
 

-  if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+  if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_TYPEDEF)

     {
     {

-      yylval.tsym.type = SYMBOL_TYPE (sym);
+      yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);

       return TYPENAME;
     }
 
       return TYPENAME;
     }
 

-  yylval.tsym.type
-    = language_lookup_primitive_type_by_name (parse_language,
-                                             parse_gdbarch, copy);
-  if (yylval.tsym.type != NULL)
-    return TYPENAME;
-

   /* See if it's an ObjC classname.  */
   /* See if it's an ObjC classname.  */

-  if (parse_language->la_language == language_objc && !sym)
+  if (par_state->language ()->la_language == language_objc && !bsym.symbol)

     {
     {

-      CORE_ADDR Class = lookup_objc_class (parse_gdbarch, copy);
+      CORE_ADDR Class = lookup_objc_class (par_state->gdbarch (),
+                                          copy.c_str ());

       if (Class)
        {
       if (Class)
        {

-         yylval.class.class = Class;
-         sym = lookup_struct_typedef (copy, expression_context_block, 1);
+         struct symbol *sym;
+
+         yylval.theclass.theclass = Class;
+         sym = lookup_struct_typedef (copy.c_str (),
+                                      par_state->expression_context_block, 1);

          if (sym)
          if (sym)

-           yylval.class.type = SYMBOL_TYPE (sym);
+           yylval.theclass.type = SYMBOL_TYPE (sym);

          return CLASSNAME;
        }
     }
          return CLASSNAME;
        }
     }


@@ -2835,28 +3012,30 @@ classify_name (const struct block *block)
   /* 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.  */
   /* 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
+  if (!bsym.symbol

       && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
          || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
     {
       YYSTYPE newlval; /* Its value is ignored.  */
       && ((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 (copy, yylval.sval.length, 0, &newlval);
+      int hextype = parse_number (par_state, copy.c_str (), yylval.sval.length,
+                                 0, &newlval);
+

       if (hextype == INT)
        {
       if (hextype == INT)
        {

-         yylval.ssym.sym = sym;
+         yylval.ssym.sym = bsym;

          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.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.sym = bsym;

   yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
 
   yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
 

-  if (sym == NULL
-      && parse_language->la_language == language_cplus
+  if (bsym.symbol == NULL
+      && par_state->language ()->la_language == language_cplus

       && is_a_field_of_this.type == NULL
       && is_a_field_of_this.type == NULL

-      && !lookup_minimal_symbol (copy, NULL, NULL))
+      && lookup_minimal_symbol (copy.c_str (), NULL, NULL).minsym == NULL)

     return UNKNOWN_CPP_NAME;
 
   return NAME;
     return UNKNOWN_CPP_NAME;
 
   return NAME;


@@ -2867,33 +3046,61 @@ classify_name (const struct block *block)
    NULL if this is the first component of a name.  */
 
 static int
    NULL if this is the first component of a name.  */
 
 static int

-classify_inner_name (const struct block *block, struct type *context)
+classify_inner_name (struct parser_state *par_state,
+                    const struct block *block, struct type *context)

 {
   struct type *type;
 {
   struct type *type;

-  char *copy;

 
   if (context == NULL)
 
   if (context == NULL)

-    return classify_name (block);
+    return classify_name (par_state, block, false, false);

 
   type = check_typedef (context);
 
   type = check_typedef (context);

-  if (TYPE_CODE (type) != TYPE_CODE_STRUCT
-      && TYPE_CODE (type) != TYPE_CODE_UNION
-      && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
+  if (!type_aggregate_p (type))

     return ERROR;
 
     return ERROR;
 

-  copy = copy_name (yylval.ssym.stoken);
-  yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block);
-  if (yylval.ssym.sym == NULL)
-    return ERROR;
+  std::string 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.c_str (), block,
+                                            VAR_DOMAIN);

 
 

-  switch (SYMBOL_CLASS (yylval.ssym.sym))
+  /* 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.symbol == NULL)
+    {
+      struct type *base_type = cp_find_type_baseclass_by_name (type,
+                                                              copy.c_str ());
+
+      if (base_type != NULL)
+       {
+         yylval.tsym.type = base_type;
+         return TYPENAME;
+       }
+
+      return ERROR;
+    }
+
+  switch (SYMBOL_CLASS (yylval.ssym.sym.symbol))

     {
     case LOC_BLOCK:
     case LOC_LABEL:
     {
     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.  */
+      {
+       struct type *base_type
+         = cp_find_type_baseclass_by_name (type, copy.c_str ());
+
+       if (base_type != NULL)
+         {
+           yylval.tsym.type = base_type;
+           return TYPENAME;
+         }
+      }

       return ERROR;
 
     case LOC_TYPEDEF:
       return ERROR;
 
     case LOC_TYPEDEF:

-      yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);;
+      yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);

       return TYPENAME;
 
     default:
       return TYPENAME;
 
     default:


@@ -2908,67 +3115,110 @@ classify_inner_name (const struct block *block, struct type *context)
    problem in our parsing approach, where the parser could not
    distinguish between qualified names and qualified types at the
    right point.
    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.  */
    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;
 static int
 yylex (void)
 {
   token_and_value current;

-  int first_was_coloncolon, last_was_coloncolon, first_iter;
+  int first_was_coloncolon, last_was_coloncolon;

   struct type *context_type = NULL;
   struct type *context_type = NULL;

+  int last_to_examine, next_to_examine, checkpoint;
+  const struct block *search_block;
+  bool is_quoted_name, last_lex_was_structop;

 
 

-  if (popping && !VEC_empty (token_and_value, token_fifo))
-    {
-      token_and_value tv = *VEC_index (token_and_value, token_fifo, 0);
-      VEC_ordered_remove (token_and_value, token_fifo, 0);
-      yylval = tv.value;
-      return tv.token;
-    }
+  if (popping && !token_fifo.empty ())
+    goto do_pop;

   popping = 0;
 
   popping = 0;
 

-  current.token = lex_one_token ();
+  last_lex_was_structop = last_was_structop;
+
+  /* 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)
   if (current.token == NAME)

-    current.token = classify_name (expression_context_block);
-  if (parse_language->la_language != language_cplus
-      || (current.token != TYPENAME && current.token != COLONCOLON))
+    current.token = classify_name (pstate, pstate->expression_context_block,
+                                  is_quoted_name, last_lex_was_structop);
+  if (pstate->language ()->la_language != language_cplus
+      || (current.token != TYPENAME && current.token != COLONCOLON
+         && current.token != FILENAME))

     return current.token;
 
     return current.token;
 

-  first_was_coloncolon = current.token == COLONCOLON;
-  last_was_coloncolon = first_was_coloncolon;
-  obstack_free (&name_obstack, obstack_base (&name_obstack));
-  if (!last_was_coloncolon)
-    {
-      obstack_grow (&name_obstack, yylval.sval.ptr, yylval.sval.length);
-      context_type = yylval.tsym.type;
-    }
+  /* Read any sequence of alternating "::" and name-like tokens into
+     the token FIFO.  */

   current.value = yylval;
   current.value = yylval;

-  first_iter = 1;
+  token_fifo.push_back (current);
+  last_was_coloncolon = current.token == COLONCOLON;

   while (1)
   while (1)

+    {
+      bool 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;
+      token_fifo.push_back (current);
+
+      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 = token_fifo.size () - 2;
+  next_to_examine = 0;
+
+  current = token_fifo[next_to_examine];
+  ++next_to_examine;
+
+  name_obstack.clear ();
+  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 = pstate->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;
 
     {
       token_and_value next;
 

-      next.token = lex_one_token ();
-      next.value = yylval;
+      next = token_fifo[next_to_examine];
+      ++next_to_examine;

 
       if (next.token == NAME && last_was_coloncolon)
        {
          int classification;
 
 
       if (next.token == NAME && last_was_coloncolon)
        {
          int classification;
 

-         classification = classify_inner_name (first_was_coloncolon
-                                               ? NULL
-                                               : expression_context_block,
+         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)
                                                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)

-           {
-             /* Push the final component and leave the loop.  */
-             VEC_safe_push (token_and_value, token_fifo, &next);
-             break;
-           }
+           break;
+
+         /* Accept up to this token.  */
+         checkpoint = next_to_examine;

 
          /* Update the partial name we are constructing.  */
          if (context_type != NULL)
 
          /* Update the partial name we are constructing.  */
          if (context_type != NULL)


@@ -2979,13 +3229,13 @@ yylex (void)
          obstack_grow (&name_obstack, next.value.sval.ptr,
                        next.value.sval.length);
 
          obstack_grow (&name_obstack, next.value.sval.ptr,
                        next.value.sval.length);
 

-         yylval.sval.ptr = obstack_base (&name_obstack);
+         yylval.sval.ptr = (const char *) obstack_base (&name_obstack);

          yylval.sval.length = obstack_object_size (&name_obstack);
          current.value = yylval;
          current.token = classification;
 
          last_was_coloncolon = 0;
          yylval.sval.length = obstack_object_size (&name_obstack);
          current.value = yylval;
          current.token = classification;
 
          last_was_coloncolon = 0;

-         
+

          if (classification == NAME)
            break;
 
          if (classification == NAME)
            break;
 


@@ -2996,82 +3246,134 @@ yylex (void)
       else
        {
          /* We've reached the end of the name.  */
       else
        {
          /* We've reached the end of the name.  */

-         VEC_safe_push (token_and_value, token_fifo, &next);

          break;
        }
          break;
        }

-
-      first_iter = 0;

     }
 
     }
 

-  popping = 1;
-
-  /* If we ended with a "::", insert it too.  */
-  if (last_was_coloncolon)
+  /* If we have a replacement token, install it as the first token in
+     the FIFO, and delete the other constituent tokens.  */
+  if (checkpoint > 0)

     {
     {

-      token_and_value cc;
-      memset (&cc, 0, sizeof (token_and_value));
-      if (first_was_coloncolon && first_iter)
-       {
-         yylval = cc.value;
-         return COLONCOLON;
-       }
-      cc.token = COLONCOLON;
-      VEC_safe_insert (token_and_value, token_fifo, 0, &cc);
+      current.value.sval.ptr
+       = obstack_strndup (&cpstate->expansion_obstack,
+                          current.value.sval.ptr,
+                          current.value.sval.length);
+
+      token_fifo[0] = current;
+      if (checkpoint > 1)
+       token_fifo.erase (token_fifo.begin () + 1,
+                         token_fifo.begin () + checkpoint);

     }
 
     }
 

+ do_pop:
+  current = token_fifo[0];
+  token_fifo.erase (token_fifo.begin ());

   yylval = current.value;
   yylval = current.value;

-  yylval.sval.ptr = obstack_copy0 (&expansion_obstack,
-                                  yylval.sval.ptr,
-                                  yylval.sval.length);

   return current.token;
 }
 
 int
   return current.token;
 }
 
 int

-c_parse (void)
+c_parse (struct parser_state *par_state)

 {
 {

-  int result;
-  struct cleanup *back_to = make_cleanup (free_current_contents,
-                                         &expression_macro_scope);
+  /* Setting up the parser state.  */
+  scoped_restore pstate_restore = make_scoped_restore (&pstate);
+  gdb_assert (par_state != NULL);
+  pstate = par_state;

 
 

-  /* Set up the scope for macro expansion.  */
-  expression_macro_scope = NULL;
+  c_parse_state cstate;
+  scoped_restore cstate_restore = make_scoped_restore (&cpstate, &cstate);

 
 

-  if (expression_context_block)
-    expression_macro_scope
-      = sal_macro_scope (find_pc_line (expression_context_pc, 0));
+  gdb::unique_xmalloc_ptr<struct macro_scope> macro_scope;
+
+  if (par_state->expression_context_block)
+    macro_scope
+      = sal_macro_scope (find_pc_line (par_state->expression_context_pc, 0));

   else
   else

-    expression_macro_scope = default_macro_scope ();
-  if (! expression_macro_scope)
-    expression_macro_scope = user_macro_scope ();
+    macro_scope = default_macro_scope ();
+  if (! macro_scope)
+    macro_scope = user_macro_scope ();

 
 

-  /* Initialize macro expansion code.  */
-  obstack_init (&expansion_obstack);
-  gdb_assert (! macro_original_text);
-  make_cleanup (scan_macro_cleanup, 0);
+  scoped_restore restore_macro_scope
+    = make_scoped_restore (&expression_macro_scope, macro_scope.get ());

 
 

-  make_cleanup_restore_integer (&yydebug);
-  yydebug = parser_debug;
+  scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
+                                                       parser_debug);

 
   /* Initialize some state used by the lexer.  */
 
   /* Initialize some state used by the lexer.  */

-  last_was_structop = 0;
+  last_was_structop = false;

   saw_name_at_eof = 0;
   saw_name_at_eof = 0;

+  paren_depth = 0;

 
 

-  VEC_free (token_and_value, token_fifo);
+  token_fifo.clear ();

   popping = 0;
   popping = 0;

-  obstack_init (&name_obstack);
-  make_cleanup_obstack_free (&name_obstack);
+  name_obstack.clear ();

 
 

-  result = yyparse ();
-  do_cleanups (back_to);
-  return result;
+  return yyparse ();

 }
 
 }
 

+#ifdef YYBISON

 
 

-void
-yyerror (char *msg)
+/* 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:
+      parser_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 = (char *) alloca (value.tsval.length + 1);
+
+       memcpy (copy, value.tsval.ptr, value.tsval.length);
+       copy[value.tsval.length] = '\0';
+
+       parser_fprintf (file, "tsval<type=%d, %s>", value.tsval.type, copy);
+      }
+      break;
+
+    case NSSTRING:
+    case DOLLAR_VARIABLE:
+      parser_fprintf (file, "sval<%s>", copy_name (value.sval).c_str ());
+      break;
+
+    case TYPENAME:
+      parser_fprintf (file, "tsym<type=%s, name=%s>",
+                     TYPE_SAFE_NAME (value.tsym.type),
+                     copy_name (value.tsym.stoken).c_str ());
+      break;
+
+    case NAME:
+    case UNKNOWN_CPP_NAME:
+    case NAME_OR_INT:
+    case BLOCKNAME:
+      parser_fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
+                      copy_name (value.ssym.stoken).c_str (),
+                      (value.ssym.sym.symbol == NULL
+                       ? "(null)" : value.ssym.sym.symbol->print_name ()),
+                      value.ssym.is_a_field_of_this);
+      break;
+
+    case FILENAME:
+      parser_fprintf (file, "bval<%s>", host_address_to_string (value.bval));
+      break;
+    }
+}
+
+#endif
+
+static void
+yyerror (const char *msg)

 {
 {

-  if (prev_lexptr)
-    lexptr = prev_lexptr;
+  if (pstate->prev_lexptr)
+    pstate->lexptr = pstate->prev_lexptr;

 
 

-  error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
+  error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);

 }
 }