+2002-04-14 Neil Booth <neil@daikokuya.demon.co.uk>
+
+ * cpperror.c (print_location): Don't print include chain
+ if line == 0.
+ (cpp_begin_message): Update to use DL_ macros.
+ (cpp_ice, cpp_fatal, cpp_error_from_errno, cpp_warning,
+ cpp_warning_with_line, cpp_pedwarn, cpp_pedwarn_with_line,
+ cpp_notice, cpp_notice_from_errno): Remove.
+ (cpp_error, cpp_error_with_line): Update to take a diagnostic
+ level.
+ (cpp_errno): New.
+ * cppexp.c (CPP_ICE): Remove.
+ (SYNTAX_ERROR, SYNTAX_ERROR2, parse_number, parse_defined,
+ lex, integer_overflow, _cpp_parse_expr): Update.
+ * cppfiles.c (read_include_file, find_include_file,
+ handle_missing_header, _cpp_read_file, remap_filename): Update.
+ * cpphash.h (enum error_type): Remove.
+ (_cpp_begin_message): Update.
+ * cppinit.c (append_include_chain, remove_dup_dirs, output_deps,
+ cpp_handle_option, cpp_post_options): Update.
+ * cpplex.c (trigraph_p, skip_escaped_newlines, skip_block_comment,
+ skip_whitespace, parse_identifier, parse_slow, parse_string,
+ _cpp_lex_direct, cpp_spell_token, maybe_read_ucs, cpp_parse_escape,
+ cpp_interpret_charconst): Update.
+ * cpplib.c (check_eol, directive_diagnostics, _cpp_handle_directive,
+ lex_macro_node, do_undef, glue_header_name, parse_include,
+ do_include_common, read_flag, do_line, do_linemarker, do_ident,
+ cpp_register_pragma, do_pragma_once, do_pragma_system_header,
+ do_pragma_poison, do_pragma_dependency, _cpp_do__Pragma, do_else,
+ do_elif, do_endif, parse_answer, parse_assertion, do_assert,
+ _cpp_pop_buffer, do_diagnostic): Update.
+ * cpplib.h (DL_WARNING, DL_WARNING_SYSHDR, DL_PEDWARN, DL_ERROR,
+ DL_FATAL, DL_ICE, DL_EXTRACT, DL_WARNING_P): New.
+ (cpp_ice, cpp_fatal, cpp_error_from_errno, cpp_warning,
+ cpp_warning_with_line, cpp_pedwarn, cpp_pedwarn_with_line,
+ cpp_notice, cpp_notice_from_errno): Remove.
+ (cpp_error, cpp_error_with_line): Update to take a diagnostic
+ level.
+ (cpp_errno): New.
+ * cppmacro.c (builtin_macro, stringify_arg, paste_all_tokens,
+ collect_args, enter_macro_context, save_parameter, parse_params,
+ _cpp_create_definition, check_trad_stringification,
+ cpp_macro_definition): Update.
+ * cppmain.c (cpp_preprocess_file): Update.
+ * fix-header.c (read_scan_file): Update.
+
2002-04-14 Andreas Schwab <schwab@suse.de>
* config/ia64/linux.h (CPP_PREDEFINES): Fix missing backslash.
static void print_location PARAMS ((cpp_reader *, unsigned int, unsigned int));
-/* Don't remove the blank before do, as otherwise the exgettext
- script will mistake this as a function definition */
-#define v_message(msgid, ap) \
- do { vfprintf (stderr, _(msgid), ap); putc ('\n', stderr); } while (0)
-
/* Print the logical file location (LINE, COL) in preparation for a
- diagnostic. Outputs the #include chain if it has changed. */
+ diagnostic. Outputs the #include chain if it has changed. A line
+ of zero suppresses the include stack, and outputs the program name
+ instead. */
static void
print_location (pfile, line, col)
cpp_reader *pfile;
unsigned int line, col;
{
- cpp_buffer *buffer = pfile->buffer;
-
- if (!buffer)
+ if (!pfile->buffer || line == 0)
fprintf (stderr, "%s: ", progname);
else
{
const struct line_map *map;
- if (line == 0)
- {
- line = pfile->cur_token[-1].line;
- col = pfile->cur_token[-1].col;
- }
-
map = lookup_line (&pfile->line_maps, line);
print_containing_files (&pfile->line_maps, map);
}
}
-/* Set up for an error message: print the file and line, bump the error
+/* Set up for a diagnostic: print the file and line, bump the error
counter, etc. LINE is the logical line number; zero means to print
- at the location of the previously lexed token, which tends to be the
- correct place by default. Returns 0 if the error has been suppressed. */
+ at the location of the previously lexed token, which tends to be
+ the correct place by default. Returns 0 if the error has been
+ suppressed. */
int
_cpp_begin_message (pfile, code, line, column)
cpp_reader *pfile;
- enum error_type code;
+ int code;
unsigned int line, column;
{
- int is_warning = 0;
+ int level = DL_EXTRACT (code);
- switch (code)
+ switch (level)
{
- case PEDWARN:
- case WARNING:
+ case DL_WARNING:
+ case DL_PEDWARN:
if (CPP_IN_SYSTEM_HEADER (pfile)
&& ! CPP_OPTION (pfile, warn_system_headers))
return 0;
- case WARNING_SYSHDR:
+ /* Fall through. */
+
+ case DL_WARNING_SYSHDR:
if (CPP_OPTION (pfile, warnings_are_errors)
- || (code == PEDWARN && CPP_OPTION (pfile, pedantic_errors)))
+ || (level == DL_PEDWARN && CPP_OPTION (pfile, pedantic_errors)))
{
if (CPP_OPTION (pfile, inhibit_errors))
return 0;
if (pfile->errors < CPP_FATAL_LIMIT)
pfile->errors++;
}
- else
- {
- if (CPP_OPTION (pfile, inhibit_warnings))
- return 0;
- is_warning = 1;
- }
+ else if (CPP_OPTION (pfile, inhibit_warnings))
+ return 0;
break;
- case ERROR:
+ case DL_ERROR:
if (CPP_OPTION (pfile, inhibit_errors))
return 0;
if (pfile->errors < CPP_FATAL_LIMIT)
pfile->errors++;
break;
+
/* Fatal errors cannot be inhibited. */
- case FATAL:
- pfile->errors = CPP_FATAL_LIMIT;
- break;
- case ICE:
- fprintf (stderr, _("internal error: "));
+ case DL_FATAL:
+ case DL_ICE:
pfile->errors = CPP_FATAL_LIMIT;
break;
}
print_location (pfile, line, column);
- if (is_warning)
+ if (DL_WARNING_P (level))
fputs (_("warning: "), stderr);
+ else if (level == DL_ICE)
+ fputs (_("internal error: "), stderr);
return 1;
}
-/* Exported interface. */
-
-/* For reporting internal errors. Prints "internal error: " for you,
- otherwise identical to cpp_fatal. */
-void
-cpp_ice VPARAMS ((cpp_reader *pfile, const char *msgid, ...))
-{
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, cpp_reader *, pfile);
- VA_FIXEDARG (ap, const char *, msgid);
-
- if (_cpp_begin_message (pfile, ICE, 0, 0))
- v_message (msgid, ap);
-
- VA_CLOSE (ap);
-}
-
-/* Same as cpp_error, except we consider the error to be "fatal",
- such as inconsistent options. I.e. there is little point in continuing.
- (We do not exit, to support use of cpplib as a library.
- Instead, it is the caller's responsibility to check
- CPP_FATAL_ERRORS. */
-void
-cpp_fatal VPARAMS ((cpp_reader *pfile, const char *msgid, ...))
-{
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, cpp_reader *, pfile);
- VA_FIXEDARG (ap, const char *, msgid);
-
- if (_cpp_begin_message (pfile, FATAL, 0, 0))
- v_message (msgid, ap);
+/* Don't remove the blank before do, as otherwise the exgettext
+ script will mistake this as a function definition */
+#define v_message(msgid, ap) \
+ do { vfprintf (stderr, _(msgid), ap); putc ('\n', stderr); } while (0)
- VA_CLOSE (ap);
-}
+/* Exported interface. */
/* Print an error at the location of the previously lexed token. */
void
-cpp_error VPARAMS ((cpp_reader * pfile, const char *msgid, ...))
-{
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, cpp_reader *, pfile);
- VA_FIXEDARG (ap, const char *, msgid);
-
- if (_cpp_begin_message (pfile, ERROR, 0, 0))
- v_message (msgid, ap);
-
- VA_CLOSE (ap);
-}
-
-/* Print an error at a specific location. */
-void
-cpp_error_with_line VPARAMS ((cpp_reader *pfile, int line, int column,
- const char *msgid, ...))
+cpp_error VPARAMS ((cpp_reader * pfile, int level, const char *msgid, ...))
{
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, cpp_reader *, pfile);
- VA_FIXEDARG (ap, int, line);
- VA_FIXEDARG (ap, int, column);
- VA_FIXEDARG (ap, const char *, msgid);
-
- if (_cpp_begin_message (pfile, ERROR, line, column))
- v_message (msgid, ap);
+ unsigned int line, column;
- VA_CLOSE (ap);
-}
-
-/* Error including a message from `errno'. */
-void
-cpp_error_from_errno (pfile, name)
- cpp_reader *pfile;
- const char *name;
-{
- cpp_error (pfile, "%s: %s", name, xstrerror (errno));
-}
-
-/* Print a warning at the location of the previously lexed token. */
-void
-cpp_warning VPARAMS ((cpp_reader * pfile, const char *msgid, ...))
-{
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, cpp_reader *, pfile);
- VA_FIXEDARG (ap, const char *, msgid);
-
- if (_cpp_begin_message (pfile, WARNING, 0, 0))
- v_message (msgid, ap);
-
- VA_CLOSE (ap);
-}
-
-/* Print a warning at a specific location. */
-void
-cpp_warning_with_line VPARAMS ((cpp_reader * pfile, int line, int column,
- const char *msgid, ...))
-{
VA_OPEN (ap, msgid);
VA_FIXEDARG (ap, cpp_reader *, pfile);
- VA_FIXEDARG (ap, int, line);
- VA_FIXEDARG (ap, int, column);
+ VA_FIXEDARG (ap, int, level);
VA_FIXEDARG (ap, const char *, msgid);
- if (_cpp_begin_message (pfile, WARNING, line, column))
- v_message (msgid, ap);
-
- VA_CLOSE (ap);
-}
-
-/* Pedwarn at the location of the previously lexed token. */
-void
-cpp_pedwarn VPARAMS ((cpp_reader * pfile, const char *msgid, ...))
-{
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, cpp_reader *, pfile);
- VA_FIXEDARG (ap, const char *, msgid);
+ if (pfile->buffer)
+ {
+ line = pfile->cur_token[-1].line;
+ column = pfile->cur_token[-1].col;
+ }
+ else
+ line = column = 0;
- if (_cpp_begin_message (pfile, PEDWARN, 0, 0))
+ if (_cpp_begin_message (pfile, level, line, column))
v_message (msgid, ap);
VA_CLOSE (ap);
}
-/* Pedwarn at a specific location. */
+/* Print an error at a specific location. */
void
-cpp_pedwarn_with_line VPARAMS ((cpp_reader * pfile, int line, int column,
- const char *msgid, ...))
+cpp_error_with_line VPARAMS ((cpp_reader *pfile, int level,
+ unsigned int line, unsigned int column,
+ const char *msgid, ...))
{
VA_OPEN (ap, msgid);
VA_FIXEDARG (ap, cpp_reader *, pfile);
- VA_FIXEDARG (ap, int, line);
- VA_FIXEDARG (ap, int, column);
+ VA_FIXEDARG (ap, int, level);
+ VA_FIXEDARG (ap, unsigned int, line);
+ VA_FIXEDARG (ap, unsigned int, column);
VA_FIXEDARG (ap, const char *, msgid);
- if (_cpp_begin_message (pfile, PEDWARN, line, column))
+ if (_cpp_begin_message (pfile, level, line, column))
v_message (msgid, ap);
VA_CLOSE (ap);
}
-/* Print an error message not associated with the translation unit. */
void
-cpp_notice VPARAMS ((cpp_reader *pfile, const char *msgid, ...))
-{
- VA_OPEN (ap, msgid);
- VA_FIXEDARG (ap, cpp_reader *, pfile);
- VA_FIXEDARG (ap, const char *, msgid);
-
- if (pfile->errors < CPP_FATAL_LIMIT)
- pfile->errors++;
-
- v_message (msgid, ap);
-
- VA_CLOSE (ap);
-}
-
-/* Print an error message originating from ERRNO and not associated
- with the translation unit. */
-void
-cpp_notice_from_errno (pfile, name)
+cpp_errno (pfile, level, msgid)
cpp_reader *pfile;
- const char *name;
+ int level;
+ const char *msgid;
{
- if (name[0] == '\0')
- name = "stdout";
- cpp_notice (pfile, "%s: %s", name, xstrerror (errno));
+ if (msgid[0] == '\0')
+ msgid = _("stdout");
+
+ cpp_error (pfile, level, "%s: %s", msgid, xstrerror (errno));
}
/* With -O2, gcc appears to produce nice code, moving the error
message load and subsequent jump completely out of the main path. */
-#define CPP_ICE(msgid) \
- do { cpp_ice (pfile, msgid); goto syntax_error; } while(0)
#define SYNTAX_ERROR(msgid) \
- do { cpp_error (pfile, msgid); goto syntax_error; } while(0)
+ do { cpp_error (pfile, DL_ERROR, msgid); goto syntax_error; } while(0)
#define SYNTAX_ERROR2(msgid, arg) \
- do { cpp_error (pfile, msgid, arg); goto syntax_error; } while(0)
+ do { cpp_error (pfile, DL_ERROR, msgid, arg); goto syntax_error; } while(0)
struct suffix
{
if (CPP_WTRADITIONAL (pfile)
&& sufftab[i].u
&& ! cpp_sys_macro_p (pfile))
- cpp_warning (pfile, "traditional C rejects the `U' suffix");
+ cpp_error (pfile, DL_WARNING, "traditional C rejects the `U' suffix");
if (sufftab[i].l == 2 && CPP_OPTION (pfile, pedantic)
&& ! CPP_OPTION (pfile, c99))
- cpp_pedwarn (pfile, "too many 'l' suffixes in integer constant");
+ cpp_error (pfile, DL_PEDWARN,
+ "too many 'l' suffixes in integer constant");
}
if (base <= largest_digit)
- cpp_pedwarn (pfile, "integer constant contains digits beyond the radix");
+ cpp_error (pfile, DL_PEDWARN,
+ "integer constant contains digits beyond the radix");
if (overflow)
- cpp_pedwarn (pfile, "integer constant out of range");
+ cpp_error (pfile, DL_PEDWARN, "integer constant out of range");
/* If too big to be signed, consider it unsigned. */
else if ((HOST_WIDEST_INT) n < 0 && ! op.unsignedp)
{
if (base == 10)
- cpp_warning (pfile, "integer constant is so large that it is unsigned");
+ cpp_error (pfile, DL_WARNING,
+ "integer constant is so large that it is unsigned");
op.unsignedp = 1;
}
return op;
invalid_suffix:
- cpp_error (pfile, "invalid suffix '%.*s' on integer constant",
+ cpp_error (pfile, DL_ERROR, "invalid suffix '%.*s' on integer constant",
(int) (end - p), p);
syntax_error:
op.op = CPP_ERROR;
node = token->val.node;
if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
{
- cpp_error (pfile, "missing ')' after \"defined\"");
+ cpp_error (pfile, DL_ERROR, "missing ')' after \"defined\"");
node = 0;
}
}
else
{
- cpp_error (pfile, "operator \"defined\" requires an identifier");
+ cpp_error (pfile, DL_ERROR,
+ "operator \"defined\" requires an identifier");
if (token->flags & NAMED_OP)
{
cpp_token op;
op.flags = 0;
op.type = token->type;
- cpp_error (pfile,
+ cpp_error (pfile, DL_ERROR,
"(\"%s\" is an alternative token for \"%s\" in C++)",
cpp_token_as_text (pfile, token),
cpp_token_as_text (pfile, &op));
else
{
if (pfile->context != initial_context)
- cpp_warning (pfile, "this use of \"defined\" may not be portable");
+ cpp_error (pfile, DL_WARNING,
+ "this use of \"defined\" may not be portable");
op.value = node->type == NT_MACRO;
op.unsignedp = 0;
and stdbool.h has not been included. */
if (CPP_PEDANTIC (pfile)
&& ! cpp_defined (pfile, DSC("__bool_true_false_are_defined")))
- cpp_pedwarn (pfile, "ISO C++ does not permit \"%s\" in #if",
- NODE_NAME (token->val.node));
+ cpp_error (pfile, DL_PEDWARN,
+ "ISO C++ does not permit \"%s\" in #if",
+ NODE_NAME (token->val.node));
return op;
}
else
op.value = 0;
if (CPP_OPTION (pfile, warn_undef) && !skip_evaluation)
- cpp_warning (pfile, "\"%s\" is not defined",
- NODE_NAME (token->val.node));
+ cpp_error (pfile, DL_WARNING, "\"%s\" is not defined",
+ NODE_NAME (token->val.node));
return op;
}
cpp_reader *pfile;
{
if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "integer overflow in preprocessor expression");
+ cpp_error (pfile, DL_PEDWARN,
+ "integer overflow in preprocessor expression");
}
/* Handle shifting A left by B bits. UNSIGNEDP is non-zero if A is
switch (top[1].op)
{
default:
- cpp_ice (pfile, "impossible operator '%s'",
- op_as_text (pfile, top[1].op));
+ cpp_error (pfile, DL_ICE, "impossible operator '%s'",
+ op_as_text (pfile, top[1].op));
goto syntax_error;
case CPP_NOT: UNARY(!); break;
top->flags |= HAVE_VALUE;
if (CPP_WTRADITIONAL (pfile))
- cpp_warning (pfile,
+ cpp_error (pfile, DL_WARNING,
"traditional C rejects the unary plus operator");
}
else
break;
case CPP_COMMA:
if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "comma operator in operand of #if");
+ cpp_error (pfile, DL_PEDWARN,
+ "comma operator in operand of #if");
top->value = v2;
top->unsignedp = unsigned2;
break;
result = (top[1].value != 0);
if (top != stack)
- CPP_ICE ("unbalanced stack in #if");
+ {
+ cpp_error (pfile, DL_ICE, "unbalanced stack in #if");
+ goto syntax_error;
+ }
else if (!(top[1].flags & HAVE_VALUE))
{
SYNTAX_ERROR ("#if with no expression");
does not bite us. */
if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
{
- cpp_error (pfile, "%s is too large", inc->name);
+ cpp_error (pfile, DL_ERROR, "%s is too large", inc->name);
goto fail;
}
size = inc->st.st_size;
if (count == 0)
{
if (!STAT_SIZE_TOO_BIG (inc->st))
- cpp_warning
- (pfile, "%s is shorter than expected", inc->name);
+ cpp_error (pfile, DL_WARNING,
+ "%s is shorter than expected", inc->name);
size = offset;
buf = xrealloc (buf, size + 1);
inc->st.st_size = size;
}
else if (S_ISBLK (inc->st.st_mode))
{
- cpp_error (pfile, "%s is a block device", inc->name);
+ cpp_error (pfile, DL_ERROR, "%s is a block device", inc->name);
goto fail;
}
else
return 0;
perror_fail:
- cpp_error_from_errno (pfile, inc->name);
+ cpp_errno (pfile, DL_ERROR, inc->name);
fail:
return 1;
}
if (path == NULL)
{
- cpp_error (pfile, "no include path in which to find %s", fname);
+ cpp_error (pfile, DL_ERROR, "no include path in which to find %s",
+ fname);
return NO_INCLUDE_PATH;
}
we can still produce correct output. Otherwise, we can't produce
correct output, because there may be dependencies we need inside
the missing file, and we don't know what directory this missing
- file exists in. FIXME: Use a future cpp_diagnostic_with_errno ()
- for both of these cases. */
- else if (CPP_PRINT_DEPS (pfile) && ! print_dep)
- cpp_warning (pfile, "%s: %s", fname, xstrerror (errno));
+ file exists in. */
else
- cpp_error_from_errno (pfile, fname);
+ cpp_errno (pfile, CPP_PRINT_DEPS (pfile) && ! print_dep
+ ? DL_WARNING: DL_ERROR, fname);
}
/* Handles #include-family directives (distinguished by TYPE),
if (f == NULL)
{
- cpp_error_from_errno (pfile, fname);
+ cpp_errno (pfile, DL_ERROR, fname);
return false;
}
/* We know p != name as absolute paths don't call remap_filename. */
if (p == name)
- cpp_ice (pfile, "absolute file name in remap_filename");
+ cpp_error (pfile, DL_ICE, "absolute file name in remap_filename");
dir = (char *) alloca (p - name + 1);
memcpy (dir, name, p - name);
#define CPP_WTRADITIONAL(PF) CPP_OPTION (PF, warn_traditional)
/* In cpperror.c */
-enum error_type { WARNING = 0, WARNING_SYSHDR, PEDWARN, ERROR, FATAL, ICE };
-extern int _cpp_begin_message PARAMS ((cpp_reader *, enum error_type,
+extern int _cpp_begin_message PARAMS ((cpp_reader *, int,
unsigned int, unsigned int));
/* In cppmacro.c */
{
/* Dirs that don't exist are silently ignored. */
if (errno != ENOENT)
- cpp_notice_from_errno (pfile, dir);
+ cpp_errno (pfile, DL_ERROR, dir);
else if (CPP_OPTION (pfile, verbose))
fprintf (stderr, _("ignoring nonexistent directory \"%s\"\n"), dir);
free (dir);
if (!S_ISDIR (st.st_mode))
{
- cpp_notice (pfile, "%s: Not a directory", dir);
+ cpp_error_with_line (pfile, DL_ERROR, 0, 0, "%s: Not a directory", dir);
free (dir);
return;
}
{
if (cur->sysp && !other->sysp)
{
- cpp_warning (pfile,
- "changing search order for system directory \"%s\"",
- cur->name);
+ cpp_error (pfile, DL_WARNING,
+ "changing search order for system directory \"%s\"",
+ cur->name);
if (strcmp (cur->name, other->name))
- cpp_warning (pfile,
- " as it is the same as non-system directory \"%s\"",
- other->name);
+ cpp_error (pfile, DL_WARNING,
+ " as it is the same as non-system directory \"%s\"",
+ other->name);
else
- cpp_warning (pfile,
- " as it has already been specified as a non-system directory");
+ cpp_error (pfile, DL_WARNING,
+ " as it has already been specified as a non-system directory");
}
cur = remove_dup_dir (pfile, prev);
break;
deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
if (deps_stream == 0)
{
- cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
+ cpp_errno (pfile, DL_ERROR, CPP_OPTION (pfile, deps_file));
return;
}
}
if (deps_stream != stdout)
{
if (ferror (deps_stream) || fclose (deps_stream) != 0)
- cpp_fatal (pfile, "I/O error on output");
+ cpp_error (pfile, DL_FATAL, "I/O error on output");
}
}
else if (CPP_OPTION (pfile, out_fname) == NULL)
CPP_OPTION (pfile, out_fname) = argv[i];
else
- cpp_fatal (pfile, "too many filenames. Type %s --help for usage info",
+ cpp_error (pfile, DL_FATAL,
+ "too many filenames. Type %s --help for usage info",
progname);
}
else
arg = argv[++i];
if (!arg)
{
- cpp_fatal (pfile, cl_options[opt_index].msg, argv[i - 1]);
+ cpp_error (pfile, DL_FATAL,
+ cl_options[opt_index].msg, argv[i - 1]);
return argc;
}
}
CPP_OPTION (pfile, out_fname) = arg;
else
{
- cpp_fatal (pfile, "output filename specified twice");
+ cpp_error (pfile, DL_FATAL, "output filename specified twice");
return argc;
}
break;
}
else
{
- cpp_fatal (pfile, "-I- specified twice");
+ cpp_error (pfile, DL_FATAL, "-I- specified twice");
return argc;
}
}
(CPP_OPTION (pfile, print_deps_missing_files)
|| CPP_OPTION (pfile, deps_file)
|| CPP_OPTION (pfile, deps_phony_targets)))
- cpp_fatal (pfile, "you must additionally specify either -M or -MM");
+ cpp_error (pfile, DL_FATAL,
+ "you must additionally specify either -M or -MM");
}
/* Set up dependency-file output. On exit, if print_deps is non-zero
if (CPP_OPTION (pfile, warn_trigraphs) && !pfile->state.lexing_comment)
{
if (accept)
- cpp_warning_with_line (pfile, pfile->line, CPP_BUF_COL (buffer) - 1,
- "trigraph ??%c converted to %c",
- (int) from_char,
- (int) _cpp_trigraph_map[from_char]);
+ cpp_error_with_line (pfile, DL_WARNING,
+ pfile->line, CPP_BUF_COL (buffer) - 1,
+ "trigraph ??%c converted to %c",
+ (int) from_char,
+ (int) _cpp_trigraph_map[from_char]);
else if (buffer->cur != buffer->last_Wtrigraphs)
{
buffer->last_Wtrigraphs = buffer->cur;
- cpp_warning_with_line (pfile, pfile->line,
- CPP_BUF_COL (buffer) - 1,
- "trigraph ??%c ignored", (int) from_char);
+ cpp_error_with_line (pfile, DL_WARNING,
+ pfile->line, CPP_BUF_COL (buffer) - 1,
+ "trigraph ??%c ignored", (int) from_char);
}
}
if (saved_cur != buffer->cur - 1
&& !pfile->state.lexing_comment)
- cpp_warning (pfile, "backslash and newline separated by space");
+ cpp_error (pfile, DL_WARNING,
+ "backslash and newline separated by space");
handle_newline (pfile);
buffer->backup_to = buffer->cur;
if (buffer->cur == buffer->rlimit)
{
- cpp_pedwarn (pfile, "backslash-newline at end of file");
+ cpp_error (pfile, DL_PEDWARN,
+ "backslash-newline at end of file");
next = EOF;
}
else
Don't bother to get it right across escaped newlines. */
if (CPP_OPTION (pfile, warn_comments)
&& buffer->cur[0] == '*' && buffer->cur[1] != '/')
- cpp_warning_with_line (pfile,
- pfile->line, CPP_BUF_COL (buffer),
- "\"/*\" within comment");
+ cpp_error_with_line (pfile, DL_WARNING,
+ pfile->line, CPP_BUF_COL (buffer),
+ "\"/*\" within comment");
}
else if (is_vspace (c))
handle_newline (pfile);
return 0;
if (!warned)
{
- cpp_warning (pfile, "null character(s) ignored");
+ cpp_error (pfile, DL_WARNING, "null character(s) ignored");
warned = 1;
}
}
else if (pfile->state.in_directive && CPP_PEDANTIC (pfile))
- cpp_pedwarn_with_line (pfile, pfile->line,
- CPP_BUF_COL (buffer),
- "%s in preprocessing directive",
- c == '\f' ? "form feed" : "vertical tab");
+ cpp_error_with_line (pfile, DL_PEDWARN, pfile->line,
+ CPP_BUF_COL (buffer),
+ "%s in preprocessing directive",
+ c == '\f' ? "form feed" : "vertical tab");
c = *buffer->cur++;
}
{
/* It is allowed to poison the same identifier twice. */
if ((result->flags & NODE_POISONED) && !pfile->state.poisoned_ok)
- cpp_error (pfile, "attempt to use poisoned \"%s\"",
+ cpp_error (pfile, DL_ERROR, "attempt to use poisoned \"%s\"",
NODE_NAME (result));
/* Constraint 6.10.3.5: __VA_ARGS__ should only appear in the
replacement list of a variadic macro. */
if (result == pfile->spec_nodes.n__VA_ARGS__
&& !pfile->state.va_args_ok)
- cpp_pedwarn (pfile,
+ cpp_error (pfile, DL_PEDWARN,
"__VA_ARGS__ can only appear in the expansion of a C99 variadic macro");
}
accepted as an extension. Don't warn about it in skipped
conditional blocks. */
if (saw_dollar && CPP_PEDANTIC (pfile) && ! pfile->state.skipping)
- cpp_pedwarn (pfile, "'$' character(s) in identifier or number");
+ cpp_error (pfile, DL_PEDWARN, "'$' character(s) in identifier or number");
/* Identifiers and numbers are null-terminated. */
*plen = obstack_object_size (stack);
comments are. */
unterminated:
if (CPP_OPTION (pfile, lang) != CLK_ASM || terminator == '>')
- cpp_error (pfile, "missing terminating %c character", terminator);
+ cpp_error (pfile, DL_ERROR, "missing terminating %c character",
+ terminator);
buffer->cur--;
break;
}
if (!warned_nulls)
{
warned_nulls = true;
- cpp_warning (pfile, "null character(s) preserved in literal");
+ cpp_error (pfile, DL_WARNING,
+ "null character(s) preserved in literal");
}
}
/* Non-empty files should end in a newline. Don't warn
for command line and _Pragma buffers. */
if (!buffer->from_stage3)
- cpp_pedwarn (pfile, "no newline at end of file");
+ cpp_error (pfile, DL_PEDWARN, "no newline at end of file");
handle_newline (pfile);
}
if (c == '*')
{
if (skip_block_comment (pfile))
- cpp_error (pfile, "unterminated comment");
+ cpp_error (pfile, DL_ERROR, "unterminated comment");
}
else if (c == '/' && (CPP_OPTION (pfile, cplusplus_comments)
|| CPP_IN_SYSTEM_HEADER (pfile)))
if (CPP_OPTION (pfile, lang) == CLK_GNUC89 && CPP_PEDANTIC (pfile)
&& ! buffer->warned_cplusplus_comments)
{
- cpp_pedwarn (pfile,
+ cpp_error (pfile, DL_PEDWARN,
"C++ style comments are not allowed in ISO C89");
- cpp_pedwarn (pfile,
- "(this will be reported only once per input file)");
+ cpp_error (pfile, DL_PEDWARN,
+ "(this will be reported only once per input file)");
buffer->warned_cplusplus_comments = 1;
}
if (skip_line_comment (pfile) && CPP_OPTION (pfile, warn_comments))
- cpp_warning (pfile, "multi-line comment");
+ cpp_error (pfile, DL_WARNING, "multi-line comment");
}
else if (c == '=')
{
case CPP_WCHAR: left = '\''; right = '\''; tag = 'L'; break;
case CPP_HEADER_NAME: left = '<'; right = '>'; tag = '\0'; break;
default:
- cpp_ice (pfile, "unknown string token %s\n", TOKEN_NAME (token));
+ cpp_error (pfile, DL_ICE, "unknown string token %s\n",
+ TOKEN_NAME (token));
return buffer;
}
if (tag) *buffer++ = tag;
break;
case SPELL_NONE:
- cpp_ice (pfile, "unspellable token %s", TOKEN_NAME (token));
+ cpp_error (pfile, DL_ICE, "unspellable token %s", TOKEN_NAME (token));
break;
}
return 1;
if (CPP_WTRADITIONAL (pfile))
- cpp_warning (pfile, "the meaning of '\\%c' is different in traditional C", c);
+ cpp_error (pfile, DL_WARNING,
+ "the meaning of '\\%c' is different in traditional C", c);
length = (c == 'u' ? 4: 8);
if ((size_t) (limit - p) < length)
{
- cpp_error (pfile, "incomplete universal-character-name");
+ cpp_error (pfile, DL_ERROR, "incomplete universal-character-name");
/* Skip to the end to avoid more diagnostics. */
p = limit;
}
code = (code << 4) + hex_digit_value (c);
else
{
- cpp_error (pfile,
+ cpp_error (pfile, DL_ERROR,
"non-hex digit '%c' in universal-character-name", c);
/* We shouldn't skip in case there are multibyte chars. */
break;
}
#ifdef TARGET_EBCDIC
- cpp_error (pfile, "universal-character-name on EBCDIC target");
+ cpp_error (pfile, DL_ERROR, "universal-character-name on EBCDIC target");
code = 0x3f; /* EBCDIC invalid character */
#else
/* True extended characters are OK. */
;
/* Don't give another error if one occurred above. */
else if (length == 0)
- cpp_error (pfile, "universal-character-name out of range");
+ cpp_error (pfile, DL_ERROR, "universal-character-name out of range");
#endif
*pstr = p;
case 'a':
if (CPP_WTRADITIONAL (pfile))
- cpp_warning (pfile, "the meaning of '\\a' is different in traditional C");
+ cpp_error (pfile, DL_WARNING,
+ "the meaning of '\\a' is different in traditional C");
c = TARGET_BELL;
break;
case 'e': case 'E':
if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "non-ISO-standard escape sequence, '\\%c'", c);
+ cpp_error (pfile, DL_PEDWARN,
+ "non-ISO-standard escape sequence, '\\%c'", c);
c = TARGET_ESC;
break;
case 'x':
if (CPP_WTRADITIONAL (pfile))
- cpp_warning (pfile, "the meaning of '\\x' is different in traditional C");
+ cpp_error (pfile, DL_WARNING,
+ "the meaning of '\\x' is different in traditional C");
{
unsigned int i = 0, overflow = 0;
}
if (!digits_found)
- cpp_error (pfile, "\\x used with no following hex digits");
+ cpp_error (pfile, DL_ERROR,
+ "\\x used with no following hex digits");
if (overflow | (i != (i & mask)))
{
- cpp_pedwarn (pfile, "hex escape sequence out of range");
+ cpp_error (pfile, DL_PEDWARN,
+ "hex escape sequence out of range");
i &= mask;
}
c = i;
if (i != (i & mask))
{
- cpp_pedwarn (pfile, "octal escape sequence out of range");
+ cpp_error (pfile, DL_PEDWARN,
+ "octal escape sequence out of range");
i &= mask;
}
c = i;
if (unknown)
{
if (ISGRAPH (c))
- cpp_pedwarn (pfile, "unknown escape sequence '\\%c'", c);
+ cpp_error (pfile, DL_PEDWARN, "unknown escape sequence '\\%c'", c);
else
- cpp_pedwarn (pfile, "unknown escape sequence: '\\%03o'", c);
+ cpp_error (pfile, DL_PEDWARN, "unknown escape sequence: '\\%03o'", c);
}
if (c > mask)
- cpp_pedwarn (pfile, "escape sequence out of range for character");
+ cpp_error (pfile, DL_PEDWARN, "escape sequence out of range for type");
*pstr = str;
return c;
char_len = local_mbtowc (&wc, str, limit - str);
if (char_len == -1)
{
- cpp_warning (pfile, "ignoring invalid multibyte character");
+ cpp_error (pfile, DL_WARNING,
+ "ignoring invalid multibyte character");
c = *str++;
}
else
}
if (chars_seen == 0)
- cpp_error (pfile, "empty character constant");
+ cpp_error (pfile, DL_ERROR, "empty character constant");
else if (chars_seen > max_chars)
{
chars_seen = max_chars;
- cpp_warning (pfile, "character constant too long");
+ cpp_error (pfile, DL_WARNING, "character constant too long");
}
else if (chars_seen > 1 && warn_multi)
- cpp_warning (pfile, "multi-character character constant");
+ cpp_error (pfile, DL_WARNING, "multi-character character constant");
/* If relevant type is signed, sign-extend the constant. */
if (chars_seen)
unsigned int));
static int strtoul_for_line PARAMS ((const U_CHAR *, unsigned int,
unsigned long *));
-static void do_diagnostic PARAMS ((cpp_reader *, enum error_type, int));
+static void do_diagnostic PARAMS ((cpp_reader *, int, int));
static cpp_hashnode *lex_macro_node PARAMS ((cpp_reader *));
static void do_include_common PARAMS ((cpp_reader *, enum include_type));
static struct pragma_entry *lookup_pragma_entry
cpp_reader *pfile;
{
if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
- cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
- pfile->directive->name);
+ cpp_error (pfile, DL_PEDWARN, "extra tokens at end of #%s directive",
+ pfile->directive->name);
}
/* Called when entering a directive, _Pragma or command-line directive. */
if (CPP_PEDANTIC (pfile)
&& ! pfile->state.skipping
&& dir->origin == EXTENSION)
- cpp_pedwarn (pfile, "#%s is a GCC extension", dir->name);
+ cpp_error (pfile, DL_PEDWARN, "#%s is a GCC extension", dir->name);
/* Traditionally, a directive is ignored unless its # is in
column 1. Therefore in code intended to work with K+R
if (CPP_WTRADITIONAL (pfile))
{
if (dir == &dtable[T_ELIF])
- cpp_warning (pfile, "suggest not using #elif in traditional C");
+ cpp_error (pfile, DL_WARNING,
+ "suggest not using #elif in traditional C");
else if (indented && dir->origin == KANDR)
- cpp_warning (pfile,
- "traditional C ignores #%s with the # indented",
- dir->name);
+ cpp_error (pfile, DL_WARNING,
+ "traditional C ignores #%s with the # indented",
+ dir->name);
else if (!indented && dir->origin != KANDR)
- cpp_warning (pfile,
- "suggest hiding #%s from traditional C with an indented #",
- dir->name);
+ cpp_error (pfile, DL_WARNING,
+ "suggest hiding #%s from traditional C with an indented #",
+ dir->name);
}
}
if (was_parsing_args)
{
if (CPP_OPTION (pfile, pedantic))
- cpp_pedwarn (pfile,
+ cpp_error (pfile, DL_PEDWARN,
"embedding a directive within macro arguments is not portable");
pfile->state.parsing_args = 0;
pfile->state.prevent_expansion = 0;
dir = &linemarker_dir;
if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
&& ! pfile->state.skipping)
- cpp_pedwarn (pfile, "style of line directive is a GCC extension");
+ cpp_error (pfile, DL_PEDWARN,
+ "style of line directive is a GCC extension");
}
if (dir)
if (CPP_OPTION (pfile, lang) == CLK_ASM)
skip = 0;
else if (!pfile->state.skipping)
- cpp_error (pfile, "invalid preprocessing directive #%s",
+ cpp_error (pfile, DL_ERROR, "invalid preprocessing directive #%s",
cpp_token_as_text (pfile, dname));
}
if (token->type != CPP_NAME)
{
if (token->type == CPP_EOF)
- cpp_error (pfile, "no macro name given in #%s directive",
+ cpp_error (pfile, DL_ERROR, "no macro name given in #%s directive",
pfile->directive->name);
else if (token->flags & NAMED_OP)
- cpp_error (pfile,
+ cpp_error (pfile, DL_ERROR,
"\"%s\" cannot be used as a macro name as it is an operator in C++",
NODE_NAME (token->val.node));
else
- cpp_error (pfile, "macro names must be identifiers");
+ cpp_error (pfile, DL_ERROR, "macro names must be identifiers");
return 0;
}
if (node == pfile->spec_nodes.n_defined)
{
- cpp_error (pfile, "\"%s\" cannot be used as a macro name",
+ cpp_error (pfile, DL_ERROR, "\"%s\" cannot be used as a macro name",
NODE_NAME (node));
return 0;
}
(*pfile->cb.undef) (pfile, pfile->directive_line, node);
if (node->flags & NODE_WARN)
- cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
+ cpp_error (pfile, DL_WARNING, "undefining \"%s\"", NODE_NAME (node));
_cpp_free_definition (node);
}
}
if (token->type == CPP_EOF)
- cpp_error (pfile, "missing terminating > character");
+ cpp_error (pfile, DL_ERROR, "missing terminating > character");
else
{
unsigned char *token_mem = _cpp_unaligned_alloc (pfile, total_len + 1);
{
if (header->type != CPP_LESS)
{
- cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
+ cpp_error (pfile, DL_ERROR,
+ "#%s expects \"FILENAME\" or <FILENAME>", dir);
return NULL;
}
if (header->val.str.len == 0)
{
- cpp_error (pfile, "empty file name in #%s", dir);
+ cpp_error (pfile, DL_ERROR, "empty file name in #%s", dir);
return NULL;
}
use the normal search logic. */
if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
{
- cpp_warning (pfile, "#include_next in primary source file");
+ cpp_error (pfile, DL_WARNING, "#include_next in primary source file");
type = IT_INCLUDE;
}
else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
{
CPP_OPTION (pfile, warn_import) = 0;
- cpp_warning (pfile,
+ cpp_error (pfile, DL_WARNING,
"#import is obsolete, use an #ifndef wrapper in the header file");
}
{
/* Prevent #include recursion. */
if (pfile->line_maps.depth >= CPP_STACK_MAX)
- cpp_fatal (pfile, "#include nested too deeply");
+ cpp_error (pfile, DL_FATAL, "#include nested too deeply");
else
{
check_eol (pfile);
}
if (token->type != CPP_EOF)
- cpp_error (pfile, "invalid flag \"%s\" in line directive",
+ cpp_error (pfile, DL_ERROR, "invalid flag \"%s\" in line directive",
cpp_token_as_text (pfile, token));
return 0;
}
|| strtoul_for_line (token->val.str.text, token->val.str.len,
&new_lineno))
{
- cpp_error (pfile, "\"%s\" after #line is not a positive integer",
+ cpp_error (pfile, DL_ERROR,
+ "\"%s\" after #line is not a positive integer",
cpp_token_as_text (pfile, token));
return;
}
if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
- cpp_pedwarn (pfile, "line number out of range");
+ cpp_error (pfile, DL_PEDWARN, "line number out of range");
token = cpp_get_token (pfile);
if (token->type == CPP_STRING)
}
else if (token->type != CPP_EOF)
{
- cpp_error (pfile, "\"%s\" is not a valid filename",
+ cpp_error (pfile, DL_ERROR, "\"%s\" is not a valid filename",
cpp_token_as_text (pfile, token));
return;
}
|| strtoul_for_line (token->val.str.text, token->val.str.len,
&new_lineno))
{
- cpp_error (pfile, "\"%s\" after # is not a positive integer",
+ cpp_error (pfile, DL_ERROR, "\"%s\" after # is not a positive integer",
cpp_token_as_text (pfile, token));
return;
}
}
else if (token->type != CPP_EOF)
{
- cpp_error (pfile, "\"%s\" is not a valid filename",
+ cpp_error (pfile, DL_ERROR, "\"%s\" is not a valid filename",
cpp_token_as_text (pfile, token));
return;
}
static void
do_diagnostic (pfile, code, print_dir)
cpp_reader *pfile;
- enum error_type code;
+ int code;
int print_dir;
{
- if (_cpp_begin_message (pfile, code, 0, 0))
+ if (_cpp_begin_message (pfile, code,
+ pfile->cur_token[-1].line,
+ pfile->cur_token[-1].col))
{
if (print_dir)
fprintf (stderr, "#%s ", pfile->directive->name);
do_error (pfile)
cpp_reader *pfile;
{
- do_diagnostic (pfile, ERROR, 1);
+ do_diagnostic (pfile, DL_ERROR, 1);
}
static void
cpp_reader *pfile;
{
/* We want #warning diagnostics to be emitted in system headers too. */
- do_diagnostic (pfile, WARNING_SYSHDR, 1);
+ do_diagnostic (pfile, DL_WARNING_SYSHDR, 1);
}
/* Report program identification. */
const cpp_token *str = cpp_get_token (pfile);
if (str->type != CPP_STRING)
- cpp_error (pfile, "invalid #ident directive");
+ cpp_error (pfile, DL_ERROR, "invalid #ident directive");
else if (pfile->cb.ident)
(*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str);
{
if (entry->is_nspace)
clash:
- cpp_ice (pfile,
+ cpp_error (pfile, DL_ICE,
"registering \"%s\" as both a pragma and a pragma namespace",
NODE_NAME (node));
else if (space)
- cpp_ice (pfile, "#pragma %s %s is already registered", space, name);
+ cpp_error (pfile, DL_ICE, "#pragma %s %s is already registered",
+ space, name);
else
- cpp_ice (pfile, "#pragma %s is already registered", name);
+ cpp_error (pfile, DL_ICE, "#pragma %s is already registered", name);
}
else
insert_pragma_entry (pfile, chain, node, handler);
do_pragma_once (pfile)
cpp_reader *pfile;
{
- cpp_warning (pfile, "#pragma once is obsolete");
+ cpp_error (pfile, DL_WARNING, "#pragma once is obsolete");
if (pfile->buffer->prev == NULL)
- cpp_warning (pfile, "#pragma once in main file");
+ cpp_error (pfile, DL_WARNING, "#pragma once in main file");
else
_cpp_never_reread (pfile->buffer->inc);
break;
if (tok->type != CPP_NAME)
{
- cpp_error (pfile, "invalid #pragma GCC poison directive");
+ cpp_error (pfile, DL_ERROR, "invalid #pragma GCC poison directive");
break;
}
continue;
if (hp->type == NT_MACRO)
- cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
+ cpp_error (pfile, DL_WARNING, "poisoning existing macro \"%s\"",
+ NODE_NAME (hp));
_cpp_free_definition (hp);
hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
}
cpp_buffer *buffer = pfile->buffer;
if (buffer->prev == 0)
- cpp_warning (pfile, "#pragma system_header ignored outside include file");
+ cpp_error (pfile, DL_WARNING,
+ "#pragma system_header ignored outside include file");
else
{
check_eol (pfile);
ordering = _cpp_compare_file_date (pfile, header);
if (ordering < 0)
- cpp_warning (pfile, "cannot find source %s",
- cpp_token_as_text (pfile, header));
+ cpp_error (pfile, DL_WARNING, "cannot find source %s",
+ cpp_token_as_text (pfile, header));
else if (ordering > 0)
{
- cpp_warning (pfile, "current file is older than %s",
- cpp_token_as_text (pfile, header));
+ cpp_error (pfile, DL_WARNING, "current file is older than %s",
+ cpp_token_as_text (pfile, header));
if (cpp_get_token (pfile)->type != CPP_EOF)
{
_cpp_backup_tokens (pfile, 1);
- do_diagnostic (pfile, WARNING, 0);
+ do_diagnostic (pfile, DL_WARNING, 0);
}
}
}
const cpp_token *string = get__Pragma_string (pfile);
if (!string)
- cpp_error (pfile, "_Pragma takes a parenthesized string literal");
+ cpp_error (pfile, DL_ERROR,
+ "_Pragma takes a parenthesized string literal");
else
{
/* Ideally, we'd like
struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
- cpp_error (pfile, "#else without #if");
+ cpp_error (pfile, DL_ERROR, "#else without #if");
else
{
if (ifs->type == T_ELSE)
{
- cpp_error (pfile, "#else after #else");
- cpp_error_with_line (pfile, ifs->line, 0,
+ cpp_error (pfile, DL_ERROR, "#else after #else");
+ cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
"the conditional began here");
}
ifs->type = T_ELSE;
struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
- cpp_error (pfile, "#elif without #if");
+ cpp_error (pfile, DL_ERROR, "#elif without #if");
else
{
if (ifs->type == T_ELSE)
{
- cpp_error (pfile, "#elif after #else");
- cpp_error_with_line (pfile, ifs->line, 0,
+ cpp_error (pfile, DL_ERROR, "#elif after #else");
+ cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
"the conditional began here");
}
ifs->type = T_ELIF;
struct if_stack *ifs = buffer->if_stack;
if (ifs == NULL)
- cpp_error (pfile, "#endif without #if");
+ cpp_error (pfile, DL_ERROR, "#endif without #if");
else
{
/* Only check EOL if was not originally skipping. */
if (type == T_UNASSERT && paren->type == CPP_EOF)
return 0;
- cpp_error (pfile, "missing '(' after predicate");
+ cpp_error (pfile, DL_ERROR, "missing '(' after predicate");
return 1;
}
if (token->type == CPP_EOF)
{
- cpp_error (pfile, "missing ')' to complete answer");
+ cpp_error (pfile, DL_ERROR, "missing ')' to complete answer");
return 1;
}
if (acount == 0)
{
- cpp_error (pfile, "predicate's answer is empty");
+ cpp_error (pfile, DL_ERROR, "predicate's answer is empty");
return 1;
}
*answerp = 0;
predicate = cpp_get_token (pfile);
if (predicate->type == CPP_EOF)
- cpp_error (pfile, "assertion without predicate");
+ cpp_error (pfile, DL_ERROR, "assertion without predicate");
else if (predicate->type != CPP_NAME)
- cpp_error (pfile, "predicate must be an identifier");
+ cpp_error (pfile, DL_ERROR, "predicate must be an identifier");
else if (parse_answer (pfile, answerp, type) == 0)
{
unsigned int len = NODE_LEN (predicate->val.node);
{
if (*find_answer (node, new_answer))
{
- cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
+ cpp_error (pfile, DL_WARNING, "\"%s\" re-asserted",
+ NODE_NAME (node) + 1);
return;
}
new_answer->next = node->value.answers;
/* Walk back up the conditional stack till we reach its level at
entry to this file, issuing error messages. */
for (ifs = buffer->if_stack; ifs; ifs = ifs->next)
- cpp_error_with_line (pfile, ifs->line, 0,
+ cpp_error_with_line (pfile, DL_ERROR, ifs->line, 0,
"unterminated #%s", dtable[ifs->type].name);
/* In case of a missing #endif. */
int, int));
extern int cpp_defined PARAMS ((cpp_reader *, const unsigned char *, int));
+/* Diagnostic levels. To get a dianostic without associating a
+ position in the translation unit with it, use cpp_error_with_line
+ with a line number of zero. */
+
+/* Warning, an error with -Werror. */
+#define DL_WARNING 0x00
+/* Same as DL_WARNING, except it is not suppressed in system headers. */
+#define DL_WARNING_SYSHDR 0x01
+/* Warning, an error with -pedantic-errors or -Werror. */
+#define DL_PEDWARN 0x02
+/* An error. */
+#define DL_ERROR 0x03
+/* A fatal error. We do not exit, to support use of cpplib as a
+ library, but may only return CPP_EOF tokens thereon. It is the
+ caller's responsibility to check CPP_FATAL_ERRORS. */
+#define DL_FATAL 0x04
+/* An internal consistency check failed. Prints "internal error: ",
+ otherwise the same as DL_FATAL. */
+#define DL_ICE 0x05
+/* Extracts a diagnostic level from an int. */
+#define DL_EXTRACT(l) (l & 0xf)
+/* Non-zero if a diagnostic level is one of the warnings. */
+#define DL_WARNING_P(l) (DL_EXTRACT (l) >= DL_WARNING \
+ && DL_EXTRACT (l) <= DL_PEDWARN)
+
/* N.B. The error-message-printer prototypes have not been nicely
formatted because exgettext needs to see 'msgid' on the same line
as the name of the function in order to work properly. Only the
string argument gets a name in an effort to keep the lines from
getting ridiculously oversized. */
-extern void cpp_ice PARAMS ((cpp_reader *, const char *msgid, ...))
- ATTRIBUTE_PRINTF_2;
-extern void cpp_fatal PARAMS ((cpp_reader *, const char *msgid, ...))
- ATTRIBUTE_PRINTF_2;
-extern void cpp_error PARAMS ((cpp_reader *, const char *msgid, ...))
- ATTRIBUTE_PRINTF_2;
-extern void cpp_warning PARAMS ((cpp_reader *, const char *msgid, ...))
- ATTRIBUTE_PRINTF_2;
-extern void cpp_pedwarn PARAMS ((cpp_reader *, const char *msgid, ...))
- ATTRIBUTE_PRINTF_2;
-extern void cpp_notice PARAMS ((cpp_reader *, const char *msgid, ...))
- ATTRIBUTE_PRINTF_2;
-extern void cpp_error_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
- ATTRIBUTE_PRINTF_4;
-extern void cpp_warning_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
- ATTRIBUTE_PRINTF_4;
-extern void cpp_pedwarn_with_line PARAMS ((cpp_reader *, int, int, const char *msgid, ...))
- ATTRIBUTE_PRINTF_4;
-extern void cpp_error_from_errno PARAMS ((cpp_reader *, const char *));
-extern void cpp_notice_from_errno PARAMS ((cpp_reader *, const char *));
+/* Output a diagnostic of some kind. */
+extern void cpp_error PARAMS ((cpp_reader *, int, const char *msgid, ...))
+ ATTRIBUTE_PRINTF_3;
+
+/* Output a diagnostic of severity LEVEL, with "MSG: " preceding the
+ error string of errno. No location is printed. */
+extern void cpp_errno PARAMS ((cpp_reader *, int level, const char *msg));
+
+/* Same as cpp_error, except additionally specifies a position as a
+ (translation unit) physical line and physical column. If the line is
+ zero, then no location is printed. */
+extern void cpp_error_with_line PARAMS ((cpp_reader *, int, unsigned, unsigned, const char *msgid, ...))
+ ATTRIBUTE_PRINTF_5;
/* In cpplex.c */
extern int cpp_ideq PARAMS ((const cpp_token *,
switch (node->value.builtin)
{
default:
- cpp_ice (pfile, "invalid built-in macro \"%s\"", NODE_NAME (node));
+ cpp_error (pfile, DL_ICE, "invalid built-in macro \"%s\"",
+ NODE_NAME (node));
return 0;
case BT_FILE:
/* Ignore the final \ of invalid string literals. */
if (backslash_count & 1)
{
- cpp_warning (pfile, "invalid string literal, ignoring final '\\'");
+ cpp_error (pfile, DL_WARNING,
+ "invalid string literal, ignoring final '\\'");
dest--;
}
/* Mandatory warning for all apart from assembler. */
if (CPP_OPTION (pfile, lang) != CLK_ASM)
- cpp_warning (pfile,
+ cpp_error (pfile, DL_WARNING,
"pasting \"%s\" and \"%s\" does not give a valid preprocessing token",
- cpp_token_as_text (pfile, lhs),
- cpp_token_as_text (pfile, rhs));
+ cpp_token_as_text (pfile, lhs),
+ cpp_token_as_text (pfile, rhs));
break;
}
}
callers at the end of an -include-d file. */
if (pfile->context->prev || pfile->state.in_directive)
_cpp_backup_tokens (pfile, 1);
- cpp_error (pfile, "unterminated argument list invoking macro \"%s\"",
+ cpp_error (pfile, DL_ERROR,
+ "unterminated argument list invoking macro \"%s\"",
NODE_NAME (node));
error = true;
}
if (argc + 1 == macro->paramc && macro->variadic)
{
if (CPP_PEDANTIC (pfile) && ! macro->syshdr)
- cpp_pedwarn (pfile, "ISO C99 requires rest arguments to be used");
+ cpp_error (pfile, DL_PEDWARN,
+ "ISO C99 requires rest arguments to be used");
}
else
{
- cpp_error (pfile,
+ cpp_error (pfile, DL_ERROR,
"macro \"%s\" requires %u arguments, but only %u given",
NODE_NAME (node), macro->paramc, argc);
error = true;
/* Empty argument to a macro taking no arguments is OK. */
if (argc != 1 || arg->count)
{
- cpp_error (pfile,
+ cpp_error (pfile, DL_ERROR,
"macro \"%s\" passed %u arguments, but takes just %u",
NODE_NAME (node), argc, macro->paramc);
error = true;
if (buff == NULL)
{
if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
- cpp_warning (pfile,
+ cpp_error (pfile, DL_WARNING,
"function-like macro \"%s\" must be used with arguments in traditional C",
- NODE_NAME (node));
+ NODE_NAME (node));
return 0;
}
/* Constraint 6.10.3.6 - duplicate parameter names. */
if (node->arg_index)
{
- cpp_error (pfile, "duplicate macro parameter \"%s\"", NODE_NAME (node));
+ cpp_error (pfile, DL_ERROR, "duplicate macro parameter \"%s\"",
+ NODE_NAME (node));
return 1;
}
&& ! CPP_OPTION (pfile, discard_comments_in_macro_exp))
continue;
- cpp_error (pfile, "\"%s\" may not appear in macro parameter list",
+ cpp_error (pfile, DL_ERROR,
+ "\"%s\" may not appear in macro parameter list",
cpp_token_as_text (pfile, token));
return 0;
case CPP_NAME:
if (prev_ident)
{
- cpp_error (pfile, "macro parameters must be comma-separated");
+ cpp_error (pfile, DL_ERROR,
+ "macro parameters must be comma-separated");
return 0;
}
prev_ident = 1;
case CPP_COMMA:
if (!prev_ident)
{
- cpp_error (pfile, "parameter name missing");
+ cpp_error (pfile, DL_ERROR, "parameter name missing");
return 0;
}
prev_ident = 0;
save_parameter (pfile, macro, pfile->spec_nodes.n__VA_ARGS__);
pfile->state.va_args_ok = 1;
if (! CPP_OPTION (pfile, c99) && CPP_OPTION (pfile, pedantic))
- cpp_pedwarn (pfile,
- "anonymous variadic macros were introduced in C99");
+ cpp_error (pfile, DL_PEDWARN,
+ "anonymous variadic macros were introduced in C99");
}
else if (CPP_OPTION (pfile, pedantic))
- cpp_pedwarn (pfile, "ISO C does not permit named variadic macros");
+ cpp_error (pfile, DL_PEDWARN,
+ "ISO C does not permit named variadic macros");
/* We're at the end, and just expect a closing parenthesis. */
token = _cpp_lex_token (pfile);
/* Fall through. */
case CPP_EOF:
- cpp_error (pfile, "missing ')' in macro parameter list");
+ cpp_error (pfile, DL_ERROR, "missing ')' in macro parameter list");
return 0;
}
}
macro->fun_like = 1;
}
else if (ctoken->type != CPP_EOF && !(ctoken->flags & PREV_WHITE))
- cpp_pedwarn (pfile, "ISO C requires whitespace after the macro name");
+ cpp_error (pfile, DL_PEDWARN,
+ "ISO C requires whitespace after the macro name");
saved_cur_token = pfile->cur_token;
else if (CPP_OPTION (pfile, lang) != CLK_ASM)
{
ok = 0;
- cpp_error (pfile, "'#' is not followed by a macro parameter");
+ cpp_error (pfile, DL_ERROR,
+ "'#' is not followed by a macro parameter");
goto cleanup1;
}
}
if (macro->count == 0 || token->type == CPP_EOF)
{
ok = 0;
- cpp_error (pfile,
+ cpp_error (pfile, DL_ERROR,
"'##' cannot appear at either end of a macro expansion");
goto cleanup1;
}
{
if (warn_of_redefinition (node, macro))
{
- cpp_pedwarn_with_line (pfile, pfile->directive_line, 0,
- "\"%s\" redefined", NODE_NAME (node));
+ cpp_error_with_line (pfile, DL_PEDWARN, pfile->directive_line, 0,
+ "\"%s\" redefined", NODE_NAME (node));
if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
- cpp_pedwarn_with_line (pfile, node->value.macro->line, 0,
+ cpp_error_with_line (pfile, DL_PEDWARN, node->value.macro->line, 0,
"this is the location of the previous definition");
}
_cpp_free_definition (node);
if (NODE_LEN (node) == len
&& !memcmp (p, NODE_NAME (node), len))
{
- cpp_warning (pfile,
+ cpp_error (pfile, DL_WARNING,
"macro argument \"%s\" would be stringified in traditional C",
- NODE_NAME (node));
+ NODE_NAME (node));
break;
}
}
if (node->type != NT_MACRO || (node->flags & NODE_BUILTIN))
{
- cpp_ice (pfile, "invalid hash type %d in cpp_macro_definition", node->type);
+ cpp_error (pfile, DL_ICE,
+ "invalid hash type %d in cpp_macro_definition", node->type);
return 0;
}
print.outf = fopen (options->out_fname, "w");
if (print.outf == NULL)
{
- cpp_notice_from_errno (pfile, options->out_fname);
+ cpp_errno (pfile, DL_ERROR, options->out_fname);
return;
}
}
if (print.outf != stdout)
{
if (ferror (print.outf) || fclose (print.outf))
- cpp_notice_from_errno (pfile, options->out_fname);
+ cpp_errno (pfile, DL_ERROR, options->out_fname);
}
}
i = cpp_handle_options (scan_in, argc, argv);
if (i < argc && ! CPP_FATAL_ERRORS (scan_in))
- cpp_fatal (scan_in, "Invalid option `%s'", argv[i]);
+ cpp_error (scan_in, DL_FATAL, "invalid option `%s'", argv[i]);
cpp_post_options (scan_in);
if (CPP_FATAL_ERRORS (scan_in))
exit (FATAL_EXIT_CODE);
projects / gcc.git / commitdiff