addind nonowned window implementation

[wxWidgets.git] / src / png / pngmem.c

diff --git a/src/png/pngmem.c b/src/png/pngmem.c
index feb8a5dfc52287476d8bb9e97a9e2652dd2d110b..248060f38175a5452b3c56b417c2c421b5fa332b 100644 (file)
--- a/src/png/pngmem.c
+++ b/src/png/pngmem.c
@@ -1,9 +1,9 @@
 
 /* pngmem.c - stub functions for memory allocation
  *
 
 /* pngmem.c - stub functions for memory allocation
  *

- * libpng 1.2.4 - July 8, 2002
+ * Last changed in libpng 1.2.13 November 13, 2006

  * For conditions of distribution and use, see copyright notice in png.h
  * For conditions of distribution and use, see copyright notice in png.h

- * Copyright (c) 1998-2002 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2006 Glenn Randers-Pehrson

  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *


@@ -17,6 +17,8 @@
 #define PNG_INTERNAL
 #include "png.h"
 
 #define PNG_INTERNAL
 #include "png.h"
 

+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+

 /* Borland DOS special memory handler */
 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
 /* if you change this, be sure to change the one in png.h also */
 /* Borland DOS special memory handler */
 #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
 /* if you change this, be sure to change the one in png.h also */


@@ -39,11 +41,11 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
    png_voidp struct_ptr;
 
    if (type == PNG_STRUCT_INFO)
    png_voidp struct_ptr;
 
    if (type == PNG_STRUCT_INFO)

-     size = sizeof(png_info);
+     size = png_sizeof(png_info);

    else if (type == PNG_STRUCT_PNG)
    else if (type == PNG_STRUCT_PNG)

-     size = sizeof(png_struct);
+     size = png_sizeof(png_struct);

    else
    else

-     return (png_get_copyright());
+     return (png_get_copyright(NULL));

 
 #ifdef PNG_USER_MEM_SUPPORTED
    if(malloc_fn != NULL)
 
 #ifdef PNG_USER_MEM_SUPPORTED
    if(malloc_fn != NULL)


@@ -55,7 +57,7 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
    }
    else
 #endif /* PNG_USER_MEM_SUPPORTED */
    }
    else
 #endif /* PNG_USER_MEM_SUPPORTED */

-      struct_ptr = (png_voidp)farmalloc(size));
+      struct_ptr = (png_voidp)farmalloc(size);

    if (struct_ptr != NULL)
       png_memset(struct_ptr, 0, size);
    return (struct_ptr);
    if (struct_ptr != NULL)
       png_memset(struct_ptr, 0, size);
    return (struct_ptr);


@@ -121,14 +123,12 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
 
 #ifdef PNG_USER_MEM_SUPPORTED
    if(png_ptr->malloc_fn != NULL)
 
 #ifdef PNG_USER_MEM_SUPPORTED
    if(png_ptr->malloc_fn != NULL)

-   {

        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

-       if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
-          png_error(png_ptr, "Out of memory!");
-       return (ret);
-   }

    else
    else

-       return png_malloc_default(png_ptr, size);
+       ret = (png_malloc_default(png_ptr, size));
+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+       png_error(png_ptr, "Out of memory!");
+   return (ret);

 }
 
 png_voidp PNGAPI
 }
 
 png_voidp PNGAPI


@@ -137,12 +137,21 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
    png_voidp ret;
 #endif /* PNG_USER_MEM_SUPPORTED */
 
    png_voidp ret;
 #endif /* PNG_USER_MEM_SUPPORTED */
 

+   if (png_ptr == NULL || size == 0)
+      return (NULL);
+

 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)
 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)

-      png_error(png_ptr, "Cannot Allocate > 64K");
+   {
+      png_warning(png_ptr, "Cannot Allocate > 64K");
+      ret = NULL;
+   }
+   else

 #endif
 
 #endif
 

