diff options
Diffstat (limited to 'contrib/less/xbuf.c')
-rw-r--r-- | contrib/less/xbuf.c | 147 |
1 files changed, 129 insertions, 18 deletions
diff --git a/contrib/less/xbuf.c b/contrib/less/xbuf.c index f20dfae1e7df..92076764d314 100644 --- a/contrib/less/xbuf.c +++ b/contrib/less/xbuf.c @@ -4,43 +4,35 @@ /* * Initialize an expandable text buffer. */ - public void -xbuf_init(xbuf) - struct xbuffer *xbuf; +public void xbuf_init(struct xbuffer *xbuf) { xbuf->data = NULL; xbuf->size = xbuf->end = 0; } - public void -xbuf_deinit(xbuf) - struct xbuffer *xbuf; +public void xbuf_deinit(struct xbuffer *xbuf) { if (xbuf->data != NULL) free(xbuf->data); xbuf_init(xbuf); } - public void -xbuf_reset(xbuf) - struct xbuffer *xbuf; +public void xbuf_reset(struct xbuffer *xbuf) { xbuf->end = 0; } /* - * Add a char to an expandable text buffer. + * Add a byte to an expandable text buffer. */ - public void -xbuf_add(xbuf, ch) - struct xbuffer *xbuf; - char ch; +public void xbuf_add_byte(struct xbuffer *xbuf, unsigned char b) { if (xbuf->end >= xbuf->size) { - char *data; - xbuf->size = (xbuf->size == 0) ? 16 : xbuf->size * 2; - data = (char *) ecalloc(xbuf->size, sizeof(char)); + unsigned char *data; + if (ckd_add(&xbuf->size, xbuf->size, xbuf->size ? xbuf->size : 16)) + out_of_memory(); + data = (unsigned char *) ecalloc(xbuf->size, sizeof(unsigned char)); if (xbuf->data != NULL) { memcpy(data, xbuf->data, xbuf->end); @@ -48,5 +40,124 @@ xbuf_add(xbuf, ch) } xbuf->data = data; } - xbuf->data[xbuf->end++] = ch; + xbuf->data[xbuf->end++] = (unsigned char) b; } + +public void xbuf_add_data(struct xbuffer *xbuf, unsigned char *data, int len) +{ + int i; + for (i = 0; i < len; i++) + xbuf_add_byte(xbuf, data[i]); +} + +public int xbuf_pop(struct xbuffer *buf) +{ + if (buf->end == 0) + return -1; + return (int) buf->data[--(buf->end)]; +} + +public void xbuf_set(struct xbuffer *dst, struct xbuffer *src) +{ + xbuf_reset(dst); + xbuf_add_data(dst, src->data, src->end); +} + +public char * xbuf_char_data(struct xbuffer *xbuf) +{ + return (char *)(xbuf->data); +} + + +/* + * Helper functions for the ckd_add and ckd_mul macro substitutes. + * These helper functions do not set *R on overflow, and assume that + * arguments are nonnegative, that INTMAX_MAX <= UINTMAX_MAX, and that + * sizeof is a reliable way to distinguish integer representations. + * Despite these limitations they are good enough for 'less' on all + * known practical platforms. For more-complicated substitutes + * without most of these limitations, see Gnulib's stdckdint module. + */ +#if !HAVE_STDCKDINT_H +/* + * If the integer *R can represent VAL, store the value and return FALSE. + * Otherwise, possibly set *R to an indeterminate value and return TRUE. + * R has size RSIZE, and is signed if and only if RSIGNED is nonzero. + */ +static int help_fixup(void *r, uintmax val, int rsize, int rsigned) +{ + if (rsigned) + { + if (rsize == sizeof (int)) + { + int *pr = r; + if (INT_MAX < val) + return TRUE; + *pr = (int) val; +#ifdef LLONG_MAX + } else if (rsize == sizeof (long long)) + { + long long *pr = r; + if (LLONG_MAX < val) + return TRUE; + *pr = val; +#endif +#ifdef INTMAX_MAX + } else if (rsize == sizeof (intmax_t)) { + intmax_t *pr = r; + if (INTMAX_MAX < val) + return TRUE; + *pr = val; +#endif + } else /* rsize == sizeof (long) */ + { + long *pr = r; + if (LONG_MAX < val) + return TRUE; + *pr = (long) val; + } + } else { + if (rsize == sizeof (unsigned)) { + unsigned *pr = r; + if (UINT_MAX < val) + return TRUE; + *pr = (unsigned) val; + } else if (rsize == sizeof (unsigned long)) { + unsigned long *pr = r; + if (ULONG_MAX < val) + return TRUE; + *pr = (unsigned long) val; +#ifdef ULLONG_MAX + } else if (rsize == sizeof (unsigned long long)) { + long long *pr = r; + if (ULLONG_MAX < val) + return TRUE; + *pr = val; +#endif + } else /* rsize == sizeof (uintmax) */ + { + uintmax *pr = r; + *pr = val; + } + } + return FALSE; +} +/* + * If *R can represent the mathematical sum of A and B, store the sum + * and return FALSE. Otherwise, possibly set *R to an indeterminate + * value and return TRUE. R has size RSIZE, and is signed if and only + * if RSIGNED is nonzero. + */ +public int help_ckd_add(void *r, uintmax a, uintmax b, int rsize, int rsigned) +{ + uintmax sum = a + b; + return sum < a || help_fixup(r, sum, rsize, rsigned); +} +/* Likewise, but for the product of A and B. */ +public int help_ckd_mul(void *r, uintmax a, uintmax b, int rsize, int rsigned) +{ + uintmax product = a * b; + return ((b != 0 && a != product / b) + || help_fixup(r, product, rsize, rsigned)); +} +#endif |