]> mj.ucw.cz Git - libucw.git/blob - lib/fastbuf.h
Added very simple functions for emulating a fastbuf stream over a static
[libucw.git] / lib / fastbuf.h
1 /*
2  *      Sherlock Library -- Fast Buffered I/O
3  *
4  *      (c) 1997--2002 Martin Mares <mj@ucw.cz>
5  *
6  *      This software may be freely distributed and used according to the terms
7  *      of the GNU Lesser General Public License.
8  */
9
10 #ifndef _SHERLOCK_FASTBUF_H
11 #define _SHERLOCK_FASTBUF_H
12
13 #ifndef EOF
14 #include <stdio.h>
15 #endif
16
17 #include <string.h>
18 #include <stdarg.h>
19
20 #include "lib/unaligned.h"
21
22 /*
23  *  Generic buffered I/O. You supply hooks to be called for low-level operations
24  *  (swapping of buffers, seeking and closing), we do the rest.
25  *
26  *  Buffer layout when reading:
27  *
28  *  +----------------+---------------------------+
29  *  | read data      | free space                |
30  *  +----------------+---------------------------+
31  *  ^        ^        ^                           ^
32  *  buffer   bptr     bstop                       bufend
33  *
34  *  After the last character is read, bptr == bstop and buffer refill
35  *  is deferred to the next read attempt. This gives us an easy way
36  *  how to implement bungetc().
37  *
38  *  When writing:
39  *
40  *  +--------+--------------+--------------------+
41  *  | unused | written data | free space         |
42  *  +--------+--------------+--------------------+
43  *  ^         ^              ^                    ^
44  *  buffer    bstop          bptr                 bufend
45  *
46  *  Dirty tricks:
47  *
48  *    - You can mix reads and writes on the same stream, but you must
49  *      call bflush() in between and remember that the file position
50  *      points after the flushed buffer which is not necessarily the same
51  *      as after the data you've read.
52  *    - The spout/refill hooks can change not only bptr and bstop, but also
53  *      the location of the buffer; fb-mem.c takes advantage of it.
54  */
55
56 struct fastbuf {
57   byte is_fastbuf[0];                   /* Dummy field for checking of type casts */
58   byte *bptr, *bstop;                   /* Access pointers */
59   byte *buffer, *bufend;                /* Start and end of the buffer */
60   byte *name;                           /* File name for error messages */
61   sh_off_t pos;                         /* Position of bstop in the file */
62   int (*refill)(struct fastbuf *);      /* Get a buffer with new data */
63   void (*spout)(struct fastbuf *);      /* Write buffer data to the file */
64   void (*seek)(struct fastbuf *, sh_off_t, int);  /* Slow path for bseek(), buffer already flushed */
65   void (*close)(struct fastbuf *);      /* Close the stream */
66   int (*config)(struct fastbuf *, uns, int);    /* Configure the stream */
67 };
68
69 /* FastIO on standard files (specify buffer size 0 to enable mmaping) */
70
71 struct fastbuf *bopen(byte *name, uns mode, uns buffer);
72 struct fastbuf *bopen_tmp(uns buffer);
73 struct fastbuf *bfdopen(int fd, uns buffer);
74 struct fastbuf *bfdopen_shared(int fd, uns buffer);
75
76 /* FastIO on in-memory streams */
77
78 struct fastbuf *fbmem_create(unsigned blocksize);       /* Create stream and return its writing fastbuf */
79 struct fastbuf *fbmem_clone_read(struct fastbuf *);     /* Create reading fastbuf */
80
81 /* FastIO on memory mapped files */
82
83 struct fastbuf *bopen_mm(byte *name, uns mode);
84
85 /* FastI on file descriptors with limit */
86
87 struct fastbuf *bopen_limited_fd(int fd, uns bufsize, uns limit);
88
89 /* FastIO on static buffers */
90
91 void fbbuf_init_read(struct fastbuf *f, byte *buffer, uns size);
92 void fbbuf_init_write(struct fastbuf *f, byte *buffer, uns size);
93 static inline uns
94 fbbuf_count_written(struct fastbuf *f)
95 {
96   return f->bptr - f->bstop;
97 }
98
99 /* Configuring stream parameters */
100
101 int bconfig(struct fastbuf *f, uns type, int data);
102
103 #define BCONFIG_IS_TEMP_FILE 0
104
105 /* Universal functions working on all fastbuf's */
106
107 void bclose(struct fastbuf *f);
108 void bflush(struct fastbuf *f);
109 void bseek(struct fastbuf *f, sh_off_t pos, int whence);
110 void bsetpos(struct fastbuf *f, sh_off_t pos);
111
112 static inline sh_off_t btell(struct fastbuf *f)
113 {
114   return f->pos + (f->bptr - f->bstop);
115 }
116
117 int bgetc_slow(struct fastbuf *f);
118 static inline int bgetc(struct fastbuf *f)
119 {
120   return (f->bptr < f->bstop) ? (int) *f->bptr++ : bgetc_slow(f);
121 }
122
123 int bpeekc_slow(struct fastbuf *f);
124 static inline int bpeekc(struct fastbuf *f)
125 {
126   return (f->bptr < f->bstop) ? (int) *f->bptr : bpeekc_slow(f);
127 }
128
129 static inline void bungetc(struct fastbuf *f)
130 {
131   f->bptr--;
132 }
133
134 void bputc_slow(struct fastbuf *f, uns c);
135 static inline void bputc(struct fastbuf *f, uns c)
136 {
137   if (f->bptr < f->bufend)
138     *f->bptr++ = c;
139   else
140     bputc_slow(f, c);
141 }
142
143 int bgetw_slow(struct fastbuf *f);
144 static inline int bgetw(struct fastbuf *f)
145 {
146   int w;
147   if (f->bptr + 2 <= f->bstop)
148     {
149       w = GET_U16(f->bptr);
150       f->bptr += 2;
151       return w;
152     }
153   else
154     return bgetw_slow(f);
155 }
156
157 u32 bgetl_slow(struct fastbuf *f);
158 static inline u32 bgetl(struct fastbuf *f)
159 {
160   u32 l;
161   if (f->bptr + 4 <= f->bstop)
162     {
163       l = GET_U32(f->bptr);
164       f->bptr += 4;
165       return l;
166     }
167   else
168     return bgetl_slow(f);
169 }
170
171 u64 bgetq_slow(struct fastbuf *f);
172 static inline u64 bgetq(struct fastbuf *f)
173 {
174   u64 l;
175   if (f->bptr + 8 <= f->bstop)
176     {
177       l = GET_U64(f->bptr);
178       f->bptr += 8;
179       return l;
180     }
181   else
182     return bgetq_slow(f);
183 }
184
185 u64 bget5_slow(struct fastbuf *f);
186 static inline u64 bget5(struct fastbuf *f)
187 {
188   u64 l;
189   if (f->bptr + 5 <= f->bstop)
190     {
191       l = GET_U40(f->bptr);
192       f->bptr += 5;
193       return l;
194     }
195   else
196     return bget5_slow(f);
197 }
198
199 void bputw_slow(struct fastbuf *f, uns w);
200 static inline void bputw(struct fastbuf *f, uns w)
201 {
202   if (f->bptr + 2 <= f->bufend)
203     {
204       PUT_U16(f->bptr, w);
205       f->bptr += 2;
206     }
207   else
208     bputw_slow(f, w);
209 }
210
211 void bputl_slow(struct fastbuf *f, u32 l);
212 static inline void bputl(struct fastbuf *f, u32 l)
213 {
214   if (f->bptr + 4 <= f->bufend)
215     {
216       PUT_U32(f->bptr, l);
217       f->bptr += 4;
218     }
219   else
220     bputl_slow(f, l);
221 }
222
223 void bputq_slow(struct fastbuf *f, u64 l);
224 static inline void bputq(struct fastbuf *f, u64 l)
225 {
226   if (f->bptr + 8 <= f->bufend)
227     {
228       PUT_U64(f->bptr, l);
229       f->bptr += 8;
230     }
231   else
232     bputq_slow(f, l);
233 }
234
235 void bput5_slow(struct fastbuf *f, u64 l);
236 static inline void bput5(struct fastbuf *f, u64 l)
237 {
238   if (f->bptr + 5 <= f->bufend)
239     {
240       PUT_U40(f->bptr, l);
241       f->bptr += 5;
242     }
243   else
244     bput5_slow(f, l);
245 }
246
247 uns bread_slow(struct fastbuf *f, void *b, uns l, uns check);
248 static inline uns bread(struct fastbuf *f, void *b, uns l)
249 {
250   if (f->bptr + l <= f->bstop)
251     {
252       memcpy(b, f->bptr, l);
253       f->bptr += l;
254       return l;
255     }
256   else
257     return bread_slow(f, b, l, 0);
258 }
259
260 static inline uns breadb(struct fastbuf *f, void *b, uns l)
261 {
262   if (f->bptr + l <= f->bstop)
263     {
264       memcpy(b, f->bptr, l);
265       f->bptr += l;
266       return l;
267     }
268   else
269     return bread_slow(f, b, l, 1);
270 }
271
272 void bwrite_slow(struct fastbuf *f, void *b, uns l);
273 static inline void bwrite(struct fastbuf *f, void *b, uns l)
274 {
275   if (f->bptr + l <= f->bufend)
276     {
277       memcpy(f->bptr, b, l);
278       f->bptr += l;
279     }
280   else
281     bwrite_slow(f, b, l);
282 }
283
284 byte *bgets(struct fastbuf *f, byte *b, uns l); /* Non-std */
285 int bgets_nodie(struct fastbuf *f, byte *b, uns l);
286 byte *bgets0(struct fastbuf *f, byte *b, uns l);
287
288 static inline void
289 bputs(struct fastbuf *f, byte *b)
290 {
291   bwrite(f, b, strlen(b));
292 }
293
294 static inline void
295 bputs0(struct fastbuf *f, byte *b)
296 {
297   bwrite(f, b, strlen(b)+1);
298 }
299
300 static inline void
301 bputsn(struct fastbuf *f, byte *b)
302 {
303   bputs(f, b);
304   bputc(f, '\n');
305 }
306
307 void bbcopy_slow(struct fastbuf *f, struct fastbuf *t, uns l);
308 static inline void
309 bbcopy(struct fastbuf *f, struct fastbuf *t, uns l)
310 {
311   if (f->bptr + l <= f->bstop &&
312       t->bptr + l <= t->bufend)
313     {
314       memcpy(t->bptr, f->bptr, l);
315       t->bptr += l;
316       f->bptr += l;
317     }
318   else
319     bbcopy_slow(f, t, l);
320 }
321
322 /* I/O on addr_int_t */
323
324 #ifdef CPU_64BIT_POINTERS
325 #define bputa(x,p) bputq(x,p)
326 #define bgeta(x) bgetq(x)
327 #else
328 #define bputa(x,p) bputl(x,p)
329 #define bgeta(x) bgetl(x)
330 #endif
331
332 /* Direct I/O on buffers */
333
334 static inline uns
335 bdirect_read_prepare(struct fastbuf *f, byte **buf)
336 {
337   if (f->bptr == f->bstop && !f->refill(f))
338     return 0;
339   *buf = f->bptr;
340   return f->bstop - f->bptr;
341 }
342
343 static inline void
344 bdirect_read_commit(struct fastbuf *f, byte *pos)
345 {
346   f->bptr = pos;
347 }
348
349 static inline uns
350 bdirect_write_prepare(struct fastbuf *f, byte **buf)
351 {
352   if (f->bptr == f->bufend)
353     f->spout(f);
354   *buf = f->bptr;
355   return f->bufend - f->bptr;
356 }
357
358 static inline void
359 bdirect_write_commit(struct fastbuf *f, byte *pos)
360 {
361   f->bptr = pos;
362 }
363
364 /* Formatted output */
365
366 int bprintf(struct fastbuf *b, byte *msg, ...);
367 int vbprintf(struct fastbuf *b, byte *msg, va_list args);
368
369 #endif