From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 86366 invoked by alias); 27 Sep 2016 04:42:12 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 86352 invoked by uid 89); 27 Sep 2016 04:42:11 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.4 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_NONE,RCVD_IN_SORBS_SPAM,SPF_PASS autolearn=no version=3.3.2 spammy=H*r:4.86_1, irrespective, H*RU:10.0.90.82, Hx-spam-relays-external:CMOut01 X-HELO: gproxy4-pub.mail.unifiedlayer.com Received: from gproxy4-pub.mail.unifiedlayer.com (HELO gproxy4-pub.mail.unifiedlayer.com) (69.89.23.142) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with SMTP; Tue, 27 Sep 2016 04:42:01 +0000 Received: (qmail 1718 invoked by uid 0); 27 Sep 2016 04:42:00 -0000 Received: from unknown (HELO CMOut01) (10.0.90.82) by gproxy4.mail.unifiedlayer.com with SMTP; 27 Sep 2016 04:42:00 -0000 Received: from box522.bluehost.com ([74.220.219.122]) by CMOut01 with id oUhu1t00T2f2jeq01Uhx2z; Mon, 26 Sep 2016 22:41:58 -0600 X-Authority-Analysis: v=2.1 cv=OPq0g0qB c=1 sm=1 tr=0 a=GsOEXm/OWkKvwdLVJsfwcA==:117 a=GsOEXm/OWkKvwdLVJsfwcA==:17 a=L9H7d07YOLsA:10 a=9cW_t1CCXrUA:10 a=s5jvgZ67dGcA:10 a=GW1xBdLrtEIA:10 a=zstS-IiYAAAA:8 a=dvCyk_3VCPblMYh5v1QA:9 a=BBIPakOIEvsZ4OCS:21 a=Tz1eTq0Fv4Jlmmfu:21 a=4G6NA9xxw8l3yy4pmD5M:22 Received: from 71-218-192-86.hlrn.qwest.net ([71.218.192.86]:56110 helo=bapiya.Home) by box522.bluehost.com with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.86_1) (envelope-from ) id 1bojhY-0006Nj-00; Mon, 26 Sep 2016 22:09:04 -0600 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [RFA 19/22] Convert tid_range_parser to class Date: Tue, 27 Sep 2016 04:42:00 -0000 Message-Id: <1474949330-4307-20-git-send-email-tom@tromey.com> In-Reply-To: <1474949330-4307-1-git-send-email-tom@tromey.com> References: <1474949330-4307-1-git-send-email-tom@tromey.com> X-BWhitelist: no X-Exim-ID: 1bojhY-0006Nj-00 X-Source-Sender: 71-218-192-86.hlrn.qwest.net (bapiya.Home) [71.218.192.86]:56110 X-Source-Auth: tom+tromey.com X-Email-Count: 23 X-Source-Cap: ZWx5bnJvYmk7ZWx5bnJvYmk7Ym94NTIyLmJsdWVob3N0LmNvbQ== X-SW-Source: 2016-09/txt/msg00341.txt.bz2 This converts tid_range_parser to be a class, and converts various tid_range_parser_* functions to be methods on this class; then it updates the users to follow. 2016-09-26 Tom Tromey * tid-parse.h (tid_range_parser): New class. (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-parse.c (init, finished, get_string, skip, is_qualified) (get_tid_or_range, get_tid_range, get_tid, star_range): Rename; turn into methods. (tid_is_in_list): Update. * thread.c (thread_apply_command): Update. --- gdb/ChangeLog | 13 +++++ gdb/thread.c | 26 ++++----- gdb/tid-parse.c | 128 ++++++++++++++++++++---------------------- gdb/tid-parse.h | 169 +++++++++++++++++++++++++++++--------------------------- 4 files changed, 173 insertions(+), 163 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 1e2fc29..bae4443 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,18 @@ 2016-09-26 Tom Tromey + * tid-parse.h (tid_range_parser): New class. + (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-parse.c (init, finished, get_string, skip, is_qualified) + (get_tid_or_range, get_tid_range, get_tid, star_range): Rename; + turn into methods. + (tid_is_in_list): Update. + * thread.c (thread_apply_command): Update. + +2016-09-26 Tom Tromey + * dwarf2loc.c: Include . (read_pieced_value, write_pieced_value) (dwarf2_compile_expr_to_ax): Use std::vector. diff --git a/gdb/thread.c b/gdb/thread.c index a66a2b5..718c567 100644 --- a/gdb/thread.c +++ b/gdb/thread.c @@ -1825,20 +1825,18 @@ thread_apply_command (char *tidlist, int from_tty) char *cmd = NULL; struct cleanup *old_chain; char *saved_cmd; - struct tid_range_parser parser; if (tidlist == NULL || *tidlist == '\000') error (_("Please specify a thread ID list")); - tid_range_parser_init (&parser, tidlist, current_inferior ()->num); - while (!tid_range_parser_finished (&parser)) + tid_range_parser parser (tidlist, current_inferior ()->num); + while (!parser.finished ()) { int inf_num, thr_start, thr_end; - if (!tid_range_parser_get_tid_range (&parser, - &inf_num, &thr_start, &thr_end)) + if (!parser.get_tid_range (&inf_num, &thr_start, &thr_end)) { - cmd = (char *) tid_range_parser_string (&parser); + cmd = (char *) parser.get_string (); break; } } @@ -1856,32 +1854,31 @@ thread_apply_command (char *tidlist, int from_tty) make_cleanup_restore_current_thread (); - tid_range_parser_init (&parser, tidlist, current_inferior ()->num); - while (!tid_range_parser_finished (&parser) - && tid_range_parser_string (&parser) < cmd) + parser.init (tidlist, current_inferior ()->num); + while (!parser.finished () && parser.get_string () < cmd) { struct thread_info *tp = NULL; struct inferior *inf; int inf_num, thr_num; - tid_range_parser_get_tid (&parser, &inf_num, &thr_num); + parser.get_tid (&inf_num, &thr_num); inf = find_inferior_id (inf_num); if (inf != NULL) tp = find_thread_id (inf, thr_num); - if (tid_range_parser_star_range (&parser)) + if (parser.star_range ()) { if (inf == NULL) { warning (_("Unknown inferior %d"), inf_num); - tid_range_parser_skip (&parser); + parser.skip (); continue; } /* No use looking for threads past the highest thread number the inferior ever had. */ if (thr_num >= inf->highest_thread_num) - tid_range_parser_skip (&parser); + parser.skip (); /* Be quiet about unknown threads numbers. */ if (tp == NULL) @@ -1890,8 +1887,7 @@ thread_apply_command (char *tidlist, int from_tty) if (tp == NULL) { - if (show_inferior_qualified_tids () - || tid_range_parser_qualified (&parser)) + if (show_inferior_qualified_tids () || parser.is_qualified ()) warning (_("Unknown thread %d.%d"), inf_num, thr_num); else warning (_("Unknown thread %d"), thr_num); diff --git a/gdb/tid-parse.c b/gdb/tid-parse.c index 68133c6..0e775bc 100644 --- a/gdb/tid-parse.c +++ b/gdb/tid-parse.c @@ -114,28 +114,27 @@ parse_thread_id (const char *tidstr, const char **end) /* See tid-parse.h. */ void -tid_range_parser_init (struct tid_range_parser *parser, const char *tidlist, - int default_inferior) +tid_range_parser::init (const char *tidlist, int default_inferior) { - parser->state = TID_RANGE_STATE_INFERIOR; - parser->string = tidlist; - parser->inf_num = 0; - parser->qualified = 0; - parser->default_inferior = default_inferior; + this->state = TID_RANGE_STATE_INFERIOR; + this->string = tidlist; + this->inf_num = 0; + this->qualified = 0; + this->default_inferior = default_inferior; } /* See tid-parse.h. */ int -tid_range_parser_finished (struct tid_range_parser *parser) +tid_range_parser::finished () const { - switch (parser->state) + switch (this->state) { case TID_RANGE_STATE_INFERIOR: - return *parser->string == '\0'; + return *this->string == '\0'; case TID_RANGE_STATE_THREAD_RANGE: case TID_RANGE_STATE_STAR_RANGE: - return parser->range_parser.finished; + return this->range_parser.finished; } gdb_assert_not_reached (_("unhandled state")); @@ -144,15 +143,15 @@ tid_range_parser_finished (struct tid_range_parser *parser) /* See tid-parse.h. */ const char * -tid_range_parser_string (struct tid_range_parser *parser) +tid_range_parser::get_string () const { - switch (parser->state) + switch (this->state) { case TID_RANGE_STATE_INFERIOR: - return parser->string; + return this->string; case TID_RANGE_STATE_THREAD_RANGE: case TID_RANGE_STATE_STAR_RANGE: - return parser->range_parser.string; + return this->range_parser.string; } gdb_assert_not_reached (_("unhandled state")); @@ -161,40 +160,38 @@ tid_range_parser_string (struct tid_range_parser *parser) /* See tid-parse.h. */ void -tid_range_parser_skip (struct tid_range_parser *parser) +tid_range_parser::skip () { - gdb_assert ((parser->state == TID_RANGE_STATE_THREAD_RANGE - || parser->state == TID_RANGE_STATE_STAR_RANGE) - && parser->range_parser.in_range); + gdb_assert ((this->state == TID_RANGE_STATE_THREAD_RANGE + || this->state == TID_RANGE_STATE_STAR_RANGE) + && this->range_parser.in_range); - tid_range_parser_init (parser, parser->range_parser.end_ptr, - parser->default_inferior); + init (this->range_parser.end_ptr, this->default_inferior); } /* See tid-parse.h. */ int -tid_range_parser_qualified (struct tid_range_parser *parser) +tid_range_parser::is_qualified () const { - return parser->qualified; + return this->qualified; } /* Helper for tid_range_parser_get_tid and tid_range_parser_get_tid_range. Return the next range if THR_END is non-NULL, return a single thread ID otherwise. */ -static int -get_tid_or_range (struct tid_range_parser *parser, int *inf_num, - int *thr_start, int *thr_end) +int +tid_range_parser::get_tid_or_range (int *inf_num, int *thr_start, int *thr_end) { - if (parser->state == TID_RANGE_STATE_INFERIOR) + if (this->state == TID_RANGE_STATE_INFERIOR) { const char *p; const char *space; - space = skip_to_space (parser->string); + space = skip_to_space (this->string); - p = parser->string; + p = this->string; while (p < space && *p != '.') p++; if (p < space) @@ -202,13 +199,13 @@ get_tid_or_range (struct tid_range_parser *parser, int *inf_num, const char *dot = p; /* Parse number to the left of the dot. */ - p = parser->string; - parser->inf_num - = get_positive_number_trailer (&p, '.', parser->string); - if (parser->inf_num == 0) + p = this->string; + this->inf_num + = get_positive_number_trailer (&p, '.', this->string); + if (this->inf_num == 0) return 0; - parser->qualified = 1; + this->qualified = 1; p = dot + 1; if (isspace (*p)) @@ -216,42 +213,42 @@ get_tid_or_range (struct tid_range_parser *parser, int *inf_num, } else { - parser->inf_num = parser->default_inferior; - parser->qualified = 0; - p = parser->string; + this->inf_num = this->default_inferior; + this->qualified = 0; + p = this->string; } - init_number_or_range (&parser->range_parser, p); + init_number_or_range (&this->range_parser, p); if (p[0] == '*' && (p[1] == '\0' || isspace (p[1]))) { /* Setup the number range parser to return numbers in the whole [1,INT_MAX] range. */ - number_range_setup_range (&parser->range_parser, 1, INT_MAX, + number_range_setup_range (&this->range_parser, 1, INT_MAX, skip_spaces_const (p + 1)); - parser->state = TID_RANGE_STATE_STAR_RANGE; + this->state = TID_RANGE_STATE_STAR_RANGE; } else - parser->state = TID_RANGE_STATE_THREAD_RANGE; + this->state = TID_RANGE_STATE_THREAD_RANGE; } - *inf_num = parser->inf_num; - *thr_start = get_number_or_range (&parser->range_parser); + *inf_num = this->inf_num; + *thr_start = get_number_or_range (&this->range_parser); if (*thr_start < 0) - error (_("negative value: %s"), parser->string); + error (_("negative value: %s"), this->string); if (*thr_start == 0) { - parser->state = TID_RANGE_STATE_INFERIOR; + this->state = TID_RANGE_STATE_INFERIOR; return 0; } /* 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 (this->range_parser.end_ptr == NULL + || this->range_parser.string == this->range_parser.end_ptr) { - parser->state = TID_RANGE_STATE_INFERIOR; - parser->string = parser->range_parser.string; + this->state = TID_RANGE_STATE_INFERIOR; + this->string = this->range_parser.string; if (thr_end != NULL) *thr_end = *thr_start; @@ -260,11 +257,11 @@ get_tid_or_range (struct tid_range_parser *parser, int *inf_num, /* If we're midway through a range, and the caller wants the end value, return it and skip to the end of the range. */ if (thr_end != NULL - && (parser->state == TID_RANGE_STATE_THREAD_RANGE - || parser->state == TID_RANGE_STATE_STAR_RANGE)) + && (this->state == TID_RANGE_STATE_THREAD_RANGE + || this->state == TID_RANGE_STATE_STAR_RANGE)) { - *thr_end = parser->range_parser.end_value; - tid_range_parser_skip (parser); + *thr_end = this->range_parser.end_value; + skip (); } return (*inf_num != 0 && *thr_start != 0); @@ -273,31 +270,29 @@ get_tid_or_range (struct tid_range_parser *parser, int *inf_num, /* See tid-parse.h. */ int -tid_range_parser_get_tid_range (struct tid_range_parser *parser, int *inf_num, - int *thr_start, int *thr_end) +tid_range_parser::get_tid_range (int *inf_num, int *thr_start, int *thr_end) { gdb_assert (inf_num != NULL && thr_start != NULL && thr_end != NULL); - return get_tid_or_range (parser, inf_num, thr_start, thr_end); + return get_tid_or_range (inf_num, thr_start, thr_end); } /* See tid-parse.h. */ int -tid_range_parser_get_tid (struct tid_range_parser *parser, - int *inf_num, int *thr_num) +tid_range_parser::get_tid (int *inf_num, int *thr_num) { gdb_assert (inf_num != NULL && thr_num != NULL); - return get_tid_or_range (parser, inf_num, thr_num, NULL); + return get_tid_or_range (inf_num, thr_num, NULL); } /* See tid-parse.h. */ int -tid_range_parser_star_range (struct tid_range_parser *parser) +tid_range_parser::star_range () { - return parser->state == TID_RANGE_STATE_STAR_RANGE; + return this->state == TID_RANGE_STATE_STAR_RANGE; } /* See gdbthread.h. */ @@ -306,19 +301,16 @@ int tid_is_in_list (const char *list, int default_inferior, int inf_num, int thr_num) { - struct tid_range_parser parser; - if (list == NULL || *list == '\0') return 1; - tid_range_parser_init (&parser, list, default_inferior); - while (!tid_range_parser_finished (&parser)) + tid_range_parser parser (list, default_inferior); + while (!parser.finished ()) { int tmp_inf, tmp_thr_start, tmp_thr_end; - if (!tid_range_parser_get_tid_range (&parser, &tmp_inf, - &tmp_thr_start, &tmp_thr_end)) - invalid_thread_id_error (parser.string); + if (!parser.get_tid_range (&tmp_inf, &tmp_thr_start, &tmp_thr_end)) + invalid_thread_id_error (parser.get_string ()); if (tmp_inf == inf_num && tmp_thr_start <= thr_num && thr_num <= tmp_thr_end) return 1; diff --git a/gdb/tid-parse.h b/gdb/tid-parse.h index 830cf36..e02dc16 100644 --- a/gdb/tid-parse.h +++ b/gdb/tid-parse.h @@ -49,119 +49,128 @@ enum tid_range_state 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 +/* An object of this type is passed to tid_range_parser_get_tid. */ +class 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; + public: - /* The inferior number to assume if the TID is not qualified. */ - int default_inferior; -}; + /* Initialize a tid_range_parser for use with 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. */ + tid_range_parser (const char *tidlist, int default_inferior) + { + init (tidlist, 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); + /* Initialize a tid_range_parser for use with 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. */ + void init (const char *tidlist, int default_inferior); -/* Parse a thread ID or a thread range list. + /* Parse a thread ID or a thread range list. - A range will be of the form + A range will be of the form .- - and will represent all the threads of inferior INFERIOR_NUM with - number between THREAD_NUMBER1 and THREAD_NUMBER2, inclusive. - can also be omitted, as in + and will represent all the threads of inferior INFERIOR_NUM with + number between THREAD_NUMBER1 and THREAD_NUMBER2, inclusive. + can also be omitted, as in - - in which case GDB infers the inferior number from the default - passed to the tid_range_parser_init function. + in which case GDB infers the inferior number from the default + passed to the constructor. - 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 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). - At the beginning of parsing a thread range, the char pointer - PARSER->string will be advanced past 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 . + At the beginning of parsing a thread range, the char pointer + THIS->string will be advanced past 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 . - 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). + 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": + 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 parsed a thread/range successfully, false + otherwise. */ + int 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. */ + int get_tid_range (int *inf_num, int *thr_start, int *thr_end); + + /* Returns non-zero if processing a star wildcard (e.g., "1.*") + range. */ + int star_range (); + + /* Returns non-zero if parsing has completed. */ + int finished () const; + + /* Return the string being parsed. When parsing has finished, this + points past the last parsed token. */ + const char *get_string () 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 (); -/* 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. */ + int is_qualified () const; + + private: + + // No need for these. They are intentionally not defined anywhere. + tid_range_parser &operator= (const tid_range_parser &); + tid_range_parser (const tid_range_parser &); + + int get_tid_or_range (int *inf_num, int *thr_start, int *thr_end); + + /* 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; -/* 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); + /* Last inferior number returned. */ + int inf_num; -/* When parsing a range, advance past the final token in the range. */ -extern void tid_range_parser_skip (struct tid_range_parser *parser); + /* True if the TID last parsed was explicitly inferior-qualified. + IOW, whether the spec specified an inferior number + explicitly. */ + int qualified; -/* 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); + /* The inferior number to assume if the TID is not qualified. */ + int default_inferior; +}; /* 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 -- 2.7.4