← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/modules/libimg/png/pngerror.c

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/modules/libimg/png/pngerror.c
 
1
 
 
2
/* pngerror.c - stub functions for i/o and memory allocation
 
3
 *
 
4
 * libpng 1.2.5 - October 2, 2002
 
5
 * For conditions of distribution and use, see copyright notice in png.h
 
6
 * Copyright (c) 1998-2002 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
     int offset = 0;
 
39
     if (*error_message == '#')
 
40
     {
 
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->error_fn != NULL)
 
67
      (*(png_ptr->error_fn))(png_ptr, error_message);
 
68
 
 
69
   /* if the following returns or doesn't exist, use the default function,
 
70
      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->warning_fn != NULL)
 
95
      (*(png_ptr->warning_fn))(png_ptr,
 
96
         (png_const_charp)(warning_message+offset));
 
97
   else
 
98
      png_default_warning(png_ptr, (png_const_charp)(warning_message+offset));
 
99
}
 
100
 
 
101
/* These utilities are used internally to build an error message that relates
 
102
 * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
 
103
 * this is used to prefix the message.  The message is limited in length
 
104
 * to 63 bytes, the name characters are output as hex digits wrapped in []
 
105
 * if the character is invalid.
 
106
 */
 
107
#define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97))
 
108
static PNG_CONST char png_digit[16] = {
 
109
   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E',
 
110
   'F' };
 
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
#else
 
194
   if (error_message)
 
195
     /* make compiler happy */ ;
 
196
#endif
 
197
 
 
198
#ifdef PNG_SETJMP_SUPPORTED
 
199
#  ifdef USE_FAR_KEYWORD
 
200
   {
 
201
      jmp_buf jmpbuf;
 
202
      png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
 
203
      longjmp(jmpbuf, 1);
 
204
   }
 
205
#  else
 
206
   longjmp(png_ptr->jmpbuf, 1);
 
207
# endif
 
208
#else
 
209
   if (png_ptr)
 
210
     /* make compiler happy */ ;
 
211
   PNG_ABORT();
 
212
#endif
 
213
}
 
214
 
 
215
/* This function is called when there is a warning, but the library thinks
 
216
 * it can continue anyway.  Replacement functions don't have to do anything
 
217
 * here if you don't want them to.  In the default configuration, png_ptr is
 
218
 * not used, but it is passed in case it may be useful.
 
219
 */
 
220
static void /* PRIVATE */
 
221
png_default_warning(png_structp png_ptr, png_const_charp warning_message)
 
222
{
 
223
#ifndef PNG_NO_CONSOLE_IO
 
224
#  ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
225
   if (*warning_message == '#')
 
226
   {
 
227
     int offset;
 
228
     char warning_number[16];
 
229
     for (offset=0; offset<15; offset++)
 
230
     {
 
231
        warning_number[offset]=*(warning_message+offset+1);
 
232
        if (*(warning_message+offset) == ' ')
 
233
            break;
 
234
     }
 
235
     if((offset > 1) && (offset < 15))
 
236
     {
 
237
       warning_number[offset-1]='\0';
 
238
       fprintf(stderr, "libpng warning no. %s: %s\n", warning_number,
 
239
          warning_message+offset);
 
240
     }
 
241
     else
 
242
       fprintf(stderr, "libpng warning: %s\n", warning_message);
 
243
   }
 
244
   else
 
245
#  endif
 
246
     fprintf(stderr, "libpng warning: %s\n", warning_message);
 
247
#else
 
248
   if (warning_message)
 
249
     /* appease compiler */ ;
 
250
#endif
 
251
   if (png_ptr)
 
252
      return;
 
253
}
 
254
 
 
255
/* This function is called when the application wants to use another method
 
256
 * of handling errors and warnings.  Note that the error function MUST NOT
 
257
 * return to the calling routine or serious problems will occur.  The return
 
258
 * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
 
259
 */
 
260
void PNGAPI
 
261
png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
 
262
   png_error_ptr error_fn, png_error_ptr warning_fn)
 
263
{
 
264
   png_ptr->error_ptr = error_ptr;
 
265
   png_ptr->error_fn = error_fn;
 
266
   png_ptr->warning_fn = warning_fn;
 
267
}
 
268
 
 
269
 
 
270
/* This function returns a pointer to the error_ptr associated with the user
 
271
 * functions.  The application should free any memory associated with this
 
272
 * pointer before png_write_destroy and png_read_destroy are called.
 
273
 */
 
274
png_voidp PNGAPI
 
275
png_get_error_ptr(png_structp png_ptr)
 
276
{
 
277
   return ((png_voidp)png_ptr->error_ptr);
 
278
}
 
279
 
 
280
 
 
281
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
 
282
void PNGAPI
 
283
png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
 
284
{
 
285
   if(png_ptr != NULL)
 
286
   {
 
287
     png_ptr->flags &=
 
288
       ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
 
289
   }
 
290
}
 
291
#endif