lib/fastbuf.c

   1 /*
   2  *      Sherlock Library -- Fast File Buffering
   3  *
   4  *      (c) 1997 Martin Mares, <mj@atrey.karlin.mff.cuni.cz>
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <fcntl.h>
  11 #include <unistd.h>
  12
  13 #include "lib.h"
  14 #include "fastbuf.h"
  15
  16 struct fastbuf *__bfdopen(int fd, uns buffer, byte *name)
  17 {
  18   struct fastbuf *b = xmalloc(sizeof(struct fastbuf));
  19
  20   b->buflen = buffer;
  21   b->buffer = xmalloc(buffer);
  22   b->bptr = b->bstop = b->buffer;
  23   b->bufend = b->buffer + buffer;
  24   b->name = stralloc(name);
  25   b->pos = b->fdpos = 0;
  26   b->fd = fd;
  27   return b;
  28 }
  29
  30 struct fastbuf *
  31 bopen(byte *name, uns mode, uns buffer)
  32 {
  33   int fd = open(name, mode, 0666);
  34
  35   if (fd < 0)
  36     die("Unable to %s file %s: %m",
  37         (mode & O_CREAT) ? "create" : "open", name);
  38   return __bfdopen(fd, buffer, name);
  39 }
  40
  41 struct fastbuf *
  42 bfdopen(int fd, uns buffer)
  43 {
  44   byte x[32];
  45
  46   sprintf(x, "fd%d", fd);
  47   return __bfdopen(fd, buffer, x);
  48 }
  49
  50 void bclose(struct fastbuf *f)
  51 {
  52   bflush(f);
  53   close(f->fd);
  54   free(f->name);
  55   free(f->buffer);
  56   free(f);
  57 }
  58
  59 static int
  60 rdbuf(struct fastbuf *f)
  61 {
  62   int l = read(f->fd, f->buffer, f->buflen);
  63
  64   if (l < 0)
  65     die("Error reading %s: %m", f->name);
  66   f->bptr = f->buffer;
  67   f->bstop = f->buffer + l;
  68   f->pos = f->fdpos;
  69   f->fdpos += l;
  70   return l;
  71 }
  72
  73 static void
  74 wrbuf(struct fastbuf *f)
  75 {
  76   int l = f->bptr - f->buffer;
  77
  78   if (l)
  79     {
  80       if (write(f->fd, f->buffer, l) != l)
  81         die("Error writing %s: %m");
  82       f->bptr = f->buffer;
  83       f->fdpos += l;
  84       f->pos = f->fdpos;
  85     }
  86 }
  87
  88 void bflush(struct fastbuf *f)
  89 {
  90   if (f->bptr != f->buffer)
  91     {                                   /* Have something to flush */
  92       if (f->bstop > f->buffer)
  93         {                               /* And it's read data */
  94           f->bptr = f->bstop = f->buffer;
  95         }
  96       else
  97         {                               /* Write data */
  98           wrbuf(f);
  99         }
 100     }
 101 }
 102
 103 inline void bsetpos(struct fastbuf *f, uns pos)
 104 {
 105   if (pos >= f->pos
 106       && (pos <= f->pos + (f->bptr - f->buffer) || pos <= f->pos + (f->bstop - f->buffer)))
 107     {
 108       f->bptr = f->buffer + (pos - f->pos);
 109     }
 110   else
 111     {
 112       bflush(f);
 113       if (f->fdpos != pos && lseek(f->fd, pos, SEEK_SET) < 0)
 114         die("lseek on %s: %m", f->name);
 115       f->fdpos = f->pos = pos;
 116     }
 117 }
 118
 119 void bseek(struct fastbuf *f, uns pos, int whence)
 120 {
 121   int l;
 122
 123   switch (whence)
 124     {
 125     case SEEK_SET:
 126       return bsetpos(f, pos);
 127     case SEEK_CUR:
 128       return bsetpos(f, btell(f) + pos);
 129     case SEEK_END:
 130       bflush(f);
 131       l = lseek(f->fd, pos, whence);
 132       if (l < 0)
 133         die("lseek on %s: %m", f->name);
 134       f->fdpos = f->pos = l;
 135       break;
 136     default:
 137       die("bseek: invalid whence=%d", whence);
 138     }
 139 }
 140
 141 int bgetc_slow(struct fastbuf *f)
 142 {
 143   if (f->bptr < f->bstop)
 144     return *f->bptr++;
 145   if (!rdbuf(f))
 146     return EOF;
 147   return *f->bptr++;
 148 }
 149
 150 void bputc_slow(struct fastbuf *f, byte c)
 151 {
 152   if (f->bptr >= f->bufend)
 153     wrbuf(f);
 154   *f->bptr++ = c;
 155 }
 156
 157 word bgetw_slow(struct fastbuf *f)
 158 {
 159   word w = bgetc_slow(f);
 160 #ifdef CPU_BIG_ENDIAN
 161   return (w << 8) | bgetc_slow(f);
 162 #else
 163   return w | (bgetc_slow(f) << 8);
 164 #endif
 165 }
 166
 167 ulg bgetl_slow(struct fastbuf *f)
 168 {
 169   ulg l = bgetc_slow(f);
 170 #ifdef CPU_BIG_ENDIAN
 171   l = (l << 8) | bgetc_slow(f);
 172   l = (l << 8) | bgetc_slow(f);
 173   return (l << 8) | bgetc_slow(f);
 174 #else
 175   l = (bgetc_slow(f) << 8) | l;
 176   l = (bgetc_slow(f) << 16) | l;
 177   return (bgetc_slow(f) << 24) | l;
 178 #endif
 179 }
 180
 181 void bputw_slow(struct fastbuf *f, word w)
 182 {
 183 #ifdef CPU_BIG_ENDIAN
 184   bputc_slow(f, w >> 8);
 185   bputc_slow(f, w);
 186 #else
 187   bputc_slow(f, w);
 188   bputc_slow(f, w >> 8);
 189 #endif
 190 }
 191
 192 void bputl_slow(struct fastbuf *f, ulg l)
 193 {
 194 #ifdef CPU_BIG_ENDIAN
 195   bputc_slow(f, l >> 24);
 196   bputc_slow(f, l >> 16);
 197   bputc_slow(f, l >> 8);
 198   bputc_slow(f, l);
 199 #else
 200   bputc_slow(f, l);
 201   bputc_slow(f, l >> 8);
 202   bputc_slow(f, l >> 16);
 203   bputc_slow(f, l >> 24);
 204 #endif
 205 }
 206
 207 void bread_slow(struct fastbuf *f, void *b, uns l)
 208 {
 209   while (l)
 210     {
 211       uns k = f->bstop - f->bptr;
 212
 213       if (!k)
 214         {
 215           rdbuf(f);
 216           k = f->bstop - f->bptr;
 217           if (!k)
 218             die("bread on %s: file exhausted", f->name);
 219         }
 220       if (k > l)
 221         k = l;
 222       memcpy(b, f->bptr, k);
 223       f->bptr += k;
 224       b = (byte *)b + k;
 225       l -= k;
 226     }
 227 }
 228
 229 void bwrite_slow(struct fastbuf *f, void *b, uns l)
 230 {
 231   while (l)
 232     {
 233       uns k = f->bufend - f->bptr;
 234
 235       if (!k)
 236         {
 237           wrbuf(f);
 238           k = f->bufend - f->bptr;
 239         }
 240       if (k > l)
 241         k = l;
 242       memcpy(f->bptr, b, k);
 243       f->bptr += k;
 244       b = (byte *)b + k;
 245       l -= k;
 246     }
 247 }
 248
 249 void bbcopy(struct fastbuf *f, struct fastbuf *t, uns l)
 250 {
 251   uns rf = f->bstop - f->bptr;
 252   uns rt = t->bufend - t->bptr;
 253
 254   if (!l)
 255     return;
 256   if (rf && rt)
 257     {
 258       uns k = l;
 259       if (k > rf)
 260         k = rf;
 261       if (k > rt)
 262         k = rt;
 263       memcpy(t->bptr, f->bptr, k);
 264       t->bptr += k;
 265       f->bptr += k;
 266       l -= k;
 267     }
 268   while (l >= t->buflen)
 269     {
 270       wrbuf(t);
 271       if (read(f->fd, t->buffer, t->buflen) != t->buflen)
 272         die("bbcopy: %s exhausted", f->name);
 273       f->fdpos += t->buflen;
 274       t->bptr = t->bufend;
 275       l -= t->buflen;
 276     }
 277   while (l)
 278     {
 279       uns k = t->bufend - t->bptr;
 280
 281       if (!k)
 282         {
 283           wrbuf(t);
 284           k = t->bufend - t->bptr;
 285         }
 286       if (k > l)
 287         k = l;
 288       bread(f, t->bptr, k);
 289       t->bptr += k;
 290       l -= k;
 291     }
 292 }
 293
 294 #ifdef TEST
 295
 296 int main(int argc, char **argv)
 297 {
 298   struct fastbuf *f, *t;
 299   int c;
 300
 301   f = bopen("/etc/profile", O_RDONLY, 16);
 302   t = bfdopen(1, 13);
 303   bbcopy(f, t, 100);
 304   bclose(f);
 305   bclose(t);
 306 }
 307
 308 #endif