Convert tid_range_parser and get_number_or_range to classes

This converts tid_range_parser and get_number_or_range to be classes.
The various tid_range_parser_* and get_number_or_range_* functions
become methods on the respective classes.  Then it updates the users
to follow.

The rationale for the change is that this provides better
encapsulation.  For example, this forced me to think of a better
interface between tid_range_parser and get_number_or_range, since the
former peeked into the latter's internals a bit too much.  That ended
up resulting mostly in these two not-just-straight-1-1 changes:

  void
 -tid_range_parser_skip (struct tid_range_parser *parser)
 +tid_range_parser::skip_range ()
  {
 ...

 -  tid_range_parser_init (parser, parser->range_parser.end_ptr,
 -			 parser->default_inferior);
 +  m_range_parser.skip_range ();
 +  init (m_range_parser.string (), m_default_inferior);
  }

 and:

    /* If we successfully parsed a thread number or finished parsing a
       thread range, switch back to assuming the next TID is
       inferior-qualified.  */
 -  if (parser->range_parser.end_ptr == NULL
 -      || parser->range_parser.string == parser->range_parser.end_ptr)
 +  if (!m_range_parser.in_range ())
      {

For the same reason (encapsulation), this moves the enum
tid_range_state definition to within the tid_parser class's scope,
since that is private implementation detail.

While at it, switch to use "bool" for booleans.

gdb/ChangeLog:
2016-10-13  Pedro Alves  <palves@redhat.com>
	    Tom Tromey  <tom@tromey.com>

	* tid-parse.h (tid_range_parser): New class.
	(enum tid_range_state): Move into tid_range_parser's scope.
	Remove TID_RANGE_ prefix from all values.
	(tid_range_parser_get_tid, tid_range_parser_get_tid_range)
	(tid_range_parser_star_range, tid_range_parser_finished)
	(tid_range_parser_skip, tid_range_parser_qualified): Don't
	declare.
	(tid_is_in_list): Update comment.
	* tid-parse.c (tid_range_parser::tid_range_parser): New.
	(init, finished, get_string, skip, tid_is_qualified)
	(get_tid_or_range, get_tid_range, get_tid, star_range): Rename;
	turn into methods.
	(tid_is_in_list): Adjust.
	* cli/cli-utils.h (number_or_range_parser): New class.
	(init_number_or_range, get_number_or_range)
	(number_range_setup_range): Don't declare.
	* cli/cli-utils.c
	(number_or_range_parser::number_or_range_parser): New.
	(init_number_or_range, get_number_or_range)
	(number_range_setup_range): Rename; turn into methods.
	(number_is_in_list): Adjust.
	* breakpoint.c (map_breakpoint_numbers): Adjust.  Use bool.
	(trace_pass_command, get_tracepoint_by_number): Adjust.
	* breakpoint.h (get_tracepoint_by_number): Adjust.
	* inferior.c (detach_inferior_command, kill_inferior_command)
	(remove_inferior_command): Adjust.
	* linespec.c (decode_line_2): Adjust.
	* memattr.c (mem_enable_command, mem_disable_command)
	(mem_delete_command): Adjust.
	* printcmd.c (map_display_numbers): Adjust.
	* reverse.c (delete_bookmark_command, bookmarks_info): Adjust.
	* thread.c (thread_apply_command): Adjust.

1 files changed, 103 insertions, 94 deletions

diff --git a/gdb/tid-parse.h b/gdb/tid-parse.h
index 830cf36..1f6ae90 100644
--- a/gdb/tid-parse.h
+++ b/gdb/tid-parse.h
@@ -36,56 +36,6 @@ extern void ATTRIBUTE_NORETURN invalid_thread_id_error (const char *string);
    thrown.  */
 struct thread_info *parse_thread_id (const char *tidstr, const char **end);
 
-/* The possible states of the tid range parser's state machine.  */
-enum tid_range_state
-{
-  /* Parsing the inferior number.  */
-  TID_RANGE_STATE_INFERIOR,
-
-  /* Parsing the thread number or thread number range.  */
-  TID_RANGE_STATE_THREAD_RANGE,
-
-  /* Parsing a star wildcard thread range.  E.g., "1.*".  */
-  TID_RANGE_STATE_STAR_RANGE,
-};
-
-/* An object of this type is passed to tid_range_parser_get_tid.  It
-   must be initialized by calling tid_range_parser_init.  This type is
-   defined here so that it can be stack-allocated, but all members
-   should be treated as opaque.  */
-struct tid_range_parser
-{
-  /* What sub-component are we expecting.  */
-  enum tid_range_state state;
-
-  /* The string being parsed.  When parsing has finished, this points
-     past the last parsed token.  */
-  const char *string;
-
-  /* The range parser state when we're parsing the thread number
-     sub-component.  */
-  struct get_number_or_range_state range_parser;
-
-  /* Last inferior number returned.  */
-  int inf_num;
-
-  /* True if the TID last parsed was explicitly inferior-qualified.
-     IOW, whether the spec specified an inferior number
-     explicitly.  */
-  int qualified;
-
-  /* The inferior number to assume if the TID is not qualified.  */
-  int default_inferior;
-};
-
-/* Initialize a tid_range_parser for use with
-   tid_range_parser_get_tid.  TIDLIST is the string to be parsed.
-   DEFAULT_INFERIOR is the inferior number to assume if a
-   non-qualified thread ID is found.  */
-extern void tid_range_parser_init (struct tid_range_parser *parser,
-				   const char *tidlist,
-				   int default_inferior);
-
 /* Parse a thread ID or a thread range list.
 
    A range will be of the form
@@ -99,74 +49,133 @@ extern void tid_range_parser_init (struct tid_range_parser *parser,
      <thread_number1>-<thread_number2>
 
    in which case GDB infers the inferior number from the default
-   passed to the tid_range_parser_init function.
+   passed to the constructor or to the last call to the init
+   function.  */
+class tid_range_parser
+{
+public:
+  /* Default construction.  Must call init before calling get_*.  */
+  tid_range_parser () {}
+
+  /* Calls init automatically.  See init for description of
+     parameters.  */
+  tid_range_parser (const char *tidlist, int default_inferior);
+
+  /* Reinitialize a tid_range_parser.  TIDLIST is the string to be
+     parsed.  DEFAULT_INFERIOR is the inferior number to assume if a
+     non-qualified thread ID is found.  */
+  void init (const char *tidlist, int default_inferior);
 
-   This function is designed to be called iteratively.  While
-   processing a thread ID range list, at each call it will return (in
-   the INF_NUM and THR_NUM output parameters) the next thread ID in
-   the range (irrespective of whether the thread actually exists).
+  /* Parse a thread ID or a thread range list.
 
-   At the beginning of parsing a thread range, the char pointer
-   PARSER->string will be advanced past <thread_number1> and left
-   pointing at the '-' token.  Subsequent calls will not advance the
-   pointer until the range is completed.  The call that completes the
-   range will advance the pointer past <thread_number2>.
+     This function is designed to be called iteratively.  While
+     processing a thread ID range list, at each call it will return
+     (in the INF_NUM and THR_NUM output parameters) the next thread ID
+     in the range (irrespective of whether the thread actually
+     exists).
 
-   This function advances through the input string for as long you
-   call it.  Once the end of the input string is reached, a call to
-   tid_range_parser_finished returns false (see below).
+     At the beginning of parsing a thread range, the char pointer
+     PARSER->m_cur_tok will be advanced past <thread_number1> and left
+     pointing at the '-' token.  Subsequent calls will not advance the
+     pointer until the range is completed.  The call that completes
+     the range will advance the pointer past <thread_number2>.
 
-   E.g., with list: "1.2 3.4-6":
+     This function advances through the input string for as long you
+     call it.  Once the end of the input string is reached, a call to
+     finished returns false (see below).
+
+     E.g., with list: "1.2 3.4-6":
 
      1st call: *INF_NUM=1; *THR_NUM=2 (finished==0)
      2nd call: *INF_NUM=3; *THR_NUM=4 (finished==0)
      3rd call: *INF_NUM=3; *THR_NUM=5 (finished==0)
      4th call: *INF_NUM=3; *THR_NUM=6 (finished==1)
 
-   Returns true if parsed a thread/range successfully, false
-   otherwise.  */
-extern int tid_range_parser_get_tid (struct tid_range_parser *parser,
-				      int *inf_num, int *thr_num);
+     Returns true if a thread/range is parsed successfully, false
+     otherwise.  */
+  bool get_tid (int *inf_num, int *thr_num);
 
-/* Like tid_range_parser_get_tid, but return a thread ID range per
-   call, rather then a single thread ID.
+  /* Like get_tid, but return a thread ID range per call, rather then
+     a single thread ID.
 
-   If the next element in the list is a single thread ID, then
-   *THR_START and *THR_END are set to the same value.
+     If the next element in the list is a single thread ID, then
+     *THR_START and *THR_END are set to the same value.
 
-   E.g.,. with list: "1.2 3.4-6"
+     E.g.,. with list: "1.2 3.4-6"
 
      1st call: *INF_NUM=1; *THR_START=2; *THR_END=2 (finished==0)
      2nd call: *INF_NUM=3; *THR_START=4; *THR_END=6 (finished==1)
 
-   Returns true if parsed a thread/range successfully, false
-   otherwise.  */
-extern int tid_range_parser_get_tid_range (struct tid_range_parser *parser,
-					   int *inf_num,
-					   int *thr_start, int *thr_end);
+     Returns true if parsed a thread/range successfully, false
+     otherwise.  */
+  bool get_tid_range (int *inf_num, int *thr_start, int *thr_end);
+
+  /* Returns true if processing a star wildcard (e.g., "1.*")
+     range.  */
+  bool in_star_range () const;
+
+  /* Returns true if parsing has completed.  */
+  bool finished () const;
+
+  /* Return the current token being parsed.  When parsing has
+     finished, this points past the last parsed token.  */
+  const char *cur_tok () const;
 
-/* Returns non-zero if processing a star wildcard (e.g., "1.*")
-   range.  */
-extern int tid_range_parser_star_range (struct tid_range_parser *parser);
+  /* When parsing a range, advance past the final token in the
+     range.  */
+  void skip_range ();
 
-/* Returns non-zero if parsing has completed.  */
-extern int tid_range_parser_finished (struct tid_range_parser *parser);
+  /* True if the TID last parsed was explicitly inferior-qualified.
+     IOW, whether the spec specified an inferior number
+     explicitly.  */
+  bool tid_is_qualified () const;
 
-/* Return the string being parsed.  When parsing has finished, this
-   points past the last parsed token.  */
-const char *tid_range_parser_string (struct tid_range_parser *parser);
+private:
+  /* No need for these.  They are intentionally not defined anywhere.  */
+  tid_range_parser (const tid_range_parser &);
+  tid_range_parser &operator= (const tid_range_parser &);
 
-/* When parsing a range, advance past the final token in the range.  */
-extern void tid_range_parser_skip (struct tid_range_parser *parser);
+  bool get_tid_or_range (int *inf_num, int *thr_start, int *thr_end);
+
+  /* The possible states of the tid range parser's state machine,
+     indicating what sub-component are we expecting.  */
+  enum
+    {
+      /* Parsing the inferior number.  */
+      STATE_INFERIOR,
+
+      /* Parsing the thread number or thread number range.  */
+      STATE_THREAD_RANGE,
+
+      /* Parsing a star wildcard thread range.  E.g., "1.*".  */
+      STATE_STAR_RANGE,
+    } m_state;
+
+  /* The string being parsed.  When parsing has finished, this points
+     past the last parsed token.  */
+  const char *m_cur_tok;
+
+  /* The range parser state when we're parsing the thread number
+     sub-component.  */
+  number_or_range_parser m_range_parser;
+
+  /* Last inferior number returned.  */
+  int m_inf_num;
+
+  /* True if the TID last parsed was explicitly inferior-qualified.
+     IOW, whether the spec specified an inferior number
+     explicitly.  */
+  bool m_qualified;
+
+  /* The inferior number to assume if the TID is not qualified.  */
+  int m_default_inferior;
+};
 
-/* True if the TID last parsed was explicitly inferior-qualified.
-   IOW, whether the spec specified an inferior number explicitly.  */
-extern int tid_range_parser_qualified (struct tid_range_parser *parser);
 
 /* Accept a string-form list of thread IDs such as is accepted by
-   tid_range_parser_get_tid.  Return true if the INF_NUM.THR.NUM
-   thread is in the list.  DEFAULT_INFERIOR is the inferior number to
-   assume if a non-qualified thread ID is found in the list.
+   tid_range_parser.  Return true if the INF_NUM.THR.NUM thread is in
+   the list.  DEFAULT_INFERIOR is the inferior number to assume if a
+   non-qualified thread ID is found in the list.
 
    By definition, an empty list includes all threads.  This is to be
    interpreted as typing a command such as "info threads" with no