2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Contributed by Andy Vaught & Niels Kristian Bech Jensen
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
23 /* Handle the inevitable errors. A major catch here is that things
24 flagged as errors in one match subroutine can conceivably be legal
25 elsewhere. This means that error messages are recorded and saved
26 for possible use later. If a line does not match a legal
27 construction, then the saved error message is reported. */
34 int gfc_suppress_error = 0;
36 static int terminal_width, buffer_flag, errors, warnings;
38 static gfc_error_buf error_buffer, warning_buffer, *cur_error_buffer;
41 /* Per-file error initialization. */
44 gfc_error_init_1 (void)
46 terminal_width = gfc_terminal_width ();
53 /* Set the flag for buffering errors or not. */
56 gfc_buffer_error (int flag)
62 /* Add a single character to the error buffer or output depending on
70 if (cur_error_buffer->index >= cur_error_buffer->allocated)
72 cur_error_buffer->allocated = cur_error_buffer->allocated
73 ? cur_error_buffer->allocated * 2 : 1000;
74 cur_error_buffer->message = xrealloc (cur_error_buffer->message,
75 cur_error_buffer->allocated);
77 cur_error_buffer->message[cur_error_buffer->index++] = c;
83 /* We build up complete lines before handing things
84 over to the library in order to speed up error printing. */
86 static size_t allocated = 0, index = 0;
88 if (index + 1 >= allocated)
90 allocated = allocated ? allocated * 2 : 1000;
91 line = xrealloc (line, allocated);
105 /* Copy a string to wherever it needs to go. */
108 error_string (const char *p)
115 /* Print a formatted integer to the error buffer or output. */
120 error_integer (int i)
122 char *p, int_buf[IBUF_LEN];
130 p = int_buf + IBUF_LEN - 1;
142 error_string (p + 1);
146 /* Show the file, where it was included, and the source line, give a
147 locus. Calls error_printf() recursively, but the recursion is at
148 most one level deep. */
150 static void error_printf (const char *, ...) ATTRIBUTE_GCC_GFC(1,2);
153 show_locus (locus *loc, int c1, int c2)
158 int i, m, offset, cmax;
160 /* TODO: Either limit the total length and number of included files
161 displayed or add buffering of arbitrary number of characters in
164 /* Write out the error header line, giving the source file and error
165 location (in GNU standard "[file]:[line].[column]:" format),
166 followed by an "included by" stack and a blank line. This header
167 format is matched by a testsuite parser defined in
168 lib/gfortran-dg.exp. */
173 error_string (f->filename);
176 #ifdef USE_MAPPED_LOCATION
177 error_integer (LOCATION_LINE (lb->location));
179 error_integer (lb->linenum);
182 if ((c1 > 0) || (c2 > 0))
188 if ((c1 > 0) && (c2 > 0))
199 i = f->inclusion_line;
202 if (f == NULL) break;
204 error_printf (" Included at %s:%d:", f->filename, i);
209 /* Calculate an appropriate horizontal offset of the source line in
210 order to get the error locus within the visible portion of the
211 line. Note that if the margin of 5 here is changed, the
212 corresponding margin of 10 in show_loci should be changed. */
216 /* When the loci is not associated with a column, it will have a
217 value of zero. We adjust this to 1 so that it will appear. */
224 /* If the two loci would appear in the same column, we shift
225 '2' one column to the right, so as to print '12' rather than
226 just '1'. We do this here so it will be accounted for in the
227 margin calculations. */
232 cmax = (c1 < c2) ? c2 : c1;
233 if (cmax > terminal_width - 5)
234 offset = cmax - terminal_width + 5;
236 /* TODO: Is there a good reason for the following apparently-redundant
237 check, and the similar ones in the single-locus cases below? */
242 /* Show the line itself, taking care not to print more than what can
243 show up on the terminal. Tabs are converted to spaces, and
244 nonprintable characters are converted to a "\xNN" sequence. */
246 /* TODO: Although setting i to the terminal width is clever, it fails
247 to work correctly when nonprintable characters exist. A better
248 solution should be found. */
250 p = lb->line + offset;
252 if (i > terminal_width)
253 i = terminal_width - 1;
268 m = ((c >> 4) & 0x0F) + '0';
273 m = (c & 0x0F) + '0';
282 /* Show the '1' and/or '2' corresponding to the column of the error
283 locus. Note that a value of -1 for c1 or c2 will simply cause
284 the relevant number not to be printed. */
289 for (i = 1; i <= cmax; i++)
304 /* As part of printing an error, we show the source lines that caused
305 the problem. We show at least one, and possibly two loci; the two
306 loci may or may not be on the same source line. */
309 show_loci (locus *l1, locus *l2)
313 if (l1 == NULL || l1->lb == NULL)
315 error_printf ("<During initialization>\n");
319 /* While calculating parameters for printing the loci, we consider possible
320 reasons for printing one per line. If appropriate, print the loci
321 individually; otherwise we print them both on the same line. */
323 c1 = l1->nextc - l1->lb->line;
326 show_locus (l1, c1, -1);
330 c2 = l2->nextc - l2->lb->line;
337 /* Note that the margin value of 10 here needs to be less than the
338 margin of 5 used in the calculation of offset in show_locus. */
340 if (l1->lb != l2->lb || m > terminal_width - 10)
342 show_locus (l1, c1, -1);
343 show_locus (l2, -1, c2);
347 show_locus (l1, c1, c2);
353 /* Workhorse for the error printing subroutines. This subroutine is
354 inspired by g77's error handling and is similar to printf() with
355 the following %-codes:
357 %c Character, %d or %i Integer, %s String, %% Percent
358 %L Takes locus argument
359 %C Current locus (no argument)
361 If a locus pointer is given, the actual source line is printed out
362 and the column is indicated. Since we want the error message at
363 the bottom of any source file information, we must scan the
364 argument list twice -- once to determine whether the loci are
365 present and record this for printing, and once to print the error
366 message after and loci have been printed. A maximum of two locus
367 arguments are permitted.
369 This function is also called (recursively) by show_locus in the
370 case of included files; however, as show_locus does not resupply
371 any loci, the recursion is at most one level deep. */
375 static void ATTRIBUTE_GCC_GFC(2,0)
376 error_print (const char *type, const char *format0, va_list argp)
378 enum { TYPE_CURRENTLOC, TYPE_LOCUS, TYPE_INTEGER, TYPE_CHAR, TYPE_STRING,
388 const char * stringval;
390 } arg[MAX_ARGS], spec[MAX_ARGS];
391 /* spec is the array of specifiers, in the same order as they
392 appear in the format string. arg is the array of arguments,
393 in the same order as they appear in the va_list. */
396 int i, n, have_l1, pos, maxpos;
397 locus *l1, *l2, *loc;
409 for (i = 0; i < MAX_ARGS; i++)
411 arg[i].type = NOTYPE;
415 /* First parse the format string for position specifiers. */
425 if (ISDIGIT (*format))
427 /* This is a position specifier. For example, the number
428 12 in the format string "%12$d", which specifies the third
429 argument of the va_list, formatted in %d format.
430 For details, see "man 3 printf". */
431 pos = atoi(format) - 1;
432 gcc_assert (pos >= 0);
433 while (ISDIGIT(*format))
435 gcc_assert (*format++ == '$');
448 arg[pos].type = TYPE_CURRENTLOC;
452 arg[pos].type = TYPE_LOCUS;
457 arg[pos].type = TYPE_INTEGER;
461 arg[pos].type = TYPE_CHAR;
465 arg[pos].type = TYPE_STRING;
475 /* Then convert the values for each %-style argument. */
476 for (pos = 0; pos <= maxpos; pos++)
478 gcc_assert (arg[pos].type != NOTYPE);
479 switch (arg[pos].type)
481 case TYPE_CURRENTLOC:
482 loc = &gfc_current_locus;
486 if (arg[pos].type == TYPE_LOCUS)
487 loc = va_arg (argp, locus *);
492 arg[pos].u.stringval = "(2)";
498 arg[pos].u.stringval = "(1)";
503 arg[pos].u.intval = va_arg (argp, int);
507 arg[pos].u.charval = (char) va_arg (argp, int);
511 arg[pos].u.stringval = (const char *) va_arg (argp, char *);
519 for (n = 0; spec[n].pos >= 0; n++)
520 spec[n].u = arg[spec[n].pos].u;
522 /* Show the current loci if we have to. */
536 for (; *format; format++)
540 error_char (*format);
545 if (ISDIGIT (*format))
547 /* This is a position specifier. See comment above. */
548 while (ISDIGIT (*format))
551 /* Skip over the dollar sign. */
562 error_char (spec[n++].u.charval);
566 case 'C': /* Current locus */
567 case 'L': /* Specified locus */
568 error_string (spec[n++].u.stringval);
573 error_integer (spec[n++].u.intval);
582 /* Wrapper for error_print(). */
585 error_printf (const char *nocmsgid, ...)
589 va_start (argp, nocmsgid);
590 error_print ("", _(nocmsgid), argp);
595 /* Increment the number of errors, and check whether too many have
599 gfc_increment_error_count (void)
602 if ((gfc_option.max_errors != 0) && (errors >= gfc_option.max_errors))
603 gfc_fatal_error ("Error count reached limit of %d.", gfc_option.max_errors);
607 /* Issue a warning. */
610 gfc_warning (const char *nocmsgid, ...)
614 if (inhibit_warnings)
617 warning_buffer.flag = 1;
618 warning_buffer.index = 0;
619 cur_error_buffer = &warning_buffer;
621 va_start (argp, nocmsgid);
622 error_print (_("Warning:"), _(nocmsgid), argp);
627 if (buffer_flag == 0)
630 if (warnings_are_errors)
631 gfc_increment_error_count();
636 /* Whether, for a feature included in a given standard set (GFC_STD_*),
637 we should issue an error or a warning, or be quiet. */
640 gfc_notification_std (int std)
644 warning = ((gfc_option.warn_std & std) != 0) && !inhibit_warnings;
645 if ((gfc_option.allow_std & std) != 0 && !warning)
648 return warning ? WARNING : ERROR;
652 /* Possibly issue a warning/error about use of a nonstandard (or deleted)
653 feature. An error/warning will be issued if the currently selected
654 standard does not contain the requested bits. Return FAILURE if
655 an error is generated. */
658 gfc_notify_std (int std, const char *nocmsgid, ...)
663 warning = ((gfc_option.warn_std & std) != 0) && !inhibit_warnings;
664 if ((gfc_option.allow_std & std) != 0 && !warning)
667 if (gfc_suppress_error)
668 return warning ? SUCCESS : FAILURE;
670 cur_error_buffer = (warning && !warnings_are_errors)
671 ? &warning_buffer : &error_buffer;
672 cur_error_buffer->flag = 1;
673 cur_error_buffer->index = 0;
675 va_start (argp, nocmsgid);
677 error_print (_("Warning:"), _(nocmsgid), argp);
679 error_print (_("Error:"), _(nocmsgid), argp);
684 if (buffer_flag == 0)
686 if (warning && !warnings_are_errors)
689 gfc_increment_error_count();
692 return (warning && !warnings_are_errors) ? SUCCESS : FAILURE;
696 /* Immediate warning (i.e. do not buffer the warning). */
699 gfc_warning_now (const char *nocmsgid, ...)
704 if (inhibit_warnings)
710 if (warnings_are_errors)
711 gfc_increment_error_count();
713 va_start (argp, nocmsgid);
714 error_print (_("Warning:"), _(nocmsgid), argp);
722 /* Clear the warning flag. */
725 gfc_clear_warning (void)
727 warning_buffer.flag = 0;
731 /* Check to see if any warnings have been saved.
732 If so, print the warning. */
735 gfc_warning_check (void)
737 if (warning_buffer.flag)
740 if (warning_buffer.message != NULL)
741 fputs (warning_buffer.message, stderr);
742 warning_buffer.flag = 0;
747 /* Issue an error. */
750 gfc_error (const char *nocmsgid, ...)
754 if (gfc_suppress_error)
757 error_buffer.flag = 1;
758 error_buffer.index = 0;
759 cur_error_buffer = &error_buffer;
761 va_start (argp, nocmsgid);
762 error_print (_("Error:"), _(nocmsgid), argp);
767 if (buffer_flag == 0)
768 gfc_increment_error_count();
772 /* Immediate error. */
775 gfc_error_now (const char *nocmsgid, ...)
780 error_buffer.flag = 1;
781 error_buffer.index = 0;
782 cur_error_buffer = &error_buffer;
787 va_start (argp, nocmsgid);
788 error_print (_("Error:"), _(nocmsgid), argp);
793 gfc_increment_error_count();
797 if (flag_fatal_errors)
802 /* Fatal error, never returns. */
805 gfc_fatal_error (const char *nocmsgid, ...)
811 va_start (argp, nocmsgid);
812 error_print (_("Fatal Error:"), _(nocmsgid), argp);
819 /* This shouldn't happen... but sometimes does. */
822 gfc_internal_error (const char *format, ...)
828 va_start (argp, format);
830 show_loci (&gfc_current_locus, NULL);
831 error_printf ("Internal Error at (1):");
833 error_print ("", format, argp);
836 exit (ICE_EXIT_CODE);
840 /* Clear the error flag when we start to compile a source line. */
843 gfc_clear_error (void)
845 error_buffer.flag = 0;
849 /* Tests the state of error_flag. */
852 gfc_error_flag_test (void)
854 return error_buffer.flag;
858 /* Check to see if any errors have been saved.
859 If so, print the error. Returns the state of error_flag. */
862 gfc_error_check (void)
866 rc = error_buffer.flag;
868 if (error_buffer.flag)
870 if (error_buffer.message != NULL)
871 fputs (error_buffer.message, stderr);
872 error_buffer.flag = 0;
874 gfc_increment_error_count();
876 if (flag_fatal_errors)
884 /* Save the existing error state. */
887 gfc_push_error (gfc_error_buf *err)
889 err->flag = error_buffer.flag;
890 if (error_buffer.flag)
891 err->message = xstrdup (error_buffer.message);
893 error_buffer.flag = 0;
897 /* Restore a previous pushed error state. */
900 gfc_pop_error (gfc_error_buf *err)
902 error_buffer.flag = err->flag;
903 if (error_buffer.flag)
905 size_t len = strlen (err->message) + 1;
906 gcc_assert (len <= error_buffer.allocated);
907 memcpy (error_buffer.message, err->message, len);
908 gfc_free (err->message);
913 /* Free a pushed error state, but keep the current error state. */
916 gfc_free_error (gfc_error_buf *err)
919 gfc_free (err->message);
923 /* Debug wrapper for printf. */
926 gfc_status (const char *cmsgid, ...)
930 va_start (argp, cmsgid);
932 vprintf (_(cmsgid), argp);
938 /* Subroutine for outputting a single char so that we don't have to go
939 around creating a lot of 1-character strings. */
942 gfc_status_char (char c)
948 /* Report the number of warnings and errors that occurred to the caller. */
951 gfc_get_errors (int *w, int *e)