From 32b3ed0a1362a4b0798ad71fac3450fb77cb7e41 Mon Sep 17 00:00:00 2001
From: Thomas Groman <tgroman@nuegia.net>
Date: Thu, 19 Sep 2019 00:41:48 -0700
Subject: merged from 0.6.7 codebase

---
 libraries/pack200/src/bytes.h | 472 +++++++++++++++++++++---------------------
 1 file changed, 236 insertions(+), 236 deletions(-)

(limited to 'libraries/pack200/src/bytes.h')

diff --git a/libraries/pack200/src/bytes.h b/libraries/pack200/src/bytes.h
index b116efda..2ce1f7f4 100644
--- a/libraries/pack200/src/bytes.h
+++ b/libraries/pack200/src/bytes.h
@@ -27,225 +27,225 @@
 
 struct bytes
 {
-	int8_t *ptr;
-	size_t len;
-	int8_t *limit()
-	{
-		return ptr + len;
-	}
+    int8_t *ptr;
+    size_t len;
+    int8_t *limit()
+    {
+        return ptr + len;
+    }
 
-	void set(int8_t *ptr_, size_t len_)
-	{
-		ptr = ptr_;
-		len = len_;
-	}
-	void set(const char *str)
-	{
-		ptr = (int8_t *)str;
-		len = strlen(str);
-	}
-	bool inBounds(const void *p); // p in [ptr, limit)
-	void malloc(size_t len_);
-	void realloc(size_t len_);
-	void free();
-	void copyFrom(const void *ptr_, size_t len_, size_t offset = 0);
-	void saveFrom(const void *ptr_, size_t len_);
-	void saveFrom(const char *str)
-	{
-		saveFrom(str, strlen(str));
-	}
-	void copyFrom(bytes &other, size_t offset = 0)
-	{
-		copyFrom(other.ptr, other.len, offset);
-	}
-	void saveFrom(bytes &other)
-	{
-		saveFrom(other.ptr, other.len);
-	}
-	void clear(int fill_byte = 0)
-	{
-		memset(ptr, fill_byte, len);
-	}
-	int8_t *writeTo(int8_t *bp);
-	bool equals(bytes &other)
-	{
-		return 0 == compareTo(other);
-	}
-	int compareTo(bytes &other);
-	bool contains(int8_t c)
-	{
-		return indexOf(c) >= 0;
-	}
-	int indexOf(int8_t c);
-	// substrings:
-	static bytes of(int8_t *ptr, size_t len)
-	{
-		bytes res;
-		res.set(ptr, len);
-		return res;
-	}
-	bytes slice(size_t beg, size_t end)
-	{
-		bytes res;
-		res.ptr = ptr + beg;
-		res.len = end - beg;
-		assert(res.len == 0 ||(inBounds(res.ptr) && inBounds(res.limit() - 1)));
-		return res;
-	}
-	// building C strings inside byte buffers:
-	bytes &strcat(const char *str)
-	{
-		::strcat((char *)ptr, str);
-		return *this;
-	}
-	bytes &strcat(bytes &other)
-	{
-		::strncat((char *)ptr, (char *)other.ptr, other.len);
-		return *this;
-	}
-	char *strval()
-	{
-		assert(strlen((char *)ptr) == len);
-		return (char *)ptr;
-	}
+    void set(int8_t *ptr_, size_t len_)
+    {
+        ptr = ptr_;
+        len = len_;
+    }
+    void set(const char *str)
+    {
+        ptr = (int8_t *)str;
+        len = strlen(str);
+    }
+    bool inBounds(const void *p); // p in [ptr, limit)
+    void malloc(size_t len_);
+    void realloc(size_t len_);
+    void free();
+    void copyFrom(const void *ptr_, size_t len_, size_t offset = 0);
+    void saveFrom(const void *ptr_, size_t len_);
+    void saveFrom(const char *str)
+    {
+        saveFrom(str, strlen(str));
+    }
+    void copyFrom(bytes &other, size_t offset = 0)
+    {
+        copyFrom(other.ptr, other.len, offset);
+    }
+    void saveFrom(bytes &other)
+    {
+        saveFrom(other.ptr, other.len);
+    }
+    void clear(int fill_byte = 0)
+    {
+        memset(ptr, fill_byte, len);
+    }
+    int8_t *writeTo(int8_t *bp);
+    bool equals(bytes &other)
+    {
+        return 0 == compareTo(other);
+    }
+    int compareTo(bytes &other);
+    bool contains(int8_t c)
+    {
+        return indexOf(c) >= 0;
+    }
+    int indexOf(int8_t c);
+    // substrings:
+    static bytes of(int8_t *ptr, size_t len)
+    {
+        bytes res;
+        res.set(ptr, len);
+        return res;
+    }
+    bytes slice(size_t beg, size_t end)
+    {
+        bytes res;
+        res.ptr = ptr + beg;
+        res.len = end - beg;
+        assert(res.len == 0 ||(inBounds(res.ptr) && inBounds(res.limit() - 1)));
+        return res;
+    }
+    // building C strings inside byte buffers:
+    bytes &strcat(const char *str)
+    {
+        ::strcat((char *)ptr, str);
+        return *this;
+    }
+    bytes &strcat(bytes &other)
+    {
+        ::strncat((char *)ptr, (char *)other.ptr, other.len);
+        return *this;
+    }
+    char *strval()
+    {
+        assert(strlen((char *)ptr) == len);
+        return (char *)ptr;
+    }
 };
 #define BYTES_OF(var) (bytes::of((int8_t *)&(var), sizeof(var)))
 
 struct fillbytes
 {
-	bytes b;
-	size_t allocated;
+    bytes b;
+    size_t allocated;
 
-	int8_t *base()
-	{
-		return b.ptr;
-	}
-	size_t size()
-	{
-		return b.len;
-	}
-	int8_t *limit()
-	{
-		return b.limit();
-	} // logical limit
-	void setLimit(int8_t *lp)
-	{
-		assert(isAllocated(lp));
-		b.len = lp - b.ptr;
-	}
-	int8_t *end()
-	{
-		return b.ptr + allocated;
-	} // physical limit
-	int8_t *loc(size_t o)
-	{
-		assert(o < b.len);
-		return b.ptr + o;
-	}
-	void init()
-	{
-		allocated = 0;
-		b.set(nullptr, 0);
-	}
-	void init(size_t s)
-	{
-		init();
-		ensureSize(s);
-	}
-	void free()
-	{
-		if (allocated != 0)
-			b.free();
-		allocated = 0;
-	}
-	void empty()
-	{
-		b.len = 0;
-	}
-	int8_t *grow(size_t s); // grow so that limit() += s
-	int getByte(uint32_t i)
-	{
-		return *loc(i) & 0xFF;
-	}
-	void addByte(int8_t x)
-	{
-		*grow(1) = x;
-	}
-	void ensureSize(size_t s); // make sure allocated >= s
-	void trimToSize()
-	{
-		if (allocated > size())
-			b.realloc(allocated = size());
-	}
-	bool canAppend(size_t s)
-	{
-		return allocated > b.len + s;
-	}
-	bool isAllocated(int8_t *p)
-	{
-		return p >= base() && p <= end();
-	} // asserts
-	void set(bytes &src)
-	{
-		set(src.ptr, src.len);
-	}
+    int8_t *base()
+    {
+        return b.ptr;
+    }
+    size_t size()
+    {
+        return b.len;
+    }
+    int8_t *limit()
+    {
+        return b.limit();
+    } // logical limit
+    void setLimit(int8_t *lp)
+    {
+        assert(isAllocated(lp));
+        b.len = lp - b.ptr;
+    }
+    int8_t *end()
+    {
+        return b.ptr + allocated;
+    } // physical limit
+    int8_t *loc(size_t o)
+    {
+        assert(o < b.len);
+        return b.ptr + o;
+    }
+    void init()
+    {
+        allocated = 0;
+        b.set(nullptr, 0);
+    }
+    void init(size_t s)
+    {
+        init();
+        ensureSize(s);
+    }
+    void free()
+    {
+        if (allocated != 0)
+            b.free();
+        allocated = 0;
+    }
+    void empty()
+    {
+        b.len = 0;
+    }
+    int8_t *grow(size_t s); // grow so that limit() += s
+    int getByte(uint32_t i)
+    {
+        return *loc(i) & 0xFF;
+    }
+    void addByte(int8_t x)
+    {
+        *grow(1) = x;
+    }
+    void ensureSize(size_t s); // make sure allocated >= s
+    void trimToSize()
+    {
+        if (allocated > size())
+            b.realloc(allocated = size());
+    }
+    bool canAppend(size_t s)
+    {
+        return allocated > b.len + s;
+    }
+    bool isAllocated(int8_t *p)
+    {
+        return p >= base() && p <= end();
+    } // asserts
+    void set(bytes &src)
+    {
+        set(src.ptr, src.len);
+    }
 
-	void set(int8_t *ptr, size_t len)
-	{
-		b.set(ptr, len);
-		allocated = 0; // mark as not reallocatable
-	}
+    void set(int8_t *ptr, size_t len)
+    {
+        b.set(ptr, len);
+        allocated = 0; // mark as not reallocatable
+    }
 
-	// block operations on resizing byte buffer:
-	fillbytes &append(const void *ptr_, size_t len_)
-	{
-		memcpy(grow(len_), ptr_, len_);
-		return (*this);
-	}
-	fillbytes &append(bytes &other)
-	{
-		return append(other.ptr, other.len);
-	}
-	fillbytes &append(const char *str)
-	{
-		return append(str, strlen(str));
-	}
+    // block operations on resizing byte buffer:
+    fillbytes &append(const void *ptr_, size_t len_)
+    {
+        memcpy(grow(len_), ptr_, len_);
+        return (*this);
+    }
+    fillbytes &append(bytes &other)
+    {
+        return append(other.ptr, other.len);
+    }
+    fillbytes &append(const char *str)
+    {
+        return append(str, strlen(str));
+    }
 };
 
 struct ptrlist : fillbytes
 {
-	typedef const void *cvptr;
-	int length()
-	{
-		return (int)(size() / sizeof(cvptr));
-	}
-	cvptr *base()
-	{
-		return (cvptr *)fillbytes::base();
-	}
-	cvptr &get(int i)
-	{
-		return *(cvptr *)loc(i * sizeof(cvptr));
-	}
-	cvptr *limit()
-	{
-		return (cvptr *)fillbytes::limit();
-	}
-	void add(cvptr x)
-	{
-		*(cvptr *)grow(sizeof(x)) = x;
-	}
-	void popTo(int l)
-	{
-		assert(l <= length());
-		b.len = l * sizeof(cvptr);
-	}
-	int indexOf(cvptr x);
-	bool contains(cvptr x)
-	{
-		return indexOf(x) >= 0;
-	}
-	void freeAll(); // frees every ptr on the list, plus the list itself
+    typedef const void *cvptr;
+    int length()
+    {
+        return (int)(size() / sizeof(cvptr));
+    }
+    cvptr *base()
+    {
+        return (cvptr *)fillbytes::base();
+    }
+    cvptr &get(int i)
+    {
+        return *(cvptr *)loc(i * sizeof(cvptr));
+    }
+    cvptr *limit()
+    {
+        return (cvptr *)fillbytes::limit();
+    }
+    void add(cvptr x)
+    {
+        *(cvptr *)grow(sizeof(x)) = x;
+    }
+    void popTo(int l)
+    {
+        assert(l <= length());
+        b.len = l * sizeof(cvptr);
+    }
+    int indexOf(cvptr x);
+    bool contains(cvptr x)
+    {
+        return indexOf(x) >= 0;
+    }
+    void freeAll(); // frees every ptr on the list, plus the list itself
 };
 // Use a macro rather than mess with subtle mismatches
 // between member and non-member function pointers.
