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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (hide annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 4 months ago) by william
File MIME type: text/plain
File size: 10526 byte(s)
committing r3113 initial commit again...
1 william 31
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