1 /* messages.c - error reporter -
2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001, 2003
3 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
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
8 the Free Software Foundation; either version 2, or (at your option)
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.
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 the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
36 #if !defined (USE_STDARG) && !defined (USE_VARARGS)
40 typedef int * va_list;
41 #define va_start(ARGS) ARGS = &REST
45 static void identify (char *);
46 static void as_show_where (void);
47 static void as_warn_internal (char *, unsigned int, char *);
48 static void as_bad_internal (char *, unsigned int, char *);
50 /* Despite the rest of the comments in this file, (FIXME-SOON),
51 here is the current scheme for error messages etc:
53 as_fatal() is used when gas is quite confused and
54 continuing the assembly is pointless. In this case we
55 exit immediately with error status.
57 as_bad() is used to mark errors that result in what we
58 presume to be a useless object file. Say, we ignored
59 something that might have been vital. If we see any of
60 these, assembly will continue to the end of the source,
61 no object file will be produced, and we will terminate
62 with error status. The new option, -Z, tells us to
63 produce an object file anyway but we still exit with
64 error status. The assumption here is that you don't want
65 this object file but we could be wrong.
67 as_warn() is used when we have an error from which we
68 have a plausible error recovery. eg, masking the top
69 bits of a constant that is longer than will fit in the
70 destination. In this case we will continue to assemble
71 the source, although we may have made a bad assumption,
72 and we will produce an object file and return normal exit
73 status (ie, no error). The new option -X tells us to
74 treat all as_warn() errors as as_bad() errors. That is,
75 no object file will be produced and we will exit with
76 error status. The idea here is that we don't kill an
77 entire make because of an error that we knew how to
78 correct. On the other hand, sometimes you might want to
79 stop the make at these points.
81 as_tsktsk() is used when we see a minor error for which
82 our error recovery action is almost certainly correct.
83 In this case, we print a message and then assembly
84 continues as though no error occurred. */
89 static int identified
;
102 fprintf (stderr
, "%s: ", file
);
103 fprintf (stderr
, _("Assembler messages:\n"));
106 /* The number of warnings issued. */
107 static int warning_count
;
112 return warning_count
;
115 /* Nonzero if we've hit a 'bad error', and should not write an obj file,
116 and exit with a nonzero error code. */
118 static int error_count
;
126 /* Print the current location to stderr. */
134 as_where (&file
, &line
);
137 fprintf (stderr
, "%s:%u: ", file
, line
);
140 /* Like perror(3), but with more info. */
143 as_perror (const char *gripe
, /* Unpunctuated error theme. */
144 const char *filename
)
147 int saved_errno
= errno
;
150 fprintf (stderr
, gripe
, filename
);
153 errtxt
= bfd_errmsg (bfd_get_error ());
155 errtxt
= xstrerror (errno
);
157 fprintf (stderr
, ": %s\n", errtxt
);
160 bfd_set_error (bfd_error_no_error
);
164 /* Send to stderr a string as a warning, and locate warning
166 Please only use this for when we have some recovery action.
167 Please explain in string (which may have '\n's) what recovery was
172 as_tsktsk (const char *format
, ...)
177 va_start (args
, format
);
178 vfprintf (stderr
, format
, args
);
180 (void) putc ('\n', stderr
);
184 as_tsktsk (format
, va_alist
)
192 vfprintf (stderr
, format
, args
);
194 (void) putc ('\n', stderr
);
196 #endif /* not NO_STDARG */
198 /* The common portion of as_warn and as_warn_where. */
201 as_warn_internal (char *file
, unsigned int line
, char *buffer
)
206 as_where (&file
, &line
);
210 fprintf (stderr
, "%s:%u: ", file
, line
);
211 fprintf (stderr
, _("Warning: "));
212 fputs (buffer
, stderr
);
213 (void) putc ('\n', stderr
);
215 listing_warning (buffer
);
219 /* Send to stderr a string as a warning, and locate warning
221 Please only use this for when we have some recovery action.
222 Please explain in string (which may have '\n's) what recovery was
227 as_warn (const char *format
, ...)
232 if (!flag_no_warnings
)
234 va_start (args
, format
);
235 vsprintf (buffer
, format
, args
);
237 as_warn_internal ((char *) NULL
, 0, buffer
);
242 as_warn (format
, va_alist
)
249 if (!flag_no_warnings
)
252 vsprintf (buffer
, format
, args
);
254 as_warn_internal ((char *) NULL
, 0, buffer
);
257 #endif /* not NO_STDARG */
259 /* Like as_bad but the file name and line number are passed in.
260 Unfortunately, we have to repeat the function in order to handle
261 the varargs correctly and portably. */
265 as_warn_where (char *file
, unsigned int line
, const char *format
, ...)
270 if (!flag_no_warnings
)
272 va_start (args
, format
);
273 vsprintf (buffer
, format
, args
);
275 as_warn_internal (file
, line
, buffer
);
280 as_warn_where (file
, line
, format
, va_alist
)
289 if (!flag_no_warnings
)
292 vsprintf (buffer
, format
, args
);
294 as_warn_internal (file
, line
, buffer
);
297 #endif /* not NO_STDARG */
299 /* The common portion of as_bad and as_bad_where. */
302 as_bad_internal (char *file
, unsigned int line
, char *buffer
)
307 as_where (&file
, &line
);
311 fprintf (stderr
, "%s:%u: ", file
, line
);
312 fprintf (stderr
, _("Error: "));
313 fputs (buffer
, stderr
);
314 (void) putc ('\n', stderr
);
316 listing_error (buffer
);
320 /* Send to stderr a string as a warning, and locate warning in input
321 file(s). Please us when there is no recovery, but we want to
322 continue processing but not produce an object file.
323 Please explain in string (which may have '\n's) what recovery was
328 as_bad (const char *format
, ...)
333 va_start (args
, format
);
334 vsprintf (buffer
, format
, args
);
337 as_bad_internal ((char *) NULL
, 0, buffer
);
342 as_bad (format
, va_alist
)
350 vsprintf (buffer
, format
, args
);
353 as_bad_internal ((char *) NULL
, 0, buffer
);
355 #endif /* not NO_STDARG */
357 /* Like as_bad but the file name and line number are passed in.
358 Unfortunately, we have to repeat the function in order to handle
359 the varargs correctly and portably. */
363 as_bad_where (char *file
, unsigned int line
, const char *format
, ...)
368 va_start (args
, format
);
369 vsprintf (buffer
, format
, args
);
372 as_bad_internal (file
, line
, buffer
);
377 as_bad_where (file
, line
, format
, va_alist
)
387 vsprintf (buffer
, format
, args
);
390 as_bad_internal (file
, line
, buffer
);
392 #endif /* not NO_STDARG */
394 /* Send to stderr a string as a fatal message, and print location of
395 error in input file(s).
396 Please only use this for when we DON'T have some recovery action.
397 It xexit()s with a warning status. */
401 as_fatal (const char *format
, ...)
406 va_start (args
, format
);
407 fprintf (stderr
, _("Fatal error: "));
408 vfprintf (stderr
, format
, args
);
409 (void) putc ('\n', stderr
);
411 /* Delete the output file, if it exists. This will prevent make from
412 thinking that a file was created and hence does not need rebuilding. */
413 if (out_file_name
!= NULL
)
414 unlink (out_file_name
);
415 xexit (EXIT_FAILURE
);
419 as_fatal (format
, va_alist
)
427 fprintf (stderr
, _("Fatal error: "));
428 vfprintf (stderr
, format
, args
);
429 (void) putc ('\n', stderr
);
431 xexit (EXIT_FAILURE
);
433 #endif /* not NO_STDARG */
435 /* Indicate assertion failure.
436 Arguments: Filename, line number, optional function name. */
439 as_assert (const char *file
, int line
, const char *fn
)
442 fprintf (stderr
, _("Internal error!\n"));
444 fprintf (stderr
, _("Assertion failure in %s at %s line %d.\n"),
447 fprintf (stderr
, _("Assertion failure at %s line %d.\n"), file
, line
);
448 fprintf (stderr
, _("Please report this bug.\n"));
449 xexit (EXIT_FAILURE
);
452 /* as_abort: Print a friendly message saying how totally hosed we are,
453 and exit without producing a core file. */
456 as_abort (const char *file
, int line
, const char *fn
)
460 fprintf (stderr
, _("Internal error, aborting at %s line %d in %s\n"),
463 fprintf (stderr
, _("Internal error, aborting at %s line %d\n"),
465 fprintf (stderr
, _("Please report this bug.\n"));
466 xexit (EXIT_FAILURE
);
469 /* Support routines. */
472 fprint_value (FILE *file
, valueT val
)
474 if (sizeof (val
) <= sizeof (long))
476 fprintf (file
, "%ld", (long) val
);
480 if (sizeof (val
) <= sizeof (bfd_vma
))
482 fprintf_vma (file
, val
);
490 sprint_value (char *buf
, valueT val
)
492 if (sizeof (val
) <= sizeof (long))
494 sprintf (buf
, "%ld", (long) val
);
498 if (sizeof (val
) <= sizeof (bfd_vma
))
500 sprintf_vma (buf
, val
);
This page took 0.038789 seconds and 4 git commands to generate.