-   if (size == (png_uint_32)65536L)
+   if (size != (size_t)size)
+     ret = NULL;
+   else if (size == (png_uint_32)65536L)

    {
       if (png_ptr->offset_table == NULL)
       {
    {
       if (png_ptr->offset_table == NULL)
       {


@@ -177,34 +186,40 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
 
             if (table == NULL)
             {
 
             if (table == NULL)
             {

-               if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+#ifndef PNG_USER_MEM_SUPPORTED
+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

                   png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
                else
                   png_warning(png_ptr, "Out Of Memory.");
                   png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
                else
                   png_warning(png_ptr, "Out Of Memory.");

+#endif

                return (NULL);
             }
 
             if ((png_size_t)table & 0xfff0)
             {
                return (NULL);
             }
 
             if ((png_size_t)table & 0xfff0)
             {

-               if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+#ifndef PNG_USER_MEM_SUPPORTED
+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

                   png_error(png_ptr,
                     "Farmalloc didn't return normalized pointer");
                else
                   png_warning(png_ptr,
                     "Farmalloc didn't return normalized pointer");
                   png_error(png_ptr,
                     "Farmalloc didn't return normalized pointer");
                else
                   png_warning(png_ptr,
                     "Farmalloc didn't return normalized pointer");

+#endif

                return (NULL);
             }
 
             png_ptr->offset_table = table;
             png_ptr->offset_table_ptr = farmalloc(num_blocks *
                return (NULL);
             }
 
             png_ptr->offset_table = table;
             png_ptr->offset_table_ptr = farmalloc(num_blocks *

-               sizeof (png_bytep));
+               png_sizeof (png_bytep));

 
             if (png_ptr->offset_table_ptr == NULL)
             {
 
             if (png_ptr->offset_table_ptr == NULL)
             {

-               if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+#ifndef PNG_USER_MEM_SUPPORTED
+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

                   png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */
                else
                   png_warning(png_ptr, "Out Of memory.");
                   png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */
                else
                   png_warning(png_ptr, "Out Of memory.");

+#endif

                return (NULL);
             }
 
                return (NULL);
             }
 


@@ -228,10 +243,12 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
 
       if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
       {
 
       if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
       {

-         if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+#ifndef PNG_USER_MEM_SUPPORTED
+         if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

             png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */
          else
             png_warning(png_ptr, "Out of Memory.");
             png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */
          else
             png_warning(png_ptr, "Out of Memory.");

+#endif

          return (NULL);
       }
 
          return (NULL);
       }
 


@@ -240,13 +257,15 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
    else
       ret = farmalloc(size);
 
    else
       ret = farmalloc(size);
 

+#ifndef PNG_USER_MEM_SUPPORTED

    if (ret == NULL)
    {
    if (ret == NULL)
    {

-      if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)

          png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
       else
          png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */
    }
          png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
       else
          png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */
    }

+#endif

 
    return (ret);
 }
 
    return (ret);
 }


@@ -274,6 +293,8 @@ png_free_default(png_structp png_ptr, png_voidp ptr)
 {
 #endif /* PNG_USER_MEM_SUPPORTED */
 
 {
 #endif /* PNG_USER_MEM_SUPPORTED */
 

+   if(png_ptr == NULL) return;
+

    if (png_ptr->offset_table != NULL)
    {
       int i;
    if (png_ptr->offset_table != NULL)
    {
       int i;


@@ -325,9 +346,9 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
    png_voidp struct_ptr;
 
    if (type == PNG_STRUCT_INFO)
    png_voidp struct_ptr;
 
    if (type == PNG_STRUCT_INFO)

-      size = sizeof(png_info);
+      size = png_sizeof(png_info);

    else if (type == PNG_STRUCT_PNG)
    else if (type == PNG_STRUCT_PNG)

-      size = sizeof(png_struct);
+      size = png_sizeof(png_struct);

    else
       return (NULL);
 
    else
       return (NULL);
 


@@ -345,17 +366,16 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
 #endif /* PNG_USER_MEM_SUPPORTED */
 
 #if defined(__TURBOC__) && !defined(__FLAT__)
 #endif /* PNG_USER_MEM_SUPPORTED */
 
 #if defined(__TURBOC__) && !defined(__FLAT__)

-   if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL)
+   struct_ptr = (png_voidp)farmalloc(size);

 #else
 # if defined(_MSC_VER) && defined(MAXSEG_64K)
 #else
 # if defined(_MSC_VER) && defined(MAXSEG_64K)

-   if ((struct_ptr = (png_voidp)halloc(size,1)) != NULL)
+   struct_ptr = (png_voidp)halloc(size,1);

 # else
 # else

-   if ((struct_ptr = (png_voidp)malloc(size)) != NULL)
+   struct_ptr = (png_voidp)malloc(size);

 # endif
 #endif
 # endif
 #endif

-   {
+   if (struct_ptr != NULL)

       png_memset(struct_ptr, 0, size);
       png_memset(struct_ptr, 0, size);

-   }

 
    return (struct_ptr);
 }
 
    return (struct_ptr);
 }


@@ -410,19 +430,17 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
 {
    png_voidp ret;
 
 {
    png_voidp ret;
 

+#ifdef PNG_USER_MEM_SUPPORTED

    if (png_ptr == NULL || size == 0)
       return (NULL);
 
    if (png_ptr == NULL || size == 0)
       return (NULL);
 

-#ifdef PNG_USER_MEM_SUPPORTED

    if(png_ptr->malloc_fn != NULL)
    if(png_ptr->malloc_fn != NULL)

-   {

        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));

-       if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
-          png_error(png_ptr, "Out of Memory!");
-       return (ret);
-   }

    else
    else

-       return (png_malloc_default(png_ptr, size));
+       ret = (png_malloc_default(png_ptr, size));
+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+       png_error(png_ptr, "Out of Memory!");
+   return (ret);

 }
 
 png_voidp PNGAPI
 }
 
 png_voidp PNGAPI


