home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pdflb302.zip / pdf / lpng.1-0-8 / pngerror.c < prev    next >
C/C++ Source or Header  |  2000-07-24  |  6KB  |  192 lines
  1.  
  2. /* pngerror.c - stub functions for i/o and memory allocation
  3.  *
  4.  * libpng 1.0.8 - July 24, 2000
  5.  * For conditions of distribution and use, see copyright notice in png.h
  6.  * Copyright (c) 1998, 1999, 2000 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[16+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[16+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.  
  192.