The current implementation of 'strbuf_split_buf()' includes the
terminator at the end of each strbuf post splitting. Include an option
wherein we can drop the terminator if required. In this context
introduce a wrapper function 'strbuf_split_str_without_term()' which
splits a given string into strbufs without including the terminator.

Signed-off-by: Karthik Nayak <karthik....@gmail.com>
---
 ref-filter.c |  5 +----
 strbuf.c     | 17 +++++++++++++----
 strbuf.h     | 14 ++++++++++----
 3 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/ref-filter.c b/ref-filter.c
index 0523d54..4e8b3c9 100644
--- a/ref-filter.c
+++ b/ref-filter.c
@@ -892,14 +892,11 @@ static void populate_value(struct ref_array_item *ref)
                         * TODO: Implement a function similar to 
strbuf_split_str()
                         * which would omit the separator from the end of each 
value.
                         */
-                       s = to_free = strbuf_split_str(valp, ',', 0);
+                       s = to_free = strbuf_split_str_without_term(valp, ',', 
0);
 
                        align->position = ALIGN_LEFT;
 
                        while (*s) {
-                               /*  Strip trailing comma */
-                               if (s[1])
-                                       strbuf_setlen(s[0], s[0]->len - 1);
                                if (!strtoul_ui(s[0]->buf, 10, (unsigned int 
*)&width))
                                        ;
                                else if (!strcmp(s[0]->buf, "left"))
diff --git a/strbuf.c b/strbuf.c
index b552a13..d31336f 100644
--- a/strbuf.c
+++ b/strbuf.c
@@ -115,7 +115,7 @@ void strbuf_tolower(struct strbuf *sb)
 }
 
 struct strbuf **strbuf_split_buf(const char *str, size_t slen,
-                                int terminator, int max)
+                                int terminator, int max, int with_term)
 {
        struct strbuf **ret = NULL;
        size_t nr = 0, alloc = 0;
@@ -123,18 +123,27 @@ struct strbuf **strbuf_split_buf(const char *str, size_t 
slen,
 
        while (slen) {
                int len = slen;
+               int term = with_term;
                if (max <= 0 || nr + 1 < max) {
                        const char *end = memchr(str, terminator, slen);
                        if (end)
-                               len = end - str + 1;
+                               len = end - str + term;
+                       else
+                               /*  When no terminator present, we must add the 
last character */
+                               term = 1;
                }
                t = xmalloc(sizeof(struct strbuf));
                strbuf_init(t, len);
                strbuf_add(t, str, len);
                ALLOC_GROW(ret, nr + 2, alloc);
                ret[nr++] = t;
-               str += len;
-               slen -= len;
+               if (!term) {
+                       str += len + 1;
+                       slen -= len + 1;
+               } else {
+                       str += len;
+                       slen -= len;
+               }
        }
        ALLOC_GROW(ret, nr + 1, alloc); /* In case string was empty */
        ret[nr] = NULL;
diff --git a/strbuf.h b/strbuf.h
index 6ae7a72..63e1e69 100644
--- a/strbuf.h
+++ b/strbuf.h
@@ -465,19 +465,25 @@ static inline int strbuf_strip_suffix(struct strbuf *sb, 
const char *suffix)
  * For lighter-weight alternatives, see string_list_split() and
  * string_list_split_in_place().
  */
-extern struct strbuf **strbuf_split_buf(const char *, size_t,
-                                       int terminator, int max);
+extern struct strbuf **strbuf_split_buf(const char *str, size_t slen,
+                                       int terminator, int max, int with_term);
+
+static inline struct strbuf **strbuf_split_str_without_term(const char *str,
+                                                           int terminator, int 
max)
+{
+       return strbuf_split_buf(str, strlen(str), terminator, max, 0);
+}
 
 static inline struct strbuf **strbuf_split_str(const char *str,
                                               int terminator, int max)
 {
-       return strbuf_split_buf(str, strlen(str), terminator, max);
+       return strbuf_split_buf(str, strlen(str), terminator, max, 1);
 }
 
 static inline struct strbuf **strbuf_split_max(const struct strbuf *sb,
                                                int terminator, int max)
 {
-       return strbuf_split_buf(sb->buf, sb->len, terminator, max);
+       return strbuf_split_buf(sb->buf, sb->len, terminator, max, 1);
 }
 
 static inline struct strbuf **strbuf_split(const struct strbuf *sb,
-- 
2.6.2

--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to