@@ -431,28 +449,45 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
    png_voidp ret;
 #endif /* PNG_USER_MEM_SUPPORTED */
 
    png_voidp ret;
 #endif /* PNG_USER_MEM_SUPPORTED */
 

+   if (png_ptr == NULL || size == 0)
+      return (NULL);
+

 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)
    {
 #ifdef PNG_MAX_MALLOC_64K
    if (size > (png_uint_32)65536L)
    {

+#ifndef PNG_USER_MEM_SUPPORTED

       if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
          png_error(png_ptr, "Cannot Allocate > 64K");
       else
       if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
          png_error(png_ptr, "Cannot Allocate > 64K");
       else

+#endif

          return NULL;
    }
 #endif
 
          return NULL;
    }
 #endif
 

+ /* Check for overflow */

 #if defined(__TURBOC__) && !defined(__FLAT__)
 #if defined(__TURBOC__) && !defined(__FLAT__)

+ if (size != (unsigned long)size)
+   ret = NULL;
+ else

    ret = farmalloc(size);
 #else
 # if defined(_MSC_VER) && defined(MAXSEG_64K)
    ret = farmalloc(size);
 #else
 # if defined(_MSC_VER) && defined(MAXSEG_64K)

+ if (size != (unsigned long)size)
+   ret = NULL;
+ else

    ret = halloc(size, 1);
 # else
    ret = halloc(size, 1);
 # else

+ if (size != (size_t)size)
+   ret = NULL;
+ else

    ret = malloc((size_t)size);
 # endif
 #endif
 
    ret = malloc((size_t)size);
 # endif
 #endif
 

+#ifndef PNG_USER_MEM_SUPPORTED

    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
       png_error(png_ptr, "Out of Memory");
    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
       png_error(png_ptr, "Out of Memory");

+#endif

 
    return (ret);
 }
 
    return (ret);
 }


@@ -498,15 +533,18 @@ png_free_default(png_structp png_ptr, png_voidp ptr)
 #  define png_malloc_warn png_malloc
 #else
 /* This function was added at libpng version 1.2.3.  The png_malloc_warn()
 #  define png_malloc_warn png_malloc
 #else
 /* This function was added at libpng version 1.2.3.  The png_malloc_warn()

- * function will issue a png_warning and return NULL instead of issuing a
- * png_error, if it fails to allocate the requested memory.
+ * function will set up png_malloc() to issue a png_warning and return NULL
+ * instead of issuing a png_error, if it fails to allocate the requested
+ * memory.

  */
 png_voidp PNGAPI
 png_malloc_warn(png_structp png_ptr, png_uint_32 size)
 {
    png_voidp ptr;
  */
 png_voidp PNGAPI
 png_malloc_warn(png_structp png_ptr, png_uint_32 size)
 {
    png_voidp ptr;

-   png_uint_32 save_flags=png_ptr->flags;
+   png_uint_32 save_flags;
+   if(png_ptr == NULL) return (NULL);

 
 

+   save_flags=png_ptr->flags;

    png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
    ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
    png_ptr->flags=save_flags;
    png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
    ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
    png_ptr->flags=save_flags;


@@ -549,9 +587,11 @@ void PNGAPI
 png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
   malloc_fn, png_free_ptr free_fn)
 {
 png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
   malloc_fn, png_free_ptr free_fn)
 {

+   if(png_ptr != NULL) {

    png_ptr->mem_ptr = mem_ptr;
    png_ptr->malloc_fn = malloc_fn;
    png_ptr->free_fn = free_fn;
    png_ptr->mem_ptr = mem_ptr;
    png_ptr->malloc_fn = malloc_fn;
    png_ptr->free_fn = free_fn;

+   }

 }
 
 /* This function returns a pointer to the mem_ptr associated with the user
 }
 
 /* This function returns a pointer to the mem_ptr associated with the user


@@ -561,6 +601,8 @@ png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
 png_voidp PNGAPI
 png_get_mem_ptr(png_structp png_ptr)
 {
 png_voidp PNGAPI
 png_get_mem_ptr(png_structp png_ptr)
 {

+   if(png_ptr == NULL) return (NULL);

    return ((png_voidp)png_ptr->mem_ptr);
 }
 #endif /* PNG_USER_MEM_SUPPORTED */
    return ((png_voidp)png_ptr->mem_ptr);
 }
 #endif /* PNG_USER_MEM_SUPPORTED */

+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */