]> git.jsancho.org Git - lugaru.git/blob - Dependencies/libpng/pngerror.c
Removed an unused function
[lugaru.git] / Dependencies / libpng / pngerror.c
1
2 /* pngerror.c - stub functions for i/o and memory allocation
3  *
4  * Last changed in libpng 1.4.0 [January 3, 2010]
5  * Copyright (c) 1998-2010 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_NO_PEDANTIC_WARNINGS
20 #include "png.h"
21 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
22 #include "pngpriv.h"
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,
30   png_const_charp warning_message));
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    if (png_ptr != NULL && png_ptr->error_fn != NULL)
91       (*(png_ptr->error_fn))(png_ptr, '\0');
92
93    /* If the custom handler doesn't exist, or if it returns,
94       use the default handler, which will not return. */
95    png_default_error(png_ptr, '\0');
96 }
97 #endif /* PNG_ERROR_TEXT_SUPPORTED */
98
99 #ifdef PNG_WARNINGS_SUPPORTED
100 /* This function is called whenever there is a non-fatal error.  This function
101  * should not be changed.  If there is a need to handle warnings differently,
102  * you should supply a replacement warning function and use
103  * png_set_error_fn() to replace the warning function at run-time.
104  */
105 void PNGAPI
106 png_warning(png_structp png_ptr, png_const_charp warning_message)
107 {
108    int offset = 0;
109    if (png_ptr != NULL)
110    {
111 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
112    if (png_ptr->flags&
113      (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
114 #endif
115      {
116        if (*warning_message == PNG_LITERAL_SHARP)
117        {
118            for (offset = 1; offset < 15; offset++)
119               if (warning_message[offset] == ' ')
120                   break;
121        }
122      }
123    }
124    if (png_ptr != NULL && png_ptr->warning_fn != NULL)
125       (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
126    else
127       png_default_warning(png_ptr, warning_message + offset);
128 }
129 #endif /* PNG_WARNINGS_SUPPORTED */
130
131 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
132 void PNGAPI
133 png_benign_error(png_structp png_ptr, png_const_charp error_message)
134 {
135   if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
136     png_warning(png_ptr, error_message);
137   else
138     png_error(png_ptr, error_message);
139 }
140 #endif
141
142 /* These utilities are used internally to build an error message that relates
143  * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
144  * this is used to prefix the message.  The message is limited in length
145  * to 63 bytes, the name characters are output as hex digits wrapped in []
146  * if the character is invalid.
147  */
148 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
149 static PNG_CONST char png_digit[16] = {
150    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
151    'A', 'B', 'C', 'D', 'E', 'F'
152 };
153
154 #define PNG_MAX_ERROR_TEXT 64
155 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
156 static void /* PRIVATE */
157 png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
158    error_message)
159 {
160    int iout = 0, iin = 0;
161
162    while (iin < 4)
163    {
164       int c = png_ptr->chunk_name[iin++];
165       if (isnonalpha(c))
166       {
167          buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
168          buffer[iout++] = png_digit[(c & 0xf0) >> 4];
169          buffer[iout++] = png_digit[c & 0x0f];
170          buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;
171       }
172       else
173       {
174          buffer[iout++] = (png_byte)c;
175       }
176    }
177
178    if (error_message == NULL)
179       buffer[iout] = '\0';
180    else
181    {
182       buffer[iout++] = ':';
183       buffer[iout++] = ' ';
184       png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);
185       buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';
186    }
187 }
188
189 #ifdef PNG_READ_SUPPORTED
190 void PNGAPI
191 png_chunk_error(png_structp png_ptr, png_const_charp error_message)
192 {
193    char msg[18+PNG_MAX_ERROR_TEXT];
194    if (png_ptr == NULL)
195      png_error(png_ptr, error_message);
196    else
197    {
198      png_format_buffer(png_ptr, msg, error_message);
199      png_error(png_ptr, msg);
200    }
201 }
202 #endif /* PNG_READ_SUPPORTED */
203 #endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
204
205 #ifdef PNG_WARNINGS_SUPPORTED
206 void PNGAPI
207 png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
208 {
209    char msg[18+PNG_MAX_ERROR_TEXT];
210    if (png_ptr == NULL)
211      png_warning(png_ptr, warning_message);
212    else
213    {
214      png_format_buffer(png_ptr, msg, warning_message);
215      png_warning(png_ptr, msg);
216    }
217 }
218 #endif /* PNG_WARNINGS_SUPPORTED */
219
220 #ifdef PNG_READ_SUPPORTED
221 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
222 void PNGAPI
223 png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
224 {
225   if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
226     png_chunk_warning(png_ptr, error_message);
227   else
228     png_chunk_error(png_ptr, error_message);
229 }
230 #endif
231 #endif /* PNG_READ_SUPPORTED */
232
233 #ifdef PNG_SETJMP_SUPPORTED
234 /* This API only exists if ANSI-C style error handling is used,
235  * otherwise it is necessary for png_default_error to be overridden.
236  */
237 jmp_buf* PNGAPI
238 png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn,
239     size_t jmp_buf_size)
240 {
241    if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))
242       return NULL;
243
244    png_ptr->longjmp_fn = longjmp_fn;
245    return &png_ptr->jmpbuf;
246 }
247 #endif
248
249 /* This is the default error handling function.  Note that replacements for
250  * this function MUST NOT RETURN, or the program will likely crash.  This
251  * function is used by default, or if the program supplies NULL for the
252  * error function pointer in png_set_error_fn().
253  */
254 static void /* PRIVATE */
255 png_default_error(png_structp png_ptr, png_const_charp error_message)
256 {
257 #ifdef PNG_CONSOLE_IO_SUPPORTED
258 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
259    if (*error_message == PNG_LITERAL_SHARP)
260    {
261      /* Strip "#nnnn " from beginning of error message. */
262      int offset;
263      char error_number[16];
264      for (offset = 0; offset<15; offset++)
265      {
266          error_number[offset] = error_message[offset + 1];
267          if (error_message[offset] == ' ')
268              break;
269      }
270      if ((offset > 1) && (offset < 15))
271      {
272        error_number[offset - 1] = '\0';
273        fprintf(stderr, "libpng error no. %s: %s",
274           error_number, error_message + offset + 1);
275        fprintf(stderr, PNG_STRING_NEWLINE);
276      }
277      else
278      {
279        fprintf(stderr, "libpng error: %s, offset=%d",
280           error_message, offset);
281        fprintf(stderr, PNG_STRING_NEWLINE);
282      }
283    }
284    else
285 #endif
286    {
287       fprintf(stderr, "libpng error: %s", error_message);
288       fprintf(stderr, PNG_STRING_NEWLINE);
289    }
290 #endif
291
292 #ifdef PNG_SETJMP_SUPPORTED
293    if (png_ptr && png_ptr->longjmp_fn)
294    {
295 #  ifdef USE_FAR_KEYWORD
296    {
297       jmp_buf jmpbuf;
298       png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));
299      png_ptr->longjmp_fn(jmpbuf, 1);
300    }
301 #  else
302    png_ptr->longjmp_fn(png_ptr->jmpbuf, 1);
303 #  endif
304    }
305 #endif
306    /* Here if not setjmp support or if png_ptr is null. */
307    PNG_ABORT();
308 #ifndef PNG_CONSOLE_IO_SUPPORTED
309    error_message = error_message; /* Make compiler happy */
310 #endif
311 }
312
313 #ifdef PNG_WARNINGS_SUPPORTED
314 /* This function is called when there is a warning, but the library thinks
315  * it can continue anyway.  Replacement functions don't have to do anything
316  * here if you don't want them to.  In the default configuration, png_ptr is
317  * not used, but it is passed in case it may be useful.
318  */
319 static void /* PRIVATE */
320 png_default_warning(png_structp png_ptr, png_const_charp warning_message)
321 {
322 #ifdef PNG_CONSOLE_IO_SUPPORTED
323 #  ifdef PNG_ERROR_NUMBERS_SUPPORTED
324    if (*warning_message == PNG_LITERAL_SHARP)
325    {
326      int offset;
327      char warning_number[16];
328      for (offset = 0; offset < 15; offset++)
329      {
330         warning_number[offset] = warning_message[offset + 1];
331         if (warning_message[offset] == ' ')
332             break;
333      }
334      if ((offset > 1) && (offset < 15))
335      {
336        warning_number[offset + 1] = '\0';
337        fprintf(stderr, "libpng warning no. %s: %s",
338           warning_number, warning_message + offset);
339        fprintf(stderr, PNG_STRING_NEWLINE);
340      }
341      else
342      {
343        fprintf(stderr, "libpng warning: %s",
344           warning_message);
345        fprintf(stderr, PNG_STRING_NEWLINE);
346      }
347    }
348    else
349 #  endif
350    {
351      fprintf(stderr, "libpng warning: %s", warning_message);
352      fprintf(stderr, PNG_STRING_NEWLINE);
353    }
354 #else
355    warning_message = warning_message; /* Make compiler happy */
356 #endif
357    png_ptr = png_ptr; /* Make compiler happy */
358 }
359 #endif /* PNG_WARNINGS_SUPPORTED */
360
361 /* This function is called when the application wants to use another method
362  * of handling errors and warnings.  Note that the error function MUST NOT
363  * return to the calling routine or serious problems will occur.  The return
364  * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
365  */
366 void PNGAPI
367 png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
368    png_error_ptr error_fn, png_error_ptr warning_fn)
369 {
370    if (png_ptr == NULL)
371       return;
372    png_ptr->error_ptr = error_ptr;
373    png_ptr->error_fn = error_fn;
374    png_ptr->warning_fn = warning_fn;
375 }
376
377
378 /* This function returns a pointer to the error_ptr associated with the user
379  * functions.  The application should free any memory associated with this
380  * pointer before png_write_destroy and png_read_destroy are called.
381  */
382 png_voidp PNGAPI
383 png_get_error_ptr(png_structp png_ptr)
384 {
385    if (png_ptr == NULL)
386       return NULL;
387    return ((png_voidp)png_ptr->error_ptr);
388 }
389
390
391 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
392 void PNGAPI
393 png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
394 {
395    if (png_ptr != NULL)
396    {
397      png_ptr->flags &=
398        ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
399    }
400 }
401 #endif
402 #endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */