/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/png/pngerror.c
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/png/pngerror.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (show annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 1 month ago) by william
File MIME type: text/plain
File size: 10526 byte(s)
committing r3113 initial commit again...
1
2 /* pngerror.c - stub functions for i/o and memory allocation
3 *
4 * Last changed in libpng 1.2.37 [June 4, 2009]
5 * Copyright (c) 1998-2009 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 #include "png.h"
21 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
22
23 static void /* PRIVATE */
24 png_default_error PNGARG((png_structp png_ptr,
25 png_const_charp error_message));
26 #ifndef PNG_NO_WARNINGS
27 static void /* PRIVATE */
28 png_default_warning PNGARG((png_structp png_ptr,
29 png_const_charp warning_message));
30 #endif /* PNG_NO_WARNINGS */
31
32 /* This function is called whenever there is a fatal error. This function
33 * should not be changed. If there is a need to handle errors differently,
34 * you should supply a replacement error function and use png_set_error_fn()
35 * to replace the error function at run-time.
36 */
37 #ifndef PNG_NO_ERROR_TEXT
38 void PNGAPI
39 png_error(png_structp png_ptr, png_const_charp error_message)
40 {
41 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
42 char msg[16];
43 if (png_ptr != NULL)
44 {
45 if (png_ptr->flags&
46 (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
47 {
48 if (*error_message == '#')
49 {
50 /* Strip "#nnnn " from beginning of error message. */
51 int offset;
52 for (offset = 1; offset<15; offset++)
53 if (error_message[offset] == ' ')
54 break;
55 if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
56 {
57 int i;
58 for (i = 0; i < offset - 1; i++)
59 msg[i] = error_message[i + 1];
60 msg[i - 1] = '\0';
61 error_message = msg;
62 }
63 else
64 error_message += offset;
65 }
66 else
67 {
68 if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
69 {
70 msg[0] = '0';
71 msg[1] = '\0';
72 error_message = msg;
73 }
74 }
75 }
76 }
77 #endif
78 if (png_ptr != NULL && png_ptr->error_fn != NULL)
79 (*(png_ptr->error_fn))(png_ptr, error_message);
80
81 /* If the custom handler doesn't exist, or if it returns,
82 use the default handler, which will not return. */
83 png_default_error(png_ptr, error_message);
84 }
85 #else
86 void PNGAPI
87 png_err(png_structp png_ptr)
88 {
89 if (png_ptr != NULL && png_ptr->error_fn != NULL)
90 (*(png_ptr->error_fn))(png_ptr, '\0');
91
92 /* If the custom handler doesn't exist, or if it returns,
93 use the default handler, which will not return. */
94 png_default_error(png_ptr, '\0');
95 }
96 #endif /* PNG_NO_ERROR_TEXT */
97
98 #ifndef PNG_NO_WARNINGS
99 /* This function is called whenever there is a non-fatal error. This function
100 * should not be changed. If there is a need to handle warnings differently,
101 * you should supply a replacement warning function and use
102 * png_set_error_fn() to replace the warning function at run-time.
103 */
104 void PNGAPI
105 png_warning(png_structp png_ptr, png_const_charp warning_message)
106 {
107 int offset = 0;
108 if (png_ptr != NULL)
109 {
110 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
111 if (png_ptr->flags&
112 (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
113 #endif
114 {
115 if (*warning_message == '#')
116 {
117 for (offset = 1; offset < 15; offset++)
118 if (warning_message[offset] == ' ')
119 break;
120 }
121 }
122 }
123 if (png_ptr != NULL && png_ptr->warning_fn != NULL)
124 (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
125 else
126 png_default_warning(png_ptr, warning_message + offset);
127 }
128 #endif /* PNG_NO_WARNINGS */
129
130
131 /* These utilities are used internally to build an error message that relates
132 * to the current chunk. The chunk name comes from png_ptr->chunk_name,
133 * this is used to prefix the message. The message is limited in length
134 * to 63 bytes, the name characters are output as hex digits wrapped in []
135 * if the character is invalid.
136 */
137 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
138 static PNG_CONST char png_digit[16] = {
139 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
140 'A', 'B', 'C', 'D', 'E', 'F'
141 };
142
143 #define PNG_MAX_ERROR_TEXT 64
144
145 #if !defined(PNG_NO_WARNINGS) || !defined(PNG_NO_ERROR_TEXT)
146 static void /* PRIVATE */
147 png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
148 error_message)
149 {
150 int iout = 0, iin = 0;
151
152 while (iin < 4)
153 {
154 int c = png_ptr->chunk_name[iin++];
155 if (isnonalpha(c))
156 {
157 buffer[iout++] = '[';
158 buffer[iout++] = png_digit[(c & 0xf0) >> 4];
159 buffer[iout++] = png_digit[c & 0x0f];
160 buffer[iout++] = ']';
161 }
162 else
163 {
164 buffer[iout++] = (png_byte)c;
165 }
166 }
167
168 if (error_message == NULL)
169 buffer[iout] = '\0';
170 else
171 {
172 buffer[iout++] = ':';
173 buffer[iout++] = ' ';
174 png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);
175 buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';
176 }
177 }
178
179 #ifdef PNG_READ_SUPPORTED
180 void PNGAPI
181 png_chunk_error(png_structp png_ptr, png_const_charp error_message)
182 {
183 char msg[18+PNG_MAX_ERROR_TEXT];
184 if (png_ptr == NULL)
185 png_error(png_ptr, error_message);
186 else
187 {
188 png_format_buffer(png_ptr, msg, error_message);
189 png_error(png_ptr, msg);
190 }
191 }
192 #endif /* PNG_READ_SUPPORTED */
193 #endif /* !defined(PNG_NO_WARNINGS) || !defined(PNG_NO_ERROR_TEXT) */
194
195 #ifndef PNG_NO_WARNINGS
196 void PNGAPI
197 png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
198 {
199 char msg[18+PNG_MAX_ERROR_TEXT];
200 if (png_ptr == NULL)
201 png_warning(png_ptr, warning_message);
202 else
203 {
204 png_format_buffer(png_ptr, msg, warning_message);
205 png_warning(png_ptr, msg);
206 }
207 }
208 #endif /* PNG_NO_WARNINGS */
209
210
211 /* This is the default error handling function. Note that replacements for
212 * this function MUST NOT RETURN, or the program will likely crash. This
213 * function is used by default, or if the program supplies NULL for the
214 * error function pointer in png_set_error_fn().
215 */
216 static void /* PRIVATE */
217 png_default_error(png_structp png_ptr, png_const_charp error_message)
218 {
219 #ifndef PNG_NO_CONSOLE_IO
220 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
221 if (*error_message == '#')
222 {
223 /* Strip "#nnnn " from beginning of error message. */
224 int offset;
225 char error_number[16];
226 for (offset = 0; offset<15; offset++)
227 {
228 error_number[offset] = error_message[offset + 1];
229 if (error_message[offset] == ' ')
230 break;
231 }
232 if ((offset > 1) && (offset < 15))
233 {
234 error_number[offset - 1] = '\0';
235 fprintf(stderr, "libpng error no. %s: %s",
236 error_number, error_message + offset + 1);
237 fprintf(stderr, PNG_STRING_NEWLINE);
238 }
239 else
240 {
241 fprintf(stderr, "libpng error: %s, offset=%d",
242 error_message, offset);
243 fprintf(stderr, PNG_STRING_NEWLINE);
244 }
245 }
246 else
247 #endif
248 {
249 fprintf(stderr, "libpng error: %s", error_message);
250 fprintf(stderr, PNG_STRING_NEWLINE);
251 }
252 #endif
253
254 #ifdef PNG_SETJMP_SUPPORTED
255 if (png_ptr)
256 {
257 # ifdef USE_FAR_KEYWORD
258 {
259 jmp_buf jmpbuf;
260 png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));
261 longjmp(jmpbuf, 1);
262 }
263 # else
264 longjmp(png_ptr->jmpbuf, 1);
265 # endif
266 }
267 #else
268 PNG_ABORT();
269 #endif
270 #ifdef PNG_NO_CONSOLE_IO
271 error_message = error_message; /* Make compiler happy */
272 #endif
273 }
274
275 #ifndef PNG_NO_WARNINGS
276 /* This function is called when there is a warning, but the library thinks
277 * it can continue anyway. Replacement functions don't have to do anything
278 * here if you don't want them to. In the default configuration, png_ptr is
279 * not used, but it is passed in case it may be useful.
280 */
281 static void /* PRIVATE */
282 png_default_warning(png_structp png_ptr, png_const_charp warning_message)
283 {
284 #ifndef PNG_NO_CONSOLE_IO
285 # ifdef PNG_ERROR_NUMBERS_SUPPORTED
286 if (*warning_message == '#')
287 {
288 int offset;
289 char warning_number[16];
290 for (offset = 0; offset < 15; offset++)
291 {
292 warning_number[offset] = warning_message[offset + 1];
293 if (warning_message[offset] == ' ')
294 break;
295 }
296 if ((offset > 1) && (offset < 15))
297 {
298 warning_number[offset + 1] = '\0';
299 fprintf(stderr, "libpng warning no. %s: %s",
300 warning_number, warning_message + offset);
301 fprintf(stderr, PNG_STRING_NEWLINE);
302 }
303 else
304 {
305 fprintf(stderr, "libpng warning: %s",
306 warning_message);
307 fprintf(stderr, PNG_STRING_NEWLINE);
308 }
309 }
310 else
311 # endif
312 {
313 fprintf(stderr, "libpng warning: %s", warning_message);
314 fprintf(stderr, PNG_STRING_NEWLINE);
315 }
316 #else
317 warning_message = warning_message; /* Make compiler happy */
318 #endif
319 png_ptr = png_ptr; /* Make compiler happy */
320 }
321 #endif /* PNG_NO_WARNINGS */
322
323 /* This function is called when the application wants to use another method
324 * of handling errors and warnings. Note that the error function MUST NOT
325 * return to the calling routine or serious problems will occur. The return
326 * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
327 */
328 void PNGAPI
329 png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
330 png_error_ptr error_fn, png_error_ptr warning_fn)
331 {
332 if (png_ptr == NULL)
333 return;
334 png_ptr->error_ptr = error_ptr;
335 png_ptr->error_fn = error_fn;
336 png_ptr->warning_fn = warning_fn;
337 }
338
339
340 /* This function returns a pointer to the error_ptr associated with the user
341 * functions. The application should free any memory associated with this
342 * pointer before png_write_destroy and png_read_destroy are called.
343 */
344 png_voidp PNGAPI
345 png_get_error_ptr(png_structp png_ptr)
346 {
347 if (png_ptr == NULL)
348 return NULL;
349 return ((png_voidp)png_ptr->error_ptr);
350 }
351
352
353 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
354 void PNGAPI
355 png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
356 {
357 if (png_ptr != NULL)
358 {
359 png_ptr->flags &=
360 ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
361 }
362 }
363 #endif
364 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

  ViewVC Help
Powered by ViewVC 1.1.22