2 * UCW Library -- Fast Buffered I/O
4 * (c) 1997--2011 Martin Mares <mj@ucw.cz>
5 * (c) 2004 Robert Spalek <robert@ucw.cz>
6 * (c) 2014 Pavel Charvat <pchar@ucw.cz>
8 * This software may be freely distributed and used according to the terms
9 * of the GNU Lesser General Public License.
12 #ifndef _UCW_FASTBUF_H
13 #define _UCW_FASTBUF_H
18 #ifdef CONFIG_UCW_CLEAN_ABI
19 #define bbcopy_slow ucw_bbcopy_slow
20 #define bclose ucw_bclose
21 #define bclose_file_helper ucw_bclose_file_helper
22 #define bconfig ucw_bconfig
23 #define beof_slow ucw_beof_slow
24 #define bfdopen ucw_bfdopen
25 #define bfdopen_internal ucw_bfdopen_internal
26 #define bfdopen_shared ucw_bfdopen_shared
27 #define bfilesize ucw_bfilesize
28 #define bfilesync ucw_bfilesync
29 #define bfix_tmp_file ucw_bfix_tmp_file
30 #define bflush ucw_bflush
31 #define bfmmopen_internal ucw_bfmmopen_internal
32 #define bgetc_slow ucw_bgetc_slow
33 #define bgets ucw_bgets
34 #define bgets0 ucw_bgets0
35 #define bgets_bb ucw_bgets_bb
36 #define bgets_mp ucw_bgets_mp
37 #define bgets_nodie ucw_bgets_nodie
38 #define bgets_stk_init ucw_bgets_stk_init
39 #define bgets_stk_step ucw_bgets_stk_step
40 #define bopen ucw_bopen
41 #define bopen_fd_name ucw_bopen_fd_name
42 #define bopen_file ucw_bopen_file
43 #define bopen_file_try ucw_bopen_file_try
44 #define bopen_limited_fd ucw_bopen_limited_fd
45 #define bopen_tmp ucw_bopen_tmp
46 #define bopen_tmp_file ucw_bopen_tmp_file
47 #define bopen_try ucw_bopen_try
48 #define bpeekc_slow ucw_bpeekc_slow
49 #define bprintf ucw_bprintf
50 #define bputc_slow ucw_bputc_slow
51 #define bread_slow ucw_bread_slow
52 #define brefill ucw_brefill
53 #define brewind ucw_brewind
54 #define bseek ucw_bseek
55 #define bsetpos ucw_bsetpos
56 #define bskip_slow ucw_bskip_slow
57 #define bspout ucw_bspout
58 #define bthrow ucw_bthrow
59 #define bwrite_slow ucw_bwrite_slow
60 #define fb_tie ucw_fb_tie
61 #define fbatomic_internal_write ucw_fbatomic_internal_write
62 #define fbatomic_open ucw_fbatomic_open
63 #define fbbuf_init_read ucw_fbbuf_init_read
64 #define fbbuf_init_write ucw_fbbuf_init_write
65 #define fbdir_cheat ucw_fbdir_cheat
66 #define fbdir_open_fd_internal ucw_fbdir_open_fd_internal
67 #define fbgrow_create ucw_fbgrow_create
68 #define fbgrow_create_mp ucw_fbgrow_create_mp
69 #define fbgrow_get_buf ucw_fbgrow_get_buf
70 #define fbgrow_reset ucw_fbgrow_reset
71 #define fbgrow_rewind ucw_fbgrow_rewind
72 #define fbmem_clone_read ucw_fbmem_clone_read
73 #define fbmem_create ucw_fbmem_create
74 #define fbmulti_append ucw_fbmulti_append
75 #define fbmulti_create ucw_fbmulti_create
76 #define fbmulti_remove ucw_fbmulti_remove
77 #define fbpar_cf ucw_fbpar_cf
78 #define fbpar_def ucw_fbpar_def
79 #define fbpool_end ucw_fbpool_end
80 #define fbpool_init ucw_fbpool_init
81 #define fbpool_start ucw_fbpool_start
82 #define open_tmp ucw_open_tmp
83 #define temp_file_name ucw_temp_file_name
84 #define vbprintf ucw_vbprintf
88 * === Internal structure [[internal]]
90 * Generally speaking, a fastbuf consists of a buffer and a set of callbacks.
91 * All front-end functions operate on the buffer and if the buffer becomes
92 * empty or fills up, they ask the corresponding callback to handle the
93 * situation. Back-ends then differ just in the definition of the callbacks.
95 * The state of the fastbuf is represented by a <<struct_fastbuf,`struct fastbuf`>>,
96 * which is a simple structure describing the state of the buffer (the pointers
97 * `buffer`, `bufend`), the front-end cursor (`bptr`), the back-end cursor (`bstop`),
98 * position of the back-end cursor in the file (`pos`), some flags (`flags`)
99 * and pointers to the callback functions.
101 * The buffer can be in one of the following states:
105 * +------------------------------------+---------------------------+
106 * | unused | free space |
107 * +------------------------------------+---------------------------+
109 * buffer <= bstop (BE pos) <= bptr (FE pos) <= bufend
111 * * This schema describes a fastbuf after its initialization or @bflush().
112 * * There is no cached data and we are ready for any read or write operation
113 * (well, only if the back-end supports it).
114 * * The interval `[bptr, bufend]` can be used by front-ends
115 * for writing. If it is empty, the `spout` callback gets called
116 * upon the first write attempt to allocate a new buffer. Otherwise
117 * the fastbuf silently comes to the writing mode.
118 * * When a front-end needs to read something, it calls the `refill` callback.
119 * * The pointers can be either all non-`NULL` or all NULL.
120 * * `bstop == bptr` in most back-ends, but it is not necessary. Some
121 * in-memory streams take advantage of this.
125 * +------------------------------------+---------------------------+
126 * | read data | unused |
127 * +------------------------------------+---------------------------+
129 * buffer <= bptr (FE pos) <= bstop (BE pos) <= bufend
131 * * If we try to read something, we get to the reading mode.
132 * * No writing is allowed until a flush operation. But note that @bflush()
133 * will simply set `bptr` to `bstop` before `spout`
134 * and it breaks the position of the front-end's cursor,
135 * so the user should seek afwards.
136 * * The interval `[buffer, bstop]` contains a block of data read by the back-end.
137 * `bptr` is the front-end's cursor which points to the next character to be read.
138 * After the last character is read, `bptr == bstop` and the `refill` callback
139 * gets called upon the next read attempt to bring further data.
140 * This gives us an easy way how to implement @bungetc().
144 * +-----------------------+----------------+-----------------------+
145 * | unused | written data | free space |
146 * +-----------------------+----------------+-----------------------+
148 * buffer <= bstop (BE pos) < bptr (FE pos) <= bufend
150 * * This schema corresponds to the situation after a write attempt.
151 * * No reading is allowed until a flush operation.
152 * * The `bptr` points at the position where the next character
153 * will be written to. When we want to write, but `bptr == bufend`, we call
154 * the `spout` hook to flush the witten data and get an empty buffer.
155 * * `bstop` usually points at the beginning of the written data,
156 * but it is not necessary.
159 * Rules for back-ends:
161 * - Front-ends are only allowed to change the value of `bptr`, some flags
162 * and if a fatal error occurs, then also `bstop`. Back-ends can rely on it.
163 * - `buffer <= bstop <= bufend` and `buffer <= bptr <= bufend`.
164 * - `pos` should be the real position in the file corresponding to the location of `bstop` in the buffer.
165 * It can be modified by any back-end's callback, but the position of `bptr` (`pos + (bptr - bstop)`)
166 * must stay unchanged after `refill` or `spout`.
167 * - Failed callbacks (except `close`) should use @bthrow().
168 * - Any callback pointer may be NULL in case the callback is not implemented.
169 * - Callbacks can change not only `bptr` and `bstop`, but also the location and size of the buffer;
170 * the fb-mem back-end takes advantage of it.
173 * * out: `buffer <= bstop <= bptr <= bufend` (flushed).
174 * * @fb_tie() should be called on the newly created fastbuf.
177 * * in: `buffer <= bstop <= bptr <= bufend` (reading or flushed).
178 * * out: `buffer <= bptr <= bstop <= bufend` (reading).
179 * * Resulting `bptr == bstop` signals the end of file.
180 * The next reading attempt will again call `refill` which can succeed this time.
181 * * The callback must also return zero on EOF (iff `bptr == bstop`).
184 * * in: `buffer <= bstop <= bptr <= bufend` (writing or flushed).
185 * * out: `buffer <= bstop <= bptr < bufend` (flushed).
188 * * in: `buffer <= bstop <= bptr <= bufend` (flushed).
189 * * in: `(ofs >= 0 && whence == SEEK_SET) || (ofs <= 0 && whence == SEEK_END)`.
190 * * out: `buffer <= bstop <= bptr <= bufend` (flushed).
193 * * in: `buffer <= bstop <= bptr <= bufend` (flushed or after @bthrow()).
194 * * `close` must always free all internal structures, even when it throws an exception.
198 * This structure contains the state of the fastbuf. See the discussion above
202 byte *bptr, *bstop; /* State of the buffer */
203 byte *buffer, *bufend; /* Start and end of the buffer */
204 char *name; /* File name (used for error messages) */
205 ucw_off_t pos; /* Position of bstop in the file */
206 uns flags; /* See enum fb_flags */
207 int (*refill)(struct fastbuf *); /* Get a buffer with new data, returns 0 on EOF */
208 void (*spout)(struct fastbuf *); /* Write buffer data to the file */
209 int (*seek)(struct fastbuf *, ucw_off_t, int);/* Slow path for @bseek(), buffer already flushed; returns success */
210 void (*close)(struct fastbuf *); /* Close the stream */
211 int (*config)(struct fastbuf *, uns, int); /* Configure the stream */
212 int can_overwrite_buffer; /* Can the buffer be altered? 0=never, 1=temporarily, 2=permanently */
213 struct resource *res; /* The fastbuf can be tied to a resource pool */
220 FB_DEAD = 0x1, /* Some fastbuf's method has thrown an exception */
221 FB_DIE_ON_EOF = 0x2, /* Most of read operations throw "fb.eof" on EOF */
224 /** Tie a fastbuf to a resource in the current resource pool. Returns the pointer to the same fastbuf. **/
225 struct fastbuf *fb_tie(struct fastbuf *b); /* Tie fastbuf to a resource if there is an active pool */
228 * === Fastbuf on files [[fbparam]]
230 * If you want to use fastbufs to access files, you can choose one of several
231 * back-ends and set their parameters.
238 FB_STD, /* Standard buffered I/O */
239 FB_DIRECT, /* Direct I/O bypassing system caches (see fb-direct.c for a description) */
240 FB_MMAP /* Memory mapped files */
244 * When you open a file fastbuf, you can use this structure to select a back-end
245 * and set its parameters. If you want just an "ordinary" file stream, you can
246 * happily pass NULL instead and the defaults from the configuration file (or
247 * hard-wired defaults if no config file has been read) will be used.
250 enum fb_type type; /* The chosen back-end */
251 uns buffer_size; /* 0 for default size */
252 uns keep_back_buf; /* FB_STD: optimize for bi-directional access */
253 uns read_ahead; /* FB_DIRECT options */
255 struct asio_queue *asio;
259 extern struct cf_section fbpar_cf; /** Configuration section with which you can fill the `fb_params` **/
260 extern struct fb_params fbpar_def; /** The default `fb_params` **/
263 * Opens a file with file mode @mode (see the man page of open()).
264 * Use @params to select the fastbuf back-end and its parameters or
265 * pass NULL if you are fine with defaults.
267 * Raises `ucw.fb.open` if the file does not exist.
269 struct fastbuf *bopen_file(const char *name, int mode, struct fb_params *params);
270 struct fastbuf *bopen_file_try(const char *name, int mode, struct fb_params *params); /** Like @bopen_file(), but returns NULL on failure. **/
273 * Opens a temporary file.
274 * It is placed with other temp files and it is deleted when closed.
275 * Again, use NULL for @params if you want the defaults.
277 struct fastbuf *bopen_tmp_file(struct fb_params *params);
280 * Creates a fastbuf from a file descriptor @fd and sets its filename
281 * to @name (the name is used only in error messages).
282 * When the fastbuf is closed, the fd is closed as well. You can override
283 * this behavior by calling @bconfig().
285 struct fastbuf *bopen_fd_name(int fd, struct fb_params *params, const char *name);
286 static inline struct fastbuf *bopen_fd(int fd, struct fb_params *params) /** Same as above, but with an auto-generated filename. **/
288 return bopen_fd_name(fd, params, NULL);
292 * Flushes all buffers and makes sure that they are written to the disk.
294 void bfilesync(struct fastbuf *b);
297 * === Fastbufs on regular files [[fbfile]]
299 * If you want to use the `FB_STD` back-end and not worry about setting
300 * up any parameters, there is a couple of shortcuts.
303 struct fastbuf *bopen(const char *name, uns mode, uns buflen); /** Equivalent to @bopen_file() with `FB_STD` back-end. **/
304 struct fastbuf *bopen_try(const char *name, uns mode, uns buflen); /** Equivalent to @bopen_file_try() with `FB_STD` back-end. **/
305 struct fastbuf *bopen_tmp(uns buflen); /** Equivalent to @bopen_tmp_file() with `FB_STD` back-end. **/
306 struct fastbuf *bfdopen(int fd, uns buflen); /** Equivalent to @bopen_fd() with `FB_STD` back-end. **/
307 struct fastbuf *bfdopen_shared(int fd, uns buflen); /** Like @bfdopen(), but it does not close the @fd on @bclose(). **/
310 * === Temporary files [[fbtemp]]
312 * Usually, @bopen_tmp_file() is the best way how to come to a temporary file.
313 * However, in some specific cases you can need more, so there is also a set
314 * of more general functions.
317 #define TEMP_FILE_NAME_LEN 256
320 * Generates a temporary filename and stores it to the @name_buf (of size
321 * at least * `TEMP_FILE_NAME_LEN`). If @open_flags are not NULL, flags that
322 * should be OR-ed with other flags to open() will be stored there.
324 * The location and style of temporary files is controlled by the configuration.
325 * By default, the system temp directory (`$TMPDIR` or `/tmp`) is used.
327 * If the location is a publicly writeable directory (like `/tmp`), the
328 * generated filename cannot be guaranteed to be unique, so @open_flags
329 * will include `O_EXCL` and you have to check the result of open() and
332 * This function is not specific to fastbufs, it can be used separately.
334 void temp_file_name(char *name_buf, int *open_flags);
337 * Opens a temporary file and returns its file descriptor.
338 * You specify the file @mode and @open_flags passed to open().
340 * If the @name_buf (of at last `TEMP_FILE_NAME_LEN` chars) is not NULL,
341 * the filename is also stored in it.
343 * This function is not specific to fastbufs, it can be used separately.
345 int open_tmp(char *name_buf, int open_flags, int mode);
348 * Sometimes, a file is created as temporary and then moved to a stable
349 * location. This function takes a fastbuf created by @bopen_tmp_file()
350 * or @bopen_tmp(), marks it as permanent, closes it and renames it to
353 * Please note that it assumes that the temporary file and the @name
354 * are on the same volume (otherwise, rename() fails), so you might
355 * want to configure a special location for the temporary files
358 void bfix_tmp_file(struct fastbuf *fb, const char *name);
360 /* Internal functions of some file back-ends */
362 struct fastbuf *bfdopen_internal(int fd, const char *name, uns buflen);
363 struct fastbuf *bfmmopen_internal(int fd, const char *name, uns mode);
365 #ifdef CONFIG_UCW_FB_DIRECT
366 extern uns fbdir_cheat;
368 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);
371 void bclose_file_helper(struct fastbuf *f, int fd, int is_temp_file);
374 * === Fastbufs on file fragments [[fblim]]
376 * The `fblim` back-end reads from a file handle, but at most a given
377 * number of bytes. This is frequently used for reading from sockets.
380 struct fastbuf *bopen_limited_fd(int fd, uns bufsize, uns limit); /** Create a fastbuf which reads at most @limit bytes from @fd. **/
383 * === Fastbufs on in-memory streams [[fbmem]]
385 * The `fbmem` back-end keeps the whole contents of the stream
386 * in memory (as a linked list of memory blocks, so address space
387 * fragmentation is avoided).
389 * First, you use @fbmem_create() to create the stream and the fastbuf
390 * used for writing to it. Then you can call @fbmem_clone_read() to get
391 * an arbitrary number of fastbuf for reading from the stream.
394 struct fastbuf *fbmem_create(uns blocksize); /** Create stream and return its writing fastbuf. **/
395 struct fastbuf *fbmem_clone_read(struct fastbuf *f); /** Given a writing fastbuf, create a new reading fastbuf. **/
398 * === Fastbufs on static buffers [[fbbuf]]
400 * The `fbbuf` back-end stores the stream in a given block of memory.
401 * This is useful for parsing and generating of complex data structures.
405 * Creates a read-only fastbuf that takes its data from a given buffer.
406 * The fastbuf structure is allocated by the caller and pointed to by @f.
407 * The @buffer and @size specify the location and size of the buffer.
409 * In some cases, the front-ends can take advantage of rewriting the contents
410 * of the buffer temporarily. In this case, set @can_overwrite as described
411 * in <<internal,Internals>>. If you do not care, keep @can_overwrite zero.
413 * It is not possible to close this fastbuf. This implies that no tying to
414 * resources takes place.
416 void fbbuf_init_read(struct fastbuf *f, byte *buffer, uns size, uns can_overwrite);
419 * Creates a write-only fastbuf which writes into a provided memory buffer.
420 * The fastbuf structure is allocated by the caller and pointed to by @f.
421 * An attempt to write behind the end of the buffer causes the `ucw.fb.write` exception.
423 * Data are written directly into the buffer, so it is not necessary to call @bflush()
426 * It is not possible to close this fastbuf. This implies that no tying to
427 * resources takes place.
429 void fbbuf_init_write(struct fastbuf *f, byte *buffer, uns size);
431 static inline uns fbbuf_count_written(struct fastbuf *f) /** Calculates, how many bytes were already written into the buffer. **/
433 return f->bptr - f->bstop;
437 * === Fastbuf on recyclable growing buffers [[fbgrow]]
439 * The `fbgrow` back-end keeps the stream in a contiguous buffer stored in the
440 * main memory, but unlike <<fbmem,`fbmem`>>, the buffer does not have a fixed
441 * size and it is expanded to accomodate all data.
443 * At every moment, you can use `fastbuf->buffer` to gain access to the stream.
448 struct fastbuf *fbgrow_create(unsigned basic_size); /** Create the growing buffer pre-allocated to @basic_size bytes. **/
449 struct fastbuf *fbgrow_create_mp(struct mempool *mp, unsigned basic_size); /** Create the growing buffer pre-allocated to @basic_size bytes. **/
450 void fbgrow_reset(struct fastbuf *b); /** Reset stream and prepare for writing. **/
451 void fbgrow_rewind(struct fastbuf *b); /** Prepare for reading (of already written data). **/
454 * Can be used in any state of @b (for example when writing or after
455 * @fbgrow_rewind()) to return the pointer to internal buffer and its length in
456 * bytes. The returned buffer can be invalidated by further requests.
458 uns fbgrow_get_buf(struct fastbuf *b, byte **buf);
461 * === Fastbuf on memory pools [[fbpool]]
463 * The write-only `fbpool` back-end also keeps the stream in a contiguous
464 * buffer, but this time the buffer is allocated from within a memory pool.
467 struct fbpool { /** Structure for fastbufs & mempools. **/
473 * Initialize a new `fbpool`. The structure is allocated by the caller,
474 * so @bclose() should not be called and no resource tying takes place.
476 void fbpool_init(struct fbpool *fb); /** Initialize a new mempool fastbuf. **/
478 * Start a new continuous block and prepare for writing (see <<mempool:mp_start()>>).
479 * Provide the memory pool you want to use for this block as @mp.
481 void fbpool_start(struct fbpool *fb, struct mempool *mp, uns init_size);
483 * Close the block and return the address of its start (see <<mempool:mp_end()>>).
484 * The length can be determined by calling <<mempool:mp_size(mp, ptr)>>.
486 void *fbpool_end(struct fbpool *fb);
489 * === Atomic files for multi-threaded programs [[fbatomic]]
491 * This fastbuf backend is designed for cases when several threads
492 * of a single program append records to a common file and while the
493 * record can mix in an arbitrary way, the bytes inside a single
494 * record must remain uninterrupted.
496 * In case of files with fixed record size, we just allocate the
497 * buffer to hold a whole number of records and take advantage
498 * of the atomicity of the write() system call.
500 * With variable-sized records, we need another solution: when
501 * writing a record, we keep the fastbuf in a locked state, which
502 * prevents buffer flushing (and if the buffer becomes full, we extend it),
503 * and we wait for an explicit commit operation which write()s the buffer
504 * if the free space in the buffer falls below the expected maximum record
507 * Please note that initialization of the clones is not thread-safe,
508 * so you have to serialize it yourself.
513 struct fb_atomic_file *af;
514 byte *expected_max_bptr;
519 * Open an atomic fastbuf.
520 * If @master is NULL, the file @name is opened. If it is non-null,
521 * a new clone of an existing atomic fastbuf is created.
523 * If the file has fixed record length, just set @record_len to it.
524 * Otherwise set @record_len to the expected maximum record length
525 * with a negative sign (you need not fit in this length, but as long
526 * as you do, the fastbuf is more efficient) and call @fbatomic_commit()
529 * You can specify @record_len, if it is known (for optimisations).
531 * The file is closed when all fastbufs using it are closed.
533 struct fastbuf *fbatomic_open(const char *name, struct fastbuf *master, uns bufsize, int record_len);
534 void fbatomic_internal_write(struct fastbuf *b);
537 * Declare that you have finished writing a record. This is required only
538 * if a fixed record size was not specified.
540 static inline void fbatomic_commit(struct fastbuf *b)
542 if (b->bptr >= ((struct fb_atomic *)b)->expected_max_bptr)
543 fbatomic_internal_write(b);
546 /*** === Null fastbufs ***/
549 * Creates a new "/dev/null"-like fastbuf.
550 * Any read attempt returns an EOF, any write attempt is silently ignored.
552 struct fastbuf *fbnull_open(uns bufsize);
555 * Can be used by any back-end to switch it to the null mode.
556 * You need to provide at least one byte long buffer for writing.
558 void fbnull_start(struct fastbuf *b, byte *buf, uns bufsize);
561 * Checks whether a fastbuf has been switched to the null mode.
563 bool fbnull_test(struct fastbuf *b);
566 * === Fastbufs atop other fastbufs [[fbmulti]]
568 * Imagine some code which does massive string processing. It takes an input
569 * buffer, writes a part of it into an output buffer, then some other string
570 * and then the remaining part of the input buffer. Or anything else where you
571 * copy all the data at each stage of the complicated process.
573 * This backend takes multiple fastbufs and concatenates them formally into
574 * one. You may then read them consecutively as they were one fastbuf at all.
576 * This backend is read-only.
578 * This backend is seekable iff all of the supplied fastbufs are seekable.
580 * You aren't allowed to do anything with the underlying buffers while these
581 * are connected into fbmulti.
583 * The fbmulti is inited by @fbmulti_create(). It returns an empty fbmulti.
584 * Then you call @fbmulti_append() for each fbmulti.
586 * If @bclose() is called on fbmulti, all the underlying buffers get closed
589 * If you want to keep an underlying fastbuf open after @bclose, just remove it
590 * by @fbmulti_remove where the second parameter is a pointer to the removed
591 * fastbuf. If you pass NULL, all the underlying fastbufs are removed.
593 * After @fbmulti_remove, the state of the fbmulti is undefined. The only allowed
594 * operation is either another @fbmulti_remove or @bclose on the fbmulti.
598 * Create an empty fbmulti
600 struct fastbuf *fbmulti_create(void);
603 * Append a fb to fbmulti
605 void fbmulti_append(struct fastbuf *f, struct fastbuf *fb);
608 * Remove a fb from fbmulti
610 void fbmulti_remove(struct fastbuf *f, struct fastbuf *fb);
612 /*** === Configuring stream parameters [[bconfig]] ***/
614 enum bconfig_type { /** Parameters that could be configured. **/
615 BCONFIG_IS_TEMP_FILE, /* 0=normal file, 1=temporary file, 2=shared fd */
616 BCONFIG_KEEP_BACK_BUF, /* Optimize for bi-directional access */
619 int bconfig(struct fastbuf *f, uns type, int data); /** Configure a fastbuf. Returns previous value. **/
621 /*** === Universal functions working on all fastbuf's [[ffbasic]] ***/
624 * Close and free fastbuf.
625 * Can not be used for fastbufs not returned from function (initialized in a parameter, for example the one from `fbbuf_init_read`).
627 void bclose(struct fastbuf *f);
628 void bthrow(struct fastbuf *f, const char *id, const char *fmt, ...) FORMAT_CHECK(printf,3,4) NONRET; /** Throw exception on a given fastbuf **/
629 int brefill(struct fastbuf *f, int allow_eof);
630 void bspout(struct fastbuf *f);
631 void bflush(struct fastbuf *f); /** Write data (if it makes any sense, do not use for in-memory buffers). **/
632 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. **/
633 void bsetpos(struct fastbuf *f, ucw_off_t pos); /** Set position to @pos bytes from beginning. Only for seekable fastbufs. **/
634 void brewind(struct fastbuf *f); /** Go to the beginning of the fastbuf. Only for seekable ones. **/
635 ucw_off_t bfilesize(struct fastbuf *f); /** How large is the file? -1 if not seekable. **/
637 static inline ucw_off_t btell(struct fastbuf *f) /** Where am I (from the beginning)? **/
639 return f->pos + (f->bptr - f->bstop);
642 int bgetc_slow(struct fastbuf *f);
643 static inline int bgetc(struct fastbuf *f) /** Return next character from the buffer. **/
645 return (f->bptr < f->bstop) ? (int) *f->bptr++ : bgetc_slow(f);
648 int bpeekc_slow(struct fastbuf *f);
649 static inline int bpeekc(struct fastbuf *f) /** Return next character from the buffer, but keep the current position. **/
651 return (f->bptr < f->bstop) ? (int) *f->bptr : bpeekc_slow(f);
654 int beof_slow(struct fastbuf *f);
655 static inline int beof(struct fastbuf *f) /** Have I reached EOF? **/
657 return (f->bptr < f->bstop) ? 0 : beof_slow(f);
660 static inline void bungetc(struct fastbuf *f) /** Return last read character back. Only one back is guaranteed to work. **/
665 void bputc_slow(struct fastbuf *f, uns c);
666 static inline void bputc(struct fastbuf *f, uns c) /** Write a single character. **/
668 if (f->bptr < f->bufend)
674 static inline uns bavailr(struct fastbuf *f) /** Return the length of the cached data to be read. Do not use directly. **/
676 return f->bstop - f->bptr;
679 static inline uns bavailw(struct fastbuf *f) /** Return the length of the buffer available for writing. Do not use directly. **/
681 return f->bufend - f->bptr;
684 uns bread_slow(struct fastbuf *f, void *b, uns l, uns check);
686 * Read at most @l bytes of data into @b.
687 * Returns number of bytes read.
688 * 0 means end of file.
690 static inline uns bread(struct fastbuf *f, void *b, uns l)
694 memcpy(b, f->bptr, l);
699 return bread_slow(f, b, l, 0);
703 * Reads exactly @l bytes of data into @b.
704 * If at the end of file, it returns 0.
705 * If there are data, but less than @l, it raises `ucw.fb.eof`.
707 static inline uns breadb(struct fastbuf *f, void *b, uns l)
711 memcpy(b, f->bptr, l);
716 return bread_slow(f, b, l, 1);
719 void bwrite_slow(struct fastbuf *f, const void *b, uns l);
720 static inline void bwrite(struct fastbuf *f, const void *b, uns l) /** Writes buffer @b of length @l into fastbuf. **/
724 memcpy(f->bptr, b, l);
728 bwrite_slow(f, b, l);
732 * Reads a line into @b and strips trailing `\n`.
733 * Returns pointer to the terminating 0 or NULL on `EOF`.
734 * Raises `ucw.fb.toolong` if the line is longer than @l.
736 char *bgets(struct fastbuf *f, char *b, uns l);
737 char *bgets0(struct fastbuf *f, char *b, uns l); /** The same as @bgets(), but for 0-terminated strings. **/
739 * Returns either length of read string (excluding the terminator) or -1 if it is too long.
740 * In such cases exactly @l bytes are read.
742 int bgets_nodie(struct fastbuf *f, char *b, uns l);
747 * Read a string, strip the trailing `\n` and store it into growing buffer @b.
748 * Raises `ucw.fb.toolong` if the line is longer than @limit.
750 uns bgets_bb(struct fastbuf *f, struct bb_t *b, uns limit);
752 * Read a string, strip the trailing `\n` and store it into buffer allocated from a memory pool.
754 char *bgets_mp(struct fastbuf *f, struct mempool *mp);
756 struct bgets_stk_struct {
758 byte *old_buf, *cur_buf, *src;
759 uns old_len, cur_len, src_len;
761 void bgets_stk_init(struct bgets_stk_struct *s);
762 void bgets_stk_step(struct bgets_stk_struct *s);
765 * Read a string, strip the trailing `\n` and store it on the stack (allocated using alloca()).
767 #define bgets_stk(fb) \
768 ({ 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; })
771 * Write a string, without 0 or `\n` at the end.
773 static inline void bputs(struct fastbuf *f, const char *b)
775 bwrite(f, b, strlen(b));
779 * Write string, including terminating 0.
781 static inline void bputs0(struct fastbuf *f, const char *b)
783 bwrite(f, b, strlen(b)+1);
787 * Write string and append a newline to the end.
789 static inline void bputsn(struct fastbuf *f, const char *b)
795 void bbcopy_slow(struct fastbuf *f, struct fastbuf *t, uns l);
797 * Copy @l bytes of data from fastbuf @f to fastbuf @t.
798 * `UINT_MAX` (`~0U`) means all data, even if more than `UINT_MAX` bytes remain.
800 static inline void bbcopy(struct fastbuf *f, struct fastbuf *t, uns l)
802 if (bavailr(f) >= l && bavailw(t) >= l)
804 memcpy(t->bptr, f->bptr, l);
809 bbcopy_slow(f, t, l);
812 int bskip_slow(struct fastbuf *f, uns len);
813 static inline int bskip(struct fastbuf *f, uns len) /** Skip @len bytes without reading them. **/
815 if (bavailr(f) >= len)
821 return bskip_slow(f, len);
824 /*** === Direct I/O on buffers ***/
827 * Begin direct reading from fastbuf's internal buffer to avoid unnecessary copying.
828 * The function returns a buffer @buf together with its length in bytes (zero means EOF)
829 * with cached data to be read.
831 * Some back-ends allow the user to modify the data in the returned buffer to avoid unnecessary.
832 * If the back-end allows such modifications, it can set `f->can_overwrite_buffer` accordingly:
834 * - 0 if no modification is allowed,
835 * - 1 if the user can modify the buffer on the condition that
836 * the modifications will be undone before calling the next
838 * - 2 if the user is allowed to overwrite the data in the buffer
839 * if @bdirect_read_commit_modified() is called afterwards.
840 * In this case, the back-end must be prepared for trimming
841 * of the buffer which is done by the commit function.
843 * The reading must be ended by @bdirect_read_commit() or @bdirect_read_commit_modified(),
844 * unless the user did not read or modify anything.
846 static inline uns bdirect_read_prepare(struct fastbuf *f, byte **buf)
848 if (f->bptr == f->bstop && !f->refill(f))
850 *buf = NULL; // This is not needed, but it helps to get rid of spurious warnings
858 * End direct reading started by @bdirect_read_prepare() and move the cursor at @pos.
859 * Data in the returned buffer must be same as after @bdirect_read_prepare() and
860 * @pos must point somewhere inside the buffer.
862 static inline void bdirect_read_commit(struct fastbuf *f, byte *pos)
868 * Similar to @bdirect_read_commit(), but accepts also modified data before @pos.
869 * Note that such modifications are supported only if `f->can_overwrite_buffer == 2`.
871 static inline void bdirect_read_commit_modified(struct fastbuf *f, byte *pos)
874 f->buffer = pos; /* Avoid seeking backwards in the buffer */
878 * Start direct writing to fastbuf's internal buffer to avoid copy overhead.
879 * The function returns the length of the buffer in @buf (at least one byte)
880 * where we can write to. The operation must be ended by @bdirect_write_commit(),
881 * unless nothing is written.
883 static inline uns bdirect_write_prepare(struct fastbuf *f, byte **buf)
885 if (f->bptr == f->bufend)
892 * Commit the data written to the buffer returned by @bdirect_write_prepare().
893 * The length is specified by @pos which must point just after the written data.
894 * Also moves the cursor to @pos.
896 static inline void bdirect_write_commit(struct fastbuf *f, byte *pos)
901 /*** === Formatted output ***/
904 * printf into a fastbuf.
906 int bprintf(struct fastbuf *b, const char *msg, ...)
907 FORMAT_CHECK(printf,2,3);
908 int vbprintf(struct fastbuf *b, const char *msg, va_list args); /** vprintf into a fastbuf. **/