X-Git-Url: http://mj.ucw.cz/gitweb/?a=blobdiff_plain;f=ucw%2Ffastbuf.h;h=6d02ac037b47701c3da597c2b88154946d3ce842;hb=9abc4dfc3bbc527d5dce520d54e217fe3fbebebd;hp=d6bc59c96fa37722c4d7fe32e2d29dbc4885a549;hpb=52a9ce22c23f7a61573db7bf30e58495da381952;p=libucw.git diff --git a/ucw/fastbuf.h b/ucw/fastbuf.h index d6bc59c9..6d02ac03 100644 --- a/ucw/fastbuf.h +++ b/ucw/fastbuf.h @@ -1,7 +1,7 @@ /* * UCW Library -- Fast Buffered I/O * - * (c) 1997--2008 Martin Mares + * (c) 1997--2011 Martin Mares * (c) 2004 Robert Spalek * * This software may be freely distributed and used according to the terms @@ -19,52 +19,109 @@ * * Generally speaking, a fastbuf consists of a buffer and a set of callbacks. * All front-end functions operate on the buffer and if the buffer becomes - * empty or fills up, they ask the corresponding callback to solve the + * empty or fills up, they ask the corresponding callback to handle the * situation. Back-ends then differ just in the definition of the callbacks. - * The state of the fastbuf is represented by `struct fastbuf`, which - * is a simple structure describing the state of the buffer and pointers - * to the callback functions. - * - * When we are reading from the fastbuf, the buffer is laid out as follows: - * - * +----------------+---------------------------+ - * | read data | free space | - * +----------------+---------------------------+ - * ^ ^ ^ ^ - * buffer bptr bstop bufend - * - * Here `bptr` points to the next character to be read. After the last character is - * read, `bptr == bstop` and the `refill` callback gets called upon the next read - * attempt to bring further data. This gives us an easy way how to implement bungetc(). - * - * When writing, the situation looks like: - * - * +--------+--------------+--------------------+ - * | unused | written data | free space | - * +--------+--------------+--------------------+ - * ^ ^ ^ ^ - * buffer bstop bptr bufend - * - * In this case, the `bptr` points at the position where the next character - * will be written to. When we want to write, but `bptr == bufend`, we call - * the `spout` hook to flush the data and get an empty buffer. - * - * Several dirty tricks can be played: - * - * - The `spout`/`refill` hooks can change not only `bptr` and `bstop`, but also - * the location and size of the buffer; the fb-mem back-end takes advantage of it. - * - In some cases, the user of the `bdirect` interface can be allowed to modify - * the data in the buffer to avoid unnecessary copying. If the back-end - * allows such modifications, it can set `fastbuf->can_overwrite_buffer` accordingly: - * * 0 if no modification is allowed, - * * 1 if the user can modify the buffer on the condition that - * the modifications will be undone before calling the next - * fastbuf operation - * * 2 if the user is allowed to overwrite the data in the buffer - * if bdirect_read_commit_modified() is called afterwards. - * In this case, the back-end must be prepared for trimming - * of the buffer which is done by the commit function. * + * The state of the fastbuf is represented by a <>, + * which is a simple structure describing the state of the buffer (the pointers + * `buffer`, `bufend`), the front-end cursor (`bptr`), the back-end cursor (`bstop`), + * position of the back-end cursor in the file (`pos`), some flags (`flags`) + * and pointers to the callback functions. + * + * The buffer can be in one of the following states: + * + * 1. Flushed: + * + * +------------------------------------+---------------------------+ + * | unused | free space | + * +------------------------------------+---------------------------+ + * ^ ^ ^ ^ + * buffer <= bstop (BE pos) <= bptr (FE pos) <= bufend + * + * * This schema describes a fastbuf after its initialization or bflush(). + * * There is no cached data and we are ready for any read or write operation + * (well, only if the back-end supports it). + * * The interval `[bptr, bufend]` can be used by front-ends + * for writing. If it is empty, the `spout` callback gets called + * upon the first write attempt to allocate a new buffer. Otherwise + * the fastbuf silently comes to the writing mode. + * * When a front-end needs to read something, it calls the `refill` callback. + * * The pointers can be either all non-`NULL` or all NULL. + * * `bstop == bptr` in most back-ends, but it is not necessary. Some + * in-memory streams take advantage of this. + * + * 2. Reading: + * + * +------------------------------------+---------------------------+ + * | read data | unused | + * +------------------------------------+---------------------------+ + * ^ ^ ^ ^ + * buffer <= bptr (FE pos) <= bstop (BE pos) <= bufend + * + * * If we try to read something, we get to the reading mode. + * * No writing is allowed until a flush operation. But note that @bflush() + * will simply set `bptr` to `bstop` before `spout` + * and it breaks the position of the front-end's cursor, + * so the user should seek afwards. + * * The interval `[buffer, bstop]` contains a block of data read by the back-end. + * `bptr` is the front-end's cursor which points to the next character to be read. + * After the last character is read, `bptr == bstop` and the `refill` callback + * gets called upon the next read attempt to bring further data. + * This gives us an easy way how to implement @bungetc(). + * + * 3. Writing: + * + * +-----------------------+----------------+-----------------------+ + * | unused | written data | free space | + * +-----------------------+----------------+-----------------------+ + * ^ ^ ^ ^ + * buffer <= bstop (BE pos) < bptr (FE pos) <= bufend + * + * * This schema corresponds to the situation after a write attempt. + * * No reading is allowed until a flush operation. + * * The `bptr` points at the position where the next character + * will be written to. When we want to write, but `bptr == bufend`, we call + * the `spout` hook to flush the witten data and get an empty buffer. + * * `bstop` usually points at the beginning of the written data, + * but it is not necessary. + * + * + * Rules for back-ends: + * + * - Front-ends are only allowed to change the value of `bptr`, some flags + * and if a fatal error occurs, then also `bstop`. Back-ends can rely on it. + * - `buffer <= bstop <= bufend` and `buffer <= bptr <= bufend`. + * - `pos` should be the real position in the file corresponding to the location of `bstop` in the buffer. + * It can be modified by any back-end's callback, but the position of `bptr` (`pos + (bptr - bstop)`) + * must stay unchanged after `refill` or `spout`. + * - Failed callbacks (except `close`) should use @bthrow(). + * - Any callback pointer may be NULL in case the callback is not implemented. + * - Callbacks can change not only `bptr` and `bstop`, but also the location and size of the buffer; + * the fb-mem back-end takes advantage of it. + * + * - Initialization: + * * out: `buffer <= bstop <= bptr <= bufend` (flushed). + * * @fb_tie() should be called on the newly created fastbuf. + * + * - `refill`: + * * in: `buffer <= bstop <= bptr <= bufend` (reading or flushed). + * * out: `buffer <= bptr <= bstop <= bufend` (reading). + * * Resulting `bptr == bstop` signals the end of file. + * The next reading attempt will again call `refill` which can succeed this time. + * * The callback must also return zero on EOF (iff `bptr == bstop`). + * + * - `spout`: + * * in: `buffer <= bstop <= bptr <= bufend` (writing or flushed). + * * out: `buffer <= bstop <= bptr < bufend` (flushed). + * + * - `seek`: + * * in: `buffer <= bstop <= bptr <= bufend` (flushed). + * * in: `(ofs >= 0 && whence == SEEK_SET) || (ofs <= 0 && whence == SEEK_END)`. + * * out: `buffer <= bstop <= bptr <= bufend` (flushed). + * + * - `close`: + * * in: `buffer <= bstop <= bptr <= bufend` (flushed or after @bthrow()). + * * `close` must always free all internal structures, even when it throws an exception. ***/ /** @@ -72,19 +129,31 @@ * for how it works. **/ struct fastbuf { - byte is_fastbuf[0]; /* Dummy field for checking of type casts */ byte *bptr, *bstop; /* State of the buffer */ byte *buffer, *bufend; /* Start and end of the buffer */ char *name; /* File name (used for error messages) */ ucw_off_t pos; /* Position of bstop in the file */ + uns flags; /* See enum fb_flags */ int (*refill)(struct fastbuf *); /* Get a buffer with new data, returns 0 on EOF */ void (*spout)(struct fastbuf *); /* Write buffer data to the file */ - int (*seek)(struct fastbuf *, ucw_off_t, int);/* Slow path for bseek(), buffer already flushed; returns success */ + int (*seek)(struct fastbuf *, ucw_off_t, int);/* Slow path for @bseek(), buffer already flushed; returns success */ void (*close)(struct fastbuf *); /* Close the stream */ int (*config)(struct fastbuf *, uns, int); /* Configure the stream */ int can_overwrite_buffer; /* Can the buffer be altered? 0=never, 1=temporarily, 2=permanently */ + struct resource *res; /* The fastbuf can be tied to a resource pool */ }; +/** + * Fastbuf flags + */ +enum fb_flags { + FB_DEAD = 0x1, /* Some fastbuf's method has thrown an exception */ + FB_DIE_ON_EOF = 0x2, /* Most of read operations throw "fb.eof" on EOF */ +}; + +/** Tie a fastbuf to a resource in the current resource pool. Returns the pointer to the same fastbuf. **/ +struct fastbuf *fb_tie(struct fastbuf *b); /* Tie fastbuf to a resource if there is an active pool */ + /*** * === Fastbuf on files [[fbparam]] * @@ -117,15 +186,15 @@ struct fb_params { }; struct cf_section; -extern struct cf_section fbpar_cf; /** Configuration section with which you can fill the `fb_params` **/ +extern struct cf_section fbpar_cf; /** Configuration section with which you can fill the `fb_params` **/ extern struct fb_params fbpar_def; /** The default `fb_params` **/ /** * Opens a file with file mode @mode (see the man page of open()). * Use @params to select the fastbuf back-end and its parameters or - * pass `NULL` if you are fine with defaults. + * pass NULL if you are fine with defaults. * - * Dies if the file does not exist. + * Raises `ucw.fb.open` if the file does not exist. **/ struct fastbuf *bopen_file(const char *name, int mode, struct fb_params *params); struct fastbuf *bopen_file_try(const char *name, int mode, struct fb_params *params); /** Like bopen_file(), but returns NULL on failure. **/ @@ -133,7 +202,7 @@ struct fastbuf *bopen_file_try(const char *name, int mode, struct fb_params *par /** * Opens a temporary file. * It is placed with other temp files and it is deleted when closed. - * Again, use `NULL` for @params if you want the defaults. + * Again, use NULL for @params if you want the defaults. **/ struct fastbuf *bopen_tmp_file(struct fb_params *params); @@ -141,7 +210,7 @@ struct fastbuf *bopen_tmp_file(struct fb_params *params); * Creates a fastbuf from a file descriptor @fd and sets its filename * to @name (the name is used only in error messages). * When the fastbuf is closed, the fd is closed as well. You can override - * this behavior by calling bconfig(). + * this behavior by calling @bconfig(). */ struct fastbuf *bopen_fd_name(int fd, struct fb_params *params, const char *name); static inline struct fastbuf *bopen_fd(int fd, struct fb_params *params) /** Same as above, but with an auto-generated filename. **/ @@ -161,16 +230,16 @@ void bfilesync(struct fastbuf *b); * up any parameters, there is a couple of shortcuts. ***/ -struct fastbuf *bopen(const char *name, uns mode, uns buflen); /** Equivalent to bopen_file() with `FB_STD` back-end. **/ -struct fastbuf *bopen_try(const char *name, uns mode, uns buflen); /** Equivalent to bopen_file_try() with `FB_STD` back-end. **/ -struct fastbuf *bopen_tmp(uns buflen); /** Equivalent to bopen_tmp_file() with `FB_STD` back-end. **/ -struct fastbuf *bfdopen(int fd, uns buflen); /** Equivalent to bopen_fd() with `FB_STD` back-end. **/ -struct fastbuf *bfdopen_shared(int fd, uns buflen); /** Like bfdopen(), but it does not close the @fd on bclose(). **/ +struct fastbuf *bopen(const char *name, uns mode, uns buflen); /** Equivalent to @bopen_file() with `FB_STD` back-end. **/ +struct fastbuf *bopen_try(const char *name, uns mode, uns buflen); /** Equivalent to @bopen_file_try() with `FB_STD` back-end. **/ +struct fastbuf *bopen_tmp(uns buflen); /** Equivalent to @bopen_tmp_file() with `FB_STD` back-end. **/ +struct fastbuf *bfdopen(int fd, uns buflen); /** Equivalent to @bopen_fd() with `FB_STD` back-end. **/ +struct fastbuf *bfdopen_shared(int fd, uns buflen); /** Like @bfdopen(), but it does not close the @fd on @bclose(). **/ /*** * === Temporary files [[fbtemp]] * - * Usually, bopen_tmp_file() is the best way how to come to a temporary file. + * Usually, @bopen_tmp_file() is the best way how to come to a temporary file. * However, in some specific cases you can need more, so there is also a set * of more general functions. ***/ @@ -179,7 +248,7 @@ struct fastbuf *bfdopen_shared(int fd, uns buflen); /** Like bfdopen(), but it /** * Generates a temporary filename and stores it to the @name_buf (of size - * at least * `TEMP_FILE_NAME_LEN`). If @open_flags are not `NULL`, flags that + * at least * `TEMP_FILE_NAME_LEN`). If @open_flags are not NULL, flags that * should be OR-ed with other flags to open() will be stored there. * * The location and style of temporary files is controlled by the configuration. @@ -198,7 +267,7 @@ void temp_file_name(char *name_buf, int *open_flags); * Opens a temporary file and returns its file descriptor. * You specify the file @mode and @open_flags passed to open(). * - * If the @name_buf (of at last `TEMP_FILE_NAME_LEN` chars) is not `NULL`, + * If the @name_buf (of at last `TEMP_FILE_NAME_LEN` chars) is not NULL, * the filename is also stored in it. * * This function is not specific to fastbufs, it can be used separately. @@ -207,8 +276,8 @@ int open_tmp(char *name_buf, int open_flags, int mode); /** * Sometimes, a file is created as temporary and then moved to a stable - * location. This function takes a fastbuf created by bopen_tmp_file() - * or bopen_tmp(), marks it as permanent, closes it and renames it to + * location. This function takes a fastbuf created by @bopen_tmp_file() + * or @bopen_tmp(), marks it as permanent, closes it and renames it to * @name. * * Please note that it assumes that the temporary file and the @name @@ -223,9 +292,11 @@ void bfix_tmp_file(struct fastbuf *fb, const char *name); struct fastbuf *bfdopen_internal(int fd, const char *name, uns buflen); struct fastbuf *bfmmopen_internal(int fd, const char *name, uns mode); +#ifdef CONFIG_UCW_FB_DIRECT extern uns fbdir_cheat; struct asio_queue; 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); +#endif void bclose_file_helper(struct fastbuf *f, int fd, int is_temp_file); @@ -245,8 +316,8 @@ struct fastbuf *bopen_limited_fd(int fd, uns bufsize, uns limit); /** Create a f * in memory (as a linked list of memory blocks, so address space * fragmentation is avoided). * - * First, you use fbmem_create() to create the stream and the fastbuf - * used for writing to it. Then you can call fbmem_clone_read() to get + * First, you use @fbmem_create() to create the stream and the fastbuf + * used for writing to it. Then you can call @fbmem_clone_read() to get * an arbitrary number of fastbuf for reading from the stream. ***/ @@ -267,21 +338,23 @@ struct fastbuf *fbmem_clone_read(struct fastbuf *f); /** Given a writing fastbuf * * In some cases, the front-ends can take advantage of rewriting the contents * of the buffer temporarily. In this case, set @can_overwrite as described - * in xref:internal[Internals]. If you do not care, keep @can_overwrite zero. + * in <>. If you do not care, keep @can_overwrite zero. * - * It is not possible to close this fastbuf. + * It is not possible to close this fastbuf. This implies that no tying to + * resources takes place. */ void fbbuf_init_read(struct fastbuf *f, byte *buffer, uns size, uns can_overwrite); /** * Creates a write-only fastbuf which writes into a provided memory buffer. * The fastbuf structure is allocated by the caller and pointed to by @f. - * An attempt to write behind the end of the buffer dies. + * An attempt to write behind the end of the buffer causes the `ucw.fb.write` exception. * - * Data are written directly into the buffer, so it is not necessary to call bflush() + * Data are written directly into the buffer, so it is not necessary to call @bflush() * at any moment. * - * It is not possible to close this fastbuf. + * It is not possible to close this fastbuf. This implies that no tying to + * resources takes place. */ void fbbuf_init_write(struct fastbuf *f, byte *buffer, uns size); @@ -294,16 +367,26 @@ static inline uns fbbuf_count_written(struct fastbuf *f) /** Calculates, how man * === Fastbuf on recyclable growing buffers [[fbgrow]] * * The `fbgrow` back-end keeps the stream in a contiguous buffer stored in the - * main memory, but unlike xref:fbmem[`fbmem`], the buffer does not have a fixed + * main memory, but unlike <>, the buffer does not have a fixed * size and it is expanded to accomodate all data. * * At every moment, you can use `fastbuf->buffer` to gain access to the stream. ***/ +struct mempool; + struct fastbuf *fbgrow_create(unsigned basic_size); /** Create the growing buffer pre-allocated to @basic_size bytes. **/ +struct fastbuf *fbgrow_create_mp(struct mempool *mp, unsigned basic_size); /** Create the growing buffer pre-allocated to @basic_size bytes. **/ void fbgrow_reset(struct fastbuf *b); /** Reset stream and prepare for writing. **/ void fbgrow_rewind(struct fastbuf *b); /** Prepare for reading (of already written data). **/ +/** + * Can be used in any state of @b (for example when writing or after + * @fbgrow_rewind()) to return the pointer to internal buffer and its length in + * bytes. The returned buffer can be invalidated by further requests. + **/ +uns fbgrow_get_buf(struct fastbuf *b, byte **buf); + /*** * === Fastbuf on memory pools [[fbpool]] * @@ -311,24 +394,24 @@ void fbgrow_rewind(struct fastbuf *b); /** Prepare for reading (of already wri * buffer, but this time the buffer is allocated from within a memory pool. ***/ -struct mempool; struct fbpool { /** Structure for fastbufs & mempools. **/ struct fastbuf fb; struct mempool *mp; }; /** - * Initialize a new `fbpool`. The structure is allocated by the caller. + * Initialize a new `fbpool`. The structure is allocated by the caller, + * so bclose() should not be called and no resource tying takes place. **/ void fbpool_init(struct fbpool *fb); /** Initialize a new mempool fastbuf. **/ /** - * Start a new continuous block and prepare for writing (see mp_start()). + * Start a new continuous block and prepare for writing (see <>). * Provide the memory pool you want to use for this block as @mp. **/ void fbpool_start(struct fbpool *fb, struct mempool *mp, uns init_size); /** - * Close the block and return the address of its start (see mp_end()). - * The length can be determined by calling mp_size(mp, ptr). + * Close the block and return the address of its start (see <>). + * The length can be determined by calling <>. **/ void *fbpool_end(struct fbpool *fb); @@ -361,17 +444,16 @@ struct fb_atomic { byte *expected_max_bptr; uns slack_size; }; -#define FB_ATOMIC(f) ((struct fb_atomic *)(f)->is_fastbuf) /** * Open an atomic fastbuf. - * If @master is `NULL`, the file @name is opened. If it is non-null, + * If @master is NULL, the file @name is opened. If it is non-null, * a new clone of an existing atomic fastbuf is created. * * If the file has fixed record length, just set @record_len to it. * Otherwise set @record_len to the expected maximum record length * with a negative sign (you need not fit in this length, but as long - * as you do, the fastbuf is more efficient) and call fbatomic_commit() + * as you do, the fastbuf is more efficient) and call @fbatomic_commit() * after each record. * * You can specify @record_len, if it is known (for optimisations). @@ -404,11 +486,14 @@ int bconfig(struct fastbuf *f, uns type, int data); /** Configure a fastbuf. Ret /** * Close and free fastbuf. - * Can not be used for fastbufs not returned from function (initialized in a parameter, for example the one from +fbbuf_init_read+). + * Can not be used for fastbufs not returned from function (initialized in a parameter, for example the one from `fbbuf_init_read`). */ void bclose(struct fastbuf *f); +void bthrow(struct fastbuf *f, const char *id, const char *fmt, ...) FORMAT_CHECK(printf,3,4) NONRET; /** Throw exception on a given fastbuf **/ +int brefill(struct fastbuf *f, int allow_eof); +void bspout(struct fastbuf *f); void bflush(struct fastbuf *f); /** Write data (if it makes any sense, do not use for in-memory buffers). **/ -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. **/ +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. **/ void bsetpos(struct fastbuf *f, ucw_off_t pos); /** Set position to @pos bytes from beginning. Only for seekable fastbufs. **/ void brewind(struct fastbuf *f); /** Go to the beginning of the fastbuf. Only for seekable ones. **/ ucw_off_t bfilesize(struct fastbuf *f); /** How large is the file? -1 if not seekable. **/ @@ -430,6 +515,12 @@ static inline int bpeekc(struct fastbuf *f) /** Return next character from the return (f->bptr < f->bstop) ? (int) *f->bptr : bpeekc_slow(f); } +int beof_slow(struct fastbuf *f); +static inline int beof(struct fastbuf *f) /** Have I reached EOF? **/ +{ + return (f->bptr < f->bstop) ? 0 : beof_slow(f); +} + static inline void bungetc(struct fastbuf *f) /** Return last read character back. Only one back is guaranteed to work. **/ { f->bptr--; @@ -444,12 +535,12 @@ static inline void bputc(struct fastbuf *f, uns c) /** Write a single character bputc_slow(f, c); } -static inline uns bavailr(struct fastbuf *f) +static inline uns bavailr(struct fastbuf *f) /** Return the length of the cached data to be read. Do not use directly. **/ { return f->bstop - f->bptr; } -static inline uns bavailw(struct fastbuf *f) +static inline uns bavailw(struct fastbuf *f) /** Return the length of the buffer available for writing. Do not use directly. **/ { return f->bufend - f->bptr; } @@ -475,7 +566,7 @@ static inline uns bread(struct fastbuf *f, void *b, uns l) /** * Reads exactly @l bytes of data into @b. * If at the end of file, it returns 0. - * If there are data, but less than @l, it dies. + * If there are data, but less than @l, it raises `ucw.fb.eof`. */ static inline uns breadb(struct fastbuf *f, void *b, uns l) { @@ -502,12 +593,12 @@ static inline void bwrite(struct fastbuf *f, const void *b, uns l) /** Writes bu } /** - * Reads a line into @b and strips trailing +\n+. - * Returns pointer to the terminating 0 or +NULL+ on EOF. - * Dies if the line is longer than @l. + * Reads a line into @b and strips trailing `\n`. + * Returns pointer to the terminating 0 or NULL on `EOF`. + * Raises `ucw.fb.toolong` if the line is longer than @l. **/ char *bgets(struct fastbuf *f, char *b, uns l); -char *bgets0(struct fastbuf *f, char *b, uns l); /** The same as bgets(), but for 0-terminated strings. **/ +char *bgets0(struct fastbuf *f, char *b, uns l); /** The same as @bgets(), but for 0-terminated strings. **/ /** * Returns either length of read string (excluding the terminator) or -1 if it is too long. * In such cases exactly @l bytes are read. @@ -517,12 +608,12 @@ int bgets_nodie(struct fastbuf *f, char *b, uns l); struct mempool; struct bb_t; /** - * Read a string, strip the trailing +\n+ and store it into growing buffer @b. - * Dies if the line is longer than @limit. + * Read a string, strip the trailing `\n` and store it into growing buffer @b. + * Raises `ucw.fb.toolong` if the line is longer than @limit. **/ uns bgets_bb(struct fastbuf *f, struct bb_t *b, uns limit); /** - * Read a string, strip the trailing +\n+ and store it into buffer allocated from a memory pool. + * Read a string, strip the trailing `\n` and store it into buffer allocated from a memory pool. **/ char *bgets_mp(struct fastbuf *f, struct mempool *mp); @@ -535,13 +626,13 @@ void bgets_stk_init(struct bgets_stk_struct *s); void bgets_stk_step(struct bgets_stk_struct *s); /** - * Read a string, strip the trailing +\n+ and store it on the stack (allocated using alloca()). + * Read a string, strip the trailing `\n` and store it on the stack (allocated using alloca()). **/ #define bgets_stk(fb) \ ({ 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; }) /** - * Write a string, without 0 or +\n+ at the end. + * Write a string, without 0 or `\n` at the end. **/ static inline void bputs(struct fastbuf *f, const char *b) { @@ -568,6 +659,7 @@ static inline void bputsn(struct fastbuf *f, const char *b) void bbcopy_slow(struct fastbuf *f, struct fastbuf *t, uns l); /** * Copy @l bytes of data from fastbuf @f to fastbuf @t. + * `UINT_MAX` (`~0U`) means all data, even if more than `UINT_MAX` bytes remain. **/ static inline void bbcopy(struct fastbuf *f, struct fastbuf *t, uns l) { @@ -594,10 +686,28 @@ static inline int bskip(struct fastbuf *f, uns len) /** Skip @len bytes without } /*** === Direct I/O on buffers ***/ -// TODO Documentation -- what do they do? -static inline uns -bdirect_read_prepare(struct fastbuf *f, byte **buf) +/** + * Begin direct reading from fastbuf's internal buffer to avoid unnecessary copying. + * The function returns a buffer @buf together with its length in bytes (zero means EOF) + * with cached data to be read. + * + * Some back-ends allow the user to modify the data in the returned buffer to avoid unnecessary. + * If the back-end allows such modifications, it can set `f->can_overwrite_buffer` accordingly: + * + * - 0 if no modification is allowed, + * - 1 if the user can modify the buffer on the condition that + * the modifications will be undone before calling the next + * fastbuf operation + * - 2 if the user is allowed to overwrite the data in the buffer + * if @bdirect_read_commit_modified() is called afterwards. + * In this case, the back-end must be prepared for trimming + * of the buffer which is done by the commit function. + * + * The reading must be ended by @bdirect_read_commit() or @bdirect_read_commit_modified(), + * unless the user did not read or modify anything. + **/ +static inline uns bdirect_read_prepare(struct fastbuf *f, byte **buf) { if (f->bptr == f->bstop && !f->refill(f)) { @@ -608,21 +718,33 @@ bdirect_read_prepare(struct fastbuf *f, byte **buf) return bavailr(f); } -static inline void -bdirect_read_commit(struct fastbuf *f, byte *pos) +/** + * End direct reading started by @bdirect_read_prepare() and move the cursor at @pos. + * Data in the returned buffer must be same as after @bdirect_read_prepare() and + * @pos must point somewhere inside the buffer. + **/ +static inline void bdirect_read_commit(struct fastbuf *f, byte *pos) { f->bptr = pos; } -static inline void -bdirect_read_commit_modified(struct fastbuf *f, byte *pos) +/** + * Similar to @bdirect_read_commit(), but accepts also modified data before @pos. + * Note that such modifications are supported only if `f->can_overwrite_buffer == 2`. + **/ +static inline void bdirect_read_commit_modified(struct fastbuf *f, byte *pos) { f->bptr = pos; f->buffer = pos; /* Avoid seeking backwards in the buffer */ } -static inline uns -bdirect_write_prepare(struct fastbuf *f, byte **buf) +/** + * Start direct writing to fastbuf's internal buffer to avoid copy overhead. + * The function returns the length of the buffer in @buf (at least one byte) + * where we can write to. The operation must be ended by @bdirect_write_commit(), + * unless nothing is written. + **/ +static inline uns bdirect_write_prepare(struct fastbuf *f, byte **buf) { if (f->bptr == f->bufend) f->spout(f); @@ -630,8 +752,12 @@ bdirect_write_prepare(struct fastbuf *f, byte **buf) return bavailw(f); } -static inline void -bdirect_write_commit(struct fastbuf *f, byte *pos) +/** + * Commit the data written to the buffer returned by @bdirect_write_prepare(). + * The length is specified by @pos which must point just after the written data. + * Also moves the cursor to @pos. + **/ +static inline void bdirect_write_commit(struct fastbuf *f, byte *pos) { f->bptr = pos; }