Visualization Library 2.0.0-b5

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
pngerror.c
Go to the documentation of this file.
1 
2 /* pngerror.c - stub functions for i/o and memory allocation
3  *
4  * Last changed in libpng 1.2.51 [February 6, 2014]
5  * Copyright (c) 1998-2002,2004,2006-2014 Glenn Randers-Pehrson
6  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
8  *
9  * This code is released under the libpng license.
10  * For conditions of distribution and use, see the disclaimer
11  * and license in png.h
12  *
13  * This file provides a location for all error handling. Users who
14  * need special error handling are expected to write replacement functions
15  * and use png_set_error_fn() to use those functions. See the instructions
16  * at each function.
17  */
18 
19 #define PNG_INTERNAL
20 #define PNG_NO_PEDANTIC_WARNINGS
21 #include "png.h"
22 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
23 
24 static void /* PRIVATE */
25 png_default_error PNGARG((png_structp png_ptr,
26  png_const_charp error_message)) PNG_NORETURN;
27 #ifdef PNG_WARNINGS_SUPPORTED
28 static void /* PRIVATE */
29 png_default_warning PNGARG((png_structp png_ptr,
31 #endif /* PNG_WARNINGS_SUPPORTED */
32 
33 /* This function is called whenever there is a fatal error. This function
34  * should not be changed. If there is a need to handle errors differently,
35  * you should supply a replacement error function and use png_set_error_fn()
36  * to replace the error function at run-time.
37  */
38 #ifdef PNG_ERROR_TEXT_SUPPORTED
39 void PNGAPI
40 png_error(png_structp png_ptr, png_const_charp error_message)
41 {
42 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
43  char msg[16];
44  if (png_ptr != NULL)
45  {
46  if (png_ptr->flags&
47  (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
48  {
49  if (*error_message == PNG_LITERAL_SHARP)
50  {
51  /* Strip "#nnnn " from beginning of error message. */
52  int offset;
53  for (offset = 1; offset<15; offset++)
54  if (error_message[offset] == ' ')
55  break;
56  if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
57  {
58  int i;
59  for (i = 0; i < offset - 1; i++)
60  msg[i] = error_message[i + 1];
61  msg[i - 1] = '\0';
62  error_message = msg;
63  }
64  else
65  error_message += offset;
66  }
67  else
68  {
69  if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
70  {
71  msg[0] = '0';
72  msg[1] = '\0';
73  error_message = msg;
74  }
75  }
76  }
77  }
78 #endif
79  if (png_ptr != NULL && png_ptr->error_fn != NULL)
80  (*(png_ptr->error_fn))(png_ptr, error_message);
81 
82  /* If the custom handler doesn't exist, or if it returns,
83  use the default handler, which will not return. */
84  png_default_error(png_ptr, error_message);
85 }
86 #else
87 void PNGAPI
88 png_err(png_structp png_ptr)
89 {
90  /* Prior to 1.2.45 the error_fn received a NULL pointer, expressed
91  * erroneously as '\0', instead of the empty string "". This was
92  * apparently an error, introduced in libpng-1.2.20, and png_default_error
93  * will crash in this case.
94  */
95  if (png_ptr != NULL && png_ptr->error_fn != NULL)
96  (*(png_ptr->error_fn))(png_ptr, "");
97 
98  /* If the custom handler doesn't exist, or if it returns,
99  use the default handler, which will not return. */
100  png_default_error(png_ptr, "");
101 }
102 #endif /* PNG_ERROR_TEXT_SUPPORTED */
103 
104 #ifdef PNG_WARNINGS_SUPPORTED
105 /* This function is called whenever there is a non-fatal error. This function
106  * should not be changed. If there is a need to handle warnings differently,
107  * you should supply a replacement warning function and use
108  * png_set_error_fn() to replace the warning function at run-time.
109  */
110 void PNGAPI
112 {
113  int offset = 0;
114  if (png_ptr != NULL)
115  {
116 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
117  if (png_ptr->flags&
118  (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
119 #endif
120  {
121  if (*warning_message == PNG_LITERAL_SHARP)
122  {
123  for (offset = 1; offset < 15; offset++)
124  if (warning_message[offset] == ' ')
125  break;
126  }
127  }
128  }
129  if (png_ptr != NULL && png_ptr->warning_fn != NULL)
130  (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
131  else
132  png_default_warning(png_ptr, warning_message + offset);
133 }
134 #endif /* PNG_WARNINGS_SUPPORTED */
135 
136 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
137 void PNGAPI
138 png_benign_error(png_structp png_ptr, png_const_charp error_message)
139 {
140  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
141  png_warning(png_ptr, error_message);
142  else
143  png_error(png_ptr, error_message);
144 }
145 #endif
146 
147 /* These utilities are used internally to build an error message that relates
148  * to the current chunk. The chunk name comes from png_ptr->chunk_name,
149  * this is used to prefix the message. The message is limited in length
150  * to 63 bytes, the name characters are output as hex digits wrapped in []
151  * if the character is invalid.
152  */
153 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
154 static PNG_CONST char png_digit[16] = {
155  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
156  'A', 'B', 'C', 'D', 'E', 'F'
157 };
158 
159 #define PNG_MAX_ERROR_TEXT 64
160 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
161 static void /* PRIVATE */
162 png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
163  error_message)
164 {
165  int iout = 0, iin = 0;
166 
167  while (iin < 4)
168  {
169  int c = png_ptr->chunk_name[iin++];
170  if (isnonalpha(c))
171  {
172  buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
173  buffer[iout++] = png_digit[(c & 0xf0) >> 4];
174  buffer[iout++] = png_digit[c & 0x0f];
175  buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;
176  }
177  else
178  {
179  buffer[iout++] = (png_byte)c;
180  }
181  }
182 
183  if (error_message == NULL)
184  buffer[iout] = '\0';
185  else
186  {
187  buffer[iout++] = ':';
188  buffer[iout++] = ' ';
189 
190  iin = 0;
191  while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0')
192  buffer[iout++] = error_message[iin++];
193 
194  /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */
195  buffer[iout] = '\0';
196  }
197 }
198 
199 #ifdef PNG_READ_SUPPORTED
200 void PNGAPI
202 {
203  char msg[18+PNG_MAX_ERROR_TEXT];
204  if (png_ptr == NULL)
205  png_error(png_ptr, error_message);
206  else
207  {
208  png_format_buffer(png_ptr, msg, error_message);
209  png_error(png_ptr, msg);
210  }
211 }
212 #endif /* PNG_READ_SUPPORTED */
213 #endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
214 
215 #ifdef PNG_WARNINGS_SUPPORTED
216 void PNGAPI
218 {
219  char msg[18+PNG_MAX_ERROR_TEXT];
220  if (png_ptr == NULL)
221  png_warning(png_ptr, warning_message);
222  else
223  {
224  png_format_buffer(png_ptr, msg, warning_message);
225  png_warning(png_ptr, msg);
226  }
227 }
228 #endif /* PNG_WARNINGS_SUPPORTED */
229 
230 #ifdef PNG_READ_SUPPORTED
231 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
232 void PNGAPI
233 png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
234 {
235  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
236  png_chunk_warning(png_ptr, error_message);
237  else
238  png_chunk_error(png_ptr, error_message);
239 }
240 #endif
241 #endif /* PNG_READ_SUPPORTED */
242 
243 /* This is the default error handling function. Note that replacements for
244  * this function MUST NOT RETURN, or the program will likely crash. This
245  * function is used by default, or if the program supplies NULL for the
246  * error function pointer in png_set_error_fn().
247  */
248 static void /* PRIVATE */
249 png_default_error(png_structp png_ptr, png_const_charp error_message)
250 {
251 #ifdef PNG_CONSOLE_IO_SUPPORTED
252 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
253  if (*error_message == PNG_LITERAL_SHARP)
254  {
255  /* Strip "#nnnn " from beginning of error message. */
256  int offset;
257  char error_number[16];
258  for (offset = 0; offset<15; offset++)
259  {
260  error_number[offset] = error_message[offset + 1];
261  if (error_message[offset] == ' ')
262  break;
263  }
264  if ((offset > 1) && (offset < 15))
265  {
266  error_number[offset - 1] = '\0';
267  fprintf(stderr, "libpng error no. %s: %s",
268  error_number, error_message + offset + 1);
269  fprintf(stderr, PNG_STRING_NEWLINE);
270  }
271  else
272  {
273  fprintf(stderr, "libpng error: %s, offset=%d",
274  error_message, offset);
275  fprintf(stderr, PNG_STRING_NEWLINE);
276  }
277  }
278  else
279 #endif
280  {
281  fprintf(stderr, "libpng error: %s", error_message);
282  fprintf(stderr, PNG_STRING_NEWLINE);
283  }
284 #endif
285 
286 #ifdef PNG_SETJMP_SUPPORTED
287  if (png_ptr)
288  {
289 # ifdef USE_FAR_KEYWORD
290  {
291  jmp_buf jmpbuf;
292  png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));
293  longjmp(jmpbuf,1);
294  }
295 # else
296  longjmp(png_ptr->jmpbuf, 1);
297 # endif
298  }
299 #endif
300  /* Here if not setjmp support or if png_ptr is null. */
301  PNG_ABORT();
302 #ifndef PNG_CONSOLE_IO_SUPPORTED
303  PNG_UNUSED(error_message) /* Make compiler happy */
304 #endif
305 }
306 
307 #ifdef PNG_WARNINGS_SUPPORTED
308 /* This function is called when there is a warning, but the library thinks
309  * it can continue anyway. Replacement functions don't have to do anything
310  * here if you don't want them to. In the default configuration, png_ptr is
311  * not used, but it is passed in case it may be useful.
312  */
313 static void /* PRIVATE */
314 png_default_warning(png_structp png_ptr, png_const_charp warning_message)
315 {
316 #ifdef PNG_CONSOLE_IO_SUPPORTED
317 # ifdef PNG_ERROR_NUMBERS_SUPPORTED
318  if (*warning_message == PNG_LITERAL_SHARP)
319  {
320  int offset;
321  char warning_number[16];
322  for (offset = 0; offset < 15; offset++)
323  {
324  warning_number[offset] = warning_message[offset + 1];
325  if (warning_message[offset] == ' ')
326  break;
327  }
328  if ((offset > 1) && (offset < 15))
329  {
330  warning_number[offset + 1] = '\0';
331  fprintf(stderr, "libpng warning no. %s: %s",
332  warning_number, warning_message + offset);
333  fprintf(stderr, PNG_STRING_NEWLINE);
334  }
335  else
336  {
337  fprintf(stderr, "libpng warning: %s",
338  warning_message);
339  fprintf(stderr, PNG_STRING_NEWLINE);
340  }
341  }
342  else
343 # endif
344  {
345  fprintf(stderr, "libpng warning: %s", warning_message);
346  fprintf(stderr, PNG_STRING_NEWLINE);
347  }
348 #else
349  PNG_UNUSED(warning_message) /* Make compiler happy */
350 #endif
351  PNG_UNUSED(png_ptr) /* Make compiler happy */
352 }
353 #endif /* PNG_WARNINGS_SUPPORTED */
354 
355 /* This function is called when the application wants to use another method
356  * of handling errors and warnings. Note that the error function MUST NOT
357  * return to the calling routine or serious problems will occur. The return
358  * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
359  */
360 void PNGAPI
362  png_error_ptr error_fn, png_error_ptr warning_fn)
363 {
364  if (png_ptr == NULL)
365  return;
366  png_ptr->error_ptr = error_ptr;
367  png_ptr->error_fn = error_fn;
368  png_ptr->warning_fn = warning_fn;
369 }
370 
371 
372 /* This function returns a pointer to the error_ptr associated with the user
373  * functions. The application should free any memory associated with this
374  * pointer before png_write_destroy and png_read_destroy are called.
375  */
378 {
379  if (png_ptr == NULL)
380  return NULL;
381  return ((png_voidp)png_ptr->error_ptr);
382 }
383 
384 
385 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
386 void PNGAPI
388 {
389  if (png_ptr != NULL)
390  {
391  png_ptr->flags &=
392  ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
393  }
394 }
395 #endif
396 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
png_voidp error_ptr
Definition: png.h:1377
void PNGAPI png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
Definition: pngerror.c:387
#define NULL
Definition: ftobjs.h:61
void PNGAPI png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
Definition: pngerror.c:217
png_voidp PNGAPI png_get_error_ptr(png_structp png_ptr)
Definition: pngerror.c:377
char FAR * png_charp
Definition: pngconf.h:1334
#define PNG_UNUSED(param)
Definition: pngconf.h:97
#define isnonalpha(c)
Definition: pngerror.c:153
PNG_CONST char FAR * png_const_charp
Definition: pngconf.h:1333
png_voidp png_error_ptr png_error_ptr warning_fn
Definition: png.h:1803
png_uint_32 i
Definition: png.h:2640
png_uint_32 strip_mode
Definition: png.h:2559
#define PNGARG(arglist)
Definition: pngconf.h:334
#define PNGAPI
Definition: pngconf.h:1517
png_struct FAR * png_structp
Definition: png.h:973
#define png_error(s1, s2)
Definition: pngusr.h:25
#define PNG_CONST
Definition: pngconf.h:503
png_voidp png_error_ptr error_fn
Definition: png.h:1377
unsigned char png_byte
Definition: pngconf.h:1251
#define png_memcpy
Definition: pngconf.h:1661
void PNGAPI png_warning(png_structp png_ptr, png_const_charp warning_message)
Definition: pngerror.c:111
#define PNG_LITERAL_LEFT_SQUARE_BRACKET
Definition: pngconf.h:895
GLuint buffer
const GLubyte * c
#define png_chunk_benign_error
Definition: pngconf.h:137
#define png_benign_error
Definition: pngconf.h:136
GLintptr offset
void PNGAPI png_chunk_error(png_structp png_ptr, png_const_charp error_message)
Definition: pngerror.c:201
#define PNG_LITERAL_SHARP
Definition: pngconf.h:892
png_const_charp warning_message
Definition: png.h:1982
#define PNG_LITERAL_RIGHT_SQUARE_BRACKET
Definition: pngconf.h:898
void FAR * png_voidp
Definition: pngconf.h:1327
png_const_charp error_message PNG_NORETURN
Definition: png.h:1969
unsigned long png_uint_32
Definition: pngconf.h:1247
#define PNG_ABORT()
Definition: pngconf.h:1613
#define PNG_STRING_NEWLINE
Definition: pngconf.h:903
void PNGAPI png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)
Definition: pngerror.c:361
#define PNG_MAX_ERROR_TEXT
Definition: pngerror.c:159
#define png_sizeof(x)
Definition: pngconf.h:1260
png_const_charp msg
Definition: PngFile.c:23