Imported from libpng-0.71.tar
diff --git a/pngstub.c b/pngstub.c
new file mode 100644
index 0000000..6ae1469
--- /dev/null
+++ b/pngstub.c
@@ -0,0 +1,387 @@
+
+/* pngstub.c - stub functions for i/o and memory allocation
+
+ libpng 1.0 beta 1 - version 0.71
+ For conditions of distribution and use, see copyright notice in png.h
+ Copyright (c) 1995 Guy Eric Schalnat, Group 42, Inc.
+ June 26, 1995
+
+ This file provides a location for all input/output, memory location,
+ and error handling. Users which need special handling in these areas
+ 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"
+
+/* Write the data to whatever output you are using. The default
+ routine writes to a file pointer. If you need to write to something
+ else, this is the place to do it. We suggest saving the old code
+ for future use, possibly in a #define. Note that this routine sometimes
+ gets called with very small lengths, so you should implement some kind
+ of simple buffering if you are using unbuffered writes. This should
+ never be asked to write more then 64K on a 16 bit machine. The cast
+ to png_size_t is there for insurance, but if you are having problems
+ with it, you can take it out. Just be sure to cast length to whatever
+ fwrite needs in that spot if you don't have a function prototype for
+ it. */
+void
+png_write_data(png_struct *png_ptr, png_byte *data, png_uint_32 length)
+{
+ png_uint_32 check;
+
+ check = fwrite(data, 1, (png_size_t)length, png_ptr->fp);
+ if (check != length)
+ {
+ png_error(png_ptr, "Write Error");
+ }
+}
+
+/* Read the data from whatever input you are using. The default
+ routine reads from a file pointer. If you need to read from something
+ else, this is the place to do it. We suggest saving the old code
+ for future use. Note that this routine sometimes gets called with
+ very small lengths, so you should implement some kind of simple
+ buffering if you are using unbuffered reads. This should
+ never be asked to read more then 64K on a 16 bit machine. The cast
+ to png_size_t is there for insurance, but if you are having problems
+ with it, you can take it out. Just be sure to cast length to whatever
+ fread needs in that spot if you don't have a function prototype for
+ it. */
+void
+png_read_data(png_struct *png_ptr, png_byte *data, png_uint_32 length)
+{
+ png_uint_32 check;
+
+ check = fread(data, 1, (size_t)length, png_ptr->fp);
+ if (check != length)
+ {
+ png_error(png_ptr, "Read Error");
+ }
+}
+
+/* Initialize the input/output for the png file. If you change
+ the read and write routines, you will probably need to change
+ this routine (or write your own). If you change the parameters
+ of this routine, remember to change png.h also. */
+void
+png_init_io(png_struct *png_ptr, FILE *fp)
+{
+ png_ptr->fp = fp;
+}
+
+/* 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__
+
+/* 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
+
+void *
+png_large_malloc(png_struct *png_ptr, png_uint_32 size)
+{
+ void *ret;
+
+#ifdef PNG_MAX_MALLOC_64K
+ if (size > (png_uint_32)65536L)
+ png_error(png_ptr, "Cannot Allocate > 64K");
+#endif
+
+#ifdef __TURBOC__
+# ifdef __WIN32__
+ ret = farmalloc(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");
+ save_array->mem_ptr = farmalloc(
+ (unsigned long)(NUM_SEG) * 65536L + 65528L);
+ if (!save_array->mem_ptr)
+ png_error(png_ptr, "Out of Memory");
+ 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");
+ save_array[num_save_array].mem_ptr = farmalloc(
+ (unsigned long)(NUM_SEG) * 65536L + 65528L);
+ if (!save_array[num_save_array].mem_ptr)
+ png_error(png_ptr, "Out of Memory");
+ 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)
+ {
+ 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_struct *png_ptr, void *ptr)
+{
+ if (!png_ptr)
+ return;
+
+ if (ptr != (void *)0)
+ {
+#ifdef __TURBOC__
+# ifndef __WIN32__
+ 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])
+ {
+printf("freeing pointer: i, j: %d, %d\n", i, j);
+ save_array[i].seg_used[j] = 0;
+ ptr = 0;
+ save_array[i].num_used--;
+ if (!save_array[i].num_used)
+ {
+ int k;
+printf("freeing array: %d\n", i);
+ 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;
+ }
+
+# endif
+ if (ptr)
+ farfree(ptr);
+#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)
+ 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");
+ }
+
+ 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)
+{
+ void *ret;
+
+ if (!png_ptr)
+ 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");
+ }
+
+ 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);
+}
+
+/* This function is called whenever there is an error. Replace with
+ however you wish to handle the error. Note that this function
+ MUST NOT return, or the program will crash */
+void
+png_error(png_struct *png_ptr, char *message)
+{
+ fprintf(stderr, "libpng error: %s\n", message);
+
+ longjmp(png_ptr->jmpbuf, 1);
+}
+
+/* This function is called when there is a warning, but the library
+ thinks it can continue anyway. You don't have to do anything here
+ if you don't want to. In the default configuration, png_ptr is
+ not used, but it is passed in case it may be useful. */
+void
+png_warning(png_struct *png_ptr, char *message)
+{
+ if (!png_ptr)
+ return;
+
+ fprintf(stderr, "libpng warning: %s\n", message);
+}
+