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 -------------------------------------------------*/