Move comma_terminates global to parser_state

[deliverable/binutils-gdb.git] / gdb / parse.c

diff --git a/gdb/parse.c b/gdb/parse.c
index 83bfa4b24138ca3533c7e9934014ae7aa50e10b5..617ff70d67ea77efb73fc92b90153b6f42e137a8 100644 (file)
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -1,6 +1,6 @@
 /* Parse expressions for GDB.
 
 /* Parse expressions for GDB.
 

-   Copyright (C) 1986-2017 Free Software Foundation, Inc.
+   Copyright (C) 1986-2019 Free Software Foundation, Inc.

 
    Modified from expread.y by the Department of Computer Science at the
    State University of New York at Buffalo, 1991.
 
    Modified from expread.y by the Department of Computer Science at the
    State University of New York at Buffalo, 1991.


@@ -44,7 +44,7 @@
 #include "gdbcmd.h"
 #include "symfile.h"           /* for overlay functions */
 #include "inferior.h"
 #include "gdbcmd.h"
 #include "symfile.h"           /* for overlay functions */
 #include "inferior.h"

-#include "doublest.h"
+#include "target-float.h"

 #include "block.h"
 #include "source.h"
 #include "objfiles.h"
 #include "block.h"
 #include "source.h"
 #include "objfiles.h"


@@ -66,15 +66,11 @@ const struct exp_descriptor exp_descriptor_standard =
   };
 \f
 /* Global variables declared in parser-defs.h (and commented there).  */
   };
 \f
 /* Global variables declared in parser-defs.h (and commented there).  */

-const struct block *expression_context_block;
-CORE_ADDR expression_context_pc;
-const struct block *innermost_block;
+innermost_block_tracker innermost_block;

 int arglist_len;
 static struct type_stack type_stack;
 const char *lexptr;
 const char *prev_lexptr;
 int arglist_len;
 static struct type_stack type_stack;
 const char *lexptr;
 const char *prev_lexptr;

-int paren_depth;
-int comma_terminates;

 
 /* True if parsing an expression to attempt completion.  */
 int parse_completion;
 
 /* True if parsing an expression to attempt completion.  */
 int parse_completion;


@@ -88,7 +84,7 @@ static int expout_last_struct = -1;
 static enum type_code expout_tag_completion_type = TYPE_CODE_UNDEF;
 
 /* The token for tagged type name completion.  */
 static enum type_code expout_tag_completion_type = TYPE_CODE_UNDEF;
 
 /* The token for tagged type name completion.  */

-static char *expout_completion_name;
+static gdb::unique_xmalloc_ptr<char> expout_completion_name;

 
 \f
 static unsigned int expressiondebug = 0;
 
 \f
 static unsigned int expressiondebug = 0;


@@ -111,30 +107,33 @@ show_parserdebug (struct ui_file *file, int from_tty,
 }
 
 
 }
 
 

-static void free_funcalls (void *ignore);
-

 static int prefixify_subexp (struct expression *, struct expression *, int,
                             int);
 
 static expression_up parse_exp_in_context (const char **, CORE_ADDR,
                                           const struct block *, int,
 static int prefixify_subexp (struct expression *, struct expression *, int,
                             int);
 
 static expression_up parse_exp_in_context (const char **, CORE_ADDR,
                                           const struct block *, int,

-                                          int, int *);
-static expression_up parse_exp_in_context_1 (const char **, CORE_ADDR,
-                                            const struct block *, int,
-                                            int, int *);
+                                          int, int *,
+                                          innermost_block_tracker_types);
+
+static void increase_expout_size (struct expr_builder *ps, size_t lenelt);
+

 
 

-void _initialize_parse (void);
+/* Documented at it's declaration.  */
+
+void
+innermost_block_tracker::update (const struct block *b,
+                                innermost_block_tracker_types t)
+{
+  if ((m_types & t) != 0
+      && (m_innermost_block == NULL
+         || contained_in (b, m_innermost_block)))
+    m_innermost_block = b;
+}

 
 /* Data structure for saving values of arglist_len for function calls whose
    arguments contain other function calls.  */
 
 
 /* Data structure for saving values of arglist_len for function calls whose
    arguments contain other function calls.  */
 

-struct funcall
-  {
-    struct funcall *next;
-    int arglist_len;
-  };
-
-static struct funcall *funcall_chain;
+static std::vector<int> *funcall_chain;

 
 /* Begin counting arguments for a function call,
    saving the data about any containing call.  */
 
 /* Begin counting arguments for a function call,
    saving the data about any containing call.  */


