← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/fltk1.1/jaunty

« back to all changes in this revision

Viewing changes to png/pngerror.c

  • Committer: Bazaar Package Importer
  • Author(s): Aaron M. Ucko
  • Date: 2005-05-22 13:57:06 UTC
  • mfrom: (2.1.1 hoary)
  • Revision ID: james.westby@ubuntu.com-20050522135706-mchag24yf42lu7bu
Tags: 1.1.6-5
http://bugs.debian.org/310151
http://bugs.debian.org/310240
* Revert previous change, which seems to have been ineffective for some
  reason, in favor of commenting out the problematic Makefile rule
  altogether.  (Closes: #310151.)
* debian/control: Go back to specifying the URL as part of the
  description rather than via a non-standard field that doesn't seem to
  have caught on.  (Closes: #310240.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
png/pngerror.c
 
1
 
 
2
/* pngerror.c - stub functions for i/o and memory allocation
 
3
 *
 
4
 * libpng version 1.2.7 - September 12, 2004
 
5
 * For conditions of distribution and use, see copyright notice in png.h
 
6
 * Copyright (c) 1998-2004 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 error_message));
 
22
static void /* PRIVATE */
 
23
png_default_warning PNGARG((png_structp png_ptr,
 
24
  png_const_charp warning_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 error_message)
 
33
{
 
34
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
35
   char msg[16];
 
36
   if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
 
37
   {
 
38
     if (*error_message == '#')
 
39
     {
 
40
         int offset;
 
41
         for (offset=1; offset<15; offset++)
 
42
            if (*(error_message+offset) == ' ')
 
43
                break;
 
44
         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
 
45
         {
 
46
            int i;
 
47
            for (i=0; i<offset-1; i++)
 
48
               msg[i]=error_message[i+1];
 
49
            msg[i]='\0';
 
50
            error_message=msg;
 
51
         }
 
52
         else
 
53
            error_message+=offset;
 
54
     }
 
55
     else
 
56
     {
 
57
         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
 
58
         {
 
59
            msg[0]='0';        
 
60
            msg[1]='\0';
 
61
            error_message=msg;
 
62
         }
 
63
     }
 
64
   }
 
65
#endif
 
66
   if (png_ptr != NULL && png_ptr->error_fn != NULL)
 
67
      (*(png_ptr->error_fn))(png_ptr, error_message);
 
68
 
 
69
   /* If the custom handler doesn't exist, or if it returns,
 
70
      use the default handler, which will not return. */
 
71
   png_default_error(png_ptr, error_message);
 
72
}
 
73
 
 
74
/* This function is called whenever there is a non-fatal error.  This function
 
75
 * should not be changed.  If there is a need to handle warnings differently,
 
76
 * you should supply a replacement warning function and use
 
77
 * png_set_error_fn() to replace the warning function at run-time.
 
78
 */
 
79
void PNGAPI
 
80
png_warning(png_structp png_ptr, png_const_charp warning_message)
 
81
{
 
82
   int offset = 0;
 
83
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
84
   if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
 
85
#endif
 
86
   {
 
87
     if (*warning_message == '#')
 
88
     {
 
89
         for (offset=1; offset<15; offset++)
 
90
            if (*(warning_message+offset) == ' ')
 
91
                break;
 
92
     }
 
93
   }
 
94
   if (png_ptr != NULL && png_ptr->warning_fn != NULL)
 
95
      (*(png_ptr->warning_fn))(png_ptr, warning_message+offset);
 
96
   else
 
97
      png_default_warning(png_ptr, warning_message+offset);
 
98
}
 
99
 
 
100
/* These utilities are used internally to build an error message that relates
 
101
 * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
 
102
 * this is used to prefix the message.  The message is limited in length
 
103
 * to 63 bytes, the name characters are output as hex digits wrapped in []
 
104
 * if the character is invalid.
 
105
 */
 
106
#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
 
107
static PNG_CONST char png_digit[16] = {
 
108
   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 
109
   'A', 'B', 'C', 'D', 'E', 'F'
 
110
};
 
111
 
 
112
static void /* PRIVATE */
 
113
png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
 
114
   error_message)
 
115
{
 
116
   int iout = 0, iin = 0;
 
117
 
 
118
   while (iin < 4)
 
119
   {
 
120
      int c = png_ptr->chunk_name[iin++];
 
121
      if (isnonalpha(c))
 
122
      {
 
123
         buffer[iout++] = '[';
 
124
         buffer[iout++] = png_digit[(c & 0xf0) >> 4];
 
125
         buffer[iout++] = png_digit[c & 0x0f];
 
126
         buffer[iout++] = ']';
 
127
      }
 
128
      else
 
129
      {
 
130
         buffer[iout++] = (png_byte)c;
 
131
      }
 
132
   }
 
133
 
 
134
   if (error_message == NULL)
 
135
      buffer[iout] = 0;
 
136
   else
 
137
   {
 
138
      buffer[iout++] = ':';
 
139
      buffer[iout++] = ' ';
 
140
      png_strncpy(buffer+iout, error_message, 63);
 
141
      buffer[iout+63] = 0;
 
142
   }
 
143
}
 
144
 
 
145
void PNGAPI
 
146
png_chunk_error(png_structp png_ptr, png_const_charp error_message)
 
147
{
 
148
   char msg[18+64];
 
149
   png_format_buffer(png_ptr, msg, error_message);
 
150
   png_error(png_ptr, msg);
 
151
}
 
152
 
 
153
void PNGAPI
 
154
png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
 
155
{
 
156
   char msg[18+64];
 
157
   png_format_buffer(png_ptr, msg, warning_message);
 
158
   png_warning(png_ptr, msg);
 
159
}
 
160
 
 
161
/* This is the default error handling function.  Note that replacements for
 
162
 * this function MUST NOT RETURN, or the program will likely crash.  This
 
163
 * function is used by default, or if the program supplies NULL for the
 
164
 * error function pointer in png_set_error_fn().
 
165
 */
 
166
static void /* PRIVATE */
 
167
png_default_error(png_structp png_ptr, png_const_charp error_message)
 
168
{
 
169
#ifndef PNG_NO_CONSOLE_IO
 
170
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
171
   if (*error_message == '#')
 
172
   {
 
173
     int offset;
 
174
     char error_number[16];
 
175
     for (offset=0; offset<15; offset++)
 
176
     {
 
177
         error_number[offset] = *(error_message+offset+1);
 
178
         if (*(error_message+offset) == ' ')
 
179
             break;
 
180
     }
 
181
     if((offset > 1) && (offset < 15))
 
182
     {
 
183
       error_number[offset-1]='\0';
 
184
       fprintf(stderr, "libpng error no. %s: %s\n", error_number,
 
185
          error_message+offset);
 
186
     }
 
187
     else
 
188
       fprintf(stderr, "libpng error: %s, offset=%d\n", error_message,offset);
 
189
   }
 
190
   else
 
191
#endif
 
192
   fprintf(stderr, "libpng error: %s\n", error_message);
 
193
#endif
 
194
 
 
195
#ifdef PNG_SETJMP_SUPPORTED
 
196
#  ifdef USE_FAR_KEYWORD
 
197
   {
 
198
      jmp_buf jmpbuf;
 
199
      png_memcpy(jmpbuf,png_ptr->jmpbuf,png_sizeof(jmp_buf));
 
200
      longjmp(jmpbuf, 1);
 
201
   }
 
202
#  else
 
203
   longjmp(png_ptr->jmpbuf, 1);
 
204
# endif
 
205
#else
 
206
   /* make compiler happy */ ;
 
207
   if (png_ptr)
 
208
   PNG_ABORT();
 
209
#endif
 
210
#ifdef PNG_NO_CONSOLE_IO
 
211
   /* make compiler happy */ ;
 
212
   if (&error_message != NULL)
 
213
      return;
 
214
#endif
 
215
}
 
216
 
 
217
/* This function is called when there is a warning, but the library thinks
 
218
 * it can continue anyway.  Replacement functions don't have to do anything
 
219
 * here if you don't want them to.  In the default configuration, png_ptr is
 
220
 * not used, but it is passed in case it may be useful.
 
221
 */
 
222
static void /* PRIVATE */
 
223
png_default_warning(png_structp png_ptr, png_const_charp warning_message)
 
224
{
 
225
#ifndef PNG_NO_CONSOLE_IO
 
226
#  ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
227
   if (*warning_message == '#')
 
228
   {
 
229
     int offset;
 
230
     char warning_number[16];
 
231
     for (offset=0; offset<15; offset++)
 
232
     {
 
233
        warning_number[offset]=*(warning_message+offset+1);
 
234
        if (*(warning_message+offset) == ' ')
 
235
            break;
 
236
     }
 
237
     if((offset > 1) && (offset < 15))
 
238
     {
 
239
       warning_number[offset-1]='\0';
 
240
       fprintf(stderr, "libpng warning no. %s: %s\n", warning_number,
 
241
          warning_message+offset);
 
242
     }
 
243
     else
 
244
       fprintf(stderr, "libpng warning: %s\n", warning_message);
 
245
   }
 
246
   else
 
247
#  endif
 
248
     fprintf(stderr, "libpng warning: %s\n", warning_message);
 
249
#else
 
250
   /* make compiler happy */ ;
 
251
   if (warning_message)
 
252
     return;
 
253
#endif
 
254
   /* make compiler happy */ ;
 
255
   if (png_ptr)
 
256
      return;
 
257
}
 
258
 
 
259
/* This function is called when the application wants to use another method
 
260
 * of handling errors and warnings.  Note that the error function MUST NOT
 
261
 * return to the calling routine or serious problems will occur.  The return
 
262
 * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
 
263
 */
 
264
void PNGAPI
 
265
png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
 
266
   png_error_ptr error_fn, png_error_ptr warning_fn)
 
267
{
 
268
   png_ptr->error_ptr = error_ptr;
 
269
   png_ptr->error_fn = error_fn;
 
270
   png_ptr->warning_fn = warning_fn;
 
271
}
 
272
 
 
273
 
 
274
/* This function returns a pointer to the error_ptr associated with the user
 
275
 * functions.  The application should free any memory associated with this
 
276
 * pointer before png_write_destroy and png_read_destroy are called.
 
277
 */
 
278
png_voidp PNGAPI
 
279
png_get_error_ptr(png_structp png_ptr)
 
280
{
 
281
   return ((png_voidp)png_ptr->error_ptr);
 
282
}
 
283
 
 
284
 
 
285
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
286
void PNGAPI
 
287
png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
 
288
{
 
289
   if(png_ptr != NULL)
 
290
   {
 
291
     png_ptr->flags &=
 
292
       ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
 
293
   }
 
294
}
 
295
#endif