]> mj.ucw.cz Git - eval.git/blob - ucw/fastbuf.h
Doc: Note that Isolate has moved
[eval.git] / ucw / fastbuf.h
1 /*
2  *      UCW Library -- Fast Buffered I/O
3  *
4  *      (c) 1997--2008 Martin Mares <mj@ucw.cz>
5  *      (c) 2004 Robert Spalek <robert@ucw.cz>
6  *
7  *      This software may be freely distributed and used according to the terms
8  *      of the GNU Lesser General Public License.
9  */
10
11 #ifndef _UCW_FASTBUF_H
12 #define _UCW_FASTBUF_H
13
14 #include <string.h>
15 #include <alloca.h>
16
17 /***
18  * === Internal structure [[internal]]
19  *
20  * Generally speaking, a fastbuf consists of a buffer and a set of callbacks.
21  * All front-end functions operate on the buffer and if the buffer becomes
22  * empty or fills up, they ask the corresponding callback to handle the
23  * situation. Back-ends then differ just in the definition of the callbacks.
24  *
25  * The state of the fastbuf is represented by a <<struct_fastbuf,`struct fastbuf`>>,
26  * which is a simple structure describing the state of the buffer (the pointers
27  * `buffer`, `bufend`), the front-end cursor (`bptr`), the back-end cursor (`bstop`),
28  * position of the back-end cursor in the file (`pos`), some flags (`flags`)
29  * and pointers to the callback functions.
30  *
31  * The buffer can be in one of the following states:
32  *
33  * 1. Flushed:
34  *
35  *    +------------------------------------+---------------------------+
36  *    | unused                             | free space                |
37  *    +------------------------------------+---------------------------+
38  *    ^              ^                     ^                           ^
39  *    buffer      <= bstop (BE pos)     <= bptr (FE pos)            <= bufend
40  *
41  *   * This schema describes a fastbuf after its initialization or bflush().
42  *   * There is no cached data and we are ready for any read or write operation
43  *     (well, only if the back-end supports it).
44  *   * The interval `[bptr, bufend]` can be used by front-ends
45  *     for writing. If it is empty, the `spout` callback gets called
46  *     upon the first write attempt to allocate a new buffer. Otherwise
47  *     the fastbuf silently comes to the writing mode.
48  *   * When a front-end needs to read something, it calls the `refill` callback.
49  *   * The pointers can be either all non-`NULL` or all NULL.
50  *   * `bstop == bptr` in most back-ends, but it is not necessary. Some
51  *     in-memory streams take advantage of this.
52  *
53  * 2. Reading:
54  *
55  *    +------------------------------------+---------------------------+
56  *    | read data                          | unused                    |
57  *    +------------------------------------+---------------------------+
58  *    ^               ^                    ^                           ^
59  *    buffer       <= bptr (FE pos)     <= bstop (BE pos)           <= bufend
60  *
61  *   * If we try to read something, we get to the reading mode.
62  *   * No writing is allowed until a flush operation. But note that @bflush()
63  *     will simply set `bptr` to `bstop` before `spout`
64  *     and it breaks the position of the front-end's cursor,
65  *     so the user should seek afwards.
66  *   * The interval `[buffer, bstop]` contains a block of data read by the back-end.
67  *     `bptr` is the front-end's cursor which points to the next character to be read.
68  *     After the last character is read, `bptr == bstop` and the `refill` callback
69  *     gets called upon the next read attempt to bring further data.
70  *     This gives us an easy way how to implement @bungetc().
71  *
72  * 3. Writing:
73  *
74  *    +-----------------------+----------------+-----------------------+
75  *    | unused                | written data   | free space            |
76  *    +-----------------------+----------------+-----------------------+
77  *    ^            ^                           ^                       ^
78  *    buffer    <= bstop (BE pos)            < bptr (FE pos)        <= bufend
79  *
80  *   * This schema corresponds to the situation after a write attempt.
81  *   * No reading is allowed until a flush operation.
82  *   * The `bptr` points at the position where the next character
83  *     will be written to. When we want to write, but `bptr == bufend`, we call
84  *     the `spout` hook to flush the witten data and get an empty buffer.
85  *   * `bstop` usually points at the beginning of the written data,
86  *     but it is not necessary.
87  *
88  *
89  * Rules for back-ends:
90  *
91  *   - Front-ends are only allowed to change the value of `bptr`, some flags
92  *     and if a fatal error occurs, then also `bstop`. Back-ends can rely on it.
93  *   - `buffer <= bstop <= bufend` and `buffer <= bptr <= bufend`.
94  *   - `pos` should be the real position in the file corresponding to the location of `bstop` in the buffer.
95  *     It can be modified by any back-end's callback, but the position of `bptr` (`pos + (bptr - bstop)`)
96  *     must stay unchanged after `refill` or `spout`.
97  *   - Failed callbacks (except `close`) should use @bthrow().
98  *   - Any callback pointer may be NULL in case the callback is not implemented.
99  *   - Callbacks can change not only `bptr` and `bstop`, but also the location and size of the buffer;
100  *     the fb-mem back-end takes advantage of it.
101  *
102  *   - Initialization:
103  *     * out: `buffer <= bstop <= bptr <= bufend` (flushed).
104  *
105  *   - `refill`:
106  *     * in: `buffer <= bstop <= bptr <= bufend` (reading or flushed).
107  *     * out: `buffer <= bptr <= bstop <= bufend` (reading).
108  *     * Resulting `bptr == bstop` signals the end of file.
109  *       The next reading attempt will again call `refill` which can succeed this time.
110  *     * The callback must also return zero on EOF (iff `bptr == bstop`).
111  *
112  *   - `spout`:
113  *     * in: `buffer <= bstop <= bptr <= bufend` (writing or flushed).
114  *     * out: `buffer <= bstop <= bptr < bufend` (flushed).
115  *
116  *   - `seek`:
117  *     * in: `buffer <= bstop <= bptr <= bufend` (flushed).
118  *     * in: `(ofs >= 0 && whence == SEEK_SET) || (ofs <= 0 && whence == SEEK_END)`.
119  *     * out: `buffer <= bstop <= bptr <= bufend` (flushed).
120  *
121  *   - `close`:
122  *     * in: `buffer <= bstop <= bptr <= bufend` (flushed or after @bthrow()).
123  *     * `close` must always free all internal structures, even when it throws an exception.
124  ***/
125
126 /**
127  * This structure contains the state of the fastbuf. See the discussion above
128  * for how it works.
129  **/
130 struct fastbuf {
131   byte is_fastbuf[0];                           /* Dummy field for checking of type casts */
132   byte *bptr, *bstop;                           /* State of the buffer */
133   byte *buffer, *bufend;                        /* Start and end of the buffer */
134   char *name;                                   /* File name (used for error messages) */
135   ucw_off_t pos;                                /* Position of bstop in the file */
136   int (*refill)(struct fastbuf *);              /* Get a buffer with new data, returns 0 on EOF */
137   void (*spout)(struct fastbuf *);              /* Write buffer data to the file */
138   int (*seek)(struct fastbuf *, ucw_off_t, int);/* Slow path for @bseek(), buffer already flushed; returns success */
139   void (*close)(struct fastbuf *);              /* Close the stream */
140   int (*config)(struct fastbuf *, uns, int);    /* Configure the stream */
141   int can_overwrite_buffer;                     /* Can the buffer be altered? 0=never, 1=temporarily, 2=permanently */
142 };
143
144 /***
145  * === Fastbuf on files [[fbparam]]
146  *
147  * If you want to use fastbufs to access files, you can choose one of several
148  * back-ends and set their parameters.
149  ***/
150
151 /**
152  * Back-end types
153  */
154 enum fb_type {
155   FB_STD,                               /* Standard buffered I/O */
156   FB_DIRECT,                            /* Direct I/O bypassing system caches (see fb-direct.c for a description) */
157   FB_MMAP                               /* Memory mapped files */
158 };
159
160 /**
161  * When you open a file fastbuf, you can use this structure to select a back-end
162  * and set its parameters. If you want just an "ordinary" file stream, you can
163  * happily pass NULL instead and the defaults from the configuration file (or
164  * hard-wired defaults if no config file has been read) will be used.
165  */
166 struct fb_params {
167   enum fb_type type;                    /* The chosen back-end */
168   uns buffer_size;                      /* 0 for default size */
169   uns keep_back_buf;                    /* FB_STD: optimize for bi-directional access */
170   uns read_ahead;                       /* FB_DIRECT options */
171   uns write_back;
172   struct asio_queue *asio;
173 };
174
175 struct cf_section;
176 extern struct cf_section fbpar_cf;      /** Configuration section with which you can fill the `fb_params` **/
177 extern struct fb_params fbpar_def;      /** The default `fb_params` **/
178
179 /**
180  * Opens a file with file mode @mode (see the man page of open()).
181  * Use @params to select the fastbuf back-end and its parameters or
182  * pass NULL if you are fine with defaults.
183  *
184  * Dies if the file does not exist.
185  **/
186 struct fastbuf *bopen_file(const char *name, int mode, struct fb_params *params);
187 struct fastbuf *bopen_file_try(const char *name, int mode, struct fb_params *params); /** Like bopen_file(), but returns NULL on failure. **/
188
189 /**
190  * Opens a temporary file.
191  * It is placed with other temp files and it is deleted when closed.
192  * Again, use NULL for @params if you want the defaults.
193  **/
194 struct fastbuf *bopen_tmp_file(struct fb_params *params);
195
196 /**
197  * Creates a fastbuf from a file descriptor @fd and sets its filename
198  * to @name (the name is used only in error messages).
199  * When the fastbuf is closed, the fd is closed as well. You can override
200  * this behavior by calling @bconfig().
201  */
202 struct fastbuf *bopen_fd_name(int fd, struct fb_params *params, const char *name);
203 static inline struct fastbuf *bopen_fd(int fd, struct fb_params *params) /** Same as above, but with an auto-generated filename. **/
204 {
205   return bopen_fd_name(fd, params, NULL);
206 }
207
208 /**
209  * Flushes all buffers and makes sure that they are written to the disk.
210  **/
211 void bfilesync(struct fastbuf *b);
212
213 /***
214  * === Fastbufs on regular files [[fbfile]]
215  *
216  * If you want to use the `FB_STD` back-end and not worry about setting
217  * up any parameters, there is a couple of shortcuts.
218  ***/
219
220 struct fastbuf *bopen(const char *name, uns mode, uns buflen);          /** Equivalent to @bopen_file() with `FB_STD` back-end. **/
221 struct fastbuf *bopen_try(const char *name, uns mode, uns buflen);      /** Equivalent to @bopen_file_try() with `FB_STD` back-end. **/
222 struct fastbuf *bopen_tmp(uns buflen);                                  /** Equivalent to @bopen_tmp_file() with `FB_STD` back-end. **/
223 struct fastbuf *bfdopen(int fd, uns buflen);                            /** Equivalent to @bopen_fd() with `FB_STD` back-end. **/
224 struct fastbuf *bfdopen_shared(int fd, uns buflen);                     /** Like @bfdopen(), but it does not close the @fd on @bclose(). **/
225
226 /***
227  * === Temporary files [[fbtemp]]
228  *
229  * Usually, @bopen_tmp_file() is the best way how to come to a temporary file.
230  * However, in some specific cases you can need more, so there is also a set
231  * of more general functions.
232  ***/
233
234 #define TEMP_FILE_NAME_LEN 256
235
236 /**
237  * Generates a temporary filename and stores it to the @name_buf (of size
238  * at least * `TEMP_FILE_NAME_LEN`). If @open_flags are not NULL, flags that
239  * should be OR-ed with other flags to open() will be stored there.
240  *
241  * The location and style of temporary files is controlled by the configuration.
242  * By default, the system temp directory (`$TMPDIR` or `/tmp`) is used.
243  *
244  * If the location is a publicly writeable directory (like `/tmp`), the
245  * generated filename cannot be guaranteed to be unique, so @open_flags
246  * will include `O_EXCL` and you have to check the result of open() and
247  * iterate if needed.
248  *
249  * This function is not specific to fastbufs, it can be used separately.
250  **/
251 void temp_file_name(char *name_buf, int *open_flags);
252
253 /**
254  * Opens a temporary file and returns its file descriptor.
255  * You specify the file @mode and @open_flags passed to open().
256  *
257  * If the @name_buf (of at last `TEMP_FILE_NAME_LEN` chars) is not NULL,
258  * the filename is also stored in it.
259  *
260  * This function is not specific to fastbufs, it can be used separately.
261  */
262 int open_tmp(char *name_buf, int open_flags, int mode);
263
264 /**
265  * Sometimes, a file is created as temporary and then moved to a stable
266  * location. This function takes a fastbuf created by @bopen_tmp_file()
267  * or @bopen_tmp(), marks it as permanent, closes it and renames it to
268  * @name.
269  *
270  * Please note that it assumes that the temporary file and the @name
271  * are on the same volume (otherwise, rename() fails), so you might
272  * want to configure a special location for the temporary files
273  * beforehand.
274  */
275 void bfix_tmp_file(struct fastbuf *fb, const char *name);
276
277 /* Internal functions of some file back-ends */
278
279 struct fastbuf *bfdopen_internal(int fd, const char *name, uns buflen);
280 struct fastbuf *bfmmopen_internal(int fd, const char *name, uns mode);
281
282 #ifdef CONFIG_UCW_FB_DIRECT
283 extern uns fbdir_cheat;
284 struct asio_queue;
285 struct fastbuf *fbdir_open_fd_internal(int fd, const char *name, struct asio_queue *io_queue, uns buffer_size, uns read_ahead, uns write_back);
286 #endif
287
288 void bclose_file_helper(struct fastbuf *f, int fd, int is_temp_file);
289
290 /***
291  * === Fastbufs on file fragments [[fblim]]
292  *
293  * The `fblim` back-end reads from a file handle, but at most a given
294  * number of bytes. This is frequently used for reading from sockets.
295  ***/
296
297 struct fastbuf *bopen_limited_fd(int fd, uns bufsize, uns limit); /** Create a fastbuf which reads at most @limit bytes from @fd. **/
298
299 /***
300  * === Fastbufs on in-memory streams [[fbmem]]
301  *
302  * The `fbmem` back-end keeps the whole contents of the stream
303  * in memory (as a linked list of memory blocks, so address space
304  * fragmentation is avoided).
305  *
306  * First, you use @fbmem_create() to create the stream and the fastbuf
307  * used for writing to it. Then you can call @fbmem_clone_read() to get
308  * an arbitrary number of fastbuf for reading from the stream.
309  ***/
310
311 struct fastbuf *fbmem_create(uns blocksize);            /** Create stream and return its writing fastbuf. **/
312 struct fastbuf *fbmem_clone_read(struct fastbuf *f);    /** Given a writing fastbuf, create a new reading fastbuf. **/
313
314 /***
315  * === Fastbufs on static buffers [[fbbuf]]
316  *
317  * The `fbbuf` back-end stores the stream in a given block of memory.
318  * This is useful for parsing and generating of complex data structures.
319  ***/
320
321 /**
322  * Creates a read-only fastbuf that takes its data from a given buffer.
323  * The fastbuf structure is allocated by the caller and pointed to by @f.
324  * The @buffer and @size specify the location and size of the buffer.
325  *
326  * In some cases, the front-ends can take advantage of rewriting the contents
327  * of the buffer temporarily. In this case, set @can_overwrite as described
328  * in <<internal,Internals>>. If you do not care, keep @can_overwrite zero.
329  *
330  * It is not possible to close this fastbuf.
331  */
332 void fbbuf_init_read(struct fastbuf *f, byte *buffer, uns size, uns can_overwrite);
333
334 /**
335  * Creates a write-only fastbuf which writes into a provided memory buffer.
336  * The fastbuf structure is allocated by the caller and pointed to by @f.
337  * An attempt to write behind the end of the buffer dies.
338  *
339  * Data are written directly into the buffer, so it is not necessary to call @bflush()
340  * at any moment.
341  *
342  * It is not possible to close this fastbuf.
343  */
344 void fbbuf_init_write(struct fastbuf *f, byte *buffer, uns size);
345
346 static inline uns fbbuf_count_written(struct fastbuf *f) /** Calculates, how many bytes were already written into the buffer. **/
347 {
348   return f->bptr - f->bstop;
349 }
350
351 /***
352  * === Fastbuf on recyclable growing buffers [[fbgrow]]
353  *
354  * The `fbgrow` back-end keeps the stream in a contiguous buffer stored in the
355  * main memory, but unlike <<fbmem,`fbmem`>>, the buffer does not have a fixed
356  * size and it is expanded to accomodate all data.
357  *
358  * At every moment, you can use `fastbuf->buffer` to gain access to the stream.
359  ***/
360
361 struct fastbuf *fbgrow_create(unsigned basic_size);     /** Create the growing buffer pre-allocated to @basic_size bytes. **/
362 void fbgrow_reset(struct fastbuf *b);                   /** Reset stream and prepare for writing. **/
363 void fbgrow_rewind(struct fastbuf *b);                  /** Prepare for reading (of already written data). **/
364
365 /***
366  * === Fastbuf on memory pools [[fbpool]]
367  *
368  * The write-only `fbpool` back-end also keeps the stream in a contiguous
369  * buffer, but this time the buffer is allocated from within a memory pool.
370  ***/
371
372 struct mempool;
373 struct fbpool { /** Structure for fastbufs & mempools. **/
374   struct fastbuf fb;
375   struct mempool *mp;
376 };
377
378 /**
379  * Initialize a new `fbpool`. The structure is allocated by the caller.
380  **/
381 void fbpool_init(struct fbpool *fb);    /** Initialize a new mempool fastbuf. **/
382 /**
383  * Start a new continuous block and prepare for writing (see <<mempool:mp_start()>>).
384  * Provide the memory pool you want to use for this block as @mp.
385  **/
386 void fbpool_start(struct fbpool *fb, struct mempool *mp, uns init_size);
387 /**
388  * Close the block and return the address of its start (see <<mempool:mp_end()>>).
389  * The length can be determined by calling <<mempool:mp_size(mp, ptr)>>.
390  **/
391 void *fbpool_end(struct fbpool *fb);
392
393 /***
394  * === Atomic files for multi-threaded programs [[fbatomic]]
395  *
396  * This fastbuf backend is designed for cases when several threads
397  * of a single program append records to a common file and while the
398  * record can mix in an arbitrary way, the bytes inside a single
399  * record must remain uninterrupted.
400  *
401  * In case of files with fixed record size, we just allocate the
402  * buffer to hold a whole number of records and take advantage
403  * of the atomicity of the write() system call.
404  *
405  * With variable-sized records, we need another solution: when
406  * writing a record, we keep the fastbuf in a locked state, which
407  * prevents buffer flushing (and if the buffer becomes full, we extend it),
408  * and we wait for an explicit commit operation which write()s the buffer
409  * if the free space in the buffer falls below the expected maximum record
410  * length.
411  *
412  * Please note that initialization of the clones is not thread-safe,
413  * so you have to serialize it yourself.
414  ***/
415
416 struct fb_atomic {
417   struct fastbuf fb;
418   struct fb_atomic_file *af;
419   byte *expected_max_bptr;
420   uns slack_size;
421 };
422 #define FB_ATOMIC(f) ((struct fb_atomic *)(f)->is_fastbuf)
423
424 /**
425  * Open an atomic fastbuf.
426  * If @master is NULL, the file @name is opened. If it is non-null,
427  * a new clone of an existing atomic fastbuf is created.
428  *
429  * If the file has fixed record length, just set @record_len to it.
430  * Otherwise set @record_len to the expected maximum record length
431  * with a negative sign (you need not fit in this length, but as long
432  * as you do, the fastbuf is more efficient) and call @fbatomic_commit()
433  * after each record.
434  *
435  * You can specify @record_len, if it is known (for optimisations).
436  *
437  * The file is closed when all fastbufs using it are closed.
438  **/
439 struct fastbuf *fbatomic_open(const char *name, struct fastbuf *master, uns bufsize, int record_len);
440 void fbatomic_internal_write(struct fastbuf *b);
441
442 /**
443  * Declare that you have finished writing a record. This is required only
444  * if a fixed record size was not specified.
445  **/
446 static inline void fbatomic_commit(struct fastbuf *b)
447 {
448   if (b->bptr >= ((struct fb_atomic *)b)->expected_max_bptr)
449     fbatomic_internal_write(b);
450 }
451
452 /*** === Configuring stream parameters [[bconfig]] ***/
453
454 enum bconfig_type {                     /** Parameters that could be configured. **/
455   BCONFIG_IS_TEMP_FILE,                 /* 0=normal file, 1=temporary file, 2=shared fd */
456   BCONFIG_KEEP_BACK_BUF,                /* Optimize for bi-directional access */
457 };
458
459 int bconfig(struct fastbuf *f, uns type, int data); /** Configure a fastbuf. Returns previous value. **/
460
461 /*** === Universal functions working on all fastbuf's [[ffbasic]] ***/
462
463 /**
464  * Close and free fastbuf.
465  * Can not be used for fastbufs not returned from function (initialized in a parameter, for example the one from `fbbuf_init_read`).
466  */
467 void bclose(struct fastbuf *f);
468 void bflush(struct fastbuf *f);                                 /** Write data (if it makes any sense, do not use for in-memory buffers). **/
469 void bseek(struct fastbuf *f, ucw_off_t pos, int whence);       /** Seek in the buffer. See `man fseek` for description of @whence. Only for seekable fastbufs. **/
470 void bsetpos(struct fastbuf *f, ucw_off_t pos);                 /** Set position to @pos bytes from beginning. Only for seekable fastbufs. **/
471 void brewind(struct fastbuf *f);                                /** Go to the beginning of the fastbuf. Only for seekable ones. **/
472 ucw_off_t bfilesize(struct fastbuf *f);                         /** How large is the file? -1 if not seekable. **/
473
474 static inline ucw_off_t btell(struct fastbuf *f)                /** Where am I (from the beginning)? **/
475 {
476   return f->pos + (f->bptr - f->bstop);
477 }
478
479 int bgetc_slow(struct fastbuf *f);
480 static inline int bgetc(struct fastbuf *f)                      /** Return next character from the buffer. **/
481 {
482   return (f->bptr < f->bstop) ? (int) *f->bptr++ : bgetc_slow(f);
483 }
484
485 int bpeekc_slow(struct fastbuf *f);
486 static inline int bpeekc(struct fastbuf *f)                     /** Return next character from the buffer, but keep the current position. **/
487 {
488   return (f->bptr < f->bstop) ? (int) *f->bptr : bpeekc_slow(f);
489 }
490
491 static inline void bungetc(struct fastbuf *f)                   /** Return last read character back. Only one back is guaranteed to work. **/
492 {
493   f->bptr--;
494 }
495
496 void bputc_slow(struct fastbuf *f, uns c);
497 static inline void bputc(struct fastbuf *f, uns c)              /** Write a single character. **/
498 {
499   if (f->bptr < f->bufend)
500     *f->bptr++ = c;
501   else
502     bputc_slow(f, c);
503 }
504
505 static inline uns bavailr(struct fastbuf *f)                    /** Return the length of the cached data to be read. Do not use directly. **/
506 {
507   return f->bstop - f->bptr;
508 }
509
510 static inline uns bavailw(struct fastbuf *f)                    /** Return the length of the buffer available for writing. Do not use directly. **/
511 {
512   return f->bufend - f->bptr;
513 }
514
515 uns bread_slow(struct fastbuf *f, void *b, uns l, uns check);
516 /**
517  * Read at most @l bytes of data into @b.
518  * Returns number of bytes read.
519  * 0 means end of file.
520  */
521 static inline uns bread(struct fastbuf *f, void *b, uns l)
522 {
523   if (bavailr(f) >= l)
524     {
525       memcpy(b, f->bptr, l);
526       f->bptr += l;
527       return l;
528     }
529   else
530     return bread_slow(f, b, l, 0);
531 }
532
533 /**
534  * Reads exactly @l bytes of data into @b.
535  * If at the end of file, it returns 0.
536  * If there are data, but less than @l, it dies.
537  */
538 static inline uns breadb(struct fastbuf *f, void *b, uns l)
539 {
540   if (bavailr(f) >= l)
541     {
542       memcpy(b, f->bptr, l);
543       f->bptr += l;
544       return l;
545     }
546   else
547     return bread_slow(f, b, l, 1);
548 }
549
550 void bwrite_slow(struct fastbuf *f, const void *b, uns l);
551 static inline void bwrite(struct fastbuf *f, const void *b, uns l) /** Writes buffer @b of length @l into fastbuf. **/
552 {
553   if (bavailw(f) >= l)
554     {
555       memcpy(f->bptr, b, l);
556       f->bptr += l;
557     }
558   else
559     bwrite_slow(f, b, l);
560 }
561
562 /**
563  * Reads a line into @b and strips trailing `\n`.
564  * Returns pointer to the terminating 0 or NULL on `EOF`.
565  * Dies if the line is longer than @l.
566  **/
567 char *bgets(struct fastbuf *f, char *b, uns l);
568 char *bgets0(struct fastbuf *f, char *b, uns l);        /** The same as @bgets(), but for 0-terminated strings. **/
569 /**
570  * Returns either length of read string (excluding the terminator) or -1 if it is too long.
571  * In such cases exactly @l bytes are read.
572  */
573 int bgets_nodie(struct fastbuf *f, char *b, uns l);
574
575 struct mempool;
576 struct bb_t;
577 /**
578  * Read a string, strip the trailing `\n` and store it into growing buffer @b.
579  * Dies if the line is longer than @limit.
580  **/
581 uns bgets_bb(struct fastbuf *f, struct bb_t *b, uns limit);
582 /**
583  * Read a string, strip the trailing `\n` and store it into buffer allocated from a memory pool.
584  **/
585 char *bgets_mp(struct fastbuf *f, struct mempool *mp);
586
587 struct bgets_stk_struct {
588   struct fastbuf *f;
589   byte *old_buf, *cur_buf, *src;
590   uns old_len, cur_len, src_len;
591 };
592 void bgets_stk_init(struct bgets_stk_struct *s);
593 void bgets_stk_step(struct bgets_stk_struct *s);
594
595 /**
596  * Read a string, strip the trailing `\n` and store it on the stack (allocated using alloca()).
597  **/
598 #define bgets_stk(fb) \
599   ({ struct bgets_stk_struct _s; _s.f = (fb); for (bgets_stk_init(&_s); _s.cur_len; _s.cur_buf = alloca(_s.cur_len), bgets_stk_step(&_s)); _s.cur_buf; })
600
601 /**
602  * Write a string, without 0 or `\n` at the end.
603  **/
604 static inline void bputs(struct fastbuf *f, const char *b)
605 {
606   bwrite(f, b, strlen(b));
607 }
608
609 /**
610  * Write string, including terminating 0.
611  **/
612 static inline void bputs0(struct fastbuf *f, const char *b)
613 {
614   bwrite(f, b, strlen(b)+1);
615 }
616
617 /**
618  * Write string and append a newline to the end.
619  **/
620 static inline void bputsn(struct fastbuf *f, const char *b)
621 {
622   bputs(f, b);
623   bputc(f, '\n');
624 }
625
626 void bbcopy_slow(struct fastbuf *f, struct fastbuf *t, uns l);
627 /**
628  * Copy @l bytes of data from fastbuf @f to fastbuf @t.
629  * `UINT_MAX` (`~0U`) means all data, even if more than `UINT_MAX` bytes remain.
630  **/
631 static inline void bbcopy(struct fastbuf *f, struct fastbuf *t, uns l)
632 {
633   if (bavailr(f) >= l && bavailw(t) >= l)
634     {
635       memcpy(t->bptr, f->bptr, l);
636       t->bptr += l;
637       f->bptr += l;
638     }
639   else
640     bbcopy_slow(f, t, l);
641 }
642
643 int bskip_slow(struct fastbuf *f, uns len);
644 static inline int bskip(struct fastbuf *f, uns len) /** Skip @len bytes without reading them. **/
645 {
646   if (bavailr(f) >= len)
647     {
648       f->bptr += len;
649       return 1;
650     }
651   else
652     return bskip_slow(f, len);
653 }
654
655 /*** === Direct I/O on buffers ***/
656
657 /**
658  * Begin direct reading from fastbuf's internal buffer to avoid unnecessary copying.
659  * The function returns a buffer @buf together with its length in bytes (zero means EOF)
660  * with cached data to be read.
661  *
662  * Some back-ends allow the user to modify the data in the returned buffer to avoid unnecessary.
663  * If the back-end allows such modifications, it can set `f->can_overwrite_buffer` accordingly:
664  *
665  *   - 0 if no modification is allowed,
666  *   - 1 if the user can modify the buffer on the condition that
667  *       the modifications will be undone before calling the next
668  *       fastbuf operation
669  *   - 2 if the user is allowed to overwrite the data in the buffer
670  *       if @bdirect_read_commit_modified() is called afterwards.
671  *       In this case, the back-end must be prepared for trimming
672  *       of the buffer which is done by the commit function.
673  *
674  * The reading must be ended by @bdirect_read_commit() or @bdirect_read_commit_modified(),
675  * unless the user did not read or modify anything.
676  **/
677 static inline uns bdirect_read_prepare(struct fastbuf *f, byte **buf)
678 {
679   if (f->bptr == f->bstop && !f->refill(f))
680     {
681       *buf = NULL;  // This is not needed, but it helps to get rid of spurious warnings
682       return 0;
683     }
684   *buf = f->bptr;
685   return bavailr(f);
686 }
687
688 /**
689  * End direct reading started by @bdirect_read_prepare() and move the cursor at @pos.
690  * Data in the returned buffer must be same as after @bdirect_read_prepare() and
691  * @pos must point somewhere inside the buffer.
692  **/
693 static inline void bdirect_read_commit(struct fastbuf *f, byte *pos)
694 {
695   f->bptr = pos;
696 }
697
698 /**
699  * Similar to @bdirect_read_commit(), but accepts also modified data before @pos.
700  * Note that such modifications are supported only if `f->can_overwrite_buffer == 2`.
701  **/
702 static inline void bdirect_read_commit_modified(struct fastbuf *f, byte *pos)
703 {
704   f->bptr = pos;
705   f->buffer = pos;      /* Avoid seeking backwards in the buffer */
706 }
707
708 /**
709  * Start direct writing to fastbuf's internal buffer to avoid copy overhead.
710  * The function returns the length of the buffer in @buf (at least one byte)
711  * where we can write to. The operation must be ended by @bdirect_write_commit(),
712  * unless nothing is written.
713  **/
714 static inline uns bdirect_write_prepare(struct fastbuf *f, byte **buf)
715 {
716   if (f->bptr == f->bufend)
717     f->spout(f);
718   *buf = f->bptr;
719   return bavailw(f);
720 }
721
722 /**
723  * Commit the data written to the buffer returned by @bdirect_write_prepare().
724  * The length is specified by @pos which must point just after the written data.
725  * Also moves the cursor to @pos.
726  **/
727 static inline void bdirect_write_commit(struct fastbuf *f, byte *pos)
728 {
729   f->bptr = pos;
730 }
731
732 /*** === Formatted output ***/
733
734 /**
735  * printf into a fastbuf.
736  **/
737 int bprintf(struct fastbuf *b, const char *msg, ...)
738   FORMAT_CHECK(printf,2,3);
739 int vbprintf(struct fastbuf *b, const char *msg, va_list args); /** vprintf into a fastbuf. **/
740
741 #endif