Commit | Line | Data |
---|---|---|
fecd2382 RP |
1 | /* messages.c - error reporter - |
2 | Copyright (C) 1987, 1991 Free Software Foundation, Inc. | |
a39116f1 | 3 | |
fecd2382 | 4 | This file is part of GAS, the GNU Assembler. |
a39116f1 | 5 | |
fecd2382 RP |
6 | GAS is free software; you can redistribute it and/or modify |
7 | it under the terms of the GNU General Public License as published by | |
a39116f1 | 8 | the Free Software Foundation; either version 2, or (at your option) |
fecd2382 | 9 | any later version. |
a39116f1 | 10 | |
fecd2382 RP |
11 | GAS is distributed in the hope that it will be useful, |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
a39116f1 | 15 | |
fecd2382 RP |
16 | You should have received a copy of the GNU General Public License |
17 | along with GAS; see the file COPYING. If not, write to | |
18 | the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | ||
20 | /* $Id$ */ | |
21 | ||
22 | #include <stdio.h> /* define stderr */ | |
23 | #include <errno.h> | |
24 | ||
25 | #include "as.h" | |
26 | ||
27 | #ifndef NO_STDARG | |
28 | #include <stdarg.h> | |
29 | #else | |
30 | #ifndef NO_VARARGS | |
31 | #include <varargs.h> | |
32 | #endif /* NO_VARARGS */ | |
33 | #endif /* NO_STDARG */ | |
34 | ||
35 | /* | |
36 | * Despite the rest of the comments in this file, (FIXME-SOON), | |
37 | * here is the current scheme for error messages etc: | |
38 | * | |
39 | * as_fatal() is used when gas is quite confused and | |
40 | * continuing the assembly is pointless. In this case we | |
41 | * exit immediately with error status. | |
42 | * | |
43 | * as_bad() is used to mark errors that result in what we | |
44 | * presume to be a useless object file. Say, we ignored | |
45 | * something that might have been vital. If we see any of | |
46 | * these, assembly will continue to the end of the source, | |
47 | * no object file will be produced, and we will terminate | |
48 | * with error status. The new option, -Z, tells us to | |
49 | * produce an object file anyway but we still exit with | |
50 | * error status. The assumption here is that you don't want | |
51 | * this object file but we could be wrong. | |
52 | * | |
53 | * as_warn() is used when we have an error from which we | |
54 | * have a plausible error recovery. eg, masking the top | |
55 | * bits of a constant that is longer than will fit in the | |
56 | * destination. In this case we will continue to assemble | |
57 | * the source, although we may have made a bad assumption, | |
58 | * and we will produce an object file and return normal exit | |
59 | * status (ie, no error). The new option -X tells us to | |
60 | * treat all as_warn() errors as as_bad() errors. That is, | |
61 | * no object file will be produced and we will exit with | |
62 | * error status. The idea here is that we don't kill an | |
63 | * entire make because of an error that we knew how to | |
64 | * correct. On the other hand, sometimes you might want to | |
65 | * stop the make at these points. | |
66 | * | |
67 | * as_tsktsk() is used when we see a minor error for which | |
68 | * our error recovery action is almost certainly correct. | |
69 | * In this case, we print a message and then assembly | |
70 | * continues as though no error occurred. | |
71 | */ | |
72 | ||
73 | /* | |
74 | ERRORS | |
a39116f1 | 75 | |
fecd2382 RP |
76 | JF: this is now bogus. We now print more standard error messages |
77 | that try to look like everyone else's. | |
a39116f1 | 78 | |
fecd2382 RP |
79 | We print the error message 1st, beginning in column 1. |
80 | All ancillary info starts in column 2 on lines after the | |
81 | key error text. | |
82 | We try to print a location in logical and physical file | |
83 | just after the main error text. | |
84 | Caller then prints any appendices after that, begining all | |
85 | lines with at least 1 space. | |
a39116f1 | 86 | |
fecd2382 RP |
87 | Optionally, we may die. |
88 | There is no need for a trailing '\n' in your error text format | |
89 | because we supply one. | |
a39116f1 | 90 | |
fecd2382 | 91 | as_warn(fmt,args) Like fprintf(stderr,fmt,args) but also call errwhere(). |
a39116f1 | 92 | |
fecd2382 | 93 | as_fatal(fmt,args) Like as_warn() but exit with a fatal status. |
a39116f1 RP |
94 | |
95 | */ | |
fecd2382 RP |
96 | |
97 | static int warning_count = 0; /* Count of number of warnings issued */ | |
98 | ||
99 | int had_warnings() { | |
100 | return(warning_count); | |
101 | } /* had_err() */ | |
102 | ||
103 | /* Nonzero if we've hit a 'bad error', and should not write an obj file, | |
104 | and exit with a nonzero error code */ | |
105 | ||
106 | static int error_count = 0; | |
107 | ||
108 | int had_errors() { | |
109 | return(error_count); | |
110 | } /* had_errors() */ | |
111 | ||
112 | ||
113 | /* | |
114 | * a s _ p e r r o r | |
115 | * | |
116 | * Like perror(3), but with more info. | |
117 | */ | |
118 | void as_perror(gripe, filename) | |
119 | char *gripe; /* Unpunctuated error theme. */ | |
120 | char *filename; | |
121 | { | |
122 | extern int sys_nerr; | |
123 | extern char *sys_errlist[]; | |
a39116f1 | 124 | |
fecd2382 RP |
125 | as_where(); |
126 | fprintf(stderr,gripe,filename); | |
a39116f1 | 127 | |
fecd2382 RP |
128 | if (errno > sys_nerr) |
129 | fprintf(stderr, "Unknown error #%d.\n", errno); | |
130 | else | |
131 | fprintf(stderr, "%s.\n", sys_errlist[errno]); | |
132 | errno = 0; /* After reporting, clear it. */ | |
133 | } /* as_perror() */ | |
134 | ||
135 | /* | |
136 | * a s _ t s k t s k () | |
137 | * | |
138 | * Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a warning, and locate warning | |
139 | * in input file(s). | |
140 | * Please only use this for when we have some recovery action. | |
141 | * Please explain in string (which may have '\n's) what recovery was done. | |
142 | */ | |
143 | ||
144 | #ifndef NO_STDARG | |
145 | void as_tsktsk(Format) | |
146 | const char *Format; | |
147 | { | |
148 | va_list args; | |
149 | ||
150 | as_where(); | |
151 | va_start(args, Format); | |
152 | vfprintf(stderr, Format, args); | |
153 | va_end(args); | |
154 | (void) putc('\n', stderr); | |
155 | } /* as_tsktsk() */ | |
156 | #else | |
157 | #ifndef NO_VARARGS | |
158 | void as_tsktsk(Format,va_alist) | |
159 | char *Format; | |
160 | va_dcl | |
161 | { | |
162 | va_list args; | |
163 | ||
164 | as_where(); | |
165 | va_start(args); | |
166 | vfprintf(stderr, Format, args); | |
167 | va_end(args); | |
168 | (void) putc('\n', stderr); | |
169 | } /* as_tsktsk() */ | |
170 | #else | |
171 | /*VARARGS1 */ | |
172 | as_tsktsk(Format,args) | |
173 | char *Format; | |
174 | { | |
175 | as_where(); | |
176 | _doprnt (Format, &args, stderr); | |
177 | (void)putc ('\n', stderr); | |
178 | /* as_where(); */ | |
179 | } /* as_tsktsk */ | |
180 | #endif /* not NO_VARARGS */ | |
181 | #endif /* not NO_STDARG */ | |
182 | ||
183 | #ifdef DONTDEF | |
184 | void as_tsktsk(Format,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an) | |
185 | char *format; | |
186 | { | |
187 | as_where(); | |
188 | fprintf(stderr,Format,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an); | |
189 | (void)putc('\n',stderr); | |
190 | } /* as_tsktsk() */ | |
191 | #endif | |
192 | /* | |
193 | * a s _ w a r n () | |
194 | * | |
195 | * Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a warning, and locate warning | |
196 | * in input file(s). | |
197 | * Please only use this for when we have some recovery action. | |
198 | * Please explain in string (which may have '\n's) what recovery was done. | |
199 | */ | |
200 | ||
201 | #ifndef NO_STDARG | |
202 | void as_warn(Format) | |
203 | const char *Format; | |
204 | { | |
205 | va_list args; | |
a39116f1 | 206 | char buffer[200]; |
fecd2382 RP |
207 | |
208 | if(!flagseen['W']) { | |
209 | ++warning_count; | |
210 | as_where(); | |
211 | va_start(args, Format); | |
a39116f1 RP |
212 | fprintf(stderr,"Warning: "); |
213 | vsprintf(buffer, Format, args); | |
214 | fprintf(stderr, buffer); | |
215 | #ifndef NO_LISTING | |
216 | listing_warning(buffer); | |
217 | #endif | |
fecd2382 RP |
218 | va_end(args); |
219 | (void) putc('\n', stderr); | |
220 | } | |
221 | } /* as_warn() */ | |
222 | #else | |
223 | #ifndef NO_VARARGS | |
224 | void as_warn(Format,va_alist) | |
225 | char *Format; | |
226 | va_dcl | |
227 | { | |
228 | va_list args; | |
a39116f1 | 229 | char buffer[200]; |
fecd2382 RP |
230 | |
231 | if(!flagseen['W']) { | |
232 | ++warning_count; | |
233 | as_where(); | |
234 | va_start(args); | |
a39116f1 RP |
235 | fprintf(stderr,"Warning: "); |
236 | vsprintf(buffer, Format, args); | |
237 | fprintf(stderr,buffer); | |
238 | #ifndef NO_LISTING | |
239 | listing_warning(buffer); | |
240 | #endif | |
fecd2382 RP |
241 | va_end(args); |
242 | (void) putc('\n', stderr); | |
243 | } | |
244 | } /* as_warn() */ | |
245 | #else | |
246 | /*VARARGS1 */ | |
247 | as_warn(Format,args) | |
248 | char *Format; | |
249 | { | |
250 | /* -W supresses warning messages. */ | |
251 | if (! flagseen ['W']) { | |
252 | ++warning_count; | |
253 | as_where(); | |
254 | _doprnt (Format, &args, stderr); | |
255 | (void)putc ('\n', stderr); | |
256 | /* as_where(); */ | |
257 | } | |
258 | } /* as_warn() */ | |
259 | #endif /* not NO_VARARGS */ | |
260 | #endif /* not NO_STDARG */ | |
261 | ||
262 | #ifdef DONTDEF | |
263 | void as_warn(Format,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an) | |
264 | char *format; | |
265 | { | |
266 | if(!flagseen['W']) { | |
267 | ++warning_count; | |
268 | as_where(); | |
269 | fprintf(stderr,Format,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an); | |
270 | (void)putc('\n',stderr); | |
271 | } | |
272 | } /* as_warn() */ | |
273 | #endif | |
274 | /* | |
275 | * a s _ b a d () | |
276 | * | |
277 | * Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a warning, | |
278 | * and locate warning in input file(s). | |
279 | * Please us when there is no recovery, but we want to continue processing | |
280 | * but not produce an object file. | |
281 | * Please explain in string (which may have '\n's) what recovery was done. | |
282 | */ | |
283 | ||
284 | #ifndef NO_STDARG | |
285 | void as_bad(Format) | |
286 | const char *Format; | |
287 | { | |
288 | va_list args; | |
a39116f1 RP |
289 | char buffer[200]; |
290 | ||
fecd2382 RP |
291 | ++error_count; |
292 | as_where(); | |
293 | va_start(args, Format); | |
a39116f1 RP |
294 | fprintf(stderr,"Error: "); |
295 | ||
296 | vsprintf(buffer, Format, args); | |
297 | fprintf(stderr,buffer); | |
298 | #ifndef NO_LISTING | |
299 | listing_error(buffer); | |
300 | #endif | |
fecd2382 RP |
301 | va_end(args); |
302 | (void) putc('\n', stderr); | |
303 | } /* as_bad() */ | |
304 | #else | |
305 | #ifndef NO_VARARGS | |
306 | void as_bad(Format,va_alist) | |
307 | char *Format; | |
308 | va_dcl | |
309 | { | |
310 | va_list args; | |
a39116f1 RP |
311 | char buffer[200]; |
312 | ||
fecd2382 RP |
313 | ++error_count; |
314 | as_where(); | |
315 | va_start(args); | |
a39116f1 RP |
316 | vsprintf(buffer, Format, args); |
317 | fprintf(stderr,buffer); | |
318 | #ifndef NO_LISTING | |
319 | listing_error(buffer); | |
320 | #endif | |
321 | ||
fecd2382 RP |
322 | va_end(args); |
323 | (void) putc('\n', stderr); | |
a39116f1 | 324 | } /* as_bad() */ |
fecd2382 RP |
325 | #else |
326 | /*VARARGS1 */ | |
327 | as_bad(Format,args) | |
328 | char *Format; | |
329 | { | |
330 | ++error_count; | |
a39116f1 | 331 | |
fecd2382 | 332 | as_where(); |
a39116f1 | 333 | fprintf(stderr,"Error: "); |
fecd2382 RP |
334 | _doprnt (Format, &args, stderr); |
335 | (void)putc ('\n', stderr); | |
336 | /* as_where(); */ | |
337 | } /* as_bad() */ | |
338 | #endif /* not NO_VARARGS */ | |
339 | #endif /* not NO_STDARG */ | |
340 | ||
341 | #ifdef DONTDEF | |
342 | void as_bad(Format,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an) | |
343 | char *format; | |
344 | { | |
345 | ++error_count; | |
346 | as_where(); | |
347 | fprintf(stderr,Format,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an); | |
348 | (void)putc('\n',stderr); | |
349 | } /* as_bad() */ | |
350 | #endif | |
351 | ||
352 | /* | |
353 | * a s _ f a t a l () | |
354 | * | |
355 | * Send to stderr a string (with bell) (JF: Bell is obnoxious!) as a fatal | |
356 | * message, and locate stdsource in input file(s). | |
357 | * Please only use this for when we DON'T have some recovery action. | |
358 | * It exit()s with a warning status. | |
359 | */ | |
360 | ||
361 | #ifndef NO_STDARG | |
362 | void as_fatal(Format) | |
363 | const char *Format; | |
364 | { | |
365 | va_list args; | |
a39116f1 | 366 | |
fecd2382 RP |
367 | as_where(); |
368 | va_start(args, Format); | |
369 | fprintf (stderr, "FATAL:"); | |
370 | vfprintf(stderr, Format, args); | |
371 | (void) putc('\n', stderr); | |
372 | va_end(args); | |
a39116f1 | 373 | exit(33); |
fecd2382 RP |
374 | } /* as_fatal() */ |
375 | #else | |
376 | #ifndef NO_VARARGS | |
377 | void as_fatal(Format,va_alist) | |
378 | char *Format; | |
379 | va_dcl | |
380 | { | |
381 | va_list args; | |
a39116f1 | 382 | |
fecd2382 RP |
383 | as_where(); |
384 | va_start(args); | |
385 | fprintf (stderr, "FATAL:"); | |
386 | vfprintf(stderr, Format, args); | |
387 | (void) putc('\n', stderr); | |
388 | va_end(args); | |
a39116f1 | 389 | exit(33); |
fecd2382 RP |
390 | } /* as_fatal() */ |
391 | #else | |
392 | /*VARARGS1 */ | |
393 | as_fatal(Format, args) | |
394 | char *Format; | |
395 | { | |
396 | as_where(); | |
397 | fprintf(stderr,"FATAL:"); | |
398 | _doprnt (Format, &args, stderr); | |
399 | (void)putc ('\n', stderr); | |
400 | /* as_where(); */ | |
a39116f1 | 401 | exit(33); /* What is a good exit status? */ |
fecd2382 RP |
402 | } /* as_fatal() */ |
403 | #endif /* not NO_VARARGS */ | |
404 | #endif /* not NO_STDARG */ | |
405 | ||
406 | #ifdef DONTDEF | |
407 | void as_fatal(Format,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an) | |
408 | char *Format; | |
409 | { | |
410 | as_where(); | |
411 | fprintf (stderr, "FATAL:"); | |
412 | fprintf(stderr, Format,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an); | |
413 | (void) putc('\n', stderr); | |
a39116f1 | 414 | exit(33); |
fecd2382 RP |
415 | } /* as_fatal() */ |
416 | #endif | |
417 | ||
418 | /* end: messages.c */ |