"git-apply --check" should not report "fixed"

[git.git] / convert.c

diff --git a/convert.c b/convert.c
index 00a341c595ebb6ac6965001cce84d3d4e65f60c3..4df75595b1f3e689a9685039c372ffb4c8688291 100644 (file)
--- a/convert.c
+++ b/convert.c
@@ -1,7 +1,6 @@
 #include "cache.h"
 #include "attr.h"
 #include "run-command.h"
-#include "strbuf.h"
 
 /*
  * convert.c - convert a file when checking it out and checking it in.
@@ -111,7 +110,9 @@ static int crlf_to_git(const char *path, const char *src, size_t len,
                        return 0;
        }
 
-       strbuf_grow(buf, len);
+       /* only grow if not in place */
+       if (strbuf_avail(buf) + buf->len < len)
+               strbuf_grow(buf, len - buf->len);
        dst = buf->buf;
        if (action == CRLF_GUESS) {
                /*
@@ -169,7 +170,7 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
 
        /* are we "faking" in place editing ? */
        if (src == buf->buf)
-               to_free = strbuf_detach(buf);
+               to_free = strbuf_detach(buf, NULL);
 
        strbuf_grow(buf, len + stats.lf - stats.crlf);
        for (;;) {
@@ -191,48 +192,39 @@ static int crlf_to_worktree(const char *path, const char *src, size_t len,
        return 1;
 }
 
-static int filter_buffer(const char *path, const char *src,
-                        unsigned long size, const char *cmd)
+struct filter_params {
+       const char *src;
+       unsigned long size;
+       const char *cmd;
+};
+
+static int filter_buffer(int fd, void *data)
 {
        /*
         * Spawn cmd and feed the buffer contents through its stdin.
         */
        struct child_process child_process;
-       int pipe_feed[2];
+       struct filter_params *params = (struct filter_params *)data;
        int write_err, status;
+       const char *argv[] = { "sh", "-c", params->cmd, NULL };
 
        memset(&child_process, 0, sizeof(child_process));
+       child_process.argv = argv;
+       child_process.in = -1;
+       child_process.out = fd;
 
-       if (pipe(pipe_feed) < 0) {
-               error("cannot create pipe to run external filter %s", cmd);
-               return 1;
-       }
-
-       child_process.pid = fork();
-       if (child_process.pid < 0) {
-               error("cannot fork to run external filter %s", cmd);
-               close(pipe_feed[0]);
-               close(pipe_feed[1]);
-               return 1;
-       }
-       if (!child_process.pid) {
-               dup2(pipe_feed[0], 0);
-               close(pipe_feed[0]);
-               close(pipe_feed[1]);
-               execlp("sh", "sh", "-c", cmd, NULL);
-               return 1;
-       }
-       close(pipe_feed[0]);
+       if (start_command(&child_process))
+               return error("cannot fork to run external filter %s", params->cmd);
 
-       write_err = (write_in_full(pipe_feed[1], src, size) < 0);
-       if (close(pipe_feed[1]))
+       write_err = (write_in_full(child_process.in, params->src, params->size) < 0);
+       if (close(child_process.in))
                write_err = 1;
        if (write_err)
-               error("cannot feed the input to external filter %s", cmd);
+               error("cannot feed the input to external filter %s", params->cmd);
 
        status = finish_command(&child_process);
        if (status)
-               error("external filter %s failed %d", cmd, -status);
+               error("external filter %s failed %d", params->cmd, -status);
        return (write_err || status);
 }
 
@@ -245,57 +237,43 @@ static int apply_filter(const char *path, const char *src, size_t len,
         *
         * (child --> cmd) --> us
         */
-       int pipe_feed[2];
-       int status, ret = 1;
-       struct child_process child_process;
+       int ret = 1;
        struct strbuf nbuf;
+       struct async async;
+       struct filter_params params;
 
        if (!cmd)
                return 0;
 
-       memset(&child_process, 0, sizeof(child_process));
-
-       if (pipe(pipe_feed) < 0) {
-               error("cannot create pipe to run external filter %s", cmd);
-               return 0;
-       }
+       memset(&async, 0, sizeof(async));
+       async.proc = filter_buffer;
+       async.data = &params;
+       params.src = src;
+       params.size = len;
+       params.cmd = cmd;
 
        fflush(NULL);
-       child_process.pid = fork();
-       if (child_process.pid < 0) {
-               error("cannot fork to run external filter %s", cmd);
-               close(pipe_feed[0]);
-               close(pipe_feed[1]);
-               return 0;
-       }
-       if (!child_process.pid) {
-               dup2(pipe_feed[1], 1);
-               close(pipe_feed[0]);
-               close(pipe_feed[1]);
-               exit(filter_buffer(path, src, len, cmd));
-       }
-       close(pipe_feed[1]);
+       if (start_async(&async))
+               return 0;       /* error was already reported */
 
        strbuf_init(&nbuf, 0);
-       if (strbuf_read(&nbuf, pipe_feed[0], len) < 0) {
+       if (strbuf_read(&nbuf, async.out, len) < 0) {
                error("read from external filter %s failed", cmd);
                ret = 0;
        }
-       if (close(pipe_feed[0])) {
-               ret = error("read from external filter %s failed", cmd);
+       if (close(async.out)) {
+               error("read from external filter %s failed", cmd);
                ret = 0;
        }
-       status = finish_command(&child_process);
-       if (status) {
-               ret = error("external filter %s failed %d", cmd, -status);
+       if (finish_async(&async)) {
+               error("external filter %s failed", cmd);
                ret = 0;
        }
 
        if (ret) {
-               *dst = nbuf;
-       } else {
-               strbuf_release(&nbuf);
+               strbuf_swap(dst, &nbuf);
        }
+       strbuf_release(&nbuf);
        return ret;
 }
 
@@ -324,13 +302,8 @@ static int read_convert_config(const char *var, const char *value)
                if (!strncmp(drv->name, name, namelen) && !drv->name[namelen])
                        break;
        if (!drv) {
-               char *namebuf;
                drv = xcalloc(1, sizeof(struct convert_driver));
-               namebuf = xmalloc(namelen + 1);
-               memcpy(namebuf, name, namelen);
-               namebuf[namelen] = 0;
-               drv->name = namebuf;
-               drv->next = NULL;
+               drv->name = xmemdupz(name, namelen);
                *user_convert_tail = drv;
                user_convert_tail = &(drv->next);
        }
@@ -428,7 +401,9 @@ static int ident_to_git(const char *path, const char *src, size_t len,
        if (!ident || !count_ident(src, len))
                return 0;
 
-       strbuf_grow(buf, len);
+       /* only grow if not in place */
+       if (strbuf_avail(buf) + buf->len < len)
+               strbuf_grow(buf, len - buf->len);
        dst = buf->buf;
        for (;;) {
                dollar = memchr(src, '$', len);
@@ -470,7 +445,7 @@ static int ident_to_worktree(const char *path, const char *src, size_t len,
 
        /* are we "faking" in place editing ? */
        if (src == buf->buf)
-               to_free = strbuf_detach(buf);
+               to_free = strbuf_detach(buf, NULL);
        hash_sha1_file(src, len, "blob", sha1);
 
        strbuf_grow(buf, len + cnt * 43);