git-completion.bash: add support for path completion

diff --git a/strbuf.c b/strbuf.c
index 692cf1bd9a5e7d97d68eb44722afbdd1b59d2cda..05d0693eba1eba4e2f21057388368c0890e668fe 100644 (file)
--- a/strbuf.c
+++ b/strbuf.c
@@ -44,7 +44,9 @@ void strbuf_release(struct strbuf *sb)
 
 char *strbuf_detach(struct strbuf *sb, size_t *sz)
 {
-       char *res = sb->alloc ? sb->buf : NULL;
+       char *res;
+       strbuf_grow(sb, 0);
+       res = sb->buf;
        if (sz)
                *sz = sb->len;
        strbuf_init(sb, 0);
@@ -104,35 +106,30 @@ void strbuf_ltrim(struct strbuf *sb)
        sb->buf[sb->len] = '\0';
 }
 
-struct strbuf **strbuf_split_buf(const char *str, size_t slen, int delim, int max)
+struct strbuf **strbuf_split_buf(const char *str, size_t slen,
+                                int terminator, int max)
 {
-       int alloc = 2, pos = 0;
-       const char *n, *p;
-       struct strbuf **ret;
+       struct strbuf **ret = NULL;
+       size_t nr = 0, alloc = 0;
        struct strbuf *t;
 
-       ret = xcalloc(alloc, sizeof(struct strbuf *));
-       p = n = str;
-       while (n < str + slen) {
-               int len;
-               if (max <= 0 || pos + 1 < max)
-                       n = memchr(n, delim, slen - (n - str));
-               else
-                       n = NULL;
-               if (pos + 1 >= alloc) {
-                       alloc = alloc * 2;
-                       ret = xrealloc(ret, sizeof(struct strbuf *) * alloc);
+       while (slen) {
+               int len = slen;
+               if (max <= 0 || nr + 1 < max) {
+                       const char *end = memchr(str, terminator, slen);
+                       if (end)
+                               len = end - str + 1;
                }
-               if (!n)
-                       n = str + slen - 1;
-               len = n - p + 1;
                t = xmalloc(sizeof(struct strbuf));
                strbuf_init(t, len);
-               strbuf_add(t, p, len);
-               ret[pos] = t;
-               ret[++pos] = NULL;
-               p = ++n;
+               strbuf_add(t, str, len);
+               ALLOC_GROW(ret, nr + 2, alloc);
+               ret[nr++] = t;
+               str += len;
+               slen -= len;
        }
+       ALLOC_GROW(ret, nr + 1, alloc); /* In case string was empty */
+       ret[nr] = NULL;
        return ret;
 }
 
@@ -413,3 +410,78 @@ int strbuf_read_file(struct strbuf *sb, const char *path, size_t hint)
 
        return len;
 }
+
+void strbuf_add_lines(struct strbuf *out, const char *prefix,
+                     const char *buf, size_t size)
+{
+       while (size) {
+               const char *next = memchr(buf, '\n', size);
+               next = next ? (next + 1) : (buf + size);
+               strbuf_addstr(out, prefix);
+               strbuf_add(out, buf, next - buf);
+               size -= next - buf;
+               buf = next;
+       }
+       strbuf_complete_line(out);
+}
+
+static int is_rfc3986_reserved(char ch)
+{
+       switch (ch) {
+               case '!': case '*': case '\'': case '(': case ')': case ';':
+               case ':': case '@': case '&': case '=': case '+': case '$':
+               case ',': case '/': case '?': case '#': case '[': case ']':
+                       return 1;
+       }
+       return 0;
+}
+
+static int is_rfc3986_unreserved(char ch)
+{
+       return isalnum(ch) ||
+               ch == '-' || ch == '_' || ch == '.' || ch == '~';
+}
+
+static void strbuf_add_urlencode(struct strbuf *sb, const char *s, size_t len,
+                                int reserved)
+{
+       strbuf_grow(sb, len);
+       while (len--) {
+               char ch = *s++;
+               if (is_rfc3986_unreserved(ch) ||
+                   (!reserved && is_rfc3986_reserved(ch)))
+                       strbuf_addch(sb, ch);
+               else
+                       strbuf_addf(sb, "%%%02x", ch);
+       }
+}
+
+void strbuf_addstr_urlencode(struct strbuf *sb, const char *s,
+                            int reserved)
+{
+       strbuf_add_urlencode(sb, s, strlen(s), reserved);
+}
+
+int printf_ln(const char *fmt, ...)
+{
+       int ret;
+       va_list ap;
+       va_start(ap, fmt);
+       ret = vprintf(fmt, ap);
+       va_end(ap);
+       if (ret < 0 || putchar('\n') == EOF)
+               return -1;
+       return ret + 1;
+}
+
+int fprintf_ln(FILE *fp, const char *fmt, ...)
+{
+       int ret;
+       va_list ap;
+       va_start(ap, fmt);
+       ret = vfprintf(fp, fmt, ap);
+       va_end(ap);
+       if (ret < 0 || putc('\n', fp) == EOF)
+               return -1;
+       return ret + 1;
+}