Imported from libpng-0.81.tar
diff --git a/pngmem.c b/pngmem.c
new file mode 100644
index 0000000..c115e4c
--- /dev/null
+++ b/pngmem.c
@@ -0,0 +1,313 @@
+
+/* pngstub.c - stub functions for i/o and memory allocation
+
+ libpng 1.0 beta 2 - version 0.81
+ For conditions of distribution and use, see copyright notice in png.h
+ Copyright (c) 1995 Guy Eric Schalnat, Group 42, Inc.
+ August 24, 1995
+
+ This file provides a location for all memory allocation. Users which
+ need special memory handling are expected to modify the code in this file
+ to meet their needs. See the instructions at each function. */
+
+#define PNG_INTERNAL
+#include "png.h"
+
+/* Allocate memory. For reasonable files, size should never exceed
+ 64K. However, zlib may allocate more then 64K if you don't tell
+ it not to. See zconf.h and png.h for more information. zlib does
+ need to allocate exactly 64K, so whatever you call here must
+ have the ability to do that. */
+
+/* Borland compilers have this habit of not giving you 64K chunks
+ that start on the segment in DOS mode. This has not been observed
+ in Windows, and of course it doesn't matter in 32 bit mode, as there
+ are no segments. Now libpng doesn't need that much memory normally,
+ but zlib does, so we have to normalize it, if necessary. It would be
+ better if zlib worked in less then 64K, but it doesn't, so we
+ have to deal with it. Truely, we are misusing farmalloc here,
+ as it is designed for use with huge pointers, which don't care
+ about segments. So we allocate a large amount of memory, and
+ divvy off segments when needed.
+ */
+#ifdef __TURBOC__
+#ifndef __WIN32__
+#ifndef __FLAT__
+
+/* NUM_SEG is the number of segments allocated at once */
+#define NUM_SEG 4
+typedef struct borland_seg_struct
+{
+ void *mem_ptr;
+ void *seg_ptr[NUM_SEG];
+ int seg_used[NUM_SEG];
+ int num_used;
+} borland_seg;
+
+borland_seg *save_array;
+int num_save_array;
+int max_save_array;
+
+#endif
+#endif
+#endif
+
+voidpf
+png_large_malloc(png_structf *png_ptr, png_uint_32 size)
+{
+ voidpf ret;
+ if (!png_ptr || !size)
+ return ((void *)0);
+
+#ifdef PNG_MAX_MALLOC_64K
+ if (size > (png_uint_32)65536L)
+ png_error(png_ptr, "Cannot Allocate > 64K");
+#endif
+
+#ifdef __TURBOC__
+# if defined(__WIN32__) || defined(__FLAT__)
+ ret = malloc(size);
+# else
+
+ if (size == 65536L)
+ {
+ unsigned long offset;
+ if (!save_array)
+ {
+ ret = farmalloc(size);
+ offset = (unsigned long)(ret);
+ offset &= 0xffffL;
+ }
+ else
+ {
+ ret = (void *)0;
+ }
+ if (save_array || offset)
+ {
+ int i, j;
+
+ if (ret)
+ farfree(ret);
+ ret = (void *)0;
+
+ if (!save_array)
+ {
+ unsigned long offset;
+ png_byte huge *ptr;
+ int i;
+
+ num_save_array = 1;
+ save_array = malloc(num_save_array * sizeof (borland_seg));
+ if (!save_array)
+ png_error(png_ptr, "Out of Memory 1");
+ save_array->mem_ptr = farmalloc(
+ (unsigned long)(NUM_SEG) * 65536L + 65532L);
+ if (!save_array->mem_ptr)
+ png_error(png_ptr, "Out of Memory 2");
+ offset = (unsigned long)(ret);
+ offset &= 0xffffL;
+ ptr = save_array->mem_ptr;
+ if (offset)
+ ptr += 65536L - offset;
+ for (i = 0; i < NUM_SEG; i++, ptr += 65536L)
+ {
+ save_array->seg_ptr[i] = ptr;
+ save_array->seg_used[i] = 0;
+ }
+ save_array->num_used = 0;
+ }
+
+ for (i = 0; i < num_save_array; i++)
+ {
+ for (j = 0; j < NUM_SEG; j++)
+ {
+ if (!save_array[i].seg_used[j])
+ {
+ ret = save_array[i].seg_ptr[j];
+ save_array[i].seg_used[j] = 1;
+ save_array[i].num_used++;
+ break;
+ }
+ }
+ if (ret)
+ break;
+ }
+
+ if (!ret)
+ {
+ unsigned long offset;
+ png_byte huge *ptr;
+
+ save_array = realloc(save_array,
+ (num_save_array + 1) * sizeof (borland_seg));
+ if (!save_array)
+ png_error(png_ptr, "Out of Memory 3");
+ save_array[num_save_array].mem_ptr = farmalloc(
+ (unsigned long)(NUM_SEG) * 65536L + 65532L);
+ if (!save_array[num_save_array].mem_ptr)
+ png_error(png_ptr, "Out of Memory 4");
+ offset = (unsigned long)(ret);
+ offset &= 0xffffL;
+ ptr = save_array[num_save_array].mem_ptr;
+ if (offset)
+ ptr += 65536L - offset;
+ for (i = 0; i < NUM_SEG; i++, ptr += 65536L)
+ {
+ save_array[num_save_array].seg_ptr[i] = ptr;
+ save_array[num_save_array].seg_used[i] = 0;
+ }
+ ret = save_array[num_save_array].seg_ptr[0];
+ save_array[num_save_array].seg_used[0] = 1;
+ save_array[num_save_array].num_used = 1;
+ num_save_array++;
+ }
+ }
+ }
+ else
+ {
+ ret = farmalloc(size);
+ }
+
+# endif /* __WIN32__ */
+#else /* __TURBOC__ */
+# ifdef _MSC_VER
+ ret = halloc(size, 1);
+# else
+ /* everybody else, so normal malloc should do it. */
+ ret = malloc(size);
+# endif
+#endif
+
+ if (ret == NULL)
+ {
+ png_error(png_ptr, "Out of Memory");
+ }
+
+ return ret;
+}
+
+/* free a pointer allocated by png_large_malloc(). In the default
+ configuration, png_ptr is not used, but is passed in case it
+ is needed. If ptr is NULL, return without taking any action. */
+void
+png_large_free(png_structf *png_ptr, voidpf ptr)
+{
+ if (!png_ptr)
+ return;
+
+ if (ptr != (void *)0)
+ {
+#ifdef __TURBOC__
+# if defined(__WIN32__) || defined(__FLAT__)
+ if (ptr)
+ free(ptr);
+# else
+ int i, j;
+
+ for (i = 0; i < num_save_array; i++)
+ {
+ for (j = 0; j < NUM_SEG; j++)
+ {
+ if (ptr == save_array[i].seg_ptr[j])
+ {
+ save_array[i].seg_used[j] = 0;
+ ptr = 0;
+ save_array[i].num_used--;
+ if (!save_array[i].num_used)
+ {
+ int k;
+
+ num_save_array--;
+ farfree(save_array[i].mem_ptr);
+ for (k = i; k < num_save_array; k++)
+ save_array[k] = save_array[k + 1];
+ if (!num_save_array)
+ {
+ free(save_array);
+ save_array = 0;
+ }
+ }
+ break;
+ }
+ }
+ if (!ptr)
+ break;
+ }
+
+ if (ptr)
+ farfree(ptr);
+# endif
+#else
+# ifdef _MSC_VER
+ hfree(ptr);
+# else
+ free(ptr);
+# endif
+#endif
+ }
+}
+
+/* Allocate memory. This is called for smallish blocks only It
+ should not get anywhere near 64K. */
+void *
+png_malloc(png_struct *png_ptr, png_uint_32 size)
+{
+ void *ret;
+
+ if (!png_ptr || !size)
+ return ((void *)0);
+
+#ifdef PNG_MAX_MALLOC_64K
+ if (size > (png_uint_32)65536L)
+ png_error(png_ptr, "Cannot Allocate > 64K");
+#endif
+
+ ret = malloc((png_size_t)size);
+
+ if (!ret)
+ {
+ png_error(png_ptr, "Out of Memory 6");
+ }
+
+ return ret;
+}
+
+/* Reallocate memory. This will not get near 64K on a
+ even marginally reasonable file. */
+void *
+png_realloc(png_struct *png_ptr, void *ptr, png_uint_32 size,
+ png_uint_32 old_size)
+{
+ void *ret;
+
+ if (!png_ptr || !old_size || !ptr || !size)
+ return ((void *)0);
+
+#ifdef PNG_MAX_MALLOC_64K
+ if (size > (png_uint_32)65536L)
+ png_error(png_ptr, "Cannot Allocate > 64K");
+#endif
+
+ ret = realloc(ptr, (png_size_t)size);
+
+ if (!ret)
+ {
+ png_error(png_ptr, "Out of Memory 7");
+ }
+
+ return ret;
+}
+
+/* free a pointer allocated by png_malloc(). In the default
+ configuration, png_ptr is not used, but is passed incase it
+ is needed. If ptr is NULL, return without taking any action. */
+void
+png_free(png_struct *png_ptr, void *ptr)
+{
+ if (!png_ptr)
+ return;
+
+ if (ptr != (void *)0)
+ free(ptr);
+}
+