don't let bin2hex call strlen
[deliverable/binutils-gdb.git] / gdb / parse.c
index 0d0467d9ce23cb7882b2de80b38e29eb873cf774..11712896c5632652d4aa25000f2301442c484309 100644 (file)
@@ -1,7 +1,6 @@
 /* Parse expressions for GDB.
 
 /* Parse expressions for GDB.
 
-   Copyright (C) 1986, 1989-2001, 2004-2005, 2007-2012 Free Software
-   Foundation, Inc.
+   Copyright (C) 1986-2014 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.
@@ -33,7 +32,7 @@
 #include "defs.h"
 #include <ctype.h>
 #include "arch-utils.h"
 #include "defs.h"
 #include <ctype.h>
 #include "arch-utils.h"
-#include "gdb_string.h"
+#include <string.h>
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "frame.h"
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "frame.h"
@@ -71,27 +70,32 @@ const struct exp_descriptor exp_descriptor_standard =
 struct expression *expout;
 int expout_size;
 int expout_ptr;
 struct expression *expout;
 int expout_size;
 int expout_ptr;
-struct block *expression_context_block;
+const struct block *expression_context_block;
 CORE_ADDR expression_context_pc;
 CORE_ADDR expression_context_pc;
-struct block *innermost_block;
+const struct block *innermost_block;
 int arglist_len;
 int arglist_len;
-union type_stack_elt *type_stack;
-int type_stack_depth, type_stack_size;
-char *lexptr;
-char *prev_lexptr;
+static struct type_stack type_stack;
+const char *lexptr;
+const char *prev_lexptr;
 int paren_depth;
 int comma_terminates;
 
 int paren_depth;
 int comma_terminates;
 
-/* True if parsing an expression to find a field reference.  This is
-   only used by completion.  */
-int in_parse_field;
+/* True if parsing an expression to attempt completion.  */
+int parse_completion;
 
 /* The index of the last struct expression directly before a '.' or
    '->'.  This is set when parsing and is only used when completing a
    field name.  It is -1 if no dereference operation was found.  */
 static int expout_last_struct = -1;
 
 /* The index of the last struct expression directly before a '.' or
    '->'.  This is set when parsing and is only used when completing a
    field name.  It is -1 if no dereference operation was found.  */
 static int expout_last_struct = -1;
+
+/* If we are completing a tagged type name, this will be nonzero.  */
+static enum type_code expout_tag_completion_type = TYPE_CODE_UNDEF;
+
+/* The token for tagged type name completion.  */
+static char *expout_completion_name;
+
 \f
 \f
-static int expressiondebug = 0;
+static unsigned int expressiondebug = 0;
 static void
 show_expressiondebug (struct ui_file *file, int from_tty,
                      struct cmd_list_element *c, const char *value)
 static void
 show_expressiondebug (struct ui_file *file, int from_tty,
                      struct cmd_list_element *c, const char *value)
@@ -116,8 +120,12 @@ static void free_funcalls (void *ignore);
 static int prefixify_subexp (struct expression *, struct expression *, int,
                             int);
 
 static int prefixify_subexp (struct expression *, struct expression *, int,
                             int);
 
-static struct expression *parse_exp_in_context (char **, struct block *, int, 
+static struct expression *parse_exp_in_context (const char **, CORE_ADDR,
+                                               const struct block *, int, 
                                                int, int *);
                                                int, int *);
+static struct expression *parse_exp_in_context_1 (const char **, CORE_ADDR,
+                                                 const struct block *, int,
+                                                 int, int *);
 
 void _initialize_parse (void);
 
 
 void _initialize_parse (void);
 
@@ -248,7 +256,7 @@ write_exp_elt_sym (struct symbol *expelt)
 }
 
 void
 }
 
 void
