line_buffer.c

   1 /*
   2  * Licensed under a two-clause BSD-style license.
   3  * See LICENSE for details.
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #include "line_buffer.h"
  11 #include "strbuf.h"
  12
  13 #define COPY_BUFFER_LEN 4096
  14
  15 int buffer_init(struct line_buffer *buf, const char *filename)
  16 {
  17         buf->infile = filename ? fopen(filename, "r") : stdin;
  18         if (!buf->infile)
  19                 return -1;
  20         return 0;
  21 }
  22
  23 int buffer_deinit(struct line_buffer *buf)
  24 {
  25         int err;
  26         if (buf->infile == stdin)
  27                 return ferror(buf->infile);
  28         err = ferror(buf->infile);
  29         err |= fclose(buf->infile);
  30         return err;
  31 }
  32
  33 int buffer_ferror(struct line_buffer *buf)
  34 {
  35         return ferror(buf->infile);
  36 }
  37
  38 int buffer_at_eof(struct line_buffer *buf)
  39 {
  40         int ch;
  41         if ((ch = fgetc(buf->infile)) == EOF)
  42                 return 1;
  43         if (ungetc(ch, buf->infile) == EOF)
  44                 return error("cannot unget %c: %s\n", ch, strerror(errno));
  45         return 0;
  46 }
  47
  48 int buffer_read_char(struct line_buffer *buf)
  49 {
  50         return fgetc(buf->infile);
  51 }
  52
  53 /* Read a line without trailing newline. */
  54 char *buffer_read_line(struct line_buffer *buf)
  55 {
  56         char *end;
  57         if (!fgets(buf->line_buffer, sizeof(buf->line_buffer), buf->infile))
  58                 /* Error or data exhausted. */
  59                 return NULL;
  60         end = buf->line_buffer + strlen(buf->line_buffer);
  61         if (end[-1] == '\n')
  62                 end[-1] = '\0';
  63         else if (feof(buf->infile))
  64                 ; /* No newline at end of file.  That's fine. */
  65         else
  66                 /*
  67                  * Line was too long.
  68                  * There is probably a saner way to deal with this,
  69                  * but for now let's return an error.
  70                  */
  71                 return NULL;
  72         return buf->line_buffer;
  73 }
  74
  75 char *buffer_read_string(struct line_buffer *buf, uint32_t len)
  76 {
  77         strbuf_reset(&buf->blob_buffer);
  78         strbuf_fread(&buf->blob_buffer, len, buf->infile);
  79         return ferror(buf->infile) ? NULL : buf->blob_buffer.buf;
  80 }
  81
  82 void buffer_read_binary(struct strbuf *sb, uint32_t size,
  83                         struct line_buffer *buf)
  84 {
  85         strbuf_fread(sb, size, buf->infile);
  86 }
  87
  88 void buffer_copy_bytes(struct line_buffer *buf, off_t len)
  89 {
  90         char byte_buffer[COPY_BUFFER_LEN];
  91         uint32_t in;
  92         while (len > 0 && !feof(buf->infile) && !ferror(buf->infile)) {
  93                 in = len < COPY_BUFFER_LEN ? len : COPY_BUFFER_LEN;
  94                 in = fread(byte_buffer, 1, in, buf->infile);
  95                 len -= in;
  96                 fwrite(byte_buffer, 1, in, stdout);
  97                 if (ferror(stdout)) {
  98                         buffer_skip_bytes(buf, len);
  99                         return;
 100                 }
 101         }
 102 }
 103
 104 off_t buffer_skip_bytes(struct line_buffer *buf, off_t nbytes)
 105 {
 106         off_t done = 0;
 107         while (done < nbytes && !feof(buf->infile) && !ferror(buf->infile)) {
 108                 char byte_buffer[COPY_BUFFER_LEN];
 109                 off_t len = nbytes - done;
 110                 uint32_t in = len < COPY_BUFFER_LEN ? len : COPY_BUFFER_LEN;
 111                 done += fread(byte_buffer, 1, in, buf->infile);
 112         }
 113         return done;
 114 }
 115
 116 void buffer_reset(struct line_buffer *buf)
 117 {
 118         strbuf_release(&buf->blob_buffer);
 119 }