1 /* Declaration for error-reporting function for Bison.
2
3 Copyright (C) 2000-2002, 2004-2006, 2009-2015, 2018-2021 Free
4 Software Foundation, Inc.
5
6 This program 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 3 of the License, or
9 (at your option) any later version.
10
11 This program 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.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <https://www.gnu.org/licenses/>. */
18
19 /* Based on error.c and error.h,
20 written by David MacKenzie <djm@gnu.ai.mit.edu>. */
21
22 #include <config.h>
23 #include "system.h"
24
25 #include <argmatch.h>
26 #include <c-ctype.h>
27 #include <progname.h>
28 #include <stdarg.h>
29 #include <sys/stat.h>
30 #include <textstyle.h>
31
32 #include "complain.h"
33 #include "files.h"
34 #include "fixits.h"
35 #include "getargs.h"
36 #include "quote.h"
37
38 // The URL of the manual page about diagnostics. Use the per-node
39 // manual, to avoid downloading repeatedly the whole manual over the
40 // Internet.
41 static const char *diagnostics_url
42 = "https://www.gnu.org/software/bison/manual/html_node/Diagnostics.html";
43
44
45 err_status complaint_status = status_none;
46
47 bool warnings_are_errors = false;
48
49 /** Whether -Werror/-Wno-error was applied to a warning. */
50 typedef enum
51 {
52 errority_unset = 0, /** No explicit status. */
53 errority_disabled = 1, /** Explicitly disabled with -Wno-error=foo. */
54 errority_enabled = 2 /** Explicitly enabled with -Werror=foo. */
55 } errority;
56
57 /** For each warning type, its errority. */
58 static errority errority_flag[warnings_size];
59
60 /** Diagnostics severity. */
61 typedef enum
62 {
63 severity_disabled = 0, /**< Explicitly disabled via -Wno-foo. */
64 severity_unset = 1, /**< Unspecified status. */
65 severity_warning = 2, /**< A warning. */
66 severity_error = 3, /**< An error (continue, but die soon). */
67 severity_fatal = 4 /**< Fatal error (die now). */
68 } severity;
69
70
71 /** For each warning type, its severity. */
72 static severity warnings_flag[warnings_size];
73
74 styled_ostream_t errstream = NULL;
75
76 void
77 begin_use_class (const char *s, FILE *out)
78 {
79 if (out == stderr)
80 {
81 if (color_debug)
82 fprintf (out, "<%s>", s);
83 else
84 {
85 styled_ostream_begin_use_class (errstream, s);
86 styled_ostream_flush_to_current_style (errstream);
87 }
88 }
89 }
90
91 void
92 end_use_class (const char *s, FILE *out)
93 {
94 if (out == stderr)
95 {
96 if (color_debug)
97 fprintf (out, "</%s>", s);
98 else
99 {
100 styled_ostream_end_use_class (errstream, s);
101 styled_ostream_flush_to_current_style (errstream);
102 }
103 }
104 }
105
106 static void
107 begin_hyperlink (FILE *out, const char *ref)
108 {
109 if (out == stderr)
110 styled_ostream_set_hyperlink (errstream, ref, NULL);
111 }
112
113 static void
114 end_hyperlink (FILE *out)
115 {
116 if (out == stderr)
117 styled_ostream_set_hyperlink (errstream, NULL, NULL);
118 }
119
120 void
121 flush (FILE *out)
122 {
123 if (out == stderr)
124 ostream_flush (errstream, FLUSH_THIS_STREAM);
125 fflush (out);
126 }
127
128 bool
129 is_styled (FILE *out)
130 {
131 if (out != stderr)
132 return false;
133 if (color_debug)
134 return true;
135 #if HAVE_LIBTEXTSTYLE
136 return (color_mode == color_yes
137 || color_mode == color_html
138 || (color_mode == color_tty && isatty (STDERR_FILENO)));
139 #else
140 return false;
141 #endif
142 }
143
144
145 /*------------------------.
146 | --warnings's handling. |
147 `------------------------*/
148
149 ARGMATCH_DEFINE_GROUP (warning, warnings)
150
151 static const argmatch_warning_doc argmatch_warning_docs[] =
152 {
153 { "conflicts-sr", N_("S/R conflicts (enabled by default)") },
154 { "conflicts-rr", N_("R/R conflicts (enabled by default)") },
155 { "counterexamples", N_("generate conflict counterexamples") },
156 { "dangling-alias", N_("string aliases not attached to a symbol") },
157 { "deprecated", N_("obsolete constructs") },
158 { "empty-rule", N_("empty rules without %empty") },
159 { "midrule-values", N_("unset or unused midrule values") },
160 { "precedence", N_("useless precedence and associativity") },
161 { "yacc", N_("incompatibilities with POSIX Yacc") },
162 { "other", N_("all other warnings (enabled by default)") },
163 { "all", N_("all the warnings except 'counterexamples', 'dangling-alias' and 'yacc'") },
164 { "no-CATEGORY", N_("turn off warnings in CATEGORY") },
165 { "none", N_("turn off all the warnings") },
166 { "error[=CATEGORY]", N_("treat warnings as errors") },
167 { NULL, NULL }
168 };
169
170 static const argmatch_warning_arg argmatch_warning_args[] =
171 {
172 { "all", Wall },
173 { "conflicts-rr", Wconflicts_rr },
174 { "conflicts-sr", Wconflicts_sr },
175 { "counterexamples", Wcounterexamples }, { "cex", Wcounterexamples }, // Show cex second.
176 { "dangling-alias", Wdangling_alias },
177 { "deprecated", Wdeprecated },
178 { "empty-rule", Wempty_rule },
179 { "everything", Weverything },
180 { "midrule-values", Wmidrule_values },
181 { "none", Wnone },
182 { "other", Wother },
183 { "precedence", Wprecedence },
184 { "yacc", Wyacc },
185 { NULL, Wnone }
186 };
187
188 const argmatch_warning_group_type argmatch_warning_group =
189 {
190 argmatch_warning_args,
191 argmatch_warning_docs,
192 N_("Warning categories include:"),
193 NULL
194 };
195
196 void
197 warning_usage (FILE *out)
198 {
199 argmatch_warning_usage (out);
200 }
201
202 void
203 warning_argmatch (char const *arg, size_t no, size_t err)
204 {
205 int value = *argmatch_warning_value ("--warning", arg + no + err);
206
207 /* -Wnone == -Wno-everything, and -Wno-none == -Weverything. */
208 if (!value)
209 {
210 value = Weverything;
211 no = !no;
212 }
213
214 for (size_t b = 0; b < warnings_size; ++b)
215 if (value & 1 << b)
216 {
217 if (err && no)
218 /* -Wno-error=foo. */
219 errority_flag[b] = errority_disabled;
220 else if (err && !no)
221 {
222 /* -Werror=foo: enables -Wfoo. */
223 errority_flag[b] = errority_enabled;
224 warnings_flag[b] = severity_warning;
225 }
226 else if (no)
227 /* -Wno-foo. */
228 warnings_flag[b] = severity_disabled;
229 else
230 /* -Wfoo. */
231 warnings_flag[b] = severity_warning;
232 }
233 }
234
235 /** Decode a comma-separated list of arguments from -W.
236 *
237 * \param args comma separated list of effective subarguments to decode.
238 * If 0, then activate all the flags.
239 */
240
241 void
242 warnings_argmatch (char *args)
243 {
244 if (!args)
245 warning_argmatch ("all", 0, 0);
246 else if (STREQ (args, "help"))
247 {
248 warning_usage (stdout);
249 exit (EXIT_SUCCESS);
250 }
251 else
252 for (args = strtok (args, ","); args; args = strtok (NULL, ","))
253 if (STREQ (args, "error"))
254 warnings_are_errors = true;
255 else if (STREQ (args, "no-error"))
256 warnings_are_errors = false;
257 else
258 {
259 /* The length of the possible 'no-' prefix: 3, or 0. */
260 size_t no = STRPREFIX_LIT ("no-", args) ? 3 : 0;
261 /* The length of the possible 'error=' (possibly after
262 'no-') prefix: 6, or 0. */
263 size_t err = STRPREFIX_LIT ("error=", args + no) ? 6 : 0;
264
265 warning_argmatch (args, no, err);
266 }
267 }
268
269 /* Color style for this type of message. */
270 static const char*
271 severity_style (severity s)
272 {
273 switch (s)
274 {
275 case severity_disabled:
276 case severity_unset:
277 return "note";
278 case severity_warning:
279 return "warning";
280 case severity_error:
281 case severity_fatal:
282 return "error";
283 }
284 abort ();
285 }
286
287 /* Prefix for this type of message. */
288 static const char*
289 severity_prefix (severity s)
290 {
291 switch (s)
292 {
293 case severity_disabled:
294 case severity_unset:
295 return "";
296 case severity_warning:
297 return _("warning");
298 case severity_error:
299 return _("error");
300 case severity_fatal:
301 return _("fatal error");
302 }
303 abort ();
304 }
305
306
307 static void
308 severity_print (severity s, FILE *out)
309 {
310 if (s != severity_disabled)
311 {
312 const char* style = severity_style (s);
313 begin_use_class (style, out);
314 fprintf (out, "%s:", severity_prefix (s));
315 end_use_class (style, out);
316 fputc (' ', out);
317 }
318 }
319
320
321 /*-----------.
322 | complain. |
323 `-----------*/
324
325 void
326 complain_init_color (void)
327 {
328 #if HAVE_LIBTEXTSTYLE
329 if (is_styled (stderr))
330 {
331 style_file_prepare ("BISON_STYLE", "BISON_STYLEDIR", pkgdatadir (),
332 "bison-default.css");
333 /* As a fallback, use the default in the current directory. */
334 struct stat statbuf;
335 if ((style_file_name == NULL || stat (style_file_name, &statbuf) < 0)
336 && stat ("bison-default.css", &statbuf) == 0)
337 style_file_name = "bison-default.css";
338 }
339 else
340 /* No styling. */
341 style_file_name = NULL;
342 #endif
343
344 /* Workaround clang's warning (starting at Clang 3.5) about the stub
345 code of html_styled_ostream_create:
346
347 | src/complain.c:274:7: error: code will never be executed [-Werror,-Wunreachable-code]
348 | ? html_styled_ostream_create (file_ostream_create (stderr),
349 | ^~~~~~~~~~~~~~~~~~~~~~~~~~ */
350 #if defined __clang__
351 # pragma clang diagnostic push
352 # pragma clang diagnostic ignored "-Wunreachable-code"
353 #endif
354 errstream =
355 color_mode == color_html
356 ? html_styled_ostream_create (file_ostream_create (stderr),
357 style_file_name)
358 : styled_ostream_create (STDERR_FILENO, "(stderr)", TTYCTL_AUTO,
359 style_file_name);
360 #if defined __clang__
361 # pragma clang diagnostic pop
362 #endif
363 }
364
365 void
366 complain_init (void)
367 {
368 caret_init ();
369
370 warnings warnings_default =
371 Wconflicts_sr | Wconflicts_rr | Wdeprecated | Wother;
372
373 for (size_t b = 0; b < warnings_size; ++b)
374 {
375 warnings_flag[b] = (1 << b & warnings_default
376 ? severity_warning
377 : severity_unset);
378 errority_flag[b] = errority_unset;
379 }
380 }
381
382 void
383 complain_free (void)
384 {
385 caret_free ();
386 styled_ostream_free (errstream);
387 }
388
389 /* A diagnostic with FLAGS is about to be issued. With what severity?
390 (severity_fatal, severity_error, severity_disabled, or
391 severity_warning.) */
392
393 static severity
394 warning_severity (warnings flags)
395 {
396 if (flags & fatal)
397 /* Diagnostics about fatal errors. */
398 return severity_fatal;
399 else if (flags & complaint)
400 /* Diagnostics about errors. */
401 return severity_error;
402 else
403 {
404 /* Diagnostics about warnings. */
405 severity res = severity_disabled;
406 for (size_t b = 0; b < warnings_size; ++b)
407 if (flags & 1 << b)
408 {
409 res = res < warnings_flag[b] ? warnings_flag[b] : res;
410 /* If the diagnostic is enabled, and -Werror is enabled,
411 and -Wno-error=foo was not explicitly requested, this
412 is an error. */
413 if (res == severity_warning
414 && (errority_flag[b] == errority_enabled
415 || (warnings_are_errors
416 && errority_flag[b] != errority_disabled)))
417 res = severity_error;
418 }
419 return res;
420 }
421 }
422
423 bool
424 warning_is_unset (warnings flags)
425 {
426 for (size_t b = 0; b < warnings_size; ++b)
427 if (flags & 1 << b && warnings_flag[b] != severity_unset)
428 return false;
429 return true;
430 }
431
432 bool
433 warning_is_enabled (warnings flags)
434 {
435 return severity_warning <= warning_severity (flags);
436 }
437
438 /** Display a "[-Wyacc]" like message on \a out. */
439
440 static void
441 warnings_print_categories (warnings warn_flags, FILE *out)
442 {
443 for (int wbit = 0; wbit < warnings_size; ++wbit)
444 if (warn_flags & (1 << wbit))
445 {
446 warnings w = 1 << wbit;
447 severity s = warning_severity (w);
448 const char* style = severity_style (s);
449 fputs (" [", out);
450 begin_use_class (style, out);
451 // E.g., "counterexamples".
452 const char *warning = argmatch_warning_argument (&w);
453 char ref[200];
454 snprintf (ref, sizeof ref,
455 "%s#W%s", diagnostics_url, warning);
456 begin_hyperlink (out, ref);
457 ostream_printf (errstream,
458 "-W%s%s",
459 s == severity_error ? "error=" : "",
460 warning);
461 end_hyperlink (out);
462 // Because we mix stdio with ostream I/O, we need to flush
463 // here for sake of color == debug.
464 flush (out);
465 end_use_class (style, out);
466 fputc (']', out);
467 /* Display only the first match, the second is "-Wall". */
468 return;
469 }
470 }
471
472 /** Report an error message.
473 *
474 * \param loc the location, defaulting to the current file,
475 * or the program name.
476 * \param flags the category for this message.
477 * \param sever to decide the prefix to put before the message
478 * (e.g., "warning").
479 * \param message the error message, a printf format string. Iff it
480 * ends with ": ", then no trailing newline is printed,
481 * and the caller should print the remaining
482 * newline-terminated message to stderr.
483 * \param args the arguments of the format string.
484 */
485 static
486 void
487 error_message (const location *loc, warnings flags,
488 severity sever, const char *message, va_list args)
489 {
490 const char* style = flags & note ? "note" : severity_style (sever);
491
492 if (loc)
493 location_print (*loc, stderr);
494 else
495 fprintf (stderr, "%s", grammar_file ? grammar_file : program_name);
496 fprintf (stderr, ": ");
497
498 if (sever != severity_disabled)
499 {
500 begin_use_class (style, stderr);
501 fprintf (stderr, "%s:", flags & note ? _("note") : severity_prefix (sever));
502 end_use_class (style, stderr);
503 fputc (' ', stderr);
504 }
505
506 vfprintf (stderr, message, args);
507 /* Print the type of warning, only if this is not a sub message
508 (in which case the prefix is null). */
509 if (! (flags & silent) && sever != severity_disabled)
510 warnings_print_categories (flags, stderr);
511
512 size_t l = strlen (message);
513 if (l < 2 || message[l - 2] != ':' || message[l - 1] != ' ')
514 {
515 putc ('\n', stderr);
516 flush (stderr);
517 if (loc && !(flags & no_caret))
518 location_caret (*loc, style, stderr);
519 }
520 flush (stderr);
521 }
522
523 /** Raise a complaint (fatal error, error or just warning). */
524
525 static void
526 complains (const location *loc, warnings flags,
527 const char *message, va_list args)
528 {
529 if ((flags & complaint) && complaint_status < status_complaint)
530 complaint_status = status_complaint;
531
532 severity s = warning_severity (flags);
533 if (severity_warning <= s)
534 {
535 if (severity_error <= s && ! complaint_status)
536 complaint_status = status_warning_as_error;
537 error_message (loc, flags, s, message, args);
538 }
539
540 if (flags & fatal)
541 exit (EXIT_FAILURE);
542 }
543
544 void
545 complain (location const *loc, warnings flags, const char *message, ...)
546 {
547 va_list args;
548 va_start (args, message);
549 complains (loc, flags, message, args);
550 va_end (args);
551 }
552
553 void
554 subcomplain (location const *loc, warnings flags, const char *message, ...)
555 {
556 va_list args;
557 va_start (args, message);
558 complains (loc, flags | note | silent, message, args);
559 va_end (args);
560 }
561
562 void
563 complain_args (location const *loc, warnings w,
564 int argc, char *argv[])
565 {
566 switch (argc)
567 {
568 case 1:
569 complain (loc, w, "%s", _(argv[0]));
570 break;
571 case 2:
572 complain (loc, w, _(argv[0]), argv[1]);
573 break;
574 case 3:
575 complain (loc, w, _(argv[0]), argv[1], argv[2]);
576 break;
577 case 4:
578 complain (loc, w, _(argv[0]), argv[1], argv[2], argv[3]);
579 break;
580 case 5:
581 complain (loc, w, _(argv[0]), argv[1], argv[2], argv[3], argv[4]);
582 break;
583 default:
584 complain (loc, fatal, "too many arguments for complains");
585 break;
586 }
587 }
588
589
590 void
591 bison_directive (location const *loc, char const *directive)
592 {
593 complain (loc, Wyacc,
594 _("POSIX Yacc does not support %s"), directive);
595 }
596
597 void
598 deprecated_directive (location const *loc, char const *old, char const *upd)
599 {
600 if (warning_is_enabled (Wdeprecated))
601 {
602 complain (loc, Wdeprecated,
603 _("deprecated directive: %s, use %s"),
604 quote (old), quote_n (1, upd));
605 location_caret_suggestion (*loc, upd, stderr);
606 /* Register updates only if -Wdeprecated is enabled. */
607 fixits_register (loc, upd);
608 }
609 }
610
611 void
612 duplicate_directive (char const *directive,
613 location first, location second)
614 {
615 if (feature_flag & feature_caret)
616 complain (&second, Wother, _("duplicate directive"));
617 else
618 complain (&second, Wother, _("duplicate directive: %s"), quote (directive));
619 subcomplain (&first, Wother, _("previous declaration"));
620 fixits_register (&second, "");
621 }
622
623 void
624 duplicate_rule_directive (char const *directive,
625 location first, location second)
626 {
627 complain (&second, complaint, _("only one %s allowed per rule"), directive);
628 subcomplain (&first, complaint, _("previous declaration"));
629 fixits_register (&second, "");
630 }
631
632 void
633 syntax_error (location loc,
634 int argc, const char* argv[])
635 {
636 if (complaint_status < status_complaint)
637 complaint_status = status_complaint;
638 assert (argc <= 5);
639 const char *format = NULL;
640 switch (argc)
641 {
642 #define CASE(N, S) \
643 case N: \
644 format = S; \
645 break
646 default: /* Avoid compiler warnings. */
647 CASE (0, _("syntax error"));
648 CASE (1, _("unexpected %0$s"));
649 CASE (2, _("expected %1$s before %0$s"));
650 CASE (3, _("expected %1$s or %2$s before %0$s"));
651 CASE (4, _("expected %1$s or %2$s or %3$s before %0$s"));
652 CASE (5, _("expected %1$s or %2$s or %3$s or %4$s before %0$s"));
653 #undef CASE
654 }
655 location_print (loc, stderr);
656 fputs (": ", stderr);
657 severity_print (severity_error, stderr);
658
659 while (*format)
660 if (format[0] == '%'
661 && c_isdigit (format[1])
662 && format[2] == '$'
663 && format[3] == 's'
664 && (format[1] - '0') < argc)
665 {
666 int i = format[1] - '0';
667 const char *style = i == 0 ? "unexpected" : "expected";
668 begin_use_class (style, stderr);
669 fputs (argv[i], stderr);
670 end_use_class (style, stderr);
671 format += 4;
672 }
673 else
674 {
675 fputc (*format, stderr);
676 ++format;
677 }
678 fputc ('\n', stderr);
679 location_caret (loc, "error", stderr);
680 }