shared: drop strbuf_steal

The only use case of strbuf_steal is gone. If the requirement for this
function returns, we can add it again.

Signed-off-by: Tobias Stoeckmann <tobias@stoeckmann.org>
Link: https://github.com/kmod-project/kmod/pull/296
Signed-off-by: Lucas De Marchi <lucas.de.marchi@gmail.com>

diff --git a/shared/strbuf.c b/shared/strbuf.c
index 332dbd339857ac6f28aa54ec3ad517d3f575f5f7..6ce1f05e55652833a64f4cf770f7af62d1b9743c 100644 (file)
--- a/shared/strbuf.c
+++ b/shared/strbuf.c
@@ -62,20 +62,6 @@ void strbuf_release(struct strbuf *buf)
                free(buf->bytes);
 }
 
-char *strbuf_steal(struct strbuf *buf)
-{
-       char *bytes;
-
-       if (!buf_realloc(buf, buf->used + 1))
-               return NULL;
-
-       bytes = buf->bytes;
-       buf->bytes = NULL;
-       bytes[buf->used] = '\0';
-
-       return bytes;
-}
-
 const char *strbuf_str(struct strbuf *buf)
 {
        if (!buf->used || buf->bytes[buf->used - 1]) {

diff --git a/shared/strbuf.h b/shared/strbuf.h
index cd9b8b605dcd57f54d82f57dd1ad5e5f632041a3..3d97c5dee1549b63689bc2c6cb5232496c6473ca 100644 (file)
--- a/shared/strbuf.h
+++ b/shared/strbuf.h
@@ -43,18 +43,6 @@ void strbuf_release(struct strbuf *buf);
 
 void strbuf_clear(struct strbuf *buf);
 
-/*
- * Return a copy as a C string, guaranteed to be nul-terminated. On success, the @buf
- * becomes invalid and shouldn't be used anymore, except for an (optional) call to
- * strbuf_release() which still does the right thing on an invalidated buffer. On failure,
- * NULL is returned and the buffer remains valid: strbuf_release() should be called.
- * Consider using _cleanup_strbuf_ attribute to release the buffer as needed.
- *
- * The copy may use the same underlying storage as the buffer and should be free'd later
- * with free().
- */
-char *strbuf_steal(struct strbuf *buf);
-
 /*
  * Return a C string owned by the buffer. It becomes an invalid
  * pointer if strbuf is changed. It may also not survive a return

diff --git a/testsuite/test-strbuf.c b/testsuite/test-strbuf.c
index 50c75d92446cb70b1d9995ad9a8787d86251ebc2..c212f5ed7cd4dc6d623df540d32bb7dee54d0054 100644 (file)
--- a/testsuite/test-strbuf.c
+++ b/testsuite/test-strbuf.c
@@ -20,9 +20,8 @@ static const char *TEXT =
 
 static int test_strbuf_pushchar(const struct test *t)
 {
-       struct strbuf buf;
+       _cleanup_strbuf_ struct strbuf buf;
        const char *result;
-       char *result1, *result2;
        const char *c;
 
        strbuf_init(&buf);
@@ -33,13 +32,6 @@ static int test_strbuf_pushchar(const struct test *t)
        result = strbuf_str(&buf);
        assert_return(result == buf.bytes, EXIT_FAILURE);
        assert_return(streq(result, TEXT), EXIT_FAILURE);
-       result1 = strdup(result);
-
-       result2 = strbuf_steal(&buf);
-       assert_return(streq(result1, result2), EXIT_FAILURE);
-
-       free(result1);
-       free(result2);
 
        return 0;
 }
@@ -47,9 +39,9 @@ DEFINE_TEST(test_strbuf_pushchar, .description = "test strbuf_{pushchar, str, st
 
 static int test_strbuf_pushchars(const struct test *t)
 {
-       struct strbuf buf;
-       const char *result1;
-       char *saveptr = NULL, *str, *result2;
+       _cleanup_strbuf_ struct strbuf buf;
+       const char *result;
+       char *saveptr = NULL, *str;
        const char *c;
        size_t lastwordlen = 0;
 
@@ -68,65 +60,43 @@ static int test_strbuf_pushchars(const struct test *t)
         * true
         */
        strbuf_popchar(&buf);
-       result1 = strbuf_str(&buf);
-       assert_return(result1 == buf.bytes, EXIT_FAILURE);
-       assert_return(streq(result1, TEXT), EXIT_FAILURE);
+       result = strbuf_str(&buf);
+       assert_return(result == buf.bytes, EXIT_FAILURE);
+       assert_return(streq(result, TEXT), EXIT_FAILURE);
 
        strbuf_popchars(&buf, lastwordlen);
-       result2 = strbuf_steal(&buf);
-       assert_return(!streq(TEXT, result2), EXIT_FAILURE);
-       assert_return(strncmp(TEXT, result2, strlen(TEXT) - lastwordlen) == 0,
+       result = strbuf_str(&buf);
+       assert_return(!streq(TEXT, result), EXIT_FAILURE);
+       assert_return(strncmp(TEXT, result, strlen(TEXT) - lastwordlen) == 0,
                      EXIT_FAILURE);
-       assert_return(result2[strlen(TEXT) - lastwordlen] == '\0', EXIT_FAILURE);
+       assert_return(result[strlen(TEXT) - lastwordlen] == '\0', EXIT_FAILURE);
 
        free(str);
-       free(result2);
 
        return 0;
 }
 DEFINE_TEST(test_strbuf_pushchars,
            .description = "test strbuf_{pushchars, popchar, popchars}");
 
-static int test_strbuf_steal(const struct test *t)
-{
-       char *result;
-
-       {
-               _cleanup_strbuf_ struct strbuf buf;
-
-               strbuf_init(&buf);
-               strbuf_pushchars(&buf, TEXT);
-               result = strbuf_steal(&buf);
-       }
-
-       assert_return(streq(result, TEXT), EXIT_FAILURE);
-       free(result);
-
-       return 0;
-}
-DEFINE_TEST(test_strbuf_steal, .description = "test strbuf_steal with cleanup");
-
 static int test_strbuf_with_stack(const struct test *t)
 {
        const char test[] = "test-something-small";
        const char *stack_buf;
-       char *p;
+       const char *p;
        DECLARE_STRBUF_WITH_STACK(buf, 256);
        DECLARE_STRBUF_WITH_STACK(buf2, sizeof(test) + 1);
        DECLARE_STRBUF_WITH_STACK(buf3, sizeof(test) + 1);
 
        strbuf_pushchars(&buf, test);
        assert_return(streq(test, strbuf_str(&buf)), EXIT_FAILURE);
-       p = strbuf_steal(&buf);
+       p = strbuf_str(&buf);
        assert_return(streq(test, p), EXIT_FAILURE);
-       free(p);
 
        strbuf_pushchars(&buf2, test);
        assert_return(streq(test, strbuf_str(&buf2)), EXIT_FAILURE);
        /* It fits on stack, but when we steal, we get a copy on heap */
-       p = strbuf_steal(&buf2);
+       p = strbuf_str(&buf2);
        assert_return(streq(test, p), EXIT_FAILURE);
-       free(p);
 
        /*
         * Check assumption about buffer being on stack vs heap is indeed valid.