From patchwork Mon Oct 16 23:34:25 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 23631 Received: (qmail 57018 invoked by alias); 16 Oct 2017 23:34:30 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 57007 invoked by uid 89); 16 Oct 2017 23:34:30 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_LAZY_DOMAIN_SECURITY, RP_MATCHES_RCVD, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=allocating X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 16 Oct 2017 23:34:29 +0000 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id D14053C2D; Mon, 16 Oct 2017 23:34:27 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mx1.redhat.com D14053C2D Authentication-Results: ext-mx06.extmail.prod.ext.phx2.redhat.com; dmarc=none (p=none dis=none) header.from=redhat.com Authentication-Results: ext-mx06.extmail.prod.ext.phx2.redhat.com; spf=fail smtp.mailfrom=palves@redhat.com Received: from [127.0.0.1] (ovpn04.gateway.prod.ext.ams2.redhat.com [10.39.146.4]) by smtp.corp.redhat.com (Postfix) with ESMTP id 90A5460852; Mon, 16 Oct 2017 23:34:26 +0000 (UTC) Subject: [PATCH 1/2] Introduce string_appendf/string_vappendf (Re: [RFA 4/6] Simple cleanup removals in remote.c) To: Tom Tromey References: <20171016030427.21349-1-tom@tromey.com> <20171016030427.21349-5-tom@tromey.com> <07804bc3-a6c5-2c0f-5730-5dd12fccafbe@ericsson.com> <87fuaipzgg.fsf@tromey.com> <97a40149-a30f-b2af-4441-6945b1d29cf1@redhat.com> <87vajesnor.fsf@tromey.com> Cc: Simon Marchi , gdb-patches@sourceware.org From: Pedro Alves Message-ID: Date: Tue, 17 Oct 2017 00:34:25 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.4.0 MIME-Version: 1.0 In-Reply-To: <87vajesnor.fsf@tromey.com> On 10/17/2017 12:00 AM, Tom Tromey wrote: >>>>>> "Pedro" == Pedro Alves writes: > > Pedro> This suggests to me that we're missing a string_printf variant > Pedro> that appends to a preexisting string: > Pedro> void string_appendf (std::string &dest, const char* fmt, ...); > Pedro> See (untested) patch below. > > Seems like a good idea FWIW. Alright, here's a version with unit tests, then. From 7d51020e1f1f77d9bfc3a4a06be19d1cbb889500 Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Mon, 16 Oct 2017 23:22:27 +0100 Subject: [PATCH] Introduce string_appendf/string_vappendf string_appendf is like string_printf, but instead of allocating a new string, it appends to an existing string. This allows reusing a std::string's memory buffer across several calls, for example. gdb/ChangeLog: yyyy-mm-dd Pedro Alves * common/common-utils.c (string_appendf, string_vappendf): New functions. * common/common-utils.h (string_appendf, string_vappendf): New declarations. * remote.c (remote_set_syscall_catchpoint): Use string_append. * unittests/common-utils-selftests.c (string_appendf_func) (test_appendf_func, string_vappendf_wrapper, string_appendf_tests) (string_vappendf_tests): New functions. (_initialize_common_utils_selftests): Register "string_appendf" and "string_vappendf tests". --- gdb/common/common-utils.c | 44 +++++++++++++++++++++++++++++++ gdb/common/common-utils.h | 9 +++++++ gdb/unittests/common-utils-selftests.c | 47 ++++++++++++++++++++++++++++++++++ 3 files changed, 100 insertions(+) diff --git a/gdb/common/common-utils.c b/gdb/common/common-utils.c index d8c546a..942aebb 100644 --- a/gdb/common/common-utils.c +++ b/gdb/common/common-utils.c @@ -195,6 +195,50 @@ string_vprintf (const char* fmt, va_list args) return str; } + +/* See documentation in common-utils.h. */ + +void +string_appendf (std::string &str, const char *fmt, ...) +{ + va_list vp; + int grow_size; + + va_start (vp, fmt); + grow_size = vsnprintf (NULL, 0, fmt, vp); + va_end (vp); + + size_t curr_size = str.size (); + str.resize (curr_size + grow_size); + + /* C++11 and later guarantee std::string uses contiguous memory and + always includes the terminating '\0'. */ + va_start (vp, fmt); + vsprintf (&str[curr_size], fmt, vp); + va_end (vp); +} + + +/* See documentation in common-utils.h. */ + +void +string_vappendf (std::string &str, const char *fmt, va_list args) +{ + va_list vp; + int grow_size; + + va_copy (vp, args); + grow_size = vsnprintf (NULL, 0, fmt, vp); + va_end (vp); + + size_t curr_size = str.size (); + str.resize (curr_size + grow_size); + + /* C++11 and later guarantee std::string uses contiguous memory and + always includes the terminating '\0'. */ + vsprintf (&str[curr_size], fmt, args); +} + char * savestring (const char *ptr, size_t len) { diff --git a/gdb/common/common-utils.h b/gdb/common/common-utils.h index 19724f9..a32863c 100644 --- a/gdb/common/common-utils.h +++ b/gdb/common/common-utils.h @@ -67,6 +67,15 @@ std::string string_printf (const char* fmt, ...) std::string string_vprintf (const char* fmt, va_list args) ATTRIBUTE_PRINTF (1, 0); +/* Like string_printf, but appends to DEST instead of returning a new + std::string. */ +void string_appendf (std::string &dest, const char* fmt, ...) + ATTRIBUTE_PRINTF (2, 3); + +/* Like string_appendf, but takes a va_list. */ +void string_vappendf (std::string &dest, const char* fmt, va_list args) + ATTRIBUTE_PRINTF (2, 0); + /* Make a copy of the string at PTR with LEN characters (and add a null character at the end in the copy). Uses malloc to get the space. Returns the address of the copy. */ diff --git a/gdb/unittests/common-utils-selftests.c b/gdb/unittests/common-utils-selftests.c index cf65513..9825845 100644 --- a/gdb/unittests/common-utils-selftests.c +++ b/gdb/unittests/common-utils-selftests.c @@ -76,6 +76,51 @@ string_vprintf_tests () test_format_func (format); } +/* Type of both 'string_appendf' and the 'string_vappendf_wrapper' + function below. Used to run the same tests against both + string_appendf and string_vappendf. */ +typedef void (string_appendf_func) (std::string &str, const char *fmt, ...); + +static void +test_appendf_func (string_appendf_func *func) +{ + std::string str; + + func (str, "%s", ""); + SELF_CHECK (str == ""); + + func (str, "%s", "test"); + SELF_CHECK (str == "test"); + + func (str, "%d", 23); + SELF_CHECK (str == "test23"); + + func (str, "%s %d %s", "foo", 45, "bar"); + SELF_CHECK (str == "test23foo 45 bar"); +} + +static void +string_vappendf_wrapper (std::string &str, const char *fmt, ...) +{ + va_list vp; + + va_start (vp, fmt); + string_vappendf (str, fmt, vp); + va_end (vp); +} + +static void +string_appendf_tests () +{ + test_appendf_func (string_appendf); +} + +static void +string_vappendf_tests () +{ + test_appendf_func (string_vappendf_wrapper); +} + } /* namespace selftests */ void @@ -83,4 +128,6 @@ _initialize_common_utils_selftests () { selftests::register_test ("string_printf", selftests::string_printf_tests); selftests::register_test ("string_vprintf", selftests::string_vprintf_tests); + selftests::register_test ("string_appendf", selftests::string_appendf_tests); + selftests::register_test ("string_vappendf", selftests::string_vappendf_tests); }