-write_exp_elt_block (struct block *b)
+write_exp_elt_block (const struct block *b)
 {
   union exp_element tmp;
 
 {
   union exp_element tmp;
 
@@ -488,13 +496,14 @@ write_exp_bitstring (struct stoken str)
    the expression.  */
 
 void
    the expression.  */
 
 void
-write_exp_msymbol (struct minimal_symbol *msymbol)
+write_exp_msymbol (struct bound_minimal_symbol bound_msym)
 {
 {
-  struct objfile *objfile = msymbol_objfile (msymbol);
+  struct minimal_symbol *msymbol = bound_msym.minsym;
+  struct objfile *objfile = bound_msym.objfile;
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 
   CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 
   CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
-  struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
+  struct obj_section *section = SYMBOL_OBJ_SECTION (objfile, msymbol);
   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
   CORE_ADDR pc;
 
   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
   CORE_ADDR pc;
 
@@ -503,13 +512,14 @@ write_exp_msymbol (struct minimal_symbol *msymbol)
   pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
   if (pc != addr)
     {
   pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
   if (pc != addr)
     {
-      struct minimal_symbol *ifunc_msym = lookup_minimal_symbol_by_pc (pc);
+      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.  */
 
 
       /* In this case, assume we have a code symbol instead of
         a data symbol.  */
 
-      if (ifunc_msym != NULL && MSYMBOL_TYPE (ifunc_msym) == mst_text_gnu_ifunc
-         && SYMBOL_VALUE_ADDRESS (ifunc_msym) == pc)
+      if (ifunc_msym.minsym != NULL
+         && MSYMBOL_TYPE (ifunc_msym.minsym) == mst_text_gnu_ifunc
+         && SYMBOL_VALUE_ADDRESS (ifunc_msym.minsym) == pc)
        {
          /* A function descriptor has been resolved but PC is still in the
             STT_GNU_IFUNC resolver body (such as because inferior does not
        {
          /* A function descriptor has been resolved but PC is still in the
             STT_GNU_IFUNC resolver body (such as because inferior does not
@@ -579,9 +589,32 @@ write_exp_msymbol (struct minimal_symbol *msymbol)
 void
 mark_struct_expression (void)
 {
 void
 mark_struct_expression (void)
 {
+  gdb_assert (parse_completion
+             && expout_tag_completion_type == TYPE_CODE_UNDEF);
   expout_last_struct = expout_ptr;
 }
 
   expout_last_struct = expout_ptr;
 }
 
+/* Indicate that the current parser invocation is completing a tag.
+   TAG is the type code of the tag, and PTR and LENGTH represent the
+   start of the tag name.  */
+
+void
+mark_completion_tag (enum type_code tag, const char *ptr, int length)
+{
+  gdb_assert (parse_completion
+             && expout_tag_completion_type == TYPE_CODE_UNDEF
+             && expout_completion_name == NULL
+             && expout_last_struct == -1);
+  gdb_assert (tag == TYPE_CODE_UNION
+             || tag == TYPE_CODE_STRUCT
+             || tag == TYPE_CODE_CLASS
+             || tag == TYPE_CODE_ENUM);
+  expout_tag_completion_type = tag;
+  expout_completion_name = xmalloc (length + 1);
+  memcpy (expout_completion_name, ptr, length);
+  expout_completion_name[length] = '\0';
+}
+
 \f
 /* Recognize tokens that start with '$'.  These include:
 
 \f
 /* Recognize tokens that start with '$'.  These include:
 
@@ -608,7 +641,7 @@ void
 write_dollar_variable (struct stoken str)
 {
   struct symbol *sym = NULL;
 write_dollar_variable (struct stoken str)
 {
   struct symbol *sym = NULL;
-  struct minimal_symbol *msym = NULL;
+  struct bound_minimal_symbol msym;
   struct internalvar *isym = NULL;
 
   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
   struct internalvar *isym = NULL;
 
   /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
@@ -663,7 +696,7 @@ write_dollar_variable (struct stoken str)
      have names beginning with $ or $$.  Check for those, first.  */
 
   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
      have names beginning with $ or $$.  Check for those, first.  */
 
   sym = lookup_symbol (copy_name (str), (struct block *) NULL,
-                      VAR_DOMAIN, (int *) NULL);
+                      VAR_DOMAIN, NULL);
   if (sym)
     {
       write_exp_elt_opcode (OP_VAR_VALUE);
   if (sym)
     {
       write_exp_elt_opcode (OP_VAR_VALUE);
@@ -672,8 +705,8 @@ write_dollar_variable (struct stoken str)
       write_exp_elt_opcode (OP_VAR_VALUE);
       return;
     }
       write_exp_elt_opcode (OP_VAR_VALUE);
       return;
     }
-  msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
-  if (msym)
+  msym = lookup_bound_minimal_symbol (copy_name (str));
+  if (msym.minsym)
     {
       write_exp_msymbol (msym);
       return;
     {
       write_exp_msymbol (msym);
       return;
@@ -700,8 +733,8 @@ handle_register:
 }
 
 
 }
 
 
-char *
-find_template_name_end (char *p)
+const char *
+find_template_name_end (const char *p)
 {
   int depth = 1;
   int just_seen_right = 0;
 {
   int depth = 1;
   int just_seen_right = 0;
@@ -910,10 +943,16 @@ operator_length_standard (const struct expression *expr, int endpos,
       oplen = 3;
       break;
 
       oplen = 3;
       break;
 
-    case BINOP_VAL:
-    case UNOP_CAST:
+    case UNOP_CAST_TYPE:
     case UNOP_DYNAMIC_CAST:
     case UNOP_REINTERPRET_CAST:
     case UNOP_DYNAMIC_CAST:
     case UNOP_REINTERPRET_CAST:
+    case UNOP_MEMVAL_TYPE:
+      oplen = 1;
+      args = 2;
+      break;
+
+    case BINOP_VAL:
+    case UNOP_CAST:
     case UNOP_MEMVAL:
       oplen = 3;
       args = 1;
     case UNOP_MEMVAL:
       oplen = 3;
       args = 1;
@@ -932,6 +971,9 @@ operator_length_standard (const struct expression *expr, int endpos,
     case UNOP_ODD:
     case UNOP_ORD:
     case UNOP_TRUNC:
     case UNOP_ODD:
     case UNOP_ORD:
     case UNOP_TRUNC:
+    case OP_TYPEOF:
+    case OP_DECLTYPE:
+    case OP_TYPEID:
       oplen = 1;
       args = 1;
       break;
       oplen = 1;
       args = 1;
       break;
@@ -943,7 +985,6 @@ operator_length_standard (const struct expression *expr, int endpos,
       oplen++;
       break;
 
       oplen++;
       break;
 
-    case OP_LABELED:
     case STRUCTOP_STRUCT:
     case STRUCTOP_PTR:
       args = 1;
     case STRUCTOP_STRUCT:
     case STRUCTOP_PTR:
       args = 1;
@@ -959,12 +1000,6 @@ operator_length_standard (const struct expression *expr, int endpos,
       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
       break;
 
       oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
       break;
 
-    case OP_BITSTRING:
-      oplen = longest_to_int (expr->elts[endpos - 2].longconst);
-      oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
-      oplen = 4 + BYTES_TO_EXP_ELEM (oplen);
-      break;
-
     case OP_ARRAY:
       oplen = 4;
       args = longest_to_int (expr->elts[endpos - 2].longconst);
     case OP_ARRAY:
       oplen = 4;
       args = longest_to_int (expr->elts[endpos - 2].longconst);
@@ -974,7 +1009,6 @@ operator_length_standard (const struct expression *expr, int endpos,
 
     case TERNOP_COND:
     case TERNOP_SLICE:
 
     case TERNOP_COND:
     case TERNOP_SLICE:
-    case TERNOP_SLICE_COUNT:
       args = 3;
       break;
 
       args = 3;
       break;
 
@@ -1097,9 +1131,19 @@ prefixify_subexp (struct expression *inexpr,
    If COMMA is nonzero, stop if a comma is reached.  */
 
 struct expression *
    If COMMA is nonzero, stop if a comma is reached.  */
 
 struct expression *
-parse_exp_1 (char **stringptr, struct block *block, int comma)
+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 struct expression *
+parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
+                     const struct block *block,
+                     int comma, int void_context_p, int *out_subexp)
 {
 {
-  return parse_exp_in_context (stringptr, block, comma, 0, NULL);
+  return parse_exp_in_context_1 (stringptr, pc, block, comma,
+                                void_context_p, out_subexp);
 }
 
 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
 }
 
 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then
@@ -1110,11 +1154,12 @@ parse_exp_1 (char **stringptr, struct block *block, int comma)
    is left untouched.  */
 
 static struct expression *
    is left untouched.  */
 
 static struct expression *
-parse_exp_in_context (char **stringptr, struct block *block, int comma, 
-                     int void_context_p, int *out_subexp)
+parse_exp_in_context_1 (const char **stringptr, CORE_ADDR pc,
+                       const struct block *block,
+                       int comma, int void_context_p, int *out_subexp)
 {
   volatile struct gdb_exception except;
 {
   volatile struct gdb_exception except;
-  struct cleanup *old_chain;
+  struct cleanup *old_chain, *inner_chain;
   const struct language_defn *lang = NULL;
   int subexp;
 
   const struct language_defn *lang = NULL;
   int subexp;
 
@@ -1122,8 +1167,11 @@ parse_exp_in_context (char **stringptr, struct block *block, int comma,
   prev_lexptr = NULL;
 
   paren_depth = 0;
   prev_lexptr = NULL;
 
   paren_depth = 0;
-  type_stack_depth = 0;
+  type_stack.depth = 0;
   expout_last_struct = -1;
   expout_last_struct = -1;
+  expout_tag_completion_type = TYPE_CODE_UNDEF;
+  xfree (expout_completion_name);
+  expout_completion_name = NULL;
 
   comma_terminates = comma;
 
 
   comma_terminates = comma;
 
@@ -1138,8 +1186,10 @@ parse_exp_in_context (char **stringptr, struct block *block, int comma,
   /* If no context specified, try using the current frame, if any.  */
   if (!expression_context_block)
     expression_context_block = get_selected_block (&expression_context_pc);
   /* 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
+  else if (pc == 0)
     expression_context_pc = BLOCK_START (expression_context_block);
     expression_context_pc = BLOCK_START (expression_context_block);
+  else
+    expression_context_pc = pc;
 
   /* Fall back to using the current source static context, if any.  */
 
 
   /* Fall back to using the current source static context, if any.  */
 
@@ -1179,7 +1229,13 @@ parse_exp_in_context (char **stringptr, struct block *block, int comma,
   else
     lang = current_language;
 
   else
     lang = current_language;
 
+  /* get_current_arch may reset CURRENT_LANGUAGE via select_frame.
+     While we need CURRENT_LANGUAGE to be set to LANG (for lookup_symbol
+     and others called from *.y) ensure CURRENT_LANGUAGE gets restored
+     to the value matching SELECTED_FRAME as set by get_current_arch.  */
   initialize_expout (10, lang, get_current_arch ());
   initialize_expout (10, lang, get_current_arch ());
+  inner_chain = make_cleanup_restore_current_language ();
+  set_language (lang->la_language);
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
@@ -1188,15 +1244,13 @@ parse_exp_in_context (char **stringptr, struct block *block, int comma,
     }
   if (except.reason < 0)
     {
     }
   if (except.reason < 0)
     {
-      if (! in_parse_field)
+      if (! parse_completion)
        {
          xfree (expout);
          throw_exception (except);
        }
     }
 
        {
          xfree (expout);
          throw_exception (except);
        }
     }
 
-  discard_cleanups (old_chain);
-
   reallocate_expout ();
 
   /* Convert expression from postfix form as generated by yacc
   reallocate_expout ();
 
   /* Convert expression from postfix form as generated by yacc
@@ -1215,6 +1269,9 @@ parse_exp_in_context (char **stringptr, struct block *block, int comma,
   if (expressiondebug)
     dump_prefix_expression (expout, gdb_stdlog);
 
   if (expressiondebug)
     dump_prefix_expression (expout, gdb_stdlog);
 
+  do_cleanups (inner_chain);
+  discard_cleanups (old_chain);
+
   *stringptr = lexptr;
   return expout;
 }
   *stringptr = lexptr;
   return expout;
 }
@@ -1223,11 +1280,11 @@ parse_exp_in_context (char **stringptr, struct block *block, int comma,
    to use up all of the contents of STRING.  */
 
 struct expression *
    to use up all of the contents of STRING.  */
 
 struct expression *
-parse_expression (char *string)
+parse_expression (const char *string)
 {
   struct expression *exp;
 
 {
   struct expression *exp;
 
-  exp = parse_exp_1 (&string, 0, 0);
+  exp = parse_exp_1 (&string, 0, 0, 0);
   if (*string)
     error (_("Junk after end of expression."));
   return exp;
   if (*string)
     error (_("Junk after end of expression."));
   return exp;
@@ -1242,7 +1299,8 @@ parse_expression (char *string)
    *NAME must be freed by the caller.  */
 
 struct type *
    *NAME must be freed by the caller.  */
 
 struct type *
-parse_field_expression (char *string, char **name)
+parse_expression_for_completion (const char *string, char **name,
+                                enum type_code *code)
 {
   struct expression *exp = NULL;
   struct value *val;
 {
   struct expression *exp = NULL;
   struct value *val;
@@ -1251,12 +1309,21 @@ parse_field_expression (char *string, char **name)
 
   TRY_CATCH (except, RETURN_MASK_ERROR)
     {
 
   TRY_CATCH (except, RETURN_MASK_ERROR)
     {
-      in_parse_field = 1;
-      exp = parse_exp_in_context (&string, 0, 0, 0, &subexp);
+      parse_completion = 1;
+      exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
     }
     }
-  in_parse_field = 0;
+  parse_completion = 0;
   if (except.reason < 0 || ! exp)
     return NULL;
   if (except.reason < 0 || ! exp)
     return NULL;
+
+  if (expout_tag_completion_type != TYPE_CODE_UNDEF)
+    {
+      *code = expout_tag_completion_type;
+      *name = expout_completion_name;
+      expout_completion_name = NULL;
+      return NULL;
+    }
+
   if (expout_last_struct == -1)
     {
       xfree (exp);
   if (expout_last_struct == -1)
     {
       xfree (exp);
@@ -1356,17 +1423,29 @@ parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
 /* Stuff for maintaining a stack of types.  Currently just used by C, but
    probably useful for any language which declares its types "backwards".  */
 
 /* 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
 static void
-check_type_stack_depth (void)
+type_stack_reserve (struct type_stack *stack, int howmuch)
 {
 {
-  if (type_stack_depth == type_stack_size)
+  if (stack->depth + howmuch >= stack->size)
     {
     {
-      type_stack_size *= 2;
-      type_stack = (union type_stack_elt *)
-       xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
+      stack->size *= 2;
+      if (stack->size < howmuch)
+       stack->size = howmuch;
+      stack->elements = xrealloc (stack->elements,
+                                 stack->size * sizeof (union type_stack_elt));
     }
 }
 
     }
 }
 
+/* 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.  */
@@ -1376,11 +1455,11 @@ insert_into_type_stack (int slot, union type_stack_elt element)
 {
   check_type_stack_depth ();
 
 {
   check_type_stack_depth ();
 
-  if (slot < type_stack_depth)
-    memmove (&type_stack[slot + 1], &type_stack[slot],
-            (type_stack_depth - slot) * sizeof (union type_stack_elt));
-  type_stack[slot] = element;
-  ++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;
 }
 
 /* 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
@@ -1401,7 +1480,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.depth && (tp == tp_const || tp == tp_volatile))
     slot = 1;
   else
     slot = 0;
     slot = 1;
   else
     slot = 0;
@@ -1414,14 +1493,14 @@ void
 push_type (enum type_pieces tp)
 {
   check_type_stack_depth ();
 push_type (enum type_pieces tp)
 {
   check_type_stack_depth ();
-  type_stack[type_stack_depth++].piece = tp;
+  type_stack.elements[type_stack.depth++].piece = tp;
 }
 
 void
 push_type_int (int n)
 {
   check_type_stack_depth ();
 }
 
 void
 push_type_int (int n)
 {
   check_type_stack_depth ();
-  type_stack[type_stack_depth++].int_val = n;
+  type_stack.elements[type_stack.depth++].int_val = n;
 }
 
 /* Insert a tp_space_identifier and the corresponding address space
 }
 
 /* Insert a tp_space_identifier and the corresponding address space
@@ -1441,7 +1520,7 @@ insert_type_address_space (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.depth)
     slot = 1;
   else
     slot = 0;
     slot = 1;
   else
     slot = 0;
@@ -1455,20 +1534,103 @@ insert_type_address_space (char *string)
 enum type_pieces
 pop_type (void)
 {
 enum type_pieces
 pop_type (void)
 {
-  if (type_stack_depth)
-    return type_stack[--type_stack_depth].piece;
+  if (type_stack.depth)
+    return type_stack.elements[--type_stack.depth].piece;
   return tp_end;
 }
 
 int
 pop_type_int (void)
 {
   return tp_end;
 }
 
 int
 pop_type_int (void)
 {
-  if (type_stack_depth)
-    return type_stack[--type_stack_depth].int_val;
+  if (type_stack.depth)
+    return type_stack.elements[--type_stack.depth].int_val;
   /* "Can't happen".  */
   return 0;
 }
 
   /* "Can't happen".  */
   return 0;
 }
 
+/* Pop a type list element from the global type stack.  */
+
+static VEC (type_ptr) *
+pop_typelist (void)
+{
+  gdb_assert (type_stack.depth);
+  return type_stack.elements[--type_stack.depth].typelist_val;
+}
+
+/* Pop a type_stack element from the global type stack.  */
+
+static struct type_stack *
+pop_type_stack (void)
+{
+  gdb_assert (type_stack.depth);
+  return type_stack.elements[--type_stack.depth].stack_val;
+}
+
+/* Append the elements of the type stack FROM to the type stack TO.
+   Always returns TO.  */
+
+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;
+
+  return to;
+}
+
+/* Push the type stack STACK as an element on the global type stack.  */
+
+void
+push_type_stack (struct type_stack *stack)
+{
+  check_type_stack_depth ();
+  type_stack.elements[type_stack.depth++].stack_val = 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.  */
+
+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;
+
+  return result;
+}
+
+/* A cleanup function that destroys a single type stack.  */
+
+void
+type_stack_cleanup (void *arg)
+{
+  struct type_stack *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_typelist (VEC (type_ptr) *list)
+{
+  check_type_stack_depth ();
+  type_stack.elements[type_stack.depth++].typelist_val = list;
+  push_type (tp_function_with_arguments);
+}
+
 /* 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 *
@@ -1555,6 +1717,36 @@ follow_types (struct type *follow_type)
           done with it.  */
        follow_type = lookup_function_type (follow_type);
        break;
           done with it.  */
        follow_type = lookup_function_type (follow_type);
        break;
+
+      case tp_function_with_arguments:
+       {
+         VEC (type_ptr) *args = pop_typelist ();
+
+         follow_type
+           = lookup_function_type_with_arguments (follow_type,
+                                                  VEC_length (type_ptr, args),
+                                                  VEC_address (type_ptr,
+                                                               args));
+         VEC_free (type_ptr, args);
+       }
+       break;
+
+      case tp_type_stack:
+       {
+         struct type_stack *stack = pop_type_stack ();
+         /* Sort of ugly, but not really much worse than the
+            alternatives.  */
+         struct type_stack save = type_stack;
+
+         type_stack = *stack;
+         follow_type = follow_types (follow_type);
+         gdb_assert (type_stack.depth == 0);
+
+         type_stack = save;
+       }
+       break;
+      default:
+       gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
       }
   return follow_type;
 }
       }
   return follow_type;
 }
@@ -1605,8 +1797,6 @@ operator_check_standard (struct expression *exp, int pos,
     case OP_SCOPE:
     case OP_TYPE:
     case UNOP_CAST:
     case OP_SCOPE:
     case OP_TYPE:
     case UNOP_CAST:
-    case UNOP_DYNAMIC_CAST:
-    case UNOP_REINTERPRET_CAST:
     case UNOP_MAX:
     case UNOP_MEMVAL:
     case UNOP_MIN:
     case UNOP_MAX:
     case UNOP_MEMVAL:
     case UNOP_MIN:
@@ -1722,20 +1912,19 @@ exp_uses_objfile (struct expression *exp, struct objfile *objfile)
 void
 _initialize_parse (void)
 {
 void
 _initialize_parse (void)
 {
-  type_stack_size = 80;
-  type_stack_depth = 0;
-  type_stack = (union type_stack_elt *)
-    xmalloc (type_stack_size * sizeof (*type_stack));
-
-  add_setshow_zinteger_cmd ("expression", class_maintenance,
-                           &expressiondebug,
-                           _("Set expression debugging."),
-                           _("Show expression debugging."),
-                           _("When non-zero, the internal representation "
-                             "of expressions will be printed."),
-                           NULL,
-                           show_expressiondebug,
-                           &setdebuglist, &showdebuglist);
+  type_stack.size = 0;
+  type_stack.depth = 0;
+  type_stack.elements = NULL;
+
+  add_setshow_zuinteger_cmd ("expression", class_maintenance,
+                            &expressiondebug,
+                            _("Set expression debugging."),
+                            _("Show expression debugging."),
+                            _("When non-zero, the internal representation "
+                              "of expressions will be printed."),
+                            NULL,
+                            show_expressiondebug,
+                            &setdebuglist, &showdebuglist);
   add_setshow_boolean_cmd ("parser", class_maintenance,
                            &parser_debug,
                           _("Set parser debugging."),
   add_setshow_boolean_cmd ("parser", class_maintenance,
                            &parser_debug,
                           _("Set parser debugging."),
This page took 0.035264 seconds and 4 git commands to generate.