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