lib/fastbuf.h

   1 /*
   2  *      Sherlock Library -- Fast File Buffering
   3  *
   4  *      (c) 1997--1999 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
   5  */
   6
   7 #ifndef EOF
   8 #include <stdio.h>
   9 #endif
  10
  11 struct fastbuf {
  12   byte *bptr, *bstop;                   /* Access pointers */
  13   byte *buffer, *bufend;                /* Start and end of the buffer */
  14   byte *name;                           /* File name for error messages */
  15   uns buflen;                           /* Size of standard portion of the buffer */
  16   sh_off_t pos;                         /* Position of bptr in the file */
  17   sh_off_t fdpos;                       /* Current position in the file */
  18   int fd;                               /* File descriptor */
  19 };
  20
  21 struct fastbuf *bopen(byte *name, uns mode, uns buffer);
  22 struct fastbuf *bfdopen(int fd, uns buffer);
  23 void bclose(struct fastbuf *f);
  24 void bflush(struct fastbuf *f);
  25
  26 void bseek(struct fastbuf *f, sh_off_t pos, int whence);
  27 void bsetpos(struct fastbuf *f, sh_off_t pos);
  28
  29 extern inline sh_off_t btell(struct fastbuf *f)
  30 {
  31   return f->pos + (f->bptr - f->buffer);
  32 }
  33
  34 int bgetc_slow(struct fastbuf *f);
  35 extern inline int bgetc(struct fastbuf *f)
  36 {
  37   return (f->bptr < f->bstop) ? (int) *f->bptr++ : bgetc_slow(f);
  38 }
  39
  40 int bpeekc_slow(struct fastbuf *f);
  41 extern inline int bpeekc(struct fastbuf *f)
  42 {
  43   return (f->bptr < f->bstop) ? (int) *f->bptr : bpeekc_slow(f);
  44 }
  45
  46 extern inline void bungetc(struct fastbuf *f, byte c)
  47 {
  48   *--f->bptr = c;
  49 }
  50
  51 void bputc_slow(struct fastbuf *f, byte c);
  52 extern inline void bputc(struct fastbuf *f, byte c)
  53 {
  54   if (f->bptr < f->bufend)
  55     *f->bptr++ = c;
  56   else
  57     bputc_slow(f, c);
  58 }
  59
  60 word bgetw_slow(struct fastbuf *f);
  61 extern inline word bgetw(struct fastbuf *f)
  62 {
  63   word w;
  64   if (f->bptr + 2 <= f->bstop)
  65     {
  66       byte *p = f->bptr;
  67 #ifdef CPU_CAN_DO_UNALIGNED_WORDS
  68       w = * ((word *) p);
  69 #else
  70 #ifdef CPU_BIG_ENDIAN
  71       w = (p[0] << 8) | p[1];
  72 #else
  73       w = (p[1] << 8) | p[0];
  74 #endif
  75 #endif
  76       f->bptr += 2;
  77       return w;
  78     }
  79   else
  80     return bgetw_slow(f);
  81 }
  82
  83 u32 bgetl_slow(struct fastbuf *f);
  84 extern inline u32 bgetl(struct fastbuf *f)
  85 {
  86   u32 l;
  87   if (f->bptr + 4 <= f->bstop)
  88     {
  89       byte *p = f->bptr;
  90 #ifdef CPU_CAN_DO_UNALIGNED_LONGS
  91       l = * ((u32 *) p);
  92 #else
  93 #ifdef CPU_BIG_ENDIAN
  94       l = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
  95 #else
  96       l = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
  97 #endif
  98 #endif
  99       f->bptr += 4;
 100       return l;
 101     }
 102   else
 103     return bgetl_slow(f);
 104 }
 105
 106 u64 bgetq_slow(struct fastbuf *f);
 107 extern inline u64 bgetq(struct fastbuf *f)
 108 {
 109   if (f->bptr + 8 <= f->bstop)
 110     {
 111       u64 l;
 112       memcpy(&l, f->bptr, 8);
 113       f->bptr += 8;
 114       return l;
 115     }
 116   else
 117     return bgetq_slow(f);
 118 }
 119
 120 u64 bget5_slow(struct fastbuf *f);
 121 extern inline u64 bget5(struct fastbuf *f)
 122 {
 123   u64 l;
 124   if (f->bptr + 5 <= f->bstop)
 125     {
 126       byte *p = f->bptr;
 127 #ifdef CPU_BIG_ENDIAN
 128       l = ((u64)p[0] << 32) | (u32)((p[1] << 24) | (p[2] << 16) | (p[3] << 8) | p[4]);
 129 #else
 130       l = ((u64)p[4] << 32) | (u32)((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
 131 #endif
 132       f->bptr += 5;
 133       return l;
 134     }
 135   else
 136     return bget5_slow(f);
 137 }
 138
 139 void bputw_slow(struct fastbuf *f, word w);
 140 extern inline void bputw(struct fastbuf *f, word w)
 141 {
 142   if (f->bptr + 2 <= f->bufend)
 143     {
 144       byte *p = f->bptr;
 145 #ifdef CPU_CAN_DO_UNALIGNED_WORDS
 146       * ((word *) p) = w;
 147 #else
 148 #ifdef CPU_BIG_ENDIAN
 149       p[0] = w >> 8U;
 150       p[1] = w;
 151 #else
 152       p[1] = w >> 8U;
 153       p[0] = w;
 154 #endif
 155 #endif
 156       f->bptr += 2;
 157     }
 158   else
 159     bputw_slow(f, w);
 160 }
 161
 162 void bputl_slow(struct fastbuf *f, u32 l);
 163 extern inline void bputl(struct fastbuf *f, u32 l)
 164 {
 165   if (f->bptr + 4 <= f->bufend)
 166     {
 167       byte *p = f->bptr;
 168 #ifdef CPU_CAN_DO_UNALIGNED_LONGS
 169       * ((u32 *) p) = l;
 170 #else
 171 #ifdef CPU_BIG_ENDIAN
 172       p[0] = l >> 24U;
 173       p[1] = l >> 16U;
 174       p[2] = l >> 8U;
 175       p[3] = l;
 176 #else
 177       p[3] = l >> 24U;
 178       p[2] = l >> 16U;
 179       p[1] = l >> 8U;
 180       p[0] = l;
 181 #endif
 182 #endif
 183       f->bptr += 4;
 184     }
 185   else
 186     bputl_slow(f, l);
 187 }
 188
 189 void bputq_slow(struct fastbuf *f, u64 l);
 190 extern inline void bputq(struct fastbuf *f, u64 l)
 191 {
 192   if (f->bptr + 8 <= f->bufend)
 193     {
 194       memcpy(f->bptr, &l, 8);
 195       f->bptr += 8;
 196     }
 197   else
 198     bputq_slow(f, l);
 199 }
 200
 201 void bput5_slow(struct fastbuf *f, u64 l);
 202 extern inline void bput5(struct fastbuf *f, u64 l)
 203 {
 204   if (f->bptr + 5 <= f->bufend)
 205     {
 206       byte *p = f->bptr;
 207       u32 low = l;
 208 #ifdef CPU_BIG_ENDIAN
 209       p[0] = l >> 32U;
 210       p[1] = low >> 24U;
 211       p[2] = low >> 16U;
 212       p[3] = low >> 8U;
 213       p[4] = low;
 214 #else
 215       p[4] = l >> 32U;
 216       p[3] = low >> 24U;
 217       p[2] = low >> 16U;
 218       p[1] = low >> 8U;
 219       p[0] = low;
 220 #endif
 221       f->bptr += 5;
 222     }
 223   else
 224     bput5_slow(f, l);
 225 }
 226
 227 void bread_slow(struct fastbuf *f, void *b, uns l);
 228 extern inline void bread(struct fastbuf *f, void *b, uns l)
 229 {
 230   if (f->bptr + l <= f->bstop)
 231     {
 232       memcpy(b, f->bptr, l);
 233       f->bptr += l;
 234     }
 235   else
 236     bread_slow(f, b, l);
 237 }
 238
 239 void bwrite_slow(struct fastbuf *f, void *b, uns l);
 240 extern inline void bwrite(struct fastbuf *f, void *b, uns l)
 241 {
 242   if (f->bptr + l <= f->bufend)
 243     {
 244       memcpy(f->bptr, b, l);
 245       f->bptr += l;
 246     }
 247   else
 248     bwrite_slow(f, b, l);
 249 }
 250
 251 void bbcopy(struct fastbuf *f, struct fastbuf *t, uns l);
 252 byte *bgets(struct fastbuf *f, byte *b, uns l); /* Non-std */
 253
 254 extern inline void
 255 bputs(struct fastbuf *f, byte *b)
 256 {
 257   bwrite(f, b, strlen(b));
 258 }
 259
 260 extern inline void
 261 bputsn(struct fastbuf *f, byte *b)
 262 {
 263   bputs(f, b);
 264   bputc(f, '\n');
 265 }
 266
 267 #ifdef SHERLOCK_CONFIG_LARGE_DB
 268 #define bgeto(f) bget5(f)
 269 #define bputo(f,l) bput5(f,l)
 270 #define bgetp(f) bgetq(f)
 271 #define bputp(f,l) bputq(f,l)
 272 #else
 273 #define bgeto(f) bgetl(f)
 274 #define bputo(f,l) bputl(f,l)
 275 #define bgetp(f) bgetl(f)
 276 #define bputp(f,l) bputl(f,l)
 277 #endif