/* C Compatible Compiler Preprocessor (CCCP)
-Copyright (C) 1986, 1987, 1989, 2000 Free Software Foundation, Inc.
+Copyright (C) 1986, 1987, 1989, 2000, 2001 Free Software Foundation, Inc.
Written by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
Dusted off, polished, and adapted for use as traditional
#include "version.h"
#include "cppdefault.h"
#include "tradcpp.h"
+#include "mkdeps.h"
typedef unsigned char U_CHAR;
int put_out_comments = 0;
+/* mkdeps.h opaque structure that encapsulates dependency information. */
+struct deps *deps;
+
/* Nonzero means print the names of included files rather than
the preprocessed output. 1 means just the #include "...",
2 means #include <...> as well. */
int print_deps = 0;
+/* Nonzero means print dummy targets for each header file. */
+
+int print_deps_phony_targets = 0;
+
+/* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
+
+int deps_append = 0;
+
+/* File name which deps are being written to. This is 0 if deps are
+ being written to stdout. */
+
+const char *deps_file = 0;
+
+/* Nonzero if missing .h files in -M output are assumed to be
+ generated files and not errors. */
+
+int deps_missing_files = 0;
+
/* Nonzero means don't output line number information. */
int no_line_commands;
int inhibit_warnings = 0;
+/* Non-0 means don't output the preprocessed program. */
+int inhibit_output = 0;
+
/* Nonzero means warn if slash-star appears in a comment. */
int warn_comments;
It is zero for rescanning results of macro expansion
and for expanding macro arguments. */
#define INPUT_STACK_MAX 200
+struct file_name_list;
struct file_buf {
const char *fname;
int lineno;
struct if_stack *if_stack;
/* Object to be freed at end of input at this level. */
U_CHAR *free_ptr;
+ /* Position to start scanning for #include_next in this file. */
+ struct file_name_list *next_header_dir;
} instack[INPUT_STACK_MAX];
typedef struct file_buf FILE_BUF;
enum node_type {
T_DEFINE = 1, /* `#define' */
T_INCLUDE, /* `#include' */
+ T_INCLUDE_NEXT,/* `#include_next' */
T_IFDEF, /* `#ifdef' */
T_IFNDEF, /* `#ifndef' */
T_IF, /* `#if' */
T_UNDEF, /* `#undef' */
T_LINE, /* `#line' */
T_ENDIF, /* `#endif' */
+ T_ERROR, /* `#error' */
+ T_WARNING, /* `#warning' */
T_ASSERT, /* `#assert' */
T_UNASSERT, /* `#unassert' */
T_SPECLINE, /* special symbol `__LINE__' */
/* Function prototypes. */
static void do_define PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
+static void do_error PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
+static void do_warning PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
static void do_line PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
static void do_include PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
+static void do_include_next PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
static void do_undef PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
static void do_if PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
static void do_ifdef PARAMS ((U_CHAR *, U_CHAR *, FILE_BUF *));
static int eval_if_expression PARAMS ((const U_CHAR *, int));
+static void output_deps PARAMS ((void));
static void initialize_builtins PARAMS ((void));
static void run_directive PARAMS ((const char *, size_t,
enum node_type));
static void grow_outbuf PARAMS ((FILE_BUF *, int));
static int handle_directive PARAMS ((FILE_BUF *, FILE_BUF *));
-static void finclude PARAMS ((int, const char *, FILE_BUF *));
-static void deps_output PARAMS ((const char *, int));
+static void process_include PARAMS ((struct file_name_list *,
+ const U_CHAR *, int, int, FILE_BUF *));
+static void finclude PARAMS ((int, const char *,
+ struct file_name_list *, FILE_BUF *));
+static void init_dependency_output PARAMS ((void));
static void rescan PARAMS ((FILE_BUF *, int));
static void newline_fix PARAMS ((U_CHAR *));
static void name_newline_fix PARAMS ((U_CHAR *));
{ 5, do_undef, "undef", T_UNDEF },
{ 4, do_line, "line", T_LINE },
{ 4, do_elif, "elif", T_ELIF },
+ { 5, do_error, "error", T_ERROR },
+ { 7, do_warning, "warning", T_WARNING },
+ { 12, do_include_next, "include_next", T_INCLUDE_NEXT },
{ 6, do_assert, "assert", T_ASSERT },
{ 8, do_unassert,"unassert",T_UNASSERT},
{ -1, 0, "", T_UNUSED},
typedef struct if_stack IF_STACK_FRAME;
IF_STACK_FRAME *if_stack = NULL;
-/* Buffer of -M output. */
-
-char *deps_buffer;
-
-/* Number of bytes allocated in above. */
-int deps_allocated_size;
-
-/* Number of bytes used. */
-int deps_size;
-
-/* Number of bytes since the last newline. */
-int deps_column;
-
/* Nonzero means -I- has been seen,
so don't look for #include "foo" the source-file directory. */
int ignore_srcdir;
pending_dir *pend = (pending_dir *) xcalloc (argc, sizeof (pending_dir));
int no_standard_includes = 0;
- /* Non-0 means don't output the preprocessed program. */
- int inhibit_output = 0;
-
- /* Stream on which to print the dependency information. */
- FILE *deps_stream = 0;
- /* Target-name to write with the dependency information. */
- char *deps_target = 0;
-
#ifdef RLIMIT_STACK
/* Get rid of any avoidable limit on stack size. */
{
max_include_len = cpp_GCC_INCLUDE_DIR_len + 7; /* ??? */
+ /* It's simplest to just create this struct whether or not it will
+ be needed. */
+ deps = deps_init ();
+
/* Process switches and find input file name. */
for (i = 1; i < argc; i++) {
switch (c) {
case 'E':
case '$':
- case 'g':
break; /* Ignore for compatibility with ISO/extended cpp. */
case 'l':
break;
case 'M':
- if (!strcmp (argv[i], "-M"))
- print_deps = 2;
- else if (!strcmp (argv[i], "-MM"))
- print_deps = 1;
- inhibit_output = 1;
+ {
+ char *p = NULL;
+
+ /* -MD and -MMD for tradcpp are deprecated and undocumented
+ (use -M or -MM with -MF instead), and probably should be
+ removed with the next major GCC version. For the moment
+ we allow these for the benefit of Automake 1.4, which
+ uses these when dependency tracking is enabled. Automake
+ 1.5 will fix this. */
+ if (!strncmp (argv[i], "-MD", 3)) {
+ p = argv[i] + 3;
+ print_deps = 2;
+ } else if (!strncmp (argv[i], "-MMD", 4)) {
+ p = argv[i] + 4;
+ print_deps = 1;
+ } else if (!strcmp (argv[i], "-M")) {
+ print_deps = 2;
+ } else if (!strcmp (argv[i], "-MM")) {
+ print_deps = 1;
+ } else if (!strcmp (argv[i], "-MG")) {
+ deps_missing_files = 1;
+ } else if (!strcmp (argv[i], "-MF")) {
+ p = argv[i] + 3;
+ } else if (!strcmp (argv[i], "-MP")) {
+ print_deps_phony_targets = 1;
+ } else if (!strcmp (argv[i], "-MQ") || !strcmp (argv[i], "-MT")) {
+ /* Add a target. -MQ quotes for Make. */
+ const char *tgt = argv[i] + 3;
+ int quoted = argv[i][2] == 'Q';
+
+ if (*tgt == '\0' && i + 1 == argc)
+ fatal ("Target missing after %s option", argv[i]);
+ else
+ {
+ if (*tgt == '\0')
+ tgt = argv[++i];
+
+ deps_add_target (deps, tgt, quoted);
+ }
+ }
+
+ if (p) {
+ if (*p)
+ deps_file = p;
+ else if (i + 1 == argc)
+ fatal ("Filename missing after %s option", argv[i]);
+ else
+ deps_file = argv[++i];
+ }
+ }
break;
case 'd':
}
}
+ init_dependency_output ();
+
+ /* After checking the environment variables, check if -M or -MM has
+ not been specified, but other -M options have. */
+ if (print_deps == 0
+ && (deps_missing_files || deps_file || print_deps_phony_targets))
+ fatal ("you must additionally specify either -M or -MM");
+
if (user_label_prefix == 0)
user_label_prefix = USER_LABEL_PREFIX;
+ if (print_deps)
+ {
+ /* Set the default target (if there is none already), and
+ the dependency on the main file. */
+ deps_add_default_target (deps, in_fname);
+
+ deps_add_dep (deps, in_fname);
+ }
+
/* Install __LINE__, etc. Must follow option processing. */
initialize_builtins ();
so that only their macro definitions matter. */
no_output++;
+ indepth++;
for (i = 1; i < argc; i++)
if (pend[i].type == PD_FILE)
{
perror_with_name (pend[i].arg);
return FATAL_EXIT_CODE;
}
- finclude (fd, pend[i].arg, &outbuf);
+
+ /* For -M, add this file to the dependencies. */
+ if (print_deps)
+ deps_add_dep (deps, pend[i].arg);
+
+ finclude (fd, pend[i].arg, 0, &outbuf);
}
+ indepth--;
no_output--;
/* Pending directives no longer needed. */
} else if ((f = open (in_fname, O_RDONLY, 0666)) < 0)
goto sys_error;
- /* Either of two environment variables can specify output of deps.
- Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
- where OUTPUT_FILE is the file to write deps info to
- and DEPS_TARGET is the target to mention in the deps. */
-
- if (print_deps == 0
- && (getenv ("SUNPRO_DEPENDENCIES") != 0
- || getenv ("DEPENDENCIES_OUTPUT") != 0))
- {
- char *spec = getenv ("DEPENDENCIES_OUTPUT");
- char *s;
- char *output_file;
-
- if (spec == 0)
- {
- spec = getenv ("SUNPRO_DEPENDENCIES");
- print_deps = 2;
- }
- else
- print_deps = 1;
-
- /* Find the space before the DEPS_TARGET, if there is one. */
- s = strchr (spec, ' ');
- if (s)
- {
- deps_target = s + 1;
- output_file = (char *) xmalloc (s - spec + 1);
- memcpy (output_file, spec, s - spec);
- output_file[s - spec] = 0;
- }
- else
- {
- deps_target = 0;
- output_file = spec;
- }
-
- deps_stream = fopen (output_file, "a");
- if (deps_stream == 0)
- pfatal_with_name (output_file);
- }
- /* If the -M option was used, output the deps to standard output. */
- else if (print_deps)
- deps_stream = stdout;
-
- /* For -M, print the expected object file name
- as the target of this Make-rule. */
- if (print_deps) {
- deps_allocated_size = 200;
- deps_buffer = (char *) xmalloc (deps_allocated_size);
- deps_buffer[0] = 0;
- deps_size = 0;
- deps_column = 0;
-
- if (deps_target) {
- deps_output (deps_target, 0);
- deps_output (":", 0);
- } else if (*in_fname == 0)
- deps_output ("-: ", 0);
- else {
- int len;
- const char *p = in_fname;
- const char *p1 = p;
- /* Discard all directory prefixes from P. */
- while (*p1) {
- if (*p1 == '/')
- p = p1 + 1;
- p1++;
- }
- /* Output P, but remove known suffixes. */
- len = strlen (p);
- if (p[len - 2] == '.'
- && (p[len - 1] == 'c' || p[len - 1] == 'C' || p[len - 1] == 'S'))
- deps_output (p, len - 2);
- else if (p[len - 3] == '.'
- && p[len - 2] == 'c'
- && p[len - 1] == 'c')
- deps_output (p, len - 3);
- else
- deps_output (p, 0);
- /* Supply our own suffix. */
- deps_output (".o : ", 0);
- deps_output (in_fname, 0);
- deps_output (" ", 0);
- }
- }
-
if (file_size_and_mode (f, &st_mode, &st_size))
goto sys_error;
fp->fname = in_fname;
if (dump_macros)
dump_all_macros ();
- else if (! inhibit_output && deps_stream != stdout) {
+ else if (! inhibit_output)
if (write (fileno (stdout), outbuf.buf, outbuf.bufp - outbuf.buf) < 0)
fatal ("I/O error on output");
- }
- if (print_deps) {
- fputs (deps_buffer, deps_stream);
- putc ('\n', deps_stream);
- if (deps_stream != stdout) {
- fclose (deps_stream);
- if (ferror (deps_stream))
- fatal ("I/O error on output");
- }
- }
+ /* Don't write the deps file if preprocessing has failed. */
+ if (print_deps && errors == 0)
+ output_deps ();
+
+ /* Destruct the deps object. */
+ deps_free (deps);
if (ferror (stdout))
fatal ("I/O error on output");
pfatal_with_name (in_fname);
}
+/* Set up dependency-file output. */
+static void
+init_dependency_output ()
+{
+ char *spec, *s, *output_file;
+
+ /* Either of two environment variables can specify output of deps.
+ Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
+ where OUTPUT_FILE is the file to write deps info to
+ and DEPS_TARGET is the target to mention in the deps. */
+
+ if (print_deps == 0)
+ {
+ spec = getenv ("DEPENDENCIES_OUTPUT");
+ if (spec)
+ print_deps = 1;
+ else
+ {
+ spec = getenv ("SUNPRO_DEPENDENCIES");
+ if (spec)
+ print_deps = 2;
+ else
+ return;
+ }
+
+ /* Find the space before the DEPS_TARGET, if there is one. */
+ s = strchr (spec, ' ');
+ if (s)
+ {
+ /* Let the caller perform MAKE quoting. */
+ deps_add_target (deps, s + 1, 0);
+ output_file = (char *) xmalloc (s - spec + 1);
+ memcpy (output_file, spec, s - spec);
+ output_file[s - spec] = 0;
+ }
+ else
+ output_file = spec;
+
+ /* Command line overrides environment variables. */
+ if (deps_file == 0)
+ deps_file = output_file;
+ deps_append = 1;
+ }
+
+ /* If dependencies go to standard output, or -MG is used, we should
+ suppress output. The user may be requesting other stuff to
+ stdout, with -dM, -v etc. We let them shoot themselves in the
+ foot. */
+ if (deps_file == 0 || deps_missing_files)
+ inhibit_output = 1;
+}
+
+/* Use mkdeps.c to output dependency information. */
+static void
+output_deps ()
+{
+ /* Stream on which to print the dependency information. */
+ FILE *deps_stream = 0;
+ const char *const deps_mode = deps_append ? "a" : "w";
+
+ if (deps_file == 0)
+ deps_stream = stdout;
+ else
+ {
+ deps_stream = fopen (deps_file, deps_mode);
+ if (deps_stream == 0)
+ {
+ error_from_errno (deps_file);
+ return;
+ }
+ }
+
+ deps_write (deps, deps_stream, 72);
+
+ if (print_deps_phony_targets)
+ deps_phony_targets (deps, deps_stream);
+
+ /* Don't close stdout. */
+ if (deps_file)
+ {
+ if (ferror (deps_stream) || fclose (deps_stream) != 0)
+ fatal ("I/O error on output");
+ }
+}
+
/* Move all backslash-newline pairs out of embarrassing places.
Exchange all such pairs following BP
with any potentially-embarrasing characters that follow them.
newline_fix (bp)
U_CHAR *bp;
{
- register U_CHAR *p = bp;
- register int count = 0;
+ U_CHAR *p = bp;
+ int count = 0;
/* First count the backslash-newline pairs here. */
name_newline_fix (bp)
U_CHAR *bp;
{
- register U_CHAR *p = bp;
- register int count = 0;
+ U_CHAR *p = bp;
+ int count = 0;
/* First count the backslash-newline pairs here. */
int output_marks;
{
/* Character being scanned in main loop. */
- register U_CHAR c;
+ U_CHAR c;
/* Length of pending accumulated identifier. */
- register int ident_length = 0;
+ int ident_length = 0;
/* Hash code of pending accumulated identifier. */
- register int hash = 0;
+ int hash = 0;
/* Current input level (&instack[indepth]). */
FILE_BUF *ip;
/* Pointer for scanning input. */
- register U_CHAR *ibp;
+ U_CHAR *ibp;
/* Pointer to end of input. End of scan is controlled by LIMIT. */
- register U_CHAR *limit;
+ U_CHAR *limit;
/* Pointer for storing output. */
- register U_CHAR *obp;
+ U_CHAR *obp;
/* REDO_CHAR is nonzero if we are processing an identifier
after backing up over the terminating character.
/* Record position of last `real' newline. */
U_CHAR *beg_of_line;
+ /* This has to be a global bacause of RECACHE. */
+ U_CHAR *obufp_before_macroname = NULL;
+
/* Pop the innermost input stack level, assuming it is a macro expansion. */
#define POPMACRO \
op->bufp = obp; \
check_expand (op, limit - ibp); \
beg_of_line = 0; \
+ obufp_before_macroname += op->bufp - obp; \
obp = op->bufp; } while (0)
if (no_output && instack[indepth].fname != 0)
randomchar:
if (ident_length > 0) {
- register HASHNODE *hp;
+ HASHNODE *hp;
/* We have just seen an identifier end. If it's a macro, expand it.
hp = hp->next) {
if (hp->length == ident_length) {
- U_CHAR *obufp_before_macroname;
+ /* obufp_before_macroname is used only in this block,
+ but it has to be global because of RECACHE. */
int op_lineno_before_macroname;
- register int i = ident_length;
- register U_CHAR *p = hp->name;
- register U_CHAR *q = obp - i;
+ int i = ident_length;
+ U_CHAR *p = hp->name;
+ U_CHAR *q = obp - i;
if (! redo_char)
q--;
const U_CHAR *buf, *limit;
int output_marks;
{
- register FILE_BUF *ip;
+ FILE_BUF *ip;
FILE_BUF obuf;
int length = limit - buf;
U_CHAR *buf1;
buf1 = (U_CHAR *) alloca (length + 1);
{
- register const U_CHAR *p1 = buf;
- register U_CHAR *p2 = buf1;
+ const U_CHAR *p1 = buf;
+ U_CHAR *p2 = buf1;
while (p1 != limit)
*p2++ = *p1++;
handle_directive (ip, op)
FILE_BUF *ip, *op;
{
- register U_CHAR *bp, *cp;
- register struct directive *kt;
- register int ident_length;
+ U_CHAR *bp, *cp;
+ struct directive *kt;
+ int ident_length;
U_CHAR *resume_p;
/* Nonzero means we must copy the entire command
for (kt = directive_table; kt->length > 0; kt++) {
if (kt->length == ident_length
&& !strncmp (kt->name, (const char *)ident, ident_length)) {
- register U_CHAR *buf;
- register U_CHAR *limit = ip->buf + ip->length;
+ U_CHAR *buf;
+ U_CHAR *limit = ip->buf + ip->length;
int unterminated = 0;
/* Nonzero means do not delete comments within the directive.
buf = bp = after_ident;
while (bp < limit) {
- register U_CHAR c = *bp++;
+ U_CHAR c = *bp++;
switch (c) {
case '\\':
if (bp < limit) {
A comment may come between. */
if (copy_command) {
- register U_CHAR *xp = buf;
+ U_CHAR *xp = buf;
/* Need to copy entire command into temp buffer before dispatching */
cp = (U_CHAR *) alloca (bp - buf + 5); /* room for cmd plus
and backslash-newlines (and whitespace surrounding the latter). */
while (xp < bp) {
- register U_CHAR c = *xp++;
+ U_CHAR c = *xp++;
*cp++ = c;
switch (c) {
while (cp != buf && is_space(cp[-1])) cp--;
cp++;
SKIP_WHITE_SPACE (xp);
- } else if (is_space (*xp)) {
+ } else if (is_nvspace (*xp)) {
*cp++ = *xp++;
SKIP_WHITE_SPACE (xp);
}
case '\'':
case '\"':
{
- register const U_CHAR *bp1
+ const U_CHAR *bp1
= skip_quoted_string (xp - 1, limit, ip->lineno, 0, 0, 0);
while (xp != bp1)
*cp++ = *xp++;
if (!is_idstart (*ip->bufp))
goto oops;
- if (lookup (ip->bufp, -1, -1))
- buf = " 1 ";
+ {
+ HASHNODE *hp = lookup (ip->bufp, -1, -1);
+
+ if (hp && hp->type != T_UNUSED && hp->type != T_SPEC_DEFINED)
+ buf = " 1 ";
+ }
while (is_idchar (*ip->bufp))
++ip->bufp;
SKIP_WHITE_SPACE (ip->bufp);
U_CHAR *buf, *limit;
FILE_BUF *op;
{
- char *fname; /* Dynamically allocated fname buffer */
U_CHAR *fbeg, *fend; /* Beginning and end of fname */
struct file_name_list *stackp = include; /* Chain of dirs to search */
struct file_name_list dsp[1]; /* First in chain, if #include "..." */
int flen;
- int f; /* file number */
-
int retried = 0; /* Have already tried macro
expanding the include line*/
FILE_BUF trybuf; /* It got expanded into here */
int system_header_p = 0; /* 0 for "...", 1 for <...> */
- f= -1; /* JF we iz paranoid! */
-
get_filename:
fbeg = buf;
}
flen = fend - fbeg;
+ process_include (stackp, fbeg, flen, system_header_p, op);
+}
+
+static void
+do_include_next (buf, limit, op)
+ U_CHAR *buf, *limit;
+ FILE_BUF *op;
+{
+ U_CHAR *fbeg, *fend; /* Beginning and end of fname */
+
+ struct file_name_list *stackp; /* Chain of dirs to search */
+ int flen;
+
+ int retried = 0; /* Have already tried macro
+ expanding the include line*/
+ FILE_BUF trybuf; /* It got expanded into here */
+ int system_header_p = 0; /* 0 for "...", 1 for <...> */
+
+ /* Treat as plain #include if we don't know where to start
+ looking. */
+ stackp = instack[indepth].next_header_dir;
+ if (stackp == 0)
+ {
+ do_include (buf, limit, op);
+ return;
+ }
+
+get_filename:
+
+ fbeg = buf;
+ SKIP_WHITE_SPACE (fbeg);
+ /* Discard trailing whitespace so we can easily see
+ if we have parsed all the significant chars we were given. */
+ while (limit != fbeg && is_nvspace (limit[-1])) limit--;
+
+ switch (*fbeg++) {
+ case '\"':
+ fend = fbeg;
+ while (fend != limit && *fend != '\"')
+ fend++;
+ if (*fend == '\"' && fend + 1 == limit)
+ break;
+ goto fail;
+
+ case '<':
+ fend = fbeg;
+ while (fend != limit && *fend != '>') fend++;
+ if (*fend == '>' && fend + 1 == limit) {
+ system_header_p = 1;
+ break;
+ }
+ goto fail;
+
+ default:
+ fail:
+ if (retried) {
+ error ("#include expects \"fname\" or <fname>");
+ return;
+ } else {
+ trybuf = expand_to_temp_buffer (buf, limit, 0);
+ buf = (U_CHAR *) alloca (trybuf.bufp - trybuf.buf + 1);
+ memcpy (buf, trybuf.buf, trybuf.bufp - trybuf.buf);
+ limit = buf + (trybuf.bufp - trybuf.buf);
+ free (trybuf.buf);
+ retried++;
+ goto get_filename;
+ }
+ }
+
+ flen = fend - fbeg;
+ process_include (stackp, fbeg, flen, system_header_p, op);
+}
+
+static void
+process_include (stackp, fbeg, flen, system_header_p, op)
+ struct file_name_list *stackp;
+ const U_CHAR *fbeg;
+ int flen;
+ int system_header_p;
+ FILE_BUF *op;
+{
+ char *fname;
+ int f = -1; /* file number */
+
fname = (char *) alloca (max_include_len + flen + 2);
/* + 2 above for slash and terminating null. */
/* If specified file name is absolute, just open it. */
- if (*fbeg == '/') {
+ if (IS_ABSOLUTE_PATHNAME (fbeg)) {
strncpy (fname, (const char *)fbeg, flen);
fname[flen] = 0;
f = open (fname, O_RDONLY, 0666);
if (f < 0) {
strncpy (fname, (const char *)fbeg, flen);
fname[flen] = 0;
- error_from_errno (fname);
+ if (deps_missing_files
+ && print_deps > (system_header_p || (system_include_depth > 0))) {
- /* For -M, add this file to the dependencies. */
- if (print_deps > (system_header_p || (system_include_depth > 0))) {
- if (system_header_p)
- warning ("nonexistent file <%.*s> omitted from dependency output",
- fend - fbeg, fbeg);
+ /* If requested as a system header, assume it belongs in
+ the first system header directory. */
+ if (first_bracket_include)
+ stackp = first_bracket_include;
else
- {
- deps_output ((const char *)fbeg, fend - fbeg);
- deps_output (" ", 0);
- }
- }
+ stackp = include;
+
+ if (!system_header_p || IS_ABSOLUTE_PATHNAME (fbeg) || !stackp->fname)
+ deps_add_dep (deps, fname);
+ else {
+ char *p;
+ int len = strlen(stackp->fname);
+
+ p = (char *) alloca (len + flen + 2);
+ memcpy (p, stackp->fname, len);
+ p[len++] = '/';
+ memcpy (p + len, fbeg, flen);
+ len += flen;
+ p[len] = '\0';
+ deps_add_dep (deps, p);
+ }
+ } else if (print_deps
+ && print_deps <= (system_header_p
+ || (system_include_depth > 0)))
+ warning ("No include path in which to find %.*s", flen, fbeg);
+ else
+ error_from_errno (fname);
+
} else {
/* Check to see if this include file is a once-only include file.
ptr->fname = xstrdup (fname);
/* For -M, add this file to the dependencies. */
- if (print_deps > (system_header_p || (system_include_depth > 0))) {
- deps_output (fname, strlen (fname));
- deps_output (" ", 0);
- }
+ if (print_deps > (system_header_p || (system_include_depth > 0)))
+ deps_add_dep (deps, fname);
}
if (system_header_p)
system_include_depth++;
/* Actually process the file. */
- finclude (f, fname, op);
+ finclude (f, fname, stackp->next, op);
if (system_header_p)
system_include_depth--;
with output to OP. */
static void
-finclude (f, fname, op)
+finclude (f, fname, nhd, op)
int f;
const char *fname;
+ struct file_name_list *nhd;
FILE_BUF *op;
{
int st_mode;
fp->length = 0;
fp->lineno = 1;
fp->if_stack = if_stack;
+ fp->next_header_dir = nhd;
if (S_ISREG (st_mode)) {
fp->buf = (U_CHAR *) xmalloc (st_size + 2);
output_line_command (fp, op, 0, enter_file);
rescan (op, 0);
indepth--;
+ instack[indepth].lineno++;
+ instack[indepth].bufp++; /* Skip the new line. */
output_line_command (&instack[indepth], op, 0, leave_file);
free (fp->buf);
return;
}
sym_length = bp - symname;
if (sym_length == 0)
- error ("invalid macro name");
+ {
+ error ("invalid macro name");
+ return;
+ }
else if (!is_idstart (*symname)) {
U_CHAR *msg; /* what pain... */
msg = (U_CHAR *) alloca (sym_length + 1);
memcpy (msg, symname, sym_length);
msg[sym_length] = 0;
error ("invalid macro name `%s'", msg);
+ return;
} else {
if (! strncmp ((const char *)symname, "defined", 7) && sym_length == 7)
- error ("defining `defined' as a macro");
+ {
+ error ("\"defined\" cannot be used as a macro name");
+ return;
+ }
}
/* lossage will occur if identifiers or control keywords are broken
}
}
- ++bp; /* skip paren */
- while (is_nvspace (*bp)) /* and leading whitespace */
+ ++bp; /* skip paren */
+ while (is_nvspace (*bp) && bp < limit) /* and leading whitespace */
++bp;
/* now everything from bp before limit is the definition. */
defn = collect_expansion (bp, limit, argno, arg_ptrs);
}
} else {
/* simple expansion or empty definition; skip leading whitespace */
- while (is_nvspace (*bp))
+ while (is_nvspace (*bp) && bp < limit)
++bp;
/* now everything from bp before limit is the definition. */
defn = collect_expansion (bp, limit, -1, 0);
compare_defs (d1, d2)
DEFINITION *d1, *d2;
{
- register struct reflist *a1, *a2;
- register U_CHAR *p1 = d1->expansion;
- register U_CHAR *p2 = d2->expansion;
+ struct reflist *a1, *a2;
+ U_CHAR *p1 = d1->expansion;
+ U_CHAR *p2 = d2->expansion;
int first = 1;
if (d1->nargs != d2->nargs)
int len1, len2;
int last;
{
- register const U_CHAR *end1 = beg1 + len1;
- register const U_CHAR *end2 = beg2 + len2;
+ const U_CHAR *end1 = beg1 + len1;
+ const U_CHAR *end2 = beg2 + len2;
if (first) {
while (beg1 != end1 && is_space (*beg1)) beg1++;
while (beg2 != end2 && is_space (*beg2)) beg2++;
struct arglist *arglist;
{
DEFINITION *defn;
- register U_CHAR *p, *limit, *lastp, *exp_p;
+ U_CHAR *p, *limit, *lastp, *exp_p;
struct reflist *endpat = NULL;
/* Pointer to first nonspace after last ## seen. */
U_CHAR *concat = 0;
/* Process the main body of the definition. */
while (p < limit) {
int skipped_arg = 0;
- register U_CHAR c = *p++;
+ U_CHAR c = *p++;
*exp_p++ = c;
id_len = p - id_beg;
if (is_idstart (c)) {
- register struct arglist *arg;
+ struct arglist *arg;
for (arg = arglist; arg != NULL; arg = arg->next) {
struct reflist *tpat;
tpat->argno = arg->argno;
tpat->nchars = exp_p - lastp;
{
- register U_CHAR *p1 = p;
+ U_CHAR *p1 = p;
SKIP_WHITE_SPACE (p1);
if (p1 + 2 <= limit && p1[0] == '#' && p1[1] == '#')
tpat->raw_after = 1;
/* If this was not a macro arg, copy it into the expansion. */
if (! skipped_arg) {
- register U_CHAR *lim1 = p;
+ U_CHAR *lim1 = p;
p = id_beg;
while (p != lim1)
*exp_p++ = *p++;
U_CHAR *buf, *limit;
FILE_BUF *op;
{
- register U_CHAR *bp;
+ U_CHAR *bp;
FILE_BUF *ip = &instack[indepth];
FILE_BUF tem;
int new_lineno;
/* The Newline at the end of this line remains to be processed.
To put the next line at the specified line number,
we must store a line number now that is one less. */
- new_lineno = atoi ((const char *)bp) - 1;
+ new_lineno = atoi ((const char *)bp);
/* skip over the line number. */
while (ISDIGIT (*bp))
bp++;
-#if 0 /* #line 10"foo.c" is supposed to be allowed. */
- if (*bp && !is_space (*bp)) {
- error ("invalid format #line command");
- return;
- }
-#endif
-
SKIP_WHITE_SPACE (bp);
if (*bp == '\"') {
ip->lineno = new_lineno;
output_line_command (ip, op, 0, file_change);
+ ip->bufp++; /* Skip the new line. */
check_expand (op, ip->length - (ip->bufp - ip->buf));
}
return result;
}
+/* Handle a #error directive. */
+static void
+do_error (buf, limit, op)
+ U_CHAR *buf;
+ U_CHAR *limit;
+ FILE_BUF *op ATTRIBUTE_UNUSED;
+{
+ error ("#error%.*s", (int) (limit - buf), buf);
+}
+
+/* Handle a #warning directive. */
+static void
+do_warning (buf, limit, op)
+ U_CHAR *buf;
+ U_CHAR *limit;
+ FILE_BUF *op ATTRIBUTE_UNUSED;
+{
+ warning ("#warning%.*s", (int) (limit - buf), buf);
+}
+
/* Handle a #assert directive. */
static void
do_assert (buf, limit, op)
FILE_BUF *ip;
int any;
{
- register U_CHAR *bp = ip->bufp, *cp;
- register U_CHAR *endb = ip->buf + ip->length;
+ U_CHAR *bp = ip->bufp, *cp;
+ U_CHAR *endb = ip->buf + ip->length;
struct directive *kt;
IF_STACK_FRAME *save_if_stack = if_stack; /* don't pop past here */
U_CHAR *beg_of_line = bp;
*/
static U_CHAR *
skip_to_end_of_comment (ip, line_counter)
- register FILE_BUF *ip;
+ FILE_BUF *ip;
int *line_counter; /* place to remember newlines, or NULL */
{
- register U_CHAR *limit = ip->buf + ip->length;
- register U_CHAR *bp = ip->bufp;
+ U_CHAR *limit = ip->buf + ip->length;
+ U_CHAR *bp = ip->bufp;
FILE_BUF *op = &outbuf; /* JF */
int output = put_out_comments && !line_counter;
*/
static U_CHAR *
skip_quoted_string (bp, limit, start_line, count_newlines, backslash_newlines_p, eofp)
- register const U_CHAR *bp;
- register const U_CHAR *limit;
+ const U_CHAR *bp;
+ const U_CHAR *limit;
int start_line;
int *count_newlines;
int *backslash_newlines_p;
int *eofp;
{
- register U_CHAR c, match;
+ U_CHAR c, match;
match = *bp++;
while (1) {
{
int nargs;
DEFINITION *defn = hp->value.defn;
- register U_CHAR *xbuf;
+ U_CHAR *xbuf;
int xbuf_len;
int start_line = instack[indepth].lineno;
nargs = defn->nargs;
if (nargs >= 0) {
- register int i;
+ int i;
struct argdata *args;
const char *parse_error = 0;
= macarg ((i < nargs || (nargs == 0 && i == 0)) ? &args[i] : 0);
if (parse_error)
{
- error_with_line (line_for_error (start_line), parse_error);
+ error_with_line (line_for_error (start_line), "%s", parse_error);
break;
}
i++;
/* If we got one arg but it was just whitespace, call that 0 args. */
if (i == 1) {
- register const U_CHAR *bp = args[0].raw;
- register const U_CHAR *lim = bp + args[0].raw_length;
+ const U_CHAR *bp = args[0].raw;
+ const U_CHAR *lim = bp + args[0].raw_length;
while (bp != lim && is_space (*bp)) bp++;
if (bp == lim)
i = 0;
xbuf = defn->expansion;
xbuf_len = defn->length;
} else {
- register U_CHAR *exp = defn->expansion;
- register int offset; /* offset in expansion,
+ U_CHAR *exp = defn->expansion;
+ int offset; /* offset in expansion,
copied a piece at a time */
- register int totlen; /* total amount of exp buffer filled so far */
+ int totlen; /* total amount of exp buffer filled so far */
- register struct reflist *ap;
+ struct reflist *ap;
/* Macro really takes args. Compute the expansion of this call. */
of where we are copying from. */
offset = totlen = 0;
for (ap = defn->pattern; ap != NULL; ap = ap->next) {
- register struct argdata *arg = &args[ap->argno];
+ struct argdata *arg = &args[ap->argno];
for (i = 0; i < ap->nchars; i++)
xbuf[totlen++] = exp[offset++];
/* Now put the expansion on the input stack
so our caller will commence reading from it. */
{
- register FILE_BUF *ip2;
+ FILE_BUF *ip2;
ip2 = &instack[++indepth];
static const char *
macarg (argptr)
- register struct argdata *argptr;
+ struct argdata *argptr;
{
FILE_BUF *ip = &instack[indepth];
int paren = 0;
if (argptr != 0) {
FILE_BUF obuf;
- register const U_CHAR *buf, *lim;
- register int totlen;
+ const U_CHAR *buf, *lim;
+ int totlen;
obuf = expand_to_temp_buffer (argptr->raw,
argptr->raw + argptr->raw_length,
totlen = 0;
while (buf != lim) {
- register U_CHAR c = *buf++;
+ U_CHAR c = *buf++;
totlen++;
/* Internal sequences of whitespace are replaced by one space
in most cases, but not always. So count all the whitespace
static U_CHAR *
macarg1 (start, limit, depthptr, newlines, comments)
U_CHAR *start;
- register const U_CHAR *limit;
+ const U_CHAR *limit;
int *depthptr, *newlines, *comments;
{
- register U_CHAR *bp = start;
+ U_CHAR *bp = start;
while (bp < limit) {
switch (*bp) {
int length;
int newlines;
{
- register U_CHAR *ibp;
- register U_CHAR *obp;
- register const U_CHAR *limit;
- register int c;
+ U_CHAR *ibp;
+ U_CHAR *obp;
+ const U_CHAR *limit;
+ int c;
/* If we have newlines to duplicate, copy everything
that many characters up. Then, in the second part,
void
error VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START(ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN(ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
v_message (ERROR, 0, msgid, ap);
+ VA_CLOSE (ap);
}
void
error_with_line VPARAMS ((int line, const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- int line;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START(ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- line = va_arg (ap, int);
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN(ap, msgid);
+ VA_FIXEDARG (ap, int, line);
+ VA_FIXEDARG (ap, const char *, msgid);
v_message (ERROR, line, msgid, ap);
+ VA_CLOSE (ap);
}
/* Error including a message from `errno'. */
void
warning VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START(ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN(ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
v_message (WARNING, 0, msgid, ap);
+ VA_CLOSE (ap);
}
void
fatal VPARAMS ((const char *msgid, ...))
{
-#ifndef ANSI_PROTOTYPES
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START(ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- msgid = va_arg (ap, const char *);
-#endif
+ VA_OPEN(ap, msgid);
+ VA_FIXEDARG (ap, const char *, msgid);
v_message (FATAL, 0, msgid, ap);
+ VA_CLOSE (ap);
exit (FATAL_EXIT_CODE);
}
static void
grow_outbuf (obuf, needed)
- register FILE_BUF *obuf;
- register int needed;
+ FILE_BUF *obuf;
+ int needed;
{
- register U_CHAR *p;
+ U_CHAR *p;
int minsize;
if (obuf->length - (obuf->bufp - obuf->buf) > needed)
int hash;
/* watch out here if sizeof (U_CHAR *) != sizeof (int) */
{
- register HASHNODE *hp;
- register int bucket;
- register const U_CHAR *p;
+ HASHNODE *hp;
+ int bucket;
+ const U_CHAR *p;
U_CHAR *q;
if (len < 0) {
int len;
int hash;
{
- register const U_CHAR *bp;
- register HASHNODE *bucket;
+ const U_CHAR *bp;
+ HASHNODE *bucket;
if (len < 0) {
for (bp = name; is_idchar (*bp); bp++) ;
*/
static int
hashf (name, len, hashsize)
- register const U_CHAR *name;
- register int len;
+ const U_CHAR *name;
+ int len;
int hashsize;
{
- register int r = 0;
+ int r = 0;
while (len--)
r = HASHSTEP (r, *name++);
int bucket;
for (bucket = 0; bucket < HASHSIZE; bucket++) {
- register HASHNODE *hp;
+ HASHNODE *hp;
for (hp = hashtab[bucket]; hp; hp= hp->next) {
if (hp->type == T_MACRO) {
- register DEFINITION *defn = hp->value.defn;
+ DEFINITION *defn = hp->value.defn;
struct reflist *ap;
int offset;
int concat;
DEFINITION *defn;
int argnum;
{
- register const U_CHAR *p = defn->argnames;
+ const U_CHAR *p = defn->argnames;
while (argnum + 1 < defn->nargs) {
p = (const U_CHAR *) strchr ((const char *)p, ' ') + 1;
argnum++;
run_directive (str, count, type);
}
\f
-/* Add output to `deps_buffer' for the -M switch.
- STRING points to the text to be output.
- SIZE is the number of bytes, or 0 meaning output until a null.
- If SIZE is nonzero, we break the line first, if it is long enough. */
-static void
-deps_output (string, size)
- const char *string;
- int size;
-{
-#ifndef MAX_OUTPUT_COLUMNS
-#define MAX_OUTPUT_COLUMNS 75
-#endif
- if (size != 0 && deps_column != 0
- && size + deps_column > MAX_OUTPUT_COLUMNS) {
- deps_output ("\\\n ", 0);
- deps_column = 0;
- }
-
- if (size == 0)
- size = strlen (string);
-
- if (deps_size + size + 1 > deps_allocated_size) {
- deps_allocated_size = deps_size + size + 50;
- deps_allocated_size *= 2;
- deps_buffer = (char *) xrealloc (deps_buffer, deps_allocated_size);
- }
- memcpy (&deps_buffer[deps_size], string, size);
- deps_size += size;
- deps_column += size;
- deps_buffer[deps_size] = 0;
-}
-
/* Get the file-mode and data size of the file open on FD
and store them in *MODE_POINTER and *SIZE_POINTER. */
OSDN Git Service
