compiler/libpng/pngerror.c

   1
   2 /* pngerror.c - stub functions for i/o and memory allocation
   3  *
   4  * libpng 1.0.10 - March 30, 2001
   5  * For conditions of distribution and use, see copyright notice in png.h
   6  * Copyright (c) 1998-2001 Glenn Randers-Pehrson
   7  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
   8  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
   9  *
  10  * This file provides a location for all error handling.  Users who
  11  * need special error handling are expected to write replacement functions
  12  * and use png_set_error_fn() to use those functions.  See the instructions
  13  * at each function.
  14  */
  15
  16 #define PNG_INTERNAL
  17 #include "png.h"
  18
  19 static void /* PRIVATE */
  20 png_default_error PNGARG((png_structp png_ptr,
  21                                       png_const_charp message));
  22 static void /* PRIVATE */
  23 png_default_warning PNGARG((png_structp png_ptr,
  24                                         png_const_charp message));
  25
  26 /* This function is called whenever there is a fatal error.  This function
  27  * should not be changed.  If there is a need to handle errors differently,
  28  * you should supply a replacement error function and use png_set_error_fn()
  29  * to replace the error function at run-time.
  30  */
  31 void PNGAPI
  32 png_error(png_structp png_ptr, png_const_charp message)
  33 {
  34    if (png_ptr->error_fn != NULL)
  35       (*(png_ptr->error_fn))(png_ptr, message);
  36
  37    /* if the following returns or doesn't exist, use the default function,
  38       which will not return */
  39    png_default_error(png_ptr, message);
  40 }
  41
  42 /* This function is called whenever there is a non-fatal error.  This function
  43  * should not be changed.  If there is a need to handle warnings differently,
  44  * you should supply a replacement warning function and use
  45  * png_set_error_fn() to replace the warning function at run-time.
  46  */
  47 void PNGAPI
  48 png_warning(png_structp png_ptr, png_const_charp message)
  49 {
  50    if (png_ptr->warning_fn != NULL)
  51       (*(png_ptr->warning_fn))(png_ptr, message);
  52    else
  53       png_default_warning(png_ptr, message);
  54 }
  55
  56 /* These utilities are used internally to build an error message that relates
  57  * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
  58  * this is used to prefix the message.  The message is limited in length
  59  * to 63 bytes, the name characters are output as hex digits wrapped in []
  60  * if the character is invalid.
  61  */
  62 #define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97))
  63 static PNG_CONST char png_digit[16] = {
  64    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
  65 };
  66
  67 static void /* PRIVATE */
  68 png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp message)
  69 {
  70    int iout = 0, iin = 0;
  71
  72    while (iin < 4)
  73    {
  74       int c = png_ptr->chunk_name[iin++];
  75       if (isnonalpha(c))
  76       {
  77          buffer[iout++] = '[';
  78          buffer[iout++] = png_digit[(c & 0xf0) >> 4];
  79          buffer[iout++] = png_digit[c & 0x0f];
  80          buffer[iout++] = ']';
  81       }
  82       else
  83       {
  84          buffer[iout++] = (png_byte)c;
  85       }
  86    }
  87
  88    if (message == NULL)
  89       buffer[iout] = 0;
  90    else
  91    {
  92       buffer[iout++] = ':';
  93       buffer[iout++] = ' ';
  94       png_memcpy(buffer+iout, message, 64);
  95       buffer[iout+63] = 0;
  96    }
  97 }
  98
  99 void PNGAPI
 100 png_chunk_error(png_structp png_ptr, png_const_charp message)
 101 {
 102    char msg[18+64];
 103    png_format_buffer(png_ptr, msg, message);
 104    png_error(png_ptr, msg);
 105 }
 106
 107 void PNGAPI
 108 png_chunk_warning(png_structp png_ptr, png_const_charp message)
 109 {
 110    char msg[18+64];
 111    png_format_buffer(png_ptr, msg, message);
 112    png_warning(png_ptr, msg);
 113 }
 114
 115 /* This is the default error handling function.  Note that replacements for
 116  * this function MUST NOT RETURN, or the program will likely crash.  This
 117  * function is used by default, or if the program supplies NULL for the
 118  * error function pointer in png_set_error_fn().
 119  */
 120 static void /* PRIVATE */
 121 png_default_error(png_structp png_ptr, png_const_charp message)
 122 {
 123 #ifndef PNG_NO_CONSOLE_IO
 124    fprintf(stderr, "libpng error: %s\n", message);
 125 #else
 126    if (message)
 127      /* make compiler happy */ ;
 128 #endif
 129
 130 #ifdef PNG_SETJMP_SUPPORTED
 131 #  ifdef USE_FAR_KEYWORD
 132    {
 133       jmp_buf jmpbuf;
 134       png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
 135       longjmp(jmpbuf, 1);
 136    }
 137 #  else
 138    longjmp(png_ptr->jmpbuf, 1);
 139 # endif
 140 #else
 141    if (png_ptr)
 142      /* make compiler happy */ ;
 143    PNG_ABORT();
 144 #endif
 145 }
 146
 147 /* This function is called when there is a warning, but the library thinks
 148  * it can continue anyway.  Replacement functions don't have to do anything
 149  * here if you don't want them to.  In the default configuration, png_ptr is
 150  * not used, but it is passed in case it may be useful.
 151  */
 152 static void /* PRIVATE */
 153 png_default_warning(png_structp png_ptr, png_const_charp message)
 154 {
 155 #ifndef PNG_NO_CONSOLE_IO
 156    fprintf(stderr, "libpng warning: %s\n", message);
 157 #else
 158    if (message)
 159      /* appease compiler */ ;
 160 #endif
 161    if (png_ptr)
 162       return;
 163 }
 164
 165 /* This function is called when the application wants to use another method
 166  * of handling errors and warnings.  Note that the error function MUST NOT
 167  * return to the calling routine or serious problems will occur.  The return
 168  * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
 169  */
 170 void PNGAPI
 171 png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
 172    png_error_ptr error_fn, png_error_ptr warning_fn)
 173 {
 174    png_ptr->error_ptr = error_ptr;
 175    png_ptr->error_fn = error_fn;
 176    png_ptr->warning_fn = warning_fn;
 177 }
 178
 179
 180 /* This function returns a pointer to the error_ptr associated with the user
 181  * functions.  The application should free any memory associated with this
 182  * pointer before png_write_destroy and png_read_destroy are called.
 183  */
 184 png_voidp PNGAPI
 185 png_get_error_ptr(png_structp png_ptr)
 186 {
 187    return ((png_voidp)png_ptr->error_ptr);
 188 }
 189
 190
 191