[07/13] Remove paren_depth global

Message ID 20190403013805.11978-8-tom@tromey.com
State New
Headers show
Series
  • Remove parser-related globals
Related show

Commit Message

Tom Tromey April 3, 2019, 1:37 a.m.
This removes the "paren_depth" global.  In most cases, it is made into
a static global in a given parser.  I consider this a slight
improvement, because it makes it clear that the variable isn't used
for communication between different modules of gdb.  The one exception
is the Rust parser, which already incorporates all local state into a
transient object; in this case the parser depth is now a member.

2019-04-02  Tom Tromey  <tom@tromey.com>

	* rust-exp.y (struct rust_parser) <paren_depth>: New member.
	(rustyylex, rust_lex_test_init, rust_lex_test_one)
	(rust_lex_test_sequence, rust_lex_test_push_back): Update.
	* parser-defs.h (paren_depth): Don't declare.
	* parse.c (paren_depth): Remove global.
	(parse_exp_in_context): Update.
	* p-exp.y (paren_depth): New global.
	(pascal_parse): Initialize it.
	* m2-exp.y (paren_depth): New global.
	(m2_parse): Initialize it.
	* go-exp.y (paren_depth): New global.
	(go_parse): Initialize it.
	* f-exp.y (paren_depth): New global.
	(f_parse): Initialize it.
	* d-exp.y (paren_depth): New global.
	(d_parse): Initialize it.
	* c-exp.y (paren_depth): New global.
	(c_parse): Initialize it.
	* ada-lex.l (paren_depth): New global.
	(lexer_init): Initialize it.
---
 gdb/ChangeLog     | 23 +++++++++++++++++++++++
 gdb/ada-lex.l     |  4 ++++
 gdb/c-exp.y       |  4 ++++
 gdb/d-exp.y       |  4 ++++
 gdb/f-exp.y       |  4 ++++
 gdb/go-exp.y      |  4 ++++
 gdb/m2-exp.y      |  4 ++++
 gdb/p-exp.y       |  4 ++++
 gdb/parse.c       |  2 --
 gdb/parser-defs.h |  4 ----
 gdb/rust-exp.y    | 19 +++++++++++--------
 11 files changed, 62 insertions(+), 14 deletions(-)

-- 
2.17.2

Patch

diff --git a/gdb/ada-lex.l b/gdb/ada-lex.l
index 17ac7e5d3d5..6163405545d 100644
--- a/gdb/ada-lex.l
+++ b/gdb/ada-lex.l
@@ -84,6 +84,9 @@  static void rewind_to_char (int);
 
 static int find_dot_all (const char *);
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 %}
 
 %option case-insensitive interactive nodefault
@@ -305,6 +308,7 @@  static void
 lexer_init (FILE *inp)
 {
   BEGIN INITIAL;
+  paren_depth = 0;
   yyrestart (inp);
 }
 
diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index e6d6c208f15..cb9e9e002c7 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -2527,6 +2527,9 @@  static int saw_name_at_eof;
    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
@@ -3315,6 +3318,7 @@  c_parse (struct parser_state *par_state)
   /* Initialize some state used by the lexer.  */
   last_was_structop = false;
   saw_name_at_eof = 0;
+  paren_depth = 0;
 
   token_fifo.clear ();
   popping = 0;
diff --git a/gdb/d-exp.y b/gdb/d-exp.y
index a701c2541d3..c1519953521 100644
--- a/gdb/d-exp.y
+++ b/gdb/d-exp.y
@@ -1020,6 +1020,9 @@  static int saw_name_at_eof;
    This is used only when parsing to do field name completion.  */
 static int last_was_structop;
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 /* Read one token, getting characters through lexptr.  */
 
 static int
@@ -1619,6 +1622,7 @@  d_parse (struct parser_state *par_state)
   /* Initialize some state used by the lexer.  */
   last_was_structop = 0;
   saw_name_at_eof = 0;
+  paren_depth = 0;
 
   token_fifo.clear ();
   popping = 0;
diff --git a/gdb/f-exp.y b/gdb/f-exp.y
index 5670136b2a6..100a3bbec14 100644
--- a/gdb/f-exp.y
+++ b/gdb/f-exp.y
@@ -68,6 +68,9 @@ 
 
 static struct parser_state *pstate = NULL;
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 int yyparse (void);
 
 static int yylex (void);
@@ -1328,6 +1331,7 @@  f_parse (struct parser_state *par_state)
 							parser_debug);
   gdb_assert (par_state != NULL);
   pstate = par_state;
+  paren_depth = 0;
 
   return yyparse ();
 }
diff --git a/gdb/go-exp.y b/gdb/go-exp.y
index d112a73f21a..aaffe3d45a0 100644
--- a/gdb/go-exp.y
+++ b/gdb/go-exp.y
@@ -1001,6 +1001,9 @@  static int saw_name_at_eof;
    do field name completion.  */
 static int last_was_structop;
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 /* Read one token, getting characters through lexptr.  */
 
 static int
@@ -1566,6 +1569,7 @@  go_parse (struct parser_state *par_state)
   /* Initialize some state used by the lexer.  */
   last_was_structop = 0;
   saw_name_at_eof = 0;
+  paren_depth = 0;
 
   token_fifo.clear ();
   popping = 0;
diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index c1418c751f1..c0f5e75be2a 100644
--- a/gdb/m2-exp.y
+++ b/gdb/m2-exp.y
@@ -763,6 +763,9 @@  static struct keyword keytab[] =
 };
 
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 /* Read one token, getting characters through lexptr.  */
 
 /* This is where we will check to make sure that the language and the
@@ -1039,6 +1042,7 @@  m2_parse (struct parser_state *par_state)
   scoped_restore pstate_restore = make_scoped_restore (&pstate);
   gdb_assert (par_state != NULL);
   pstate = par_state;
+  paren_depth = 0;
 
   return yyparse ();
 }
diff --git a/gdb/p-exp.y b/gdb/p-exp.y
index dbccf358d5c..768f3025921 100644
--- a/gdb/p-exp.y
+++ b/gdb/p-exp.y
@@ -68,6 +68,9 @@ 
 
 static struct parser_state *pstate = NULL;
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 int yyparse (void);
 
 static int yylex (void);
@@ -1723,6 +1726,7 @@  pascal_parse (struct parser_state *par_state)
   scoped_restore pstate_restore = make_scoped_restore (&pstate);
   gdb_assert (par_state != NULL);
   pstate = par_state;
+  paren_depth = 0;
 
   return yyparse ();
 }
diff --git a/gdb/parse.c b/gdb/parse.c
index d76aeb1d853..4ac79faaeae 100644
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -71,7 +71,6 @@  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.  */
@@ -1117,7 +1116,6 @@  parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
   lexptr = *stringptr;
   prev_lexptr = NULL;
 
-  paren_depth = 0;
   type_stack.elements.clear ();
   expout_last_struct = -1;
   expout_tag_completion_type = TYPE_CODE_UNDEF;
diff --git a/gdb/parser-defs.h b/gdb/parser-defs.h
index f895a552879..6fb0f8e5533 100644
--- a/gdb/parser-defs.h
+++ b/gdb/parser-defs.h
@@ -356,10 +356,6 @@  extern const char *lexptr;
    Currently used only for error reporting.  */
 extern const char *prev_lexptr;
 
-/* Current depth in parentheses within the expression.  */
-
-extern int paren_depth;
-
 /* Nonzero means stop parsing on first comma (if not within parentheses).  */
 
 extern int comma_terminates;
diff --git a/gdb/rust-exp.y b/gdb/rust-exp.y
index 1b7e33e6172..9d3083ead92 100644
--- a/gdb/rust-exp.y
+++ b/gdb/rust-exp.y
@@ -300,6 +300,9 @@  struct rust_parser
 
   /* The parser state gdb gave us.  */
   struct parser_state *pstate;
+
+  /* Depth of parentheses.  */
+  int paren_depth = 0;
 };
 
 /* Rust AST operations.  We build a tree of these; then lower them to
@@ -1664,14 +1667,14 @@  rustyylex (YYSTYPE *lvalp, rust_parser *parser)
   else if (lexptr[0] == '}' || lexptr[0] == ']')
     {
       /* Falls through to lex_operator.  */
-      --paren_depth;
+      --parser->paren_depth;
     }
   else if (lexptr[0] == '(' || lexptr[0] == '{')
     {
       /* Falls through to lex_operator.  */
-      ++paren_depth;
+      ++parser->paren_depth;
     }
-  else if (lexptr[0] == ',' && comma_terminates && paren_depth == 0)
+  else if (lexptr[0] == ',' && comma_terminates && parser->paren_depth == 0)
     return 0;
 
   return lex_operator (lvalp);
@@ -2552,11 +2555,11 @@  rustyyerror (rust_parser *parser, const char *msg)
 /* Initialize the lexer for testing.  */
 
 static void
-rust_lex_test_init (const char *input)
+rust_lex_test_init (rust_parser *parser, const char *input)
 {
   prev_lexptr = NULL;
   lexptr = input;
-  paren_depth = 0;
+  parser->paren_depth = 0;
 }
 
 /* A test helper that lexes a string, expecting a single token.  It
@@ -2568,7 +2571,7 @@  rust_lex_test_one (rust_parser *parser, const char *input, int expected)
   int token;
   RUSTSTYPE result;
 
-  rust_lex_test_init (input);
+  rust_lex_test_init (parser, input);
 
   token = rustyylex (&result, parser);
   SELF_CHECK (token == expected);
@@ -2632,7 +2635,7 @@  rust_lex_test_sequence (rust_parser *parser, const char *input, int len,
   int i;
 
   lexptr = input;
-  paren_depth = 0;
+  parser->paren_depth = 0;
 
   for (i = 0; i < len; ++i)
     {
@@ -2686,7 +2689,7 @@  rust_lex_test_push_back (rust_parser *parser)
   int token;
   RUSTSTYPE lval;
 
-  rust_lex_test_init (">>=");
+  rust_lex_test_init (parser, ">>=");
 
   token = rustyylex (&lval, parser);
   SELF_CHECK (token == COMPOUND_ASSIGN);