1 /* messages.c - error reporter -
2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2001,
4 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
37 #if !defined (USE_STDARG) && !defined (USE_VARARGS)
41 typedef int * va_list;
42 #define va_start(ARGS) ARGS = &REST
46 static void identify (char *);
47 static void as_show_where (void);
48 static void as_warn_internal (char *, unsigned int, char *);
49 static void as_bad_internal (char *, unsigned int, char *);
51 /* Despite the rest of the comments in this file, (FIXME-SOON),
52 here is the current scheme for error messages etc:
54 as_fatal() is used when gas is quite confused and
55 continuing the assembly is pointless. In this case we
56 exit immediately with error status.
58 as_bad() is used to mark errors that result in what we
59 presume to be a useless object file. Say, we ignored
60 something that might have been vital. If we see any of
61 these, assembly will continue to the end of the source,
62 no object file will be produced, and we will terminate
63 with error status. The new option, -Z, tells us to
64 produce an object file anyway but we still exit with
65 error status. The assumption here is that you don't want
66 this object file but we could be wrong.
68 as_warn() is used when we have an error from which we
69 have a plausible error recovery. eg, masking the top
70 bits of a constant that is longer than will fit in the
71 destination. In this case we will continue to assemble
72 the source, although we may have made a bad assumption,
73 and we will produce an object file and return normal exit
74 status (ie, no error). The new option -X tells us to
75 treat all as_warn() errors as as_bad() errors. That is,
76 no object file will be produced and we will exit with
77 error status. The idea here is that we don't kill an
78 entire make because of an error that we knew how to
79 correct. On the other hand, sometimes you might want to
80 stop the make at these points.
82 as_tsktsk() is used when we see a minor error for which
83 our error recovery action is almost certainly correct.
84 In this case, we print a message and then assembly
85 continues as though no error occurred. */
90 static int identified
;
103 fprintf (stderr
, "%s: ", file
);
104 fprintf (stderr
, _("Assembler messages:\n"));
107 /* The number of warnings issued. */
108 static int warning_count
;
113 return warning_count
;
116 /* Nonzero if we've hit a 'bad error', and should not write an obj file,
117 and exit with a nonzero error code. */
119 static int error_count
;
127 /* Print the current location to stderr. */
135 as_where (&file
, &line
);
138 fprintf (stderr
, "%s:%u: ", file
, line
);
141 /* Like perror(3), but with more info. */
144 as_perror (const char *gripe
, /* Unpunctuated error theme. */
145 const char *filename
)
148 int saved_errno
= errno
;
151 fprintf (stderr
, gripe
, filename
);
154 errtxt
= bfd_errmsg (bfd_get_error ());
156 errtxt
= xstrerror (errno
);
158 fprintf (stderr
, ": %s\n", errtxt
);
161 bfd_set_error (bfd_error_no_error
);
165 /* Send to stderr a string as a warning, and locate warning
167 Please only use this for when we have some recovery action.
168 Please explain in string (which may have '\n's) what recovery was
173 as_tsktsk (const char *format
, ...)
178 va_start (args
, format
);
179 vfprintf (stderr
, format
, args
);
181 (void) putc ('\n', stderr
);
185 as_tsktsk (format
, va_alist
)
193 vfprintf (stderr
, format
, args
);
195 (void) putc ('\n', stderr
);
197 #endif /* not NO_STDARG */
199 /* The common portion of as_warn and as_warn_where. */
202 as_warn_internal (char *file
, unsigned int line
, char *buffer
)
207 as_where (&file
, &line
);
211 fprintf (stderr
, "%s:%u: ", file
, line
);
212 fprintf (stderr
, _("Warning: "));
213 fputs (buffer
, stderr
);
214 (void) putc ('\n', stderr
);
216 listing_warning (buffer
);
220 /* Send to stderr a string as a warning, and locate warning
222 Please only use this for when we have some recovery action.
223 Please explain in string (which may have '\n's) what recovery was
228 as_warn (const char *format
, ...)
233 if (!flag_no_warnings
)
235 va_start (args
, format
);
236 vsprintf (buffer
, format
, args
);
238 as_warn_internal ((char *) NULL
, 0, buffer
);
243 as_warn (format
, va_alist
)
250 if (!flag_no_warnings
)
253 vsprintf (buffer
, format
, args
);
255 as_warn_internal ((char *) NULL
, 0, buffer
);
258 #endif /* not NO_STDARG */
260 /* Like as_bad but the file name and line number are passed in.
261 Unfortunately, we have to repeat the function in order to handle
262 the varargs correctly and portably. */
266 as_warn_where (char *file
, unsigned int line
, const char *format
, ...)
271 if (!flag_no_warnings
)
273 va_start (args
, format
);
274 vsprintf (buffer
, format
, args
);
276 as_warn_internal (file
, line
, buffer
);
281 as_warn_where (file
, line
, format
, va_alist
)
290 if (!flag_no_warnings
)
293 vsprintf (buffer
, format
, args
);
295 as_warn_internal (file
, line
, buffer
);
298 #endif /* not NO_STDARG */
300 /* The common portion of as_bad and as_bad_where. */
303 as_bad_internal (char *file
, unsigned int line
, char *buffer
)
308 as_where (&file
, &line
);
312 fprintf (stderr
, "%s:%u: ", file
, line
);
313 fprintf (stderr
, _("Error: "));
314 fputs (buffer
, stderr
);
315 (void) putc ('\n', stderr
);
317 listing_error (buffer
);
321 /* Send to stderr a string as a warning, and locate warning in input
322 file(s). Please us when there is no recovery, but we want to
323 continue processing but not produce an object file.
324 Please explain in string (which may have '\n's) what recovery was
329 as_bad (const char *format
, ...)
334 va_start (args
, format
);
335 vsprintf (buffer
, format
, args
);
338 as_bad_internal ((char *) NULL
, 0, buffer
);
343 as_bad (format
, va_alist
)
351 vsprintf (buffer
, format
, args
);
354 as_bad_internal ((char *) NULL
, 0, buffer
);
356 #endif /* not NO_STDARG */
358 /* Like as_bad but the file name and line number are passed in.
359 Unfortunately, we have to repeat the function in order to handle
360 the varargs correctly and portably. */
364 as_bad_where (char *file
, unsigned int line
, const char *format
, ...)
369 va_start (args
, format
);
370 vsprintf (buffer
, format
, args
);
373 as_bad_internal (file
, line
, buffer
);
378 as_bad_where (file
, line
, format
, va_alist
)
388 vsprintf (buffer
, format
, args
);
391 as_bad_internal (file
, line
, buffer
);
393 #endif /* not NO_STDARG */
395 /* Send to stderr a string as a fatal message, and print location of
396 error in input file(s).
397 Please only use this for when we DON'T have some recovery action.
398 It xexit()s with a warning status. */
402 as_fatal (const char *format
, ...)
407 va_start (args
, format
);
408 fprintf (stderr
, _("Fatal error: "));
409 vfprintf (stderr
, format
, args
);
410 (void) putc ('\n', stderr
);
412 /* Delete the output file, if it exists. This will prevent make from
413 thinking that a file was created and hence does not need rebuilding. */
414 if (out_file_name
!= NULL
)
415 unlink (out_file_name
);
416 xexit (EXIT_FAILURE
);
420 as_fatal (format
, va_alist
)
428 fprintf (stderr
, _("Fatal error: "));
429 vfprintf (stderr
, format
, args
);
430 (void) putc ('\n', stderr
);
432 xexit (EXIT_FAILURE
);
434 #endif /* not NO_STDARG */
436 /* Indicate assertion failure.
437 Arguments: Filename, line number, optional function name. */
440 as_assert (const char *file
, int line
, const char *fn
)
443 fprintf (stderr
, _("Internal error!\n"));
445 fprintf (stderr
, _("Assertion failure in %s at %s line %d.\n"),
448 fprintf (stderr
, _("Assertion failure at %s line %d.\n"), file
, line
);
449 fprintf (stderr
, _("Please report this bug.\n"));
450 xexit (EXIT_FAILURE
);
453 /* as_abort: Print a friendly message saying how totally hosed we are,
454 and exit without producing a core file. */
457 as_abort (const char *file
, int line
, const char *fn
)
461 fprintf (stderr
, _("Internal error, aborting at %s line %d in %s\n"),
464 fprintf (stderr
, _("Internal error, aborting at %s line %d\n"),
466 fprintf (stderr
, _("Please report this bug.\n"));
467 xexit (EXIT_FAILURE
);
470 /* Support routines. */
473 fprint_value (FILE *file
, valueT val
)
475 if (sizeof (val
) <= sizeof (long))
477 fprintf (file
, "%ld", (long) val
);
481 if (sizeof (val
) <= sizeof (bfd_vma
))
483 fprintf_vma (file
, val
);
491 sprint_value (char *buf
, valueT val
)
493 if (sizeof (val
) <= sizeof (long))
495 sprintf (buf
, "%ld", (long) val
);
499 if (sizeof (val
) <= sizeof (bfd_vma
))
501 sprintf_vma (buf
, val
);
508 #define HEX_MAX_THRESHOLD 1024
509 #define HEX_MIN_THRESHOLD -(HEX_MAX_THRESHOLD)
512 as_internal_value_out_of_range (char * prefix
,
526 if ( val
< HEX_MAX_THRESHOLD
527 && min
< HEX_MAX_THRESHOLD
528 && max
< HEX_MAX_THRESHOLD
529 && val
> HEX_MIN_THRESHOLD
530 && min
> HEX_MIN_THRESHOLD
531 && max
> HEX_MIN_THRESHOLD
)
534 /* xgettext:c-format */
535 err
= _("%s out of range (%d is not between %d and %d)");
538 as_bad_where (file
, line
, err
,
539 prefix
, (int) val
, (int) min
, (int) max
);
541 as_warn_where (file
, line
, err
,
542 prefix
, (int) val
, (int) min
, (int) max
);
547 char val_buf
[sizeof (val
) * 3 + 2];
548 char min_buf
[sizeof (val
) * 3 + 2];
549 char max_buf
[sizeof (val
) * 3 + 2];
551 if (sizeof (val
) > sizeof (bfd_vma
))
554 sprintf_vma (val_buf
, val
);
555 sprintf_vma (min_buf
, min
);
556 sprintf_vma (max_buf
, max
);
558 /* xgettext:c-format. */
559 err
= _("%s out of range (0x%s is not between 0x%s and 0x%s)");
562 as_bad_where (file
, line
, err
, prefix
, val_buf
, min_buf
, max_buf
);
564 as_warn_where (file
, line
, err
, prefix
, val_buf
, min_buf
, max_buf
);
570 as_warn_value_out_of_range (char * prefix
,
577 as_internal_value_out_of_range (prefix
, value
, min
, max
, file
, line
, 0);
581 as_bad_value_out_of_range (char * prefix
,
588 as_internal_value_out_of_range (prefix
, value
, min
, max
, file
, line
, 1);
This page took 0.041059 seconds and 4 git commands to generate.