@@ -142,13 +141,8 @@ static struct funcall *funcall_chain;
 void
 start_arglist (void)
 {
 void
 start_arglist (void)
 {

-  struct funcall *newobj;
-
-  newobj = XNEW (struct funcall);
-  newobj->next = funcall_chain;
-  newobj->arglist_len = arglist_len;
+  funcall_chain->push_back (arglist_len);

   arglist_len = 0;
   arglist_len = 0;

-  funcall_chain = newobj;

 }
 
 /* Return the number of arguments in a function call just terminated,
 }
 
 /* Return the number of arguments in a function call just terminated,


@@ -158,60 +152,40 @@ int
 end_arglist (void)
 {
   int val = arglist_len;
 end_arglist (void)
 {
   int val = arglist_len;

-  struct funcall *call = funcall_chain;
-
-  funcall_chain = call->next;
-  arglist_len = call->arglist_len;
-  xfree (call);
+  arglist_len = funcall_chain->back ();
+  funcall_chain->pop_back ();

   return val;
 }
 
   return val;
 }
 

-/* Free everything in the funcall chain.
-   Used when there is an error inside parsing.  */
-
-static void
-free_funcalls (void *ignore)
-{
-  struct funcall *call, *next;
-
-  for (call = funcall_chain; call; call = next)
-    {
-      next = call->next;
-      xfree (call);
-    }
-}

 \f
 
 /* See definition in parser-defs.h.  */
 
 \f
 
 /* See definition in parser-defs.h.  */
 

-void
-initialize_expout (struct parser_state *ps, size_t initial_size,
-                  const struct language_defn *lang,
-                  struct gdbarch *gdbarch)
+expr_builder::expr_builder (const struct language_defn *lang,
+                           struct gdbarch *gdbarch)
+  : expout_size (10),
+    expout (XNEWVAR (expression,
+                    (sizeof (expression)
+                     + EXP_ELEM_TO_BYTES (expout_size)))),
+    expout_ptr (0)

 {
 {

-  ps->expout_size = initial_size;
-  ps->expout_ptr = 0;
-  ps->expout
-    = (struct expression *) xmalloc (sizeof (struct expression)
-                                    + EXP_ELEM_TO_BYTES (ps->expout_size));
-  ps->expout->language_defn = lang;
-  ps->expout->gdbarch = gdbarch;
+  expout->language_defn = lang;
+  expout->gdbarch = gdbarch;

 }
 
 }
 

-/* See definition in parser-defs.h.  */
-
-void
-reallocate_expout (struct parser_state *ps)
+expression_up
+expr_builder::release ()

 {
   /* Record the actual number of expression elements, and then
      reallocate the expression memory so that we free up any
      excess elements.  */
 
 {
   /* Record the actual number of expression elements, and then
      reallocate the expression memory so that we free up any
      excess elements.  */
 

-  ps->expout->nelts = ps->expout_ptr;
-  ps->expout = (struct expression *)
-     xrealloc (ps->expout,
-              sizeof (struct expression)
-              + EXP_ELEM_TO_BYTES (ps->expout_ptr));
+  expout->nelts = expout_ptr;
+  expout.reset (XRESIZEVAR (expression, expout.release (),
+                           (sizeof (expression)
+                            + EXP_ELEM_TO_BYTES (expout_ptr))));
+
+  return std::move (expout);

 }
 
 /* This page contains the functions for adding data to the struct expression
 }
 
 /* This page contains the functions for adding data to the struct expression


@@ -223,20 +197,20 @@ reallocate_expout (struct parser_state *ps)
    a register through here.  */
 
 static void
    a register through here.  */
 
 static void

-write_exp_elt (struct parser_state *ps, const union exp_element *expelt)
+write_exp_elt (struct expr_builder *ps, const union exp_element *expelt)

 {
   if (ps->expout_ptr >= ps->expout_size)
     {
       ps->expout_size *= 2;
 {
   if (ps->expout_ptr >= ps->expout_size)
     {
       ps->expout_size *= 2;

-      ps->expout = (struct expression *)
-       xrealloc (ps->expout, sizeof (struct expression)
-                 + EXP_ELEM_TO_BYTES (ps->expout_size));
+      ps->expout.reset (XRESIZEVAR (expression, ps->expout.release (),
+                                   (sizeof (expression)
+                                    + EXP_ELEM_TO_BYTES (ps->expout_size))));

     }
   ps->expout->elts[ps->expout_ptr++] = *expelt;
 }
 
 void
     }
   ps->expout->elts[ps->expout_ptr++] = *expelt;
 }
 
 void

-write_exp_elt_opcode (struct parser_state *ps, enum exp_opcode expelt)
+write_exp_elt_opcode (struct expr_builder *ps, enum exp_opcode expelt)

 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 


@@ -246,7 +220,7 @@ write_exp_elt_opcode (struct parser_state *ps, enum exp_opcode expelt)
 }
 
 void
 }
 
 void

-write_exp_elt_sym (struct parser_state *ps, struct symbol *expelt)
+write_exp_elt_sym (struct expr_builder *ps, struct symbol *expelt)

 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 


@@ -256,7 +230,7 @@ write_exp_elt_sym (struct parser_state *ps, struct symbol *expelt)
 }
 
 void
 }
 
 void

-write_exp_elt_msym (struct parser_state *ps, minimal_symbol *expelt)
+write_exp_elt_msym (struct expr_builder *ps, minimal_symbol *expelt)

 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 


@@ -266,7 +240,7 @@ write_exp_elt_msym (struct parser_state *ps, minimal_symbol *expelt)
 }
 
 void
 }
 
 void

-write_exp_elt_block (struct parser_state *ps, const struct block *b)
+write_exp_elt_block (struct expr_builder *ps, const struct block *b)

 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 


@@ -276,7 +250,7 @@ write_exp_elt_block (struct parser_state *ps, const struct block *b)
 }
 
 void
 }
 
 void

-write_exp_elt_objfile (struct parser_state *ps, struct objfile *objfile)
+write_exp_elt_objfile (struct expr_builder *ps, struct objfile *objfile)

 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 


@@ -286,7 +260,7 @@ write_exp_elt_objfile (struct parser_state *ps, struct objfile *objfile)
 }
 
 void
 }
 
 void

-write_exp_elt_longcst (struct parser_state *ps, LONGEST expelt)
+write_exp_elt_longcst (struct expr_builder *ps, LONGEST expelt)

 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 


@@ -296,29 +270,19 @@ write_exp_elt_longcst (struct parser_state *ps, LONGEST expelt)
 }
 
 void
 }
 
 void

-write_exp_elt_dblcst (struct parser_state *ps, DOUBLEST expelt)
-{
-  union exp_element tmp;
-
-  memset (&tmp, 0, sizeof (union exp_element));
-  tmp.doubleconst = expelt;
-  write_exp_elt (ps, &tmp);
-}
-
-void
-write_exp_elt_decfloatcst (struct parser_state *ps, gdb_byte expelt[16])
+write_exp_elt_floatcst (struct expr_builder *ps, const gdb_byte expelt[16])

 {
   union exp_element tmp;
   int index;
 
   for (index = 0; index < 16; index++)
 {
   union exp_element tmp;
   int index;
 
   for (index = 0; index < 16; index++)

-    tmp.decfloatconst[index] = expelt[index];
+    tmp.floatconst[index] = expelt[index];

 
   write_exp_elt (ps, &tmp);
 }
 
 void
 
   write_exp_elt (ps, &tmp);
 }
 
 void

-write_exp_elt_type (struct parser_state *ps, struct type *expelt)
+write_exp_elt_type (struct expr_builder *ps, struct type *expelt)

 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 


@@ -328,7 +292,7 @@ write_exp_elt_type (struct parser_state *ps, struct type *expelt)
 }
 
 void
 }
 
 void

-write_exp_elt_intern (struct parser_state *ps, struct internalvar *expelt)
+write_exp_elt_intern (struct expr_builder *ps, struct internalvar *expelt)

 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 


@@ -359,7 +323,7 @@ write_exp_elt_intern (struct parser_state *ps, struct internalvar *expelt)
 
 
 void
 
 
 void

