Merge to XFA: Kill remaining sprintfs
[pdfium.git] / core / src / fxcodec / libjpeg / fpdfapi_jerror.c
1 #if !defined(_FX_JPEG_TURBO_)
2 /*
3  * jerror.c
4  *
5  * Copyright (C) 1991-1998, Thomas G. Lane.
6  * This file is part of the Independent JPEG Group's software.
7  * For conditions of distribution and use, see the accompanying README file.
8  *
9  * This file contains simple error-reporting and trace-message routines.
10  * These are suitable for Unix-like systems and others where writing to
11  * stderr is the right thing to do.  Many applications will want to replace
12  * some or all of these routines.
13  *
14  * These routines are used by both the compression and decompression code.
15  */
16
17 /* this is not a core library module, so it doesn't define JPEG_INTERNALS */
18 #include "jinclude.h"
19 #include "jpeglib.h"
20 #include "jversion.h"
21 #include "jerror.h"
22
23 #ifndef EXIT_FAILURE            /* define exit() codes if not provided */
24 #define EXIT_FAILURE  1
25 #endif
26
27
28 /*
29  * Create the message string table.
30  * We do this from the master message list in jerror.h by re-reading
31  * jerror.h with a suitable definition for macro JMESSAGE.
32  * The message table is made an external symbol just in case any applications
33  * want to refer to it directly.
34  */
35
36 #ifdef NEED_SHORT_EXTERNAL_NAMES
37 #define jpeg_std_message_table  jMsgTable
38 #endif
39
40 #define JMESSAGE(code,string)   string ,
41
42 const char * const jpeg_std_message_table[] = {
43 #include "jerror.h"
44   NULL
45 };
46
47
48 /*
49  * Error exit handler: must not return to caller.
50  *
51  * Applications may override this if they want to get control back after
52  * an error.  Typically one would longjmp somewhere instead of exiting.
53  * The setjmp buffer can be made a private field within an expanded error
54  * handler object.  Note that the info needed to generate an error message
55  * is stored in the error object, so you can generate the message now or
56  * later, at your convenience.
57  * You should make sure that the JPEG object is cleaned up (with jpeg_abort
58  * or jpeg_destroy) at some point.
59  */
60
61 METHODDEF(void)
62 error_exit (j_common_ptr cinfo)
63 {
64   /* Always display the message */
65   (*cinfo->err->output_message) (cinfo);
66
67   /* Let the memory manager delete any temp files before we die */
68   jpeg_destroy(cinfo);
69
70 //  exit(EXIT_FAILURE);
71 }
72
73
74 /*
75  * Actual output of an error or trace message.
76  * Applications may override this method to send JPEG messages somewhere
77  * other than stderr.
78  *
79  * On Windows, printing to stderr is generally completely useless,
80  * so we provide optional code to produce an error-dialog popup.
81  * Most Windows applications will still prefer to override this routine,
82  * but if they don't, it'll do something at least marginally useful.
83  *
84  * NOTE: to use the library in an environment that doesn't support the
85  * C stdio library, you may have to delete the call to fprintf() entirely,
86  * not just not use this routine.
87  */
88
89 METHODDEF(void)
90 output_message (j_common_ptr cinfo)
91 {
92   char buffer[JMSG_LENGTH_MAX];
93
94   /* Create the message */
95   (*cinfo->err->format_message) (cinfo, buffer);
96
97   /* Send it to stderr, adding a newline */
98   FXSYS_fprintf(stderr, "%s\n", buffer);
99 }
100
101
102 /*
103  * Decide whether to emit a trace or warning message.
104  * msg_level is one of:
105  *   -1: recoverable corrupt-data warning, may want to abort.
106  *    0: important advisory messages (always display to user).
107  *    1: first level of tracing detail.
108  *    2,3,...: successively more detailed tracing messages.
109  * An application might override this method if it wanted to abort on warnings
110  * or change the policy about which messages to display.
111  */
112
113 METHODDEF(void)
114 emit_message (j_common_ptr cinfo, int msg_level)
115 {
116   struct jpeg_error_mgr * err = cinfo->err;
117
118   if (msg_level < 0) {
119     /* It's a warning message.  Since corrupt files may generate many warnings,
120      * the policy implemented here is to show only the first warning,
121      * unless trace_level >= 3.
122      */
123     if (err->num_warnings == 0 || err->trace_level >= 3)
124       (*err->output_message) (cinfo);
125     /* Always count warnings in num_warnings. */
126     err->num_warnings++;
127   } else {
128     /* It's a trace message.  Show it if trace_level >= msg_level. */
129     if (err->trace_level >= msg_level)
130       (*err->output_message) (cinfo);
131   }
132 }
133
134
135 /*
136  * Format a message string for the most recent JPEG error or message.
137  * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX
138  * characters.  Note that no '\n' character is added to the string.
139  * Few applications should need to override this method.
140  */
141
142 METHODDEF(void)
143 format_message (j_common_ptr cinfo, char * buffer)
144 {
145 #if 0   /* XYQ */
146   struct jpeg_error_mgr * err = cinfo->err;
147   int msg_code = err->msg_code;
148   const char * msgtext = NULL;
149   const char * msgptr;
150   char ch;
151   boolean isstring;
152
153   /* Look up message string in proper table */
154   if (msg_code > 0 && msg_code <= err->last_jpeg_message) {
155     msgtext = err->jpeg_message_table[msg_code];
156   } else if (err->addon_message_table != NULL &&
157              msg_code >= err->first_addon_message &&
158              msg_code <= err->last_addon_message) {
159     msgtext = err->addon_message_table[msg_code - err->first_addon_message];
160   }
161
162   /* Defend against bogus message number */
163   if (msgtext == NULL) {
164     err->msg_parm.i[0] = msg_code;
165     msgtext = err->jpeg_message_table[0];
166   }
167
168   /* Check for string parameter, as indicated by %s in the message text */
169   isstring = FALSE;
170   msgptr = msgtext;
171   while ((ch = *msgptr++) != '\0') {
172     if (ch == '%') {
173       if (*msgptr == 's') isstring = TRUE;
174       break;
175     }
176   }
177
178   /* Format the message into the passed buffer */
179   if (isstring)
180     sprintf(buffer, msgtext, err->msg_parm.s);
181   else
182     sprintf(buffer, msgtext,
183             err->msg_parm.i[0], err->msg_parm.i[1],
184             err->msg_parm.i[2], err->msg_parm.i[3],
185             err->msg_parm.i[4], err->msg_parm.i[5],
186             err->msg_parm.i[6], err->msg_parm.i[7]);
187 #endif
188 }
189
190
191 /*
192  * Reset error state variables at start of a new image.
193  * This is called during compression startup to reset trace/error
194  * processing to default state, without losing any application-specific
195  * method pointers.  An application might possibly want to override
196  * this method if it has additional error processing state.
197  */
198
199 METHODDEF(void)
200 reset_error_mgr (j_common_ptr cinfo)
201 {
202   cinfo->err->num_warnings = 0;
203   /* trace_level is not reset since it is an application-supplied parameter */
204   cinfo->err->msg_code = 0;     /* may be useful as a flag for "no error" */
205 }
206
207
208 /*
209  * Fill in the standard error-handling methods in a jpeg_error_mgr object.
210  * Typical call is:
211  *      struct jpeg_compress_struct cinfo;
212  *      struct jpeg_error_mgr err;
213  *
214  *      cinfo.err = jpeg_std_error(&err);
215  * after which the application may override some of the methods.
216  */
217
218 GLOBAL(struct jpeg_error_mgr *)
219 jpeg_std_error (struct jpeg_error_mgr * err)
220 {
221   err->error_exit = error_exit;
222   err->emit_message = emit_message;
223   err->output_message = output_message;
224   err->format_message = format_message;
225   err->reset_error_mgr = reset_error_mgr;
226
227   err->trace_level = 0;         /* default = no tracing */
228   err->num_warnings = 0;        /* no warnings emitted yet */
229   err->msg_code = 0;            /* may be useful as a flag for "no error" */
230
231   /* Initialize message table pointers */
232   err->jpeg_message_table = jpeg_std_message_table;
233   err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
234
235   err->addon_message_table = NULL;
236   err->first_addon_message = 0; /* for safety */
237   err->last_addon_message = 0;
238
239   return err;
240 }
241
242 #endif //_FX_JPEG_TURBO_