* parser-defs.h (type_stack, type_stack_size, type_stack_depth):

	Remove.
	(struct type_stack): New.
	* parse.c (type_stack, type_stack_size, type_stack_depth):
	Remove.
	(type_stack): New global.
	(parse_exp_in_context, check_type_stack_depth)
	(insert_into_type_stack, insert_type, push_type, push_type_int)
	(insert_type_address_space, pop_type, pop_type_int)
	(_initialize_parse): Update.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 51c282d6965505ffe274c480245d1186db09f69c..b69c56aba3bed780535815bdb18eb003659ad090 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,16 @@
+2012-07-06  Tom Tromey  <tromey@redhat.com>
+
+       * parser-defs.h (type_stack, type_stack_size, type_stack_depth):
+       Remove.
+       (struct type_stack): New.
+       * parse.c (type_stack, type_stack_size, type_stack_depth):
+       Remove.
+       (type_stack): New global.
+       (parse_exp_in_context, check_type_stack_depth)
+       (insert_into_type_stack, insert_type, push_type, push_type_int)
+       (insert_type_address_space, pop_type, pop_type_int)
+       (_initialize_parse): Update.
+
 2012-07-06  Tom Tromey  <tromey@redhat.com>
 
        * c-exp.y (func_mod, direct_abs_decl, abs_decl, ptr_operator):

diff --git a/gdb/parse.c b/gdb/parse.c
index c372f407241933b7be4957fec46f848be9a04c8d..83f7fec9d39d967242e8296324f0e3adb09c47d7 100644 (file)
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -75,8 +75,7 @@ struct block *expression_context_block;
 CORE_ADDR expression_context_pc;
 struct block *innermost_block;
 int arglist_len;
-union type_stack_elt *type_stack;
-int type_stack_depth, type_stack_size;
+static struct type_stack type_stack;
 char *lexptr;
 char *prev_lexptr;
 int paren_depth;
@@ -1123,7 +1122,7 @@ parse_exp_in_context (char **stringptr, CORE_ADDR pc, struct block *block,
   prev_lexptr = NULL;
 
   paren_depth = 0;
-  type_stack_depth = 0;
+  type_stack.depth = 0;
   expout_last_struct = -1;
 
   comma_terminates = comma;
@@ -1362,11 +1361,12 @@ parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
 static void
 check_type_stack_depth (void)
 {
-  if (type_stack_depth == type_stack_size)
+  if (type_stack.depth == type_stack.size)
     {
-      type_stack_size *= 2;
-      type_stack = (union type_stack_elt *)
-       xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack));
+      type_stack.size *= 2;
+      type_stack.elements
+       = xrealloc (type_stack.elements,
+                   type_stack.size * sizeof (union type_stack_elt));
     }
 }
 
@@ -1379,11 +1379,11 @@ insert_into_type_stack (int slot, union type_stack_elt element)
 {
   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
@@ -1404,7 +1404,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 (type_stack_depth && (tp == tp_const || tp == tp_volatile))
+  if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
     slot = 1;
   else
     slot = 0;
@@ -1417,14 +1417,14 @@ void
 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 ();
-  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
@@ -1444,7 +1444,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 (type_stack_depth)
+  if (type_stack.depth)
     slot = 1;
   else
     slot = 0;
@@ -1458,16 +1458,16 @@ insert_type_address_space (char *string)
 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)
 {
-  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;
 }
@@ -1725,10 +1725,10 @@ exp_uses_objfile (struct expression *exp, struct objfile *objfile)
 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));
+  type_stack.size = 80;
+  type_stack.depth = 0;
+  type_stack.elements = xmalloc (type_stack.size
+                                * sizeof (union type_stack_elt));
 
   add_setshow_zinteger_cmd ("expression", class_maintenance,
                            &expressiondebug,

diff --git a/gdb/parser-defs.h b/gdb/parser-defs.h
index aa600a19c44eae59f02f28ce5b85424d6d694dd4..de283d04fbd9e569ebfaf048fc1c1260282260a9 100644 (file)
--- a/gdb/parser-defs.h
+++ b/gdb/parser-defs.h
@@ -127,8 +127,18 @@ union type_stack_elt
     enum type_pieces piece;
     int int_val;
   };
-extern union type_stack_elt *type_stack;
-extern int type_stack_depth, type_stack_size;
+
+/* The type stack is an instance of this structure.  */
+
+struct type_stack
+{
+  /* Elements on the stack.  */
+  union type_stack_elt *elements;
+  /* Current stack depth.  */
+  int depth;
+  /* Allocated size of stack.  */
+  int size;
+};
 
 /* Helper function to initialize the expout, expout_size, expout_ptr
    trio before it is used to store expression elements created during