short i/o: clean up the naming for the write_{in,or}_xxx family

We recently introduced a write_in_full() which would either write
the specified object or emit an error message and fail.  In order
to fix the read side we now want to introduce a read_in_full()
but without an error emit.  This patch cleans up the naming
of this family of calls:

1) convert the existing write_or_whine() to write_or_whine_pipe()
   to better indicate its pipe specific nature,
2) convert the existing write_in_full() calls to write_or_whine()
   to better indicate its nature,
3) introduce a write_in_full() providing a write or fail semantic,
   and
4) convert write_or_whine() and write_or_whine_pipe() to use
   write_in_full().

Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>

diff --git a/cache.h b/cache.h
index 36be64e3868456b11bc9a6024be5e955074241b2..38a20a806950752f0449cf244e06149d5d5aca51 100644 (file)
--- a/cache.h
+++ b/cache.h
@@ -433,9 +433,10 @@ extern char *git_log_output_encoding;
 
 extern int copy_fd(int ifd, int ofd);
 extern void read_or_die(int fd, void *buf, size_t count);
-extern int write_in_full(int fd, const void *buf, size_t count, const char *);
+extern int write_in_full(int fd, const void *buf, size_t count);
 extern void write_or_die(int fd, const void *buf, size_t count);
 extern int write_or_whine(int fd, const void *buf, size_t count, const char *msg);
+extern int write_or_whine_pipe(int fd, const void *buf, size_t count, const char *msg);
 
 /* pager.c */
 extern void setup_pager(void);

diff --git a/send-pack.c b/send-pack.c
index c195d080db7c80420e1226f7591c9e9c3059536a..6756264b293e18467a59dc0222ee82e586cda76f 100644 (file)
--- a/send-pack.c
+++ b/send-pack.c
@@ -65,14 +65,14 @@ static int pack_objects(int fd, struct ref *refs)
                        memcpy(buf + 1, sha1_to_hex(refs->old_sha1), 40);
                        buf[0] = '^';
                        buf[41] = '\n';
-                       if (!write_in_full(pipe_fd[1], buf, 42,
+                       if (!write_or_whine(pipe_fd[1], buf, 42,
                                                "send-pack: send refs"))
                                break;
                }
                if (!is_null_sha1(refs->new_sha1)) {
                        memcpy(buf, sha1_to_hex(refs->new_sha1), 40);
                        buf[40] = '\n';
-                       if (!write_in_full(pipe_fd[1], buf, 41,
+                       if (!write_or_whine(pipe_fd[1], buf, 41,
                                                "send-pack: send refs"))
                                break;
                }

diff --git a/trace.c b/trace.c
index 495e5ed92a68837a8abbd1569b2ccb59a3d50429..27fef868c4e2276638873cbda7d353cf4b8f67ed 100644 (file)
--- a/trace.c
+++ b/trace.c
@@ -101,7 +101,7 @@ void trace_printf(const char *format, ...)
        nfvasprintf(&trace_str, format, rest);
        va_end(rest);
 
-       write_or_whine(fd, trace_str, strlen(trace_str), err_msg);
+       write_or_whine_pipe(fd, trace_str, strlen(trace_str), err_msg);
 
        free(trace_str);
 
@@ -139,7 +139,7 @@ void trace_argv_printf(const char **argv, int count, const char *format, ...)
        strncpy(trace_str + format_len, argv_str, argv_len);
        strcpy(trace_str + trace_len - 1, "\n");
 
-       write_or_whine(fd, trace_str, trace_len, err_msg);
+       write_or_whine_pipe(fd, trace_str, trace_len, err_msg);
 
        free(argv_str);
        free(format_str);

diff --git a/write_or_die.c b/write_or_die.c
index 6db1d3123d1761dee4850e0a56a9b86b4bf1722a..613c0c3f6e90cc6a1b7ae9c0ade4e5c10dc25029 100644 (file)
--- a/write_or_die.c
+++ b/write_or_die.c
@@ -35,49 +35,61 @@ void write_or_die(int fd, const void *buf, size_t count)
        }
 }
 
-int write_or_whine(int fd, const void *buf, size_t count, const char *msg)
+int write_in_full(int fd, const void *buf, size_t count)
 {
        const char *p = buf;
-       ssize_t written;
+       ssize_t total = 0;
+       ssize_t wcount = 0;
 
        while (count > 0) {
-               written = xwrite(fd, p, count);
-               if (written == 0) {
-                       fprintf(stderr, "%s: disk full?\n", msg);
-                       return 0;
-               }
-               else if (written < 0) {
-                       if (errno == EPIPE)
-                               exit(0);
-                       fprintf(stderr, "%s: write error (%s)\n",
-                               msg, strerror(errno));
-                       return 0;
+               wcount = xwrite(fd, p, count);
+               if (wcount <= 0) {
+                       if (total)
+                               return total;
+                       else
+                               return wcount;
                }
-               count -= written;
-               p += written;
+               count -= wcount;
+               p += wcount;
+               total += wcount;
+       }
+
+       return wcount;
+}
+
+int write_or_whine_pipe(int fd, const void *buf, size_t count, const char *msg)
+{
+       ssize_t written;
+
+       written = write_in_full(fd, buf, count);
+       if (written == 0) {
+               fprintf(stderr, "%s: disk full?\n", msg);
+               return 0;
+       }
+       else if (written < 0) {
+               if (errno == EPIPE)
+                       exit(0);
+               fprintf(stderr, "%s: write error (%s)\n",
+                       msg, strerror(errno));
+               return 0;
        }
 
        return 1;
 }
 
-int write_in_full(int fd, const void *buf, size_t count, const char *msg)
+int write_or_whine(int fd, const void *buf, size_t count, const char *msg)
 {
-       const char *p = buf;
        ssize_t written;
 
-       while (count > 0) {
-               written = xwrite(fd, p, count);
-               if (written == 0) {
-                       fprintf(stderr, "%s: disk full?\n", msg);
-                       return 0;
-               }
-               else if (written < 0) {
-                       fprintf(stderr, "%s: write error (%s)\n",
-                               msg, strerror(errno));
-                       return 0;
-               }
-               count -= written;
-               p += written;
+       written = write_in_full(fd, buf, count);
+       if (written == 0) {
+               fprintf(stderr, "%s: disk full?\n", msg);
+               return 0;
+       }
+       else if (written < 0) {
+               fprintf(stderr, "%s: write error (%s)\n",
+                       msg, strerror(errno));
+               return 0;
        }
 
        return 1;