vcs-svn: teach line_buffer to handle multiple input files

diff --git a/vcs-svn/line_buffer.c b/vcs-svn/line_buffer.c
index 1543567093fad603e09ba61b2fc47ec232b4cae2..806932b32187bece9076131c69e8f80ae0c3a58a 100644 (file)
--- a/vcs-svn/line_buffer.c
+++ b/vcs-svn/line_buffer.c
@@ -5,47 +5,39 @@
 
 #include "git-compat-util.h"
 #include "line_buffer.h"
-#include "obj_pool.h"
+#include "strbuf.h"
 
-#define LINE_BUFFER_LEN 10000
 #define COPY_BUFFER_LEN 4096
 
-/* Create memory pool for char sequence of known length */
-obj_pool_gen(blob, char, 4096)
-
-static char line_buffer[LINE_BUFFER_LEN];
-static char byte_buffer[COPY_BUFFER_LEN];
-static FILE *infile;
-
-int buffer_init(const char *filename)
+int buffer_init(struct line_buffer *buf, const char *filename)
 {
-       infile = filename ? fopen(filename, "r") : stdin;
-       if (!infile)
+       buf->infile = filename ? fopen(filename, "r") : stdin;
+       if (!buf->infile)
                return -1;
        return 0;
 }
 
-int buffer_deinit(void)
+int buffer_deinit(struct line_buffer *buf)
 {
        int err;
-       if (infile == stdin)
-               return ferror(infile);
-       err = ferror(infile);
-       err |= fclose(infile);
+       if (buf->infile == stdin)
+               return ferror(buf->infile);
+       err = ferror(buf->infile);
+       err |= fclose(buf->infile);
        return err;
 }
 
 /* Read a line without trailing newline. */
-char *buffer_read_line(void)
+char *buffer_read_line(struct line_buffer *buf)
 {
        char *end;
-       if (!fgets(line_buffer, sizeof(line_buffer), infile))
+       if (!fgets(buf->line_buffer, sizeof(buf->line_buffer), buf->infile))
                /* Error or data exhausted. */
                return NULL;
-       end = line_buffer + strlen(line_buffer);
+       end = buf->line_buffer + strlen(buf->line_buffer);
        if (end[-1] == '\n')
                end[-1] = '\0';
-       else if (feof(infile))
+       else if (feof(buf->infile))
                ; /* No newline at end of file.  That's fine. */
        else
                /*
@@ -54,44 +46,44 @@ char *buffer_read_line(void)
                 * but for now let's return an error.
                 */
                return NULL;
-       return line_buffer;
+       return buf->line_buffer;
 }
 
-char *buffer_read_string(uint32_t len)
+char *buffer_read_string(struct line_buffer *buf, uint32_t len)
 {
-       char *s;
-       blob_free(blob_pool.size);
-       s = blob_pointer(blob_alloc(len + 1));
-       s[fread(s, 1, len, infile)] = '\0';
-       return ferror(infile) ? NULL : s;
+       strbuf_reset(&buf->blob_buffer);
+       strbuf_fread(&buf->blob_buffer, len, buf->infile);
+       return ferror(buf->infile) ? NULL : buf->blob_buffer.buf;
 }
 
-void buffer_copy_bytes(uint32_t len)
+void buffer_copy_bytes(struct line_buffer *buf, uint32_t len)
 {
+       char byte_buffer[COPY_BUFFER_LEN];
        uint32_t in;
-       while (len > 0 && !feof(infile) && !ferror(infile)) {
+       while (len > 0 && !feof(buf->infile) && !ferror(buf->infile)) {
                in = len < COPY_BUFFER_LEN ? len : COPY_BUFFER_LEN;
-               in = fread(byte_buffer, 1, in, infile);
+               in = fread(byte_buffer, 1, in, buf->infile);
                len -= in;
                fwrite(byte_buffer, 1, in, stdout);
                if (ferror(stdout)) {
-                       buffer_skip_bytes(len);
+                       buffer_skip_bytes(buf, len);
                        return;
                }
        }
 }
 
-void buffer_skip_bytes(uint32_t len)
+void buffer_skip_bytes(struct line_buffer *buf, uint32_t len)
 {
+       char byte_buffer[COPY_BUFFER_LEN];
        uint32_t in;
-       while (len > 0 && !feof(infile) && !ferror(infile)) {
+       while (len > 0 && !feof(buf->infile) && !ferror(buf->infile)) {
                in = len < COPY_BUFFER_LEN ? len : COPY_BUFFER_LEN;
-               in = fread(byte_buffer, 1, in, infile);
+               in = fread(byte_buffer, 1, in, buf->infile);
                len -= in;
        }
 }
 
-void buffer_reset(void)
+void buffer_reset(struct line_buffer *buf)
 {
-       blob_reset();
+       strbuf_release(&buf->blob_buffer);
 }