X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~mdw/git/mLib/blobdiff_plain/e63124bc579bfd97cfe2f620ddd84df9f20477d8..d93e9a33ee30faed3945b2a7acfc46b84197d432:/struct/buf.c diff --git a/struct/buf.c b/struct/buf.c index 00163bf..10e0544 100644 --- a/struct/buf.c +++ b/struct/buf.c @@ -27,17 +27,17 @@ /*----- Header files ------------------------------------------------------*/ -#include #include #include "buf.h" +#include "growbuf.h" #include "macros.h" /*----- Main code ---------------------------------------------------------*/ /* --- @buf_init@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @void *p@ = pointer to a buffer * @size_t sz@ = size of the buffer * @@ -53,7 +53,7 @@ void buf_init(buf *b, void *p, size_t sz) b->f = 0; } -/* --- @dbuf_init@ --- * +/* --- @dbuf_create@ --- * * * Arguments: @dbuf *db@ = pointer to a dynamic buffer block * @@ -63,11 +63,7 @@ void buf_init(buf *b, void *p, size_t sz) * and ready for writing. */ -void dbuf_init(dbuf *db) -{ - db->_b.base = db->_b.p = db->_b.limit = 0; db->_b.f = BF_ALLOC | BF_WRITE; - db->a = &arena_stdlib; db->sz = 0; -} +void dbuf_create(dbuf *db) { DBCREATE(db); } /* --- @dbuf_reset@ --- * * @@ -78,11 +74,7 @@ void dbuf_init(dbuf *db) * Use: Resets a buffer so that it can be written again. */ -void dbuf_reset(dbuf *db) -{ - db->_b.p = db->_b.base; db->_b.limit = db->_b.base + db->sz; - db->_b.f = (db->_b.f&~BF_BROKEN) | BF_WRITE; -} +void dbuf_reset(dbuf *db) { DBRESET(db); } /* --- @dbuf_destroy@ --- * * @@ -93,26 +85,23 @@ void dbuf_reset(dbuf *db) * Use: Release all of the resources held by a dynamic buffer. */ -void dbuf_destroy(dbuf *db) -{ - if (db->_b.base) x_free(db->a, db->_b.base); - dbuf_init(db); -} +void dbuf_destroy(dbuf *db) { DBDESTROY(db); } -/* --- @buf_break@ --- * +/* --- @{,d}buf_break@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * * Returns: Some negative value. * * Use: Marks a buffer as broken. */ -int buf_break(buf *b) { b->f |= BF_BROKEN; return (-1); } +int buf_break(buf *b) { BBREAK(b); return (-1); } +int (dbuf_break)(dbuf *db) { DBBREAK(db); return (-1); } -/* --- @buf_flip@ --- * +/* --- @{,d}buf_flip@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * * Returns: --- * @@ -120,15 +109,12 @@ int buf_break(buf *b) { b->f |= BF_BROKEN; return (-1); } * you can now read from the bit you've written. */ -void buf_flip(buf *b) -{ - b->limit = b->p; b->p = b->base; - b->f &= ~BF_WRITE; -} +void buf_flip(buf *b) { BFLIP(b); } +void (dbuf_flip)(dbuf *db) { DBFLIP(db); } -/* --- @buf_ensure@ --- * +/* --- @{,d}buf_ensure@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @size_t sz@ = size of data wanted * * Returns: Zero if it worked, nonzero if there wasn't enough space. @@ -137,10 +123,11 @@ void buf_flip(buf *b) */ int buf_ensure(buf *b, size_t sz) { return (BENSURE(b, sz)); } +int (dbuf_ensure)(dbuf *db, size_t sz) { return (dbuf_ensure(db, sz)); } -/* --- @buf_tryextend@ --- * +/* --- @{,d}buf_tryextend@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @size_t sz@ = size of data wanted * * Returns: Zero if it worked, nonzero if the buffer won't grow. @@ -152,28 +139,25 @@ int buf_ensure(buf *b, size_t sz) { return (BENSURE(b, sz)); } int buf_tryextend(buf *b, size_t sz) { dbuf *db; - size_t newsz, len; - - if (~b->f&(BF_ALLOC | BF_WRITE)) - { b->f |= BF_BROKEN; return (-1); } - db = (dbuf *)b; - len = BLEN(&db->_b); sz += len; - if (db->sz >= sz) - newsz = db->sz; - else { - newsz = db->sz ? 2*db->sz : 64; - while (newsz < sz) { assert(newsz < ((size_t)-1)/2); newsz *= 2; } - if (!db->_b.base) db->_b.base = x_alloc(db->a, newsz); - else db->_b.base = x_realloc(db->a, db->_b.base, newsz, db->sz); - db->_b.p = db->_b.base + len; db->sz = newsz; + size_t want, len; + + if (sz <= BLEFT(b)) return (0); + if (~b->f&(BF_ALLOC | BF_WRITE)) { b->f |= BF_BROKEN; return (-1); } + + db = (dbuf *)b; len = DBLEN(db); want = sz + len; + if (db->sz < want) { + GROWBUF_EXTEND(size_t, db->a, db->_b.base, db->sz, want, 64, 1); + db->_b.p = db->_b.base + len; } - db->_b.limit = db->_b.base + newsz; + db->_b.limit = db->_b.base + db->sz; return (0); } +int (dbuf_tryextend)(dbuf *db, size_t sz) + { return (dbuf_tryextend(db, sz)); } -/* --- @buf_get@ --- * +/* --- @{,d}buf_get@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @size_t sz@ = size of the buffer * * Returns: Pointer to the place in the buffer. @@ -191,10 +175,12 @@ void *buf_get(buf *b, size_t sz) BSTEP(b, sz); return (p); } +void *(dbuf_get)(dbuf *db, size_t sz) + { return (dbuf_get(db, sz)); } -/* --- @buf_put@ --- * +/* --- @{,d}buf_put@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @const void *p@ = pointer to a buffer * @size_t sz@ = size of the buffer * @@ -211,10 +197,89 @@ int buf_put(buf *b, const void *p, size_t sz) BSTEP(b, sz); return (0); } +int (dbuf_put)(dbuf *db, const void *p, size_t sz) + { return (dbuf_put(db, p, sz)); } -/* --- @buf_getbyte@ --- * +/* --- @{,d}buf_fill@ --- * + * + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block + * @int ch@ = fill character + * @size_t sz@ = size to fill + * + * Returns: Zero if it worked, nonzero if there wasn't enough space. + * + * Use: Write @sz@ bytes with value @ch@ to the buffer, as if with + * @memset@. + */ + +int buf_fill(buf *b, int ch, size_t sz) +{ + void *p; + + p = buf_get(b, sz); if (!p) return (-1); + if (sz) memset(p, ch, sz); + return (0); +} +int (dbuf_fill)(dbuf *db, int ch, size_t sz) + { return (dbuf_fill(db, ch, sz)); } + +/* --- @align_step@ --- * * * Arguments: @buf *b@ = pointer to a buffer block + * @size_t m, a@ = alignment parameters + * + * Returns: The number of bytes to skip or fill. + */ + +static size_t align_step(buf *b, size_t m, size_t a) +{ + if (m < 2) return (0); + else if (!(m&(m - 1))) return ((a - BLEN(b))&(m - 1)); + else return ((a + m - BLEN(b)%m)%m); +} + +/* --- @{,d}buf_alignskip@ --- * + * + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block + * @size_t m, a@ = alignment multiple and offset + * + * Returns: Zero if it worked, nonzero if there wasn't enough space. + * + * Use: Advance the buffer position as little as possible such that + * it is @a@ greater than a multiple of @m@. This doesn't write + * anything to the buffer, so it's probably not suitable for + * output: use @buf_alignfill@ instead. + */ + +int buf_alignskip(buf *b, size_t m, size_t a) +{ + if (!buf_get(b, align_step(b, m, a))) return (-1); + else return (0); +} +int (dbuf_alignskip)(dbuf *db, size_t m, size_t a) + { return (dbuf_alignskip(db, m, a)); } + +/* --- @{,d}buf_alignfill@ --- * + * + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block + * @int ch@ = fill character + * @size_t m, a@ = alignment multiple and offset + * + * Returns: Zero if it worked, nonzero if there wasn't enough space. + * + * Use: Fill the buffer with as few copies of @ch@ as possible, as if + * by @memset@, to advance the buffer position to a value @a@ + * greater than a multiple of @m@. + */ + +int buf_alignfill(buf *b, int ch, size_t m, size_t a) + { return (buf_fill(b, ch, align_step(b, m, a))); } +int (dbuf_alignfill)(dbuf *db, int ch, size_t m, size_t a) + { return (dbuf_alignfill(db, ch, m, a)); } + +/* --- @{,d}buf_getbyte@ --- * + * + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * * Returns: A byte, or less than zero if there wasn't a byte there. * @@ -227,10 +292,12 @@ int buf_getbyte(buf *b) return (-1); return (*b->p++); } +int (dbuf_getbyte)(dbuf *db) + { return (dbuf_getbyte(db)); } -/* --- @buf_putbyte@ --- * +/* --- @{,d}buf_putbyte@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @int ch@ = byte to write * * Returns: Zero if OK, nonzero if there wasn't enough space. @@ -245,10 +312,12 @@ int buf_putbyte(buf *b, int ch) *b->p++ = ch; return (0); } +int (dbuf_putbyte)(dbuf *db, int ch) + { return (dbuf_putbyte(db, ch)); } -/* --- @buf_getu{8,{16,24,32,64}{,l,b}}@ --- * +/* --- @{,d}buf_getu{8,{16,24,32,64}{,l,b}}@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @uintSZ *w@ = where to put the word * * Returns: Zero if OK, or nonzero if there wasn't a word there. @@ -263,12 +332,14 @@ int buf_putbyte(buf *b, int ch) *ww = LOAD##W(b->p); \ BSTEP(b, SZ_##W); \ return (0); \ - } + } \ + int (dbuf_getu##w)(dbuf *db, uint##n *ww) \ + { return (dbuf_getu##w(db, ww)); } DOUINTCONV(BUF_GETU_) -/* --- @buf_getk64{,l,b}@ --- * +/* --- @{,d}buf_getk64{,l,b}@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @kludge64 *w@ = where to put the word * * Returns: Zero if OK, or nonzero if there wasn't a word there. @@ -294,9 +365,13 @@ int buf_getk64b(buf *b, kludge64 *w) LOAD64_B_(*w, b->p); BSTEP(b, 8); return (0); } -/* --- @buf_putu{8,{16,24,32,64}{,l,b}}@ --- * +int (dbuf_getk64)(dbuf *db, kludge64 *w) { return (dbuf_getk64(db, w)); } +int (dbuf_getk64l)(dbuf *db, kludge64 *w) { return (dbuf_getk64l(db, w)); } +int (dbuf_getk64b)(dbuf *db, kludge64 *w) { return (dbuf_getk64b(db, w)); } + +/* --- @{,d}buf_putu{8,{16,24,32,64}{,l,b}}@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @uintSZ w@ = word to write * * Returns: Zero if OK, or nonzero if there wasn't enough space @@ -311,12 +386,14 @@ int buf_getk64b(buf *b, kludge64 *w) STORE##W(b->p, ww); \ BSTEP(b, SZ_##W); \ return (0); \ - } + } \ + int (dbuf_putu##w)(dbuf *db, uint##n ww) \ + { return (dbuf_putu##w(db, ww)); } DOUINTCONV(BUF_PUTU_) -/* --- @buf_putk64{,l,b}@ --- * +/* --- @{,d}buf_putk64{,l,b}@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @kludge64 w@ = word to write * * Returns: Zero if OK, or nonzero if there wasn't enough space @@ -342,9 +419,13 @@ int buf_putk64b(buf *b, kludge64 w) STORE64_B_(b->p, w); BSTEP(b, 8); return (0); } +int (dbuf_putk64)(dbuf *db, kludge64 w) { return (dbuf_putk64(db, w)); } +int (dbuf_putk64l)(dbuf *db, kludge64 w) { return (dbuf_putk64l(db, w)); } +int (dbuf_putk64b)(dbuf *db, kludge64 w) { return (dbuf_putk64b(db, w)); } + /* --- @findz@ --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @size_t *nn@ = where to put the length * * Returns: Zero if OK, nonzero if there wasn't a null byte to be found. @@ -357,17 +438,14 @@ static int findz(buf *b, size_t *nn) { octet *p; - if ((p = memchr(BCUR(b), 0, BLEFT(b))) == 0) { - buf_break(b); - return (-1); - } + if ((p = memchr(BCUR(b), 0, BLEFT(b))) == 0) { BBREAK(b); return (-1); } *nn = p - BCUR(b) + 1; return (0); } -/* --- @buf_getmem{8,{16,24,32,64}{,l,b},z} --- * +/* --- @{,d}buf_getmem{8,{16,24,32,64}{,l,b},z} --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @size_t *nn@ = where to put the length * * Returns: Pointer to the buffer data, or null. @@ -385,7 +463,9 @@ static int findz(buf *b, size_t *nn) if (BENSURE(b, sz)) return (0); \ *nn = sz; \ return (buf_get(b, sz)); \ - } + } \ + void *(dbuf_getmem##w)(dbuf *db, size_t *nn) \ + { return (dbuf_getmem##w(db, nn)); } DOUINTCONV(BUF_GETMEM_) void *buf_getmemz(buf *b, size_t *nn) @@ -393,6 +473,8 @@ void *buf_getmemz(buf *b, size_t *nn) if (findz(b, nn)) return (0); return (buf_get(b, *nn)); } +void *(dbuf_getmemz)(dbuf *db, size_t *nn) + { return (dbuf_getmemz(db, nn)); } #ifndef HAVE_UINT64 @@ -402,7 +484,7 @@ static void *getmem_k64(buf *b, size_t *nn_out, kludge64 k) size_t n; ASSIGN64(szmax, (size_t)-1); - if (CMP64(k, >, szmax)) { buf_break(b); return (-1); } + if (CMP64(k, >, szmax)) { BBREAK(b); return (-1); } n = GET64(size_t, k); *nn_out = n; return (buf_get(b, n)); } @@ -414,27 +496,34 @@ void *buf_getmem64(buf *b, size_t *nn) return (getmem_k64(b, nn, k)); } -void *buf_getmem64b(buf *b, size_t *nn) +void *buf_getmem64l(buf *b, size_t *nn) { kludge64 k; - if (buf_getk64b(b, &k)) return (-1); + if (buf_getk64l(b, &k)) return (-1); return (getmem_k64(b, nn, k)); } -void *buf_getmem64l(buf *b, size_t *nn) +void *buf_getmem64b(buf *b, size_t *nn) { kludge64 k; - if (buf_getk64l(b, &k)) return (-1); + if (buf_getk64b(b, &k)) return (-1); return (getmem_k64(b, nn, k)); } +void *(dbuf_getmem64)(dbuf *db, size_t *nn) + { return (dbuf_getmem64(db, nn)); } +void *(dbuf_getmem64l)(dbuf *db, size_t *nn) + { return (dbuf_getmem64l(db, nn)); } +void *(dbuf_getmem64b)(dbuf *db, size_t *nn) + { return (dbuf_getmem64b(db, nn)); } + #endif -/* --- @buf_putmem{8,{16,24,32,64}{,l,b},z} --- * +/* --- @{,d}buf_putmem{8,{16,24,32,64}{,l,b},z} --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @const void *p@ = pointer to data to write * @size_t n@ = length to write * @@ -450,11 +539,13 @@ void *buf_getmem64l(buf *b, size_t *nn) { \ MUFFLE_WARNINGS_STMT \ (CLANG_WARNING("-Wtautological-constant-out-of-range-compare"), \ - { assert(sz <= MASK##W); }); \ + { if (sz > MASK##W) { BBREAK(b); return (-1); } }); \ if (buf_putu##w(b, sz) || buf_put(b, p, sz)) \ return (-1); \ return (0); \ - } + } \ + int (dbuf_putmem##w)(dbuf *db, const void *p, size_t sz) \ + { return (dbuf_putmem##w(db, p, sz)); } DOUINTCONV(BUF_PUTMEM_) #ifndef HAVE_UINT64 @@ -467,39 +558,48 @@ void *buf_putmem64(buf *b, const void *p, size_t n) return (0); } -void *buf_putmem64b(buf *b, const void *p, size_t n) +void *buf_putmem64l(buf *b, const void *p, size_t n) { kludge64 k; - ASSIGN64(k, n); if (buf_putk64b(b, k) || buf_put(b, p, n)) return (-1); + ASSIGN64(k, n); if (buf_putk64l(b, k) || buf_put(b, p, n)) return (-1); return (0); } -void *buf_putmem64l(buf *b, const void *p, size_t n) +void *buf_putmem64b(buf *b, const void *p, size_t n) { kludge64 k; - ASSIGN64(k, n); if (buf_putk64l(b, k) || buf_put(b, p, n)) return (-1); + ASSIGN64(k, n); if (buf_putk64b(b, k) || buf_put(b, p, n)) return (-1); return (0); } +int (dbuf_putmem64)(dbuf *db, const void *p, size_t n) + { return (dbuf_putmem64(db, p, n)); } +int (dbuf_putmem64l)(dbuf *db, const void *p, size_t n) + { return (dbuf_putmem64l(db, p, n)); } +int (dbuf_putmem64b)(dbuf *db, const void *p, size_t n) + { return (dbuf_putmem64b(db, p, n)); } + #endif int buf_putmemz(buf *b, const void *p, size_t n) { octet *q; - assert(!memchr(p, 0, n)); + if (memchr(p, 0, n)) { BBREAK(b); return (-1); } if ((q = buf_get(b, n + 1)) == 0) return (-1); memcpy(q, p, n); q[n] = 0; return (0); } +int (dbuf_putmemz)(dbuf *db, const void *p, size_t n) + { return (dbuf_putmemz(db, p, n)); } -/* --- @buf_getbuf{8,{16,24,32,64}{,l,b},z} --- * +/* --- @{,d}buf_getbuf{8,{16,24,32,64}{,l,b},z} --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @buf *bb@ = where to put the result * * Returns: Zero if it worked, nonzero if there wasn't enough space. @@ -518,12 +618,14 @@ int buf_putmemz(buf *b, const void *p, size_t n) return (-1); \ buf_init(bb, p, sz); \ return (0); \ - } + } \ + int (dbuf_getbuf##w)(dbuf *db, buf *bb) \ + { return (dbuf_getbuf##w(db, bb)); } BUF_DOSUFFIXES(BUF_GETBUF_) -/* --- @buf_putbuf{8,{16,24,32,64}{,l,b},z} --- * +/* --- @{,d}buf_putbuf{8,{16,24,32,64}{,l,b},z} --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @buf *bb@ = buffer to write * * Returns: Zero if it worked, nonzero if there wasn't enough space. @@ -533,12 +635,14 @@ BUF_DOSUFFIXES(BUF_GETBUF_) #define BUF_PUTBUF_(n, W, w) \ int buf_putbuf##w(buf *b, buf *bb) \ - { return (buf_putmem##w(b, BBASE(bb), BLEN(bb))); } + { return (buf_putmem##w(b, BBASE(bb), BLEN(bb))); } \ + int (dbuf_putbuf##w)(dbuf *db, buf *bb) \ + { return (dbuf_putbuf##w(db, bb)); } BUF_DOSUFFIXES(BUF_PUTBUF_) -/* --- @buf_putstr{8,{16,24,32,64}{,l,b},z} --- * +/* --- @{,d}buf_putstr{8,{16,24,32,64}{,l,b},z} --- * * - * Arguments: @buf *b@ = pointer to a buffer block + * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block * @const char *p@ = string to write * * Returns: Zero if it worked, nonzero if there wasn't enough space. @@ -548,7 +652,9 @@ BUF_DOSUFFIXES(BUF_PUTBUF_) #define BUF_PUTSTR_(n, W, w) \ int buf_putstr##w(buf *b, const char *p) \ - { return (buf_putmem##w(b, p, strlen(p))); } + { return (buf_putmem##w(b, p, strlen(p))); } \ + int (dbuf_putstr##w)(dbuf *db, const char *p) \ + { return (dbuf_putstr##w(db, p)); } BUF_DOSUFFIXES(BUF_PUTSTR_) /*----- That's all, folks -------------------------------------------------*/