@@ -253,34 +253,34 @@ struct ptrlist : fillbytes
 
 struct intlist : fillbytes
 {
-	int length()
-	{
-		return (int)(size() / sizeof(int));
-	}
-	int *base()
-	{
-		return (int *)fillbytes::base();
-	}
-	int &get(int i)
-	{
-		return *(int *)loc(i * sizeof(int));
-	}
-	int *limit()
-	{
-		return (int *)fillbytes::limit();
-	}
-	void add(int x)
-	{
-		*(int *)grow(sizeof(x)) = x;
-	}
-	void popTo(int l)
-	{
-		assert(l <= length());
-		b.len = l * sizeof(int);
-	}
-	int indexOf(int x);
-	bool contains(int x)
-	{
-		return indexOf(x) >= 0;
-	}
+    int length()
+    {
+        return (int)(size() / sizeof(int));
+    }
+    int *base()
+    {
+        return (int *)fillbytes::base();
+    }
+    int &get(int i)
+    {
+        return *(int *)loc(i * sizeof(int));
+    }
+    int *limit()
+    {
+        return (int *)fillbytes::limit();
+    }
+    void add(int x)
+    {
+        *(int *)grow(sizeof(x)) = x;
+    }
+    void popTo(int l)
+    {
+        assert(l <= length());
+        b.len = l * sizeof(int);
+    }
+    int indexOf(int x);
+    bool contains(int x)
+    {
+        return indexOf(x) >= 0;
+    }
 };
-- 
cgit v1.2.3