Avoid realloc(p, 0) due to standards breakage

Once upon a time, memory allocators made sense.  If you asked for zero
bytes of memory, you would get zero bytes of memory -- no questions
asked.  Those zero bytes of memory might be at NULL, which is arguably
a silly answer to a silly question, but that was fine; after all, you
can't access beyond the end of an allocation, so if the allocation is
for zero bytes you deserve what you get if you try to dereference a
NULL pointer.

This simple design meant that realloc(p, 0) was a synonym for free(p),
and realloc(NULL, N) was a synonym for malloc(N).  In fact, some
memory allocators took advantage of this and had just a single entry
point, for realloc, and defined malloc and free in terms of realloc.

Then someone came along and said "NULL should only be returned on
failure", and decided that their malloc would instead return unique
non-NULL pointers.  This resulted in a plethora of portability bugs
since it encouraged people to assume that malloc would only return
NULL on failure; but most people who made that mistake weren't
consistently checking for memory allocation failures anyway, so it
didn't hurt them.

The standards folks came along, and as usual when confronted with two
implementations, one sane and one insane, declared that both were
equally valid.

Then someone asked how this should work for realloc.  Remember, when
realloc fails, it does not free the input pointer; this is so that
programs which are designed to safely handle memory allocation failure
(i.e., not 99% of the code out there) can respond to it (say, by saving
the data to disk) rather than losing the data before being informed of
the allocation failure.

So what happens if realloc(p, 0) fails?  It's going to return NULL,
since that's what realloc does if it fails; but should it also free
the allocation p?  The sane answer is yes: The calling application
has explicitly said that it doesn't want that data, and since realloc
is returning NULL the application has no way to distinguish this from
a successful allocation of zero bytes.

Unfortunately, some people are not sane, and have decided that it's
equally valid for realloc(p, 0) to return NULL-meaning-failure and
*not free p*.  They argue that this prevents a double-free bug if the
application code is
    if ((foo = realloc(bar, 0)) == NULL)
        free(bar);
ignoring the fact that this is *already* a double-free bug on systems
where the C library opts for "return NULL when asked to allocate zero
bytes".  In other words, they introduce a memory leak in order to
avoid a double-free bug which they're in fact not avoiding anyway.

As a result, any portable C code which wants to avoid double-free bugs
and also avoid memory leaks *must* avoid calling realloc to resize an
allocation down to zero bytes.

tl;dr: -8 +24 work around idiotic C libraries

datastruct/elasticarray.c

@@ -36,10 +36,18 @@ resize(struct elasticarray * EA, size_t nsize)
		nalloc = EA->alloc;
	}

	/* Reallocate if necessary. */
	if (nalloc != EA->alloc) {
		nbuf = realloc(EA->buf, nalloc);
		if ((nbuf == NULL) && (nalloc > 0))
	/*
	 * Resizing to zero needs special handling due to some strange
	 * interpretations of what realloc(p, 0) should do if it fails
	 * to allocate zero bytes of memory.
	 */
	if (nalloc == 0) {
		free(EA->buf);
		EA->buf = NULL;
		EA->alloc = 0;
	} else if (nalloc != EA->alloc) {
		/* Reallocate to a nonzero size if necessary. */
		if ((nbuf = realloc(EA->buf, nalloc)) == NULL)
			goto err0;
		EA->buf = nbuf;
		EA->alloc = nalloc;
@@ -204,10 +212,18 @@ elasticarray_truncate(struct elasticarray * EA)
{
	void * nbuf;

	/* If there is spare space, reallocate. */
	if (EA->alloc > EA->size) {
		nbuf = realloc(EA->buf, EA->size);
		if ((nbuf == NULL) && (EA->size > 0))
	/*
	 * Truncating down to zero needs special handling due to some strange
	 * interpretations of what realloc(p, 0) should do if it fails to
	 * allocate zero bytes of memory.
	 */
	if (EA->size == 0) {
		free(EA->buf);
		EA->buf = NULL;
		EA->alloc = 0;
	} else if (EA->alloc > EA->size) {
		/* Reallocate to eliminate spare space if necessary. */
		if ((nbuf = realloc(EA->buf, EA->size)) == NULL)
			goto err0;
		EA->buf = nbuf;
		EA->alloc = EA->size;