5 * (c) 2001 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of the mLib utilities library.
12 * mLib is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU Library General Public License as
14 * published by the Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version.
17 * mLib is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU Library General Public License for more details.
22 * You should have received a copy of the GNU Library General Public
23 * License along with mLib; if not, write to the Free
24 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
28 /*----- Header files ------------------------------------------------------*/
36 /*----- Main code ---------------------------------------------------------*/
38 /* --- @buf_init@ --- *
40 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
41 * @void *p@ = pointer to a buffer
42 * @size_t sz@ = size of the buffer
46 * Use: Initializes the buffer block appropriately.
49 void buf_init(buf *b, void *p, size_t sz)
56 /* --- @dbuf_create@ --- *
58 * Arguments: @dbuf *db@ = pointer to a dynamic buffer block
62 * Use: Initializes a dynamic buffer. The buffer is initially empty,
63 * and ready for writing.
66 void dbuf_create(dbuf *db) { DBCREATE(db); }
68 /* --- @dbuf_reset@ --- *
70 * Arguments: @dbuf *db@ = pointer to a buffer block
74 * Use: Resets a buffer so that it can be written again.
77 void dbuf_reset(dbuf *db) { DBRESET(db); }
79 /* --- @dbuf_destroy@ --- *
81 * Arguments: @dbuf *db@ = pointer to a buffer block
85 * Use: Release all of the resources held by a dynamic buffer.
88 void dbuf_destroy(dbuf *db) { DBDESTROY(db); }
90 /* --- @{,d}buf_break@ --- *
92 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
94 * Returns: Some negative value.
96 * Use: Marks a buffer as broken.
99 int buf_break(buf *b) { BBREAK(b); return (-1); }
100 int (dbuf_break)(dbuf *db) { DBBREAK(db); return (-1); }
102 /* --- @{,d}buf_flip@ --- *
104 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
108 * Use: Flips a buffer so that if you've just been writing to it,
109 * you can now read from the bit you've written.
112 void buf_flip(buf *b) { BFLIP(b); }
113 void (dbuf_flip)(dbuf *db) { DBFLIP(db); }
115 /* --- @{,d}buf_ensure@ --- *
117 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
118 * @size_t sz@ = size of data wanted
120 * Returns: Zero if it worked, nonzero if there wasn't enough space.
122 * Use: Ensures that there are @sz@ bytes still in the buffer.
125 int buf_ensure(buf *b, size_t sz) { return (BENSURE(b, sz)); }
126 int (dbuf_ensure)(dbuf *db, size_t sz) { return (dbuf_ensure(db, sz)); }
128 /* --- @{,d}buf_tryextend@ --- *
130 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
131 * @size_t sz@ = size of data wanted
133 * Returns: Zero if it worked, nonzero if the buffer won't grow.
135 * Use: Extend the buffer so that at least @sz@ bytes are available.
136 * This only works if the buffer is allocated.
139 int buf_tryextend(buf *b, size_t sz)
144 if (sz <= BLEFT(b)) return (0);
145 if (~b->f&(BF_ALLOC | BF_WRITE)) { b->f |= BF_BROKEN; return (-1); }
147 db = (dbuf *)b; len = DBLEN(db); want = sz + len;
149 GROWBUF_EXTEND(db->a, db->_b.base, db->sz, want, 64, 1);
150 db->_b.p = db->_b.base + len;
152 db->_b.limit = db->_b.base + db->sz;
155 int (dbuf_tryextend)(dbuf *db, size_t sz)
156 { return (dbuf_tryextend(db, sz)); }
158 /* --- @{,d}buf_get@ --- *
160 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
161 * @size_t sz@ = size of the buffer
163 * Returns: Pointer to the place in the buffer.
165 * Use: Reserves a space in the buffer of the requested size, and
166 * returns its start address.
169 void *buf_get(buf *b, size_t sz)
178 void *(dbuf_get)(dbuf *db, size_t sz)
179 { return (dbuf_get(db, sz)); }
181 /* --- @{,d}buf_put@ --- *
183 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
184 * @const void *p@ = pointer to a buffer
185 * @size_t sz@ = size of the buffer
187 * Returns: Zero if it worked, nonzero if there wasn't enough space.
189 * Use: Fetches data from some place and puts it in the buffer
192 int buf_put(buf *b, const void *p, size_t sz)
196 memcpy(BCUR(b), p, sz);
200 int (dbuf_put)(dbuf *db, const void *p, size_t sz)
201 { return (dbuf_put(db, p, sz)); }
203 /* --- @{,d}buf_getbyte@ --- *
205 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
207 * Returns: A byte, or less than zero if there wasn't a byte there.
209 * Use: Gets a single byte from a buffer.
212 int buf_getbyte(buf *b)
218 int (dbuf_getbyte)(dbuf *db)
219 { return (dbuf_getbyte(db)); }
221 /* --- @{,d}buf_putbyte@ --- *
223 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
224 * @int ch@ = byte to write
226 * Returns: Zero if OK, nonzero if there wasn't enough space.
228 * Use: Puts a single byte in a buffer.
231 int buf_putbyte(buf *b, int ch)
238 int (dbuf_putbyte)(dbuf *db, int ch)
239 { return (dbuf_putbyte(db, ch)); }
241 /* --- @{,d}buf_getu{8,{16,24,32,64}{,l,b}}@ --- *
243 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
244 * @uintSZ *w@ = where to put the word
246 * Returns: Zero if OK, or nonzero if there wasn't a word there.
248 * Use: Gets a word of appropriate size and order from a buffer.
251 #define BUF_GETU_(n, W, w) \
252 int buf_getu##w(buf *b, uint##n *ww) \
254 if (BENSURE(b, SZ_##W)) return (-1); \
255 *ww = LOAD##W(b->p); \
259 int (dbuf_getu##w)(dbuf *db, uint##n *ww) \
260 { return (dbuf_getu##w(db, ww)); }
261 DOUINTCONV(BUF_GETU_)
263 /* --- @{,d}buf_getk64{,l,b}@ --- *
265 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
266 * @kludge64 *w@ = where to put the word
268 * Returns: Zero if OK, or nonzero if there wasn't a word there.
270 * Use: Gets a word of appropriate size and order from a buffer.
273 int buf_getk64(buf *b, kludge64 *w)
275 if (BENSURE(b, 8)) return (-1);
276 LOAD64_(*w, b->p); BSTEP(b, 8); return (0);
279 int buf_getk64l(buf *b, kludge64 *w)
281 if (BENSURE(b, 8)) return (-1);
282 LOAD64_L_(*w, b->p); BSTEP(b, 8); return (0);
285 int buf_getk64b(buf *b, kludge64 *w)
287 if (BENSURE(b, 8)) return (-1);
288 LOAD64_B_(*w, b->p); BSTEP(b, 8); return (0);
291 int (dbuf_getk64)(dbuf *db, kludge64 *w) { return (dbuf_getk64(db, w)); }
292 int (dbuf_getk64l)(dbuf *db, kludge64 *w) { return (dbuf_getk64l(db, w)); }
293 int (dbuf_getk64b)(dbuf *db, kludge64 *w) { return (dbuf_getk64b(db, w)); }
295 /* --- @{,d}buf_putu{8,{16,24,32,64}{,l,b}}@ --- *
297 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
298 * @uintSZ w@ = word to write
300 * Returns: Zero if OK, or nonzero if there wasn't enough space
302 * Use: Puts a word into a buffer with appropriate size and order.
305 #define BUF_PUTU_(n, W, w) \
306 int buf_putu##w(buf *b, uint##n ww) \
308 if (BENSURE(b, SZ_##W)) return (-1); \
309 STORE##W(b->p, ww); \
313 int (dbuf_putu##w)(dbuf *db, uint##n ww) \
314 { return (dbuf_putu##w(db, ww)); }
315 DOUINTCONV(BUF_PUTU_)
317 /* --- @{,d}buf_putk64{,l,b}@ --- *
319 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
320 * @kludge64 w@ = word to write
322 * Returns: Zero if OK, or nonzero if there wasn't enough space
324 * Use: Gets a word of appropriate size and order from a buffer.
327 int buf_putk64(buf *b, kludge64 w)
329 if (BENSURE(b, 8)) return (-1);
330 STORE64_(b->p, w); BSTEP(b, 8); return (0);
333 int buf_putk64l(buf *b, kludge64 w)
335 if (BENSURE(b, 8)) return (-1);
336 STORE64_L_(b->p, w); BSTEP(b, 8); return (0);
339 int buf_putk64b(buf *b, kludge64 w)
341 if (BENSURE(b, 8)) return (-1);
342 STORE64_B_(b->p, w); BSTEP(b, 8); return (0);
345 int (dbuf_putk64)(dbuf *db, kludge64 w) { return (dbuf_putk64(db, w)); }
346 int (dbuf_putk64l)(dbuf *db, kludge64 w) { return (dbuf_putk64l(db, w)); }
347 int (dbuf_putk64b)(dbuf *db, kludge64 w) { return (dbuf_putk64b(db, w)); }
351 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
352 * @size_t *nn@ = where to put the length
354 * Returns: Zero if OK, nonzero if there wasn't a null byte to be found.
356 * Use: Finds a terminating null byte. The length includes this
360 static int findz(buf *b, size_t *nn)
364 if ((p = memchr(BCUR(b), 0, BLEFT(b))) == 0) { BBREAK(b); return (-1); }
365 *nn = p - BCUR(b) + 1;
369 /* --- @{,d}buf_getmem{8,{16,24,32,64}{,l,b},z} --- *
371 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
372 * @size_t *nn@ = where to put the length
374 * Returns: Pointer to the buffer data, or null.
376 * Use: Gets a chunk of memory from a buffer. The suffix is the
377 * width and byte order of the length; @z@ means null-
381 #define BUF_GETMEM_(n, W, w) \
382 void *buf_getmem##w(buf *b, size_t *nn) \
385 if (buf_getu##w(b, &sz)) return (0); \
386 if (BENSURE(b, sz)) return (0); \
388 return (buf_get(b, sz)); \
390 void *(dbuf_getmem##w)(dbuf *db, size_t *nn) \
391 { return (dbuf_getmem##w(db, nn)); }
392 DOUINTCONV(BUF_GETMEM_)
394 void *buf_getmemz(buf *b, size_t *nn)
396 if (findz(b, nn)) return (0);
397 return (buf_get(b, *nn));
399 void *(dbuf_getmemz)(dbuf *db, size_t *nn)
400 { return (dbuf_getmemz(db, nn)); }
404 static void *getmem_k64(buf *b, size_t *nn_out, kludge64 k)
409 ASSIGN64(szmax, (size_t)-1);
410 if (CMP64(k, >, szmax)) { BBREAK(b); return (-1); }
411 n = GET64(size_t, k); *nn_out = n; return (buf_get(b, n));
414 void *buf_getmem64(buf *b, size_t *nn)
418 if (buf_getk64(b, &k)) return (-1);
419 return (getmem_k64(b, nn, k));
422 void *buf_getmem64l(buf *b, size_t *nn)
426 if (buf_getk64l(b, &k)) return (-1);
427 return (getmem_k64(b, nn, k));
430 void *buf_getmem64b(buf *b, size_t *nn)
434 if (buf_getk64b(b, &k)) return (-1);
435 return (getmem_k64(b, nn, k));
438 void *(dbuf_getmem64)(dbuf *db, size_t *nn)
439 { return (dbuf_getmem64(db, nn)); }
440 void *(dbuf_getmem64l)(dbuf *db, size_t *nn)
441 { return (dbuf_getmem64l(db, nn)); }
442 void *(dbuf_getmem64b)(dbuf *db, size_t *nn)
443 { return (dbuf_getmem64b(db, nn)); }
447 /* --- @{,d}buf_putmem{8,{16,24,32,64}{,l,b},z} --- *
449 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
450 * @const void *p@ = pointer to data to write
451 * @size_t n@ = length to write
453 * Returns: Zero if OK, nonzero if there wasn't enough space.
455 * Use: Writes a chunk of data to a buffer. The suffix is the
456 * width and byte order of the length; @z@ means null-
460 #define BUF_PUTMEM_(n, W, w) \
461 int buf_putmem##w(buf *b, const void *p, size_t sz) \
463 MUFFLE_WARNINGS_STMT \
464 (CLANG_WARNING("-Wtautological-constant-out-of-range-compare"), \
465 { if (sz > MASK##W) { BBREAK(b); return (-1); } }); \
466 if (buf_putu##w(b, sz) || buf_put(b, p, sz)) \
470 int (dbuf_putmem##w)(dbuf *db, const void *p, size_t sz) \
471 { return (dbuf_putmem##w(db, p, sz)); }
472 DOUINTCONV(BUF_PUTMEM_)
476 void *buf_putmem64(buf *b, const void *p, size_t n)
480 ASSIGN64(k, n); if (buf_putk64(b, k) || buf_put(b, p, n)) return (-1);
484 void *buf_putmem64l(buf *b, const void *p, size_t n)
488 ASSIGN64(k, n); if (buf_putk64l(b, k) || buf_put(b, p, n)) return (-1);
492 void *buf_putmem64b(buf *b, const void *p, size_t n)
496 ASSIGN64(k, n); if (buf_putk64b(b, k) || buf_put(b, p, n)) return (-1);
500 int (dbuf_putmem64)(dbuf *db, const void *p, size_t n)
501 { return (dbuf_putmem64(db, p, n)); }
502 int (dbuf_putmem64l)(dbuf *db, const void *p, size_t n)
503 { return (dbuf_putmem64l(db, p, n)); }
504 int (dbuf_putmem64b)(dbuf *db, const void *p, size_t n)
505 { return (dbuf_putmem64b(db, p, n)); }
509 int buf_putmemz(buf *b, const void *p, size_t n)
513 if (memchr(p, 0, n)) { BBREAK(b); return (-1); }
514 if ((q = buf_get(b, n + 1)) == 0)
520 int (dbuf_putmemz)(dbuf *db, const void *p, size_t n)
521 { return (dbuf_putmemz(db, p, n)); }
523 /* --- @{,d}buf_getbuf{8,{16,24,32,64}{,l,b},z} --- *
525 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
526 * @buf *bb@ = where to put the result
528 * Returns: Zero if it worked, nonzero if there wasn't enough space.
530 * Use: Gets a block of data from a buffer, and writes its bounds to
534 #define BUF_GETBUF_(n, W, w) \
535 int buf_getbuf##w(buf *b, buf *bb) \
540 if ((p = buf_getmem##w(b, &sz)) == 0) \
542 buf_init(bb, p, sz); \
545 int (dbuf_getbuf##w)(dbuf *db, buf *bb) \
546 { return (dbuf_getbuf##w(db, bb)); }
547 BUF_DOSUFFIXES(BUF_GETBUF_)
549 /* --- @{,d}buf_putbuf{8,{16,24,32,64}{,l,b},z} --- *
551 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
552 * @buf *bb@ = buffer to write
554 * Returns: Zero if it worked, nonzero if there wasn't enough space.
556 * Use: Puts the contents of a buffer to a buffer.
559 #define BUF_PUTBUF_(n, W, w) \
560 int buf_putbuf##w(buf *b, buf *bb) \
561 { return (buf_putmem##w(b, BBASE(bb), BLEN(bb))); } \
562 int (dbuf_putbuf##w)(dbuf *db, buf *bb) \
563 { return (dbuf_putbuf##w(db, bb)); }
564 BUF_DOSUFFIXES(BUF_PUTBUF_)
566 /* --- @{,d}buf_putstr{8,{16,24,32,64}{,l,b},z} --- *
568 * Arguments: @buf *b@ or @dbuf *db@ = pointer to a buffer block
569 * @const char *p@ = string to write
571 * Returns: Zero if it worked, nonzero if there wasn't enough space.
573 * Use: Puts a null-terminated string to a buffer.
576 #define BUF_PUTSTR_(n, W, w) \
577 int buf_putstr##w(buf *b, const char *p) \
578 { return (buf_putmem##w(b, p, strlen(p))); } \
579 int (dbuf_putstr##w)(dbuf *db, const char *p) \
580 { return (dbuf_putstr##w(db, p)); }
581 BUF_DOSUFFIXES(BUF_PUTSTR_)
583 /*----- That's all, folks -------------------------------------------------*/