-write_exp_string (struct parser_state *ps, struct stoken str)
+write_exp_string (struct expr_builder *ps, struct stoken str)

 {
   int len = str.length;
   size_t lenelt;
 {
   int len = str.length;
   size_t lenelt;


@@ -401,7 +365,7 @@ write_exp_string (struct parser_state *ps, struct stoken str)
    long constant, followed by the contents of the string.  */
 
 void
    long constant, followed by the contents of the string.  */
 
 void

-write_exp_string_vector (struct parser_state *ps, int type,
+write_exp_string_vector (struct expr_builder *ps, int type,

                         struct stoken_vector *vec)
 {
   int i, len;
                         struct stoken_vector *vec)
 {
   int i, len;


@@ -454,7 +418,7 @@ write_exp_string_vector (struct parser_state *ps, int type,
    either end of the bitstring.  */
 
 void
    either end of the bitstring.  */
 
 void

-write_exp_bitstring (struct parser_state *ps, struct stoken str)
+write_exp_bitstring (struct expr_builder *ps, struct stoken str)

 {
   int bits = str.length;       /* length in bits */
   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
 {
   int bits = str.length;       /* length in bits */
   int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;


@@ -490,42 +454,42 @@ find_minsym_type_and_address (minimal_symbol *msymbol,
                              CORE_ADDR *address_p)
 {
   bound_minimal_symbol bound_msym = {msymbol, objfile};
                              CORE_ADDR *address_p)
 {
   bound_minimal_symbol bound_msym = {msymbol, objfile};

-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
-  CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);

   struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
   struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);

-  CORE_ADDR pc;
+
+  bool is_tls = (section != NULL
+                && section->the_bfd_section->flags & SEC_THREAD_LOCAL);

 
   /* The minimal symbol might point to a function descriptor;
      resolve it to the actual code address instead.  */
 
   /* The minimal symbol might point to a function descriptor;
      resolve it to the actual code address instead.  */

-  pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
-  if (pc != addr)
+  CORE_ADDR addr;
+  if (is_tls)

     {
     {

-      struct bound_minimal_symbol ifunc_msym = lookup_minimal_symbol_by_pc (pc);
-
-      /* In this case, assume we have a code symbol instead of
-        a data symbol.  */
-
-      if (ifunc_msym.minsym != NULL
-         && MSYMBOL_TYPE (ifunc_msym.minsym) == mst_text_gnu_ifunc
-         && BMSYMBOL_VALUE_ADDRESS (ifunc_msym) == pc)
+      /* Addresses of TLS symbols are really offsets into a
+        per-objfile/per-thread storage block.  */
+      addr = MSYMBOL_VALUE_RAW_ADDRESS (bound_msym.minsym);
+    }
+  else if (msymbol_is_function (objfile, msymbol, &addr))
+    {
+      if (addr != BMSYMBOL_VALUE_ADDRESS (bound_msym))

        {
        {

-         /* A function descriptor has been resolved but PC is still in the
-            STT_GNU_IFUNC resolver body (such as because inferior does not
-            run to be able to call it).  */
-
-         type = mst_text_gnu_ifunc;
+         /* This means we resolved a function descriptor, and we now
+            have an address for a code/text symbol instead of a data
+            symbol.  */
+         if (MSYMBOL_TYPE (msymbol) == mst_data_gnu_ifunc)
+           type = mst_text_gnu_ifunc;
+         else
+           type = mst_text;
+         section = NULL;

        }
        }

-      else
-       type = mst_text;
-      section = NULL;
-      addr = pc;

     }
     }

+  else
+    addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);

 
   if (overlay_debugging)
     addr = symbol_overlayed_address (addr, section);
 
 
   if (overlay_debugging)
     addr = symbol_overlayed_address (addr, section);
 

-  if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
+  if (is_tls)

     {
       /* Skip translation if caller does not need the address.  */
       if (address_p != NULL)
     {
       /* Skip translation if caller does not need the address.  */
       if (address_p != NULL)


@@ -536,8 +500,6 @@ find_minsym_type_and_address (minimal_symbol *msymbol,
   if (address_p != NULL)
     *address_p = addr;
 
   if (address_p != NULL)
     *address_p = addr;
 

-  struct type *the_type;
-

   switch (type)
     {
     case mst_text:
   switch (type)
     {
     case mst_text:


@@ -566,7 +528,7 @@ find_minsym_type_and_address (minimal_symbol *msymbol,
    the expression.  */
 
 void
    the expression.  */
 
 void

-write_exp_msymbol (struct parser_state *ps,
+write_exp_msymbol (struct expr_builder *ps,

                   struct bound_minimal_symbol bound_msym)
 {
   write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
                   struct bound_minimal_symbol bound_msym)
 {
   write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);


@@ -579,7 +541,7 @@ write_exp_msymbol (struct parser_state *ps,
    expression.  This is used when completing on field names.  */
 
 void
    expression.  This is used when completing on field names.  */
 
 void

-mark_struct_expression (struct parser_state *ps)
+mark_struct_expression (struct expr_builder *ps)

 {
   gdb_assert (parse_completion
              && expout_tag_completion_type == TYPE_CODE_UNDEF);
 {
   gdb_assert (parse_completion
              && expout_tag_completion_type == TYPE_CODE_UNDEF);


@@ -601,9 +563,7 @@ mark_completion_tag (enum type_code tag, const char *ptr, int length)
              || tag == TYPE_CODE_STRUCT
              || tag == TYPE_CODE_ENUM);
   expout_tag_completion_type = tag;
              || tag == TYPE_CODE_STRUCT
              || tag == TYPE_CODE_ENUM);
   expout_tag_completion_type = tag;

-  expout_completion_name = (char *) xmalloc (length + 1);
-  memcpy (expout_completion_name, ptr, length);
-  expout_completion_name[length] = '\0';
+  expout_completion_name.reset (xstrndup (ptr, length));

 }
 
 \f
 }
 
 \f


@@ -667,7 +627,7 @@ write_dollar_variable (struct parser_state *ps, struct stoken str)
 
   /* Handle tokens that refer to machine registers:
      $ followed by a register name.  */
 
   /* Handle tokens that refer to machine registers:
      $ followed by a register name.  */

-  i = user_reg_map_name_to_regnum (parse_gdbarch (ps),
+  i = user_reg_map_name_to_regnum (ps->gdbarch (),

                                   str.ptr + 1, str.length - 1);
   if (i >= 0)
     goto handle_register;
                                   str.ptr + 1, str.length - 1);
   if (i >= 0)
     goto handle_register;


@@ -686,8 +646,7 @@ write_dollar_variable (struct parser_state *ps, struct stoken str)
   /* On some systems, such as HP-UX and hppa-linux, certain system routines 
      have names beginning with $ or $$.  Check for those, first.  */
 
   /* On some systems, such as HP-UX and hppa-linux, certain system routines 
      have names beginning with $ or $$.  Check for those, first.  */
 

-  sym = lookup_symbol (copy_name (str), (struct block *) NULL,
-                      VAR_DOMAIN, NULL);
+  sym = lookup_symbol (copy_name (str), NULL, VAR_DOMAIN, NULL);

   if (sym.symbol)
     {
       write_exp_elt_opcode (ps, OP_VAR_VALUE);
   if (sym.symbol)
     {
       write_exp_elt_opcode (ps, OP_VAR_VALUE);


@@ -720,6 +679,8 @@ handle_register:
   str.ptr++;
   write_exp_string (ps, str);
   write_exp_elt_opcode (ps, OP_REGISTER);
   str.ptr++;
   write_exp_string (ps, str);
   write_exp_elt_opcode (ps, OP_REGISTER);

+  innermost_block.update (ps->expression_context_block,
+                         INNERMOST_BLOCK_FOR_REGISTERS);

   return;
 }
 
   return;
 }
 


@@ -826,6 +787,7 @@ copy_name (struct stoken token)
 int
 prefixify_expression (struct expression *expr)
 {
 int
 prefixify_expression (struct expression *expr)
 {

+  gdb_assert (expr->nelts > 0);

   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
   struct expression *temp;
   int inpos = expr->nelts, outpos = 0;
   int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
   struct expression *temp;
   int inpos = expr->nelts, outpos = 0;


@@ -894,13 +856,18 @@ operator_length_standard (const struct expression *expr, int endpos,
       break;
 
     case OP_LONG:
       break;
 
     case OP_LONG:

-    case OP_DOUBLE:
-    case OP_DECFLOAT:
+    case OP_FLOAT:

     case OP_VAR_VALUE:
     case OP_VAR_MSYM_VALUE:
       oplen = 4;
       break;
 
     case OP_VAR_VALUE:
     case OP_VAR_MSYM_VALUE:
       oplen = 4;
       break;
 

+    case OP_FUNC_STATIC_VAR:
+      oplen = longest_to_int (expr->elts[endpos - 2].longconst);
+      oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
+      args = 1;
+      break;
+

     case OP_TYPE:
     case OP_BOOL:
     case OP_LAST:
     case OP_TYPE:
     case OP_BOOL:
     case OP_LAST:


@@ -921,7 +888,7 @@ operator_length_standard (const struct expression *expr, int endpos,
       break;
 
     case TYPE_INSTANCE:
       break;
 
     case TYPE_INSTANCE:

-      oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
+      oplen = 5 + longest_to_int (expr->elts[endpos - 2].longconst);

       args = 1;
       break;
 
       args = 1;
       break;
 


@@ -950,16 +917,12 @@ operator_length_standard (const struct expression *expr, int endpos,
       args = 1;
       break;
 
       args = 1;
       break;
 

-    case UNOP_MEMVAL_TLS:
-      oplen = 4;
-      args = 1;
-      break;
-

     case UNOP_ABS:
     case UNOP_CAP:
     case UNOP_CHR:
     case UNOP_FLOAT:
     case UNOP_HIGH:
     case UNOP_ABS:
     case UNOP_CAP:
     case UNOP_CHR:
     case UNOP_FLOAT:
     case UNOP_HIGH:

+    case UNOP_KIND:

     case UNOP_ODD:
     case UNOP_ORD:
     case UNOP_TRUNC:
     case UNOP_ODD:
     case UNOP_ORD:
     case UNOP_TRUNC:


@@ -1028,6 +991,7 @@ operator_length_standard (const struct expression *expr, int endpos,
       switch (range_type)
        {
        case LOW_BOUND_DEFAULT:
       switch (range_type)
        {
        case LOW_BOUND_DEFAULT:

+       case LOW_BOUND_DEFAULT_EXCLUSIVE:

        case HIGH_BOUND_DEFAULT:
          args = 1;
          break;
        case HIGH_BOUND_DEFAULT:
          args = 1;
          break;


@@ -1035,6 +999,7 @@ operator_length_standard (const struct expression *expr, int endpos,
          args = 0;
          break;
        case NONE_BOUND_DEFAULT:
          args = 0;
          break;
        case NONE_BOUND_DEFAULT:

+       case NONE_BOUND_DEFAULT_EXCLUSIVE:

          args = 2;
          break;
        }
          args = 2;
          break;
        }


@@ -1125,18 +1090,10 @@ prefixify_subexp (struct expression *inexpr,
 
 expression_up
 parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,
 
 expression_up
 parse_exp_1 (const char **stringptr, CORE_ADDR pc, const struct block *block,

-            int comma)
-{
-  return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL);
-}
-
-static expression_up
-parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
-                     const struct block *block,
-                     int comma, int void_context_p, int *out_subexp)
+            int comma, innermost_block_tracker_types tracker_types)

 {
 {

-  return parse_exp_in_context_1 (stringptr, pc, block, comma,
-                                void_context_p, out_subexp);
+  return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL,
+                              tracker_types);

 }
 
 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
 }
 
 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then


@@ -1147,40 +1104,38 @@ parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
    is left untouched.  */
 
 static expression_up
    is left untouched.  */
 
 static expression_up

-parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
-                       const struct block *block,
-                       int comma, int void_context_p, int *out_subexp)
+parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
+                     const struct block *block,
+                     int comma, int void_context_p, int *out_subexp,
+                     innermost_block_tracker_types tracker_types)

 {
 {

-  struct cleanup *old_chain;

   const struct language_defn *lang = NULL;
   const struct language_defn *lang = NULL;

-  struct parser_state ps;

   int subexp;
 
   lexptr = *stringptr;
   prev_lexptr = NULL;
 
   int subexp;
 
   lexptr = *stringptr;
   prev_lexptr = NULL;
 

-  paren_depth = 0;
-  type_stack.depth = 0;
+  type_stack.elements.clear ();

   expout_last_struct = -1;
   expout_tag_completion_type = TYPE_CODE_UNDEF;
   expout_last_struct = -1;
   expout_tag_completion_type = TYPE_CODE_UNDEF;

-  xfree (expout_completion_name);
-  expout_completion_name = NULL;
-
-  comma_terminates = comma;
+  expout_completion_name.reset ();
+  innermost_block.reset (tracker_types);

 
   if (lexptr == 0 || *lexptr == 0)
     error_no_arg (_("expression to compute"));
 
 
   if (lexptr == 0 || *lexptr == 0)
     error_no_arg (_("expression to compute"));
 

-  old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
-  funcall_chain = 0;
+  std::vector<int> funcalls;
+  scoped_restore save_funcall_chain = make_scoped_restore (&funcall_chain,
+                                                          &funcalls);

 
 

-  expression_context_block = block;
+  const struct block *expression_context_block = block;
+  CORE_ADDR expression_context_pc = 0;

 
   /* If no context specified, try using the current frame, if any.  */
   if (!expression_context_block)
     expression_context_block = get_selected_block (&expression_context_pc);
   else if (pc == 0)
 
   /* If no context specified, try using the current frame, if any.  */
   if (!expression_context_block)
     expression_context_block = get_selected_block (&expression_context_pc);
   else if (pc == 0)

-    expression_context_pc = BLOCK_START (expression_context_block);
+    expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);

   else
     expression_context_pc = pc;
 
   else
     expression_context_pc = pc;
 


@@ -1194,7 +1149,7 @@ parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
          = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
                               STATIC_BLOCK);
       if (expression_context_block)
          = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (cursal.symtab),
                               STATIC_BLOCK);
       if (expression_context_block)

-       expression_context_pc = BLOCK_START (expression_context_block);
+       expression_context_pc = BLOCK_ENTRY_PC (expression_context_block);

     }
 
   if (language_mode == language_mode_auto && block != NULL)
     }
 
   if (language_mode == language_mode_auto && block != NULL)


@@ -1228,48 +1183,48 @@ parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
      and others called from *.y) ensure CURRENT_LANGUAGE gets restored
      to the value matching SELECTED_FRAME as set by get_current_arch.  */
 
      and others called from *.y) ensure CURRENT_LANGUAGE gets restored
      to the value matching SELECTED_FRAME as set by get_current_arch.  */
 

-  initialize_expout (&ps, 10, lang, get_current_arch ());
+  parser_state ps (lang, get_current_arch (), expression_context_block,
+                  expression_context_pc, comma);

 
   scoped_restore_current_language lang_saver;
   set_language (lang->la_language);
 
   TRY
     {
 
   scoped_restore_current_language lang_saver;
   set_language (lang->la_language);
 
   TRY
     {

-      if (lang->la_parser (&ps))
-        lang->la_error (NULL);
+      lang->la_parser (&ps);

     }
   CATCH (except, RETURN_MASK_ALL)
     {
     }
   CATCH (except, RETURN_MASK_ALL)
     {

-      if (! parse_completion)
-       {
-         xfree (ps.expout);
-         throw_exception (except);
-       }
+      /* If parsing for completion, allow this to succeed; but if no
+        expression elements have been written, then there's nothing
+        to do, so fail.  */
+      if (! parse_completion || ps.expout_ptr == 0)
+       throw_exception (except);

     }
   END_CATCH
 
     }
   END_CATCH
 

-  reallocate_expout (&ps);
+  /* We have to operate on an "expression *", due to la_post_parser,
+     which explains this funny-looking double release.  */
+  expression_up result = ps.release ();

 
   /* Convert expression from postfix form as generated by yacc
      parser, to a prefix form.  */
 
   if (expressiondebug)
 
   /* Convert expression from postfix form as generated by yacc
      parser, to a prefix form.  */
 
   if (expressiondebug)

-    dump_raw_expression (ps.expout, gdb_stdlog,
+    dump_raw_expression (result.get (), gdb_stdlog,

                         "before conversion to prefix form");
 
                         "before conversion to prefix form");
 

-  subexp = prefixify_expression (ps.expout);
+  subexp = prefixify_expression (result.get ());

   if (out_subexp)
     *out_subexp = subexp;
 
   if (out_subexp)
     *out_subexp = subexp;
 

-  lang->la_post_parser (&ps.expout, void_context_p);
+  lang->la_post_parser (&result, void_context_p);

 
   if (expressiondebug)
 
   if (expressiondebug)

-    dump_prefix_expression (ps.expout, gdb_stdlog);
-
-  discard_cleanups (old_chain);
+    dump_prefix_expression (result.get (), gdb_stdlog);

 
   *stringptr = lexptr;
 
   *stringptr = lexptr;

-  return expression_up (ps.expout);
+  return result;

 }
 
 /* Parse STRING as an expression, and complain if this fails
 }
 
 /* Parse STRING as an expression, and complain if this fails


@@ -1305,11 +1260,11 @@ parse_expression_with_language (const char *string, enum language lang)
    reference; furthermore, if the parsing ends in the field name,
    return the field name in *NAME.  If the parsing ends in the middle
    of a field reference, but the reference is somehow invalid, throw
    reference; furthermore, if the parsing ends in the field name,
    return the field name in *NAME.  If the parsing ends in the middle
    of a field reference, but the reference is somehow invalid, throw

-   an exception.  In all other cases, return NULL.  Returned non-NULL
-   *NAME must be freed by the caller.  */
+   an exception.  In all other cases, return NULL.  */

 
 struct type *
 
 struct type *

-parse_expression_for_completion (const char *string, char **name,
+parse_expression_for_completion (const char *string,
+                                gdb::unique_xmalloc_ptr<char> *name,

                                 enum type_code *code)
 {
   expression_up exp;
                                 enum type_code *code)
 {
   expression_up exp;


@@ -1319,7 +1274,8 @@ parse_expression_for_completion (const char *string, char **name,
   TRY
     {
       parse_completion = 1;
   TRY
     {
       parse_completion = 1;

-      exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
+      exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp,
+                                 INNERMOST_BLOCK_FOR_SYMBOLS);

     }
   CATCH (except, RETURN_MASK_ERROR)
     {
     }
   CATCH (except, RETURN_MASK_ERROR)
     {


@@ -1334,23 +1290,24 @@ parse_expression_for_completion (const char *string, char **name,
   if (expout_tag_completion_type != TYPE_CODE_UNDEF)
     {
       *code = expout_tag_completion_type;
   if (expout_tag_completion_type != TYPE_CODE_UNDEF)
     {
       *code = expout_tag_completion_type;

-      *name = expout_completion_name;
-      expout_completion_name = NULL;
+      *name = std::move (expout_completion_name);

       return NULL;
     }
 
   if (expout_last_struct == -1)
     return NULL;
 
       return NULL;
     }
 
   if (expout_last_struct == -1)
     return NULL;
 

-  *name = extract_field_op (exp.get (), &subexp);
-  if (!*name)
-    return NULL;
+  const char *fieldname = extract_field_op (exp.get (), &subexp);
+  if (fieldname == NULL)
+    {
+      name->reset ();
+      return NULL;
+    }

 
 

+  name->reset (xstrdup (fieldname));

   /* This might throw an exception.  If so, we want to let it
      propagate.  */
   val = evaluate_subexpression_type (exp.get (), subexp);
   /* This might throw an exception.  If so, we want to let it
      propagate.  */
   val = evaluate_subexpression_type (exp.get (), subexp);

-  /* (*NAME) is a part of the EXP memory block freed below.  */
-  *name = xstrdup (*name);

 
   return value_type (val);
 }
 
   return value_type (val);
 }


@@ -1358,102 +1315,27 @@ parse_expression_for_completion (const char *string, char **name,
 /* A post-parser that does nothing.  */
 
 void
 /* A post-parser that does nothing.  */
 
 void

-null_post_parser (struct expression **exp, int void_context_p)
+null_post_parser (expression_up *exp, int void_context_p)

 {
 }
 
 /* Parse floating point value P of length LEN.
 {
 }
 
 /* Parse floating point value P of length LEN.

-   Return 0 (false) if invalid, 1 (true) if valid.
-   The successfully parsed number is stored in D.
-   *SUFFIX points to the suffix of the number in P.
+   Return false if invalid, true if valid.
+   The successfully parsed number is stored in DATA in
+   target format for floating-point type TYPE.

 
    NOTE: This accepts the floating point syntax that sscanf accepts.  */
 
 
    NOTE: This accepts the floating point syntax that sscanf accepts.  */
 

-int
-parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
+bool
+parse_float (const char *p, int len,
+            const struct type *type, gdb_byte *data)

 {
 {

-  char *copy;
-  int n, num;
-
-  copy = (char *) xmalloc (len + 1);
-  memcpy (copy, p, len);
-  copy[len] = 0;
-
-  num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
-  xfree (copy);
-
-  /* The sscanf man page suggests not making any assumptions on the effect
-     of %n on the result, so we don't.
-     That is why we simply test num == 0.  */
-  if (num == 0)
-    return 0;
-
-  *suffix = p + n;
-  return 1;
-}
-
-/* Parse floating point value P of length LEN, using the C syntax for floats.
-   Return 0 (false) if invalid, 1 (true) if valid.
-   The successfully parsed number is stored in *D.
-   Its type is taken from builtin_type (gdbarch) and is stored in *T.  */
-
-int
-parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
-              DOUBLEST *d, struct type **t)
-{
-  const char *suffix;
-  int suffix_len;
-  const struct builtin_type *builtin_types = builtin_type (gdbarch);
-
-  if (! parse_float (p, len, d, &suffix))
-    return 0;
-
-  suffix_len = p + len - suffix;
-
-  if (suffix_len == 0)
-    *t = builtin_types->builtin_double;
-  else if (suffix_len == 1)
-    {
-      /* Handle suffixes: 'f' for float, 'l' for long double.  */
-      if (tolower (*suffix) == 'f')
-       *t = builtin_types->builtin_float;
-      else if (tolower (*suffix) == 'l')
-       *t = builtin_types->builtin_long_double;
-      else
-       return 0;
-    }
-  else
-    return 0;
-
-  return 1;
+  return target_float_from_string (data, type, std::string (p, len));

 }
 \f
 /* Stuff for maintaining a stack of types.  Currently just used by C, but
    probably useful for any language which declares its types "backwards".  */
 
 }
 \f
 /* Stuff for maintaining a stack of types.  Currently just used by C, but
    probably useful for any language which declares its types "backwards".  */
 

-/* Ensure that there are HOWMUCH open slots on the type stack STACK.  */
-
-static void
-type_stack_reserve (struct type_stack *stack, int howmuch)
-{
-  if (stack->depth + howmuch >= stack->size)
-    {
-      stack->size *= 2;
-      if (stack->size < howmuch)
-       stack->size = howmuch;
-      stack->elements = XRESIZEVEC (union type_stack_elt, stack->elements,
-                                   stack->size);
-    }
-}
-
-/* Ensure that there is a single open slot in the global type stack.  */
-
-static void
-check_type_stack_depth (void)
-{
-  type_stack_reserve (&type_stack, 1);
-}
-

 /* A helper function for insert_type and insert_type_address_space.
    This does work of expanding the type stack and inserting the new
    element, ELEMENT, into the stack at location SLOT.  */
 /* A helper function for insert_type and insert_type_address_space.
    This does work of expanding the type stack and inserting the new
    element, ELEMENT, into the stack at location SLOT.  */


@@ -1461,13 +1343,8 @@ check_type_stack_depth (void)
 static void
 insert_into_type_stack (int slot, union type_stack_elt element)
 {
 static void
 insert_into_type_stack (int slot, union type_stack_elt element)
 {

-  check_type_stack_depth ();
-
-  if (slot < type_stack.depth)
-    memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot],
-            (type_stack.depth - slot) * sizeof (union type_stack_elt));
-  type_stack.elements[slot] = element;
-  ++type_stack.depth;
+  gdb_assert (slot <= type_stack.elements.size ());
+  type_stack.elements.insert (type_stack.elements.begin () + slot, element);

 }
 
 /* Insert a new type, TP, at the bottom of the type stack.  If TP is
 }
 
 /* Insert a new type, TP, at the bottom of the type stack.  If TP is


@@ -1489,7 +1366,7 @@ insert_type (enum type_pieces tp)
   /* If there is anything on the stack (we know it will be a
      tp_pointer), insert the qualifier above it.  Otherwise, simply
      push this on the top of the stack.  */
   /* If there is anything on the stack (we know it will be a
      tp_pointer), insert the qualifier above it.  Otherwise, simply
      push this on the top of the stack.  */

-  if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
+  if (!type_stack.elements.empty () && (tp == tp_const || tp == tp_volatile))

     slot = 1;
   else
     slot = 0;
     slot = 1;
   else
     slot = 0;


@@ -1501,15 +1378,17 @@ insert_type (enum type_pieces tp)
 void
 push_type (enum type_pieces tp)
 {
 void
 push_type (enum type_pieces tp)
 {

-  check_type_stack_depth ();
-  type_stack.elements[type_stack.depth++].piece = tp;
+  type_stack_elt elt;
+  elt.piece = tp;
+  type_stack.elements.push_back (elt);

 }
 
 void
 push_type_int (int n)
 {
 }
 
 void
 push_type_int (int n)
 {

-  check_type_stack_depth ();
-  type_stack.elements[type_stack.depth++].int_val = n;
+  type_stack_elt elt;
+  elt.int_val = n;
+  type_stack.elements.push_back (elt);

 }
 
 /* Insert a tp_space_identifier and the corresponding address space
 }
 
 /* Insert a tp_space_identifier and the corresponding address space


@@ -1521,7 +1400,7 @@ push_type_int (int n)
    item.  */
 
 void
    item.  */
 
 void

-insert_type_address_space (struct parser_state *pstate, char *string)
+insert_type_address_space (struct expr_builder *pstate, char *string)

 {
   union type_stack_elt element;
   int slot;
 {
   union type_stack_elt element;
   int slot;


@@ -1529,14 +1408,14 @@ insert_type_address_space (struct parser_state *pstate, char *string)
   /* If there is anything on the stack (we know it will be a
      tp_pointer), insert the address space qualifier above it.
      Otherwise, simply push this on the top of the stack.  */
   /* If there is anything on the stack (we know it will be a
      tp_pointer), insert the address space qualifier above it.
      Otherwise, simply push this on the top of the stack.  */

-  if (type_stack.depth)
+  if (!type_stack.elements.empty ())

     slot = 1;
   else
     slot = 0;
 
   element.piece = tp_space_identifier;
   insert_into_type_stack (slot, element);
     slot = 1;
   else
     slot = 0;
 
   element.piece = tp_space_identifier;
   insert_into_type_stack (slot, element);

-  element.int_val = address_space_name_to_int (parse_gdbarch (pstate),
+  element.int_val = address_space_name_to_int (pstate->gdbarch (),

                                               string);
   insert_into_type_stack (slot, element);
 }
                                               string);
   insert_into_type_stack (slot, element);
 }


@@ -1544,27 +1423,37 @@ insert_type_address_space (struct parser_state *pstate, char *string)
 enum type_pieces
 pop_type (void)
 {
 enum type_pieces
 pop_type (void)
 {

-  if (type_stack.depth)
-    return type_stack.elements[--type_stack.depth].piece;
+  if (!type_stack.elements.empty ())
+    {
+      type_stack_elt elt = type_stack.elements.back ();
+      type_stack.elements.pop_back ();
+      return elt.piece;
+    }

   return tp_end;
 }
 
 int
 pop_type_int (void)
 {
   return tp_end;
 }
 
 int
 pop_type_int (void)
 {

-  if (type_stack.depth)
-    return type_stack.elements[--type_stack.depth].int_val;
+  if (!type_stack.elements.empty ())
+    {
+      type_stack_elt elt = type_stack.elements.back ();
+      type_stack.elements.pop_back ();
+      return elt.int_val;
+    }

   /* "Can't happen".  */
   return 0;
 }
 
 /* Pop a type list element from the global type stack.  */
 
   /* "Can't happen".  */
   return 0;
 }
 
 /* Pop a type list element from the global type stack.  */
 

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

 pop_typelist (void)
 {
 pop_typelist (void)
 {

-  gdb_assert (type_stack.depth);
-  return type_stack.elements[--type_stack.depth].typelist_val;
+  gdb_assert (!type_stack.elements.empty ());
+  type_stack_elt elt = type_stack.elements.back ();
+  type_stack.elements.pop_back ();
+  return elt.typelist_val;

 }
 
 /* Pop a type_stack element from the global type stack.  */
 }
 
 /* Pop a type_stack element from the global type stack.  */


@@ -1572,8 +1461,10 @@ pop_typelist (void)
 static struct type_stack *
 pop_type_stack (void)
 {
 static struct type_stack *
 pop_type_stack (void)
 {

-  gdb_assert (type_stack.depth);
-  return type_stack.elements[--type_stack.depth].stack_val;
+  gdb_assert (!type_stack.elements.empty ());
+  type_stack_elt elt = type_stack.elements.back ();
+  type_stack.elements.pop_back ();
+  return elt.stack_val;

 }
 
 /* Append the elements of the type stack FROM to the type stack TO.
 }
 
 /* Append the elements of the type stack FROM to the type stack TO.


@@ -1582,12 +1473,8 @@ pop_type_stack (void)
 struct type_stack *
 append_type_stack (struct type_stack *to, struct type_stack *from)
 {
 struct type_stack *
 append_type_stack (struct type_stack *to, struct type_stack *from)
 {

-  type_stack_reserve (to, from->depth);
-
-  memcpy (&to->elements[to->depth], &from->elements[0],
-         from->depth * sizeof (union type_stack_elt));
-  to->depth += from->depth;
-
+  to->elements.insert (to->elements.end (), from->elements.begin (),
+                      from->elements.end ());

   return to;
 }
 
   return to;
 }
 


@@ -1596,51 +1483,64 @@ append_type_stack (struct type_stack *to, struct type_stack *from)
 void
 push_type_stack (struct type_stack *stack)
 {
 void
 push_type_stack (struct type_stack *stack)
 {

-  check_type_stack_depth ();
-  type_stack.elements[type_stack.depth++].stack_val = stack;
+  type_stack_elt elt;
+  elt.stack_val = stack;
+  type_stack.elements.push_back (elt);

   push_type (tp_type_stack);
 }
 
 /* Copy the global type stack into a newly allocated type stack and
    return it.  The global stack is cleared.  The returned type stack
   push_type (tp_type_stack);
 }
 
 /* Copy the global type stack into a newly allocated type stack and
    return it.  The global stack is cleared.  The returned type stack

-   must be freed with type_stack_cleanup.  */
+   must be freed with delete.  */

 
 struct type_stack *
 get_type_stack (void)
 {
 
 struct type_stack *
 get_type_stack (void)
 {

-  struct type_stack *result = XNEW (struct type_stack);
-
-  *result = type_stack;
-  type_stack.depth = 0;
-  type_stack.size = 0;
-  type_stack.elements = NULL;
-
+  struct type_stack *result = new struct type_stack (std::move (type_stack));
+  type_stack.elements.clear ();

   return result;
 }
 
   return result;
 }
 

-/* A cleanup function that destroys a single type stack.  */
-
-void
-type_stack_cleanup (void *arg)
-{
-  struct type_stack *stack = (struct type_stack *) arg;
-
-  xfree (stack->elements);
-  xfree (stack);
-}
-

 /* Push a function type with arguments onto the global type stack.
    LIST holds the argument types.  If the final item in LIST is NULL,
    then the function will be varargs.  */
 
 void
 /* Push a function type with arguments onto the global type stack.
    LIST holds the argument types.  If the final item in LIST is NULL,
    then the function will be varargs.  */
 
 void

-push_typelist (VEC (type_ptr) *list)
+push_typelist (std::vector<struct type *> *list)

 {
 {

-  check_type_stack_depth ();
-  type_stack.elements[type_stack.depth++].typelist_val = list;
+  type_stack_elt elt;
+  elt.typelist_val = list;
+  type_stack.elements.push_back (elt);

   push_type (tp_function_with_arguments);
 }
 
   push_type (tp_function_with_arguments);
 }
 

+/* Pop the type stack and return a type_instance_flags that
+   corresponds the const/volatile qualifiers on the stack.  This is
+   called by the C++ parser when parsing methods types, and as such no
+   other kind of type in the type stack is expected.  */
+
+type_instance_flags
+follow_type_instance_flags ()
+{
+  type_instance_flags flags = 0;
+
+  for (;;)
+    switch (pop_type ())
+      {
+      case tp_end:
+       return flags;
+      case tp_const:
+       flags |= TYPE_INSTANCE_FLAG_CONST;
+       break;
+      case tp_volatile:
+       flags |= TYPE_INSTANCE_FLAG_VOLATILE;
+       break;
+      default:
+       gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
+      }
+}
+
+

 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
    as modified by all the stuff on the stack.  */
 struct type *
 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
    as modified by all the stuff on the stack.  */
 struct type *


@@ -1735,14 +1635,12 @@ follow_types (struct type *follow_type)
 
       case tp_function_with_arguments:
        {
 
       case tp_function_with_arguments:
        {

-         VEC (type_ptr) *args = pop_typelist ();
+         std::vector<struct type *> *args = pop_typelist ();

 
          follow_type
            = lookup_function_type_with_arguments (follow_type,
 
          follow_type
            = lookup_function_type_with_arguments (follow_type,

-                                                  VEC_length (type_ptr, args),
-                                                  VEC_address (type_ptr,
-                                                               args));
-         VEC_free (type_ptr, args);
+                                                  args->size (),
+                                                  args->data ());

        }
        break;
 
        }
        break;
 


@@ -1755,7 +1653,7 @@ follow_types (struct type *follow_type)
 
          type_stack = *stack;
          follow_type = follow_types (follow_type);
 
          type_stack = *stack;
          follow_type = follow_types (follow_type);

-         gdb_assert (type_stack.depth == 0);
+         gdb_assert (type_stack.elements.empty ());

 
          type_stack = save;
        }
 
          type_stack = save;
        }


@@ -1806,8 +1704,7 @@ operator_check_standard (struct expression *exp, int pos,
     {
     case BINOP_VAL:
     case OP_COMPLEX:
     {
     case BINOP_VAL:
     case OP_COMPLEX:

-    case OP_DECFLOAT:
-    case OP_DOUBLE:
+    case OP_FLOAT:

     case OP_LONG:
     case OP_SCOPE:
     case OP_TYPE:
     case OP_LONG:
     case OP_SCOPE:
     case OP_TYPE:


@@ -1820,24 +1717,19 @@ operator_check_standard (struct expression *exp, int pos,
 
     case TYPE_INSTANCE:
       {
 
     case TYPE_INSTANCE:
       {

-       LONGEST arg, nargs = elts[pos + 1].longconst;
+       LONGEST arg, nargs = elts[pos + 2].longconst;

 
        for (arg = 0; arg < nargs; arg++)
          {
 
        for (arg = 0; arg < nargs; arg++)
          {

-           struct type *type = elts[pos + 2 + arg].type;
-           struct objfile *objfile = TYPE_OBJFILE (type);
+           struct type *inst_type = elts[pos + 3 + arg].type;
+           struct objfile *inst_objfile = TYPE_OBJFILE (inst_type);

 
 

-           if (objfile && (*objfile_func) (objfile, data))
+           if (inst_objfile && (*objfile_func) (inst_objfile, data))

              return 1;
          }
       }
       break;
 
              return 1;
          }
       }
       break;
 

-    case UNOP_MEMVAL_TLS:
-      objfile = elts[pos + 1].objfile;
-      type = elts[pos + 2].type;
-      break;
-

     case OP_VAR_VALUE:
       {
        const struct block *const block = elts[pos + 1].block;
     case OP_VAR_VALUE:
       {
        const struct block *const block = elts[pos + 1].block;


@@ -1927,28 +1819,27 @@ exp_uses_objfile (struct expression *exp, struct objfile *objfile)
   return exp_iterate (exp, exp_uses_objfile_iter, objfile);
 }
 
   return exp_iterate (exp, exp_uses_objfile_iter, objfile);
 }
 

-/* See definition in parser-defs.h.  */
+/* Reallocate the `expout' pointer inside PS so that it can accommodate
+   at least LENELT expression elements.  This function does nothing if
+   there is enough room for the elements.  */

 
 

-void
-increase_expout_size (struct parser_state *ps, size_t lenelt)
+static void
+increase_expout_size (struct expr_builder *ps, size_t lenelt)

 {
   if ((ps->expout_ptr + lenelt) >= ps->expout_size)
     {
       ps->expout_size = std::max (ps->expout_size * 2,
 {
   if ((ps->expout_ptr + lenelt) >= ps->expout_size)
     {
       ps->expout_size = std::max (ps->expout_size * 2,

-                            ps->expout_ptr + lenelt + 10);
-      ps->expout = (struct expression *)
-       xrealloc (ps->expout, (sizeof (struct expression)
-                              + EXP_ELEM_TO_BYTES (ps->expout_size)));
+                                 ps->expout_ptr + lenelt + 10);
+      ps->expout.reset (XRESIZEVAR (expression,
+                                   ps->expout.release (),
+                                   (sizeof (struct expression)
+                                    + EXP_ELEM_TO_BYTES (ps->expout_size))));

     }
 }
 
 void
 _initialize_parse (void)
 {
     }
 }
 
 void
 _initialize_parse (void)
 {

-  type_stack.size = 0;
-  type_stack.depth = 0;
-  type_stack.elements = NULL;
-

   add_setshow_zuinteger_cmd ("expression", class_maintenance,
                             &expressiondebug,
                             _("Set expression debugging."),
   add_setshow_zuinteger_cmd ("expression", class_maintenance,
                             &expressiondebug,
                             _("Set expression debugging."),