-/* CPP Library.
- Copyright (C) 1986, 87, 89, 92-98, 1999 Free Software Foundation, Inc.
+/* CPP Library. (Directive handling.)
+ Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
Contributed by Per Bothner, 1994-95.
Based on CCCP program by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
#include "cpplib.h"
#include "cpphash.h"
-#include "intl.h"
+#include "obstack.h"
-#define SKIP_WHITE_SPACE(p) do { while (is_hspace(*p)) p++; } while (0)
-
-#define PEEKN(N) (CPP_BUFFER (pfile)->rlimit - CPP_BUFFER (pfile)->cur >= (N) ? CPP_BUFFER (pfile)->cur[N] : EOF)
-#define FORWARD(N) CPP_FORWARD (CPP_BUFFER (pfile), (N))
-#define GETC() CPP_BUF_GET (CPP_BUFFER (pfile))
-#define PEEKC() CPP_BUF_PEEK (CPP_BUFFER (pfile))
-/* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
- (Note that it is false while we're expanding macro *arguments*.) */
-#define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
-
-/* Forward declarations. */
-
-static const char *my_strerror PROTO ((int));
-static void validate_else PROTO ((cpp_reader *, const char *));
-static HOST_WIDEST_INT eval_if_expression PROTO ((cpp_reader *));
-
-static void conditional_skip PROTO ((cpp_reader *, int,
- enum node_type, U_CHAR *));
-static void skip_if_group PROTO ((cpp_reader *));
-
-static void parse_name PARAMS ((cpp_reader *, int));
-static void parse_string PARAMS ((cpp_reader *, int));
-static int parse_assertion PARAMS ((cpp_reader *));
-static const char *if_directive_name PARAMS ((cpp_reader *,
- struct if_stack *));
-
-/* External declarations. */
+/* Chained list of answers to an assertion. */
+struct answer
+{
+ struct answer *next;
+ unsigned int count;
+ cpp_token first[1];
+};
-extern HOST_WIDEST_INT cpp_parse_expr PARAMS ((cpp_reader *));
+/* Stack of conditionals currently in progress
+ (including both successful and failing conditionals). */
+struct if_stack
+{
+ struct if_stack *next;
+ unsigned int line; /* Line where condition started. */
+ const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */
+ bool skip_elses; /* Can future #else / #elif be skipped? */
+ bool was_skipping; /* If were skipping on entry. */
+ int type; /* Most recent conditional, for diagnostics. */
+};
-/* `struct directive' defines one #-directive, including how to handle it. */
+/* Contains a registered pragma or pragma namespace. */
+typedef void (*pragma_cb) PARAMS ((cpp_reader *));
+struct pragma_entry
+{
+ struct pragma_entry *next;
+ const cpp_hashnode *pragma; /* Name and length. */
+ int is_nspace;
+ union {
+ pragma_cb handler;
+ struct pragma_entry *space;
+ } u;
+};
-struct directive {
- int length; /* Length of name */
- int (*func) /* Function to handle directive */
- PARAMS ((cpp_reader *, const struct directive *));
- const char *name; /* Name of directive */
- enum node_type type; /* Code which describes which directive. */
+/* Values for the origin field of struct directive. KANDR directives
+ come from traditional (K&R) C. STDC89 directives come from the
+ 1989 C standard. EXTENSION directives are extensions. */
+#define KANDR 0
+#define STDC89 1
+#define EXTENSION 2
+
+/* Values for the flags field of struct directive. COND indicates a
+ conditional; IF_COND an opening conditional. INCL means to treat
+ "..." and <...> as q-char and h-char sequences respectively. IN_I
+ means this directive should be handled even if -fpreprocessed is in
+ effect (these are the directives with callback hooks). */
+#define COND (1 << 0)
+#define IF_COND (1 << 1)
+#define INCL (1 << 2)
+#define IN_I (1 << 3)
+
+/* Defines one #-directive, including how to handle it. */
+typedef void (*directive_handler) PARAMS ((cpp_reader *));
+typedef struct directive directive;
+struct directive
+{
+ directive_handler handler; /* Function to handle directive. */
+ const U_CHAR *name; /* Name of directive. */
+ unsigned short length; /* Length of name. */
+ unsigned char origin; /* Origin of directive. */
+ unsigned char flags; /* Flags describing this directive. */
};
-/* These functions are declared to return int instead of void since they
- are going to be placed in a table and some old compilers have trouble with
- pointers to functions returning void. */
+/* Forward declarations. */
-static int do_define PARAMS ((cpp_reader *, const struct directive *));
-static int do_line PARAMS ((cpp_reader *, const struct directive *));
-static int do_include PARAMS ((cpp_reader *, const struct directive *));
-static int do_undef PARAMS ((cpp_reader *, const struct directive *));
-static int do_error PARAMS ((cpp_reader *, const struct directive *));
-static int do_pragma PARAMS ((cpp_reader *, const struct directive *));
-static int do_ident PARAMS ((cpp_reader *, const struct directive *));
-static int do_if PARAMS ((cpp_reader *, const struct directive *));
-static int do_xifdef PARAMS ((cpp_reader *, const struct directive *));
-static int do_else PARAMS ((cpp_reader *, const struct directive *));
-static int do_elif PARAMS ((cpp_reader *, const struct directive *));
-static int do_endif PARAMS ((cpp_reader *, const struct directive *));
+static void skip_rest_of_line PARAMS ((cpp_reader *));
+static void check_eol PARAMS ((cpp_reader *));
+static void start_directive PARAMS ((cpp_reader *));
+static void end_directive PARAMS ((cpp_reader *, int));
+static void directive_diagnostics
+ PARAMS ((cpp_reader *, const directive *, int));
+static void run_directive PARAMS ((cpp_reader *, int,
+ const char *, size_t));
+static const cpp_token *glue_header_name PARAMS ((cpp_reader *));
+static const cpp_token *parse_include PARAMS ((cpp_reader *));
+static void push_conditional PARAMS ((cpp_reader *, int, int,
+ const cpp_hashnode *));
+static unsigned int read_flag PARAMS ((cpp_reader *, 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 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
+ PARAMS ((struct pragma_entry *, const cpp_hashnode *pragma));
+static struct pragma_entry *insert_pragma_entry
+ PARAMS ((cpp_reader *, struct pragma_entry **, const cpp_hashnode *,
+ pragma_cb));
+static void do_pragma_once PARAMS ((cpp_reader *));
+static void do_pragma_poison PARAMS ((cpp_reader *));
+static void do_pragma_system_header PARAMS ((cpp_reader *));
+static void do_pragma_dependency PARAMS ((cpp_reader *));
+static const cpp_token *get_token_no_padding PARAMS ((cpp_reader *));
+static const cpp_token *get__Pragma_string PARAMS ((cpp_reader *));
+static void destringize_and_run PARAMS ((cpp_reader *, const cpp_string *));
+static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
+static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
+ int));
+static struct answer ** find_answer PARAMS ((cpp_hashnode *,
+ const struct answer *));
+static void handle_assertion PARAMS ((cpp_reader *, const char *, int));
+
+/* This is the table of directive handlers. It is ordered by
+ frequency of occurrence; the numbers at the end are directive
+ counts from all the source code I have lying around (egcs and libc
+ CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and
+ pcmcia-cs-3.0.9). This is no longer important as directive lookup
+ is now O(1). All extensions other than #warning and #include_next
+ are deprecated. The name is where the extension appears to have
+ come from. */
+
+#define DIRECTIVE_TABLE \
+D(define, T_DEFINE = 0, KANDR, IN_I) /* 270554 */ \
+D(include, T_INCLUDE, KANDR, INCL) /* 52262 */ \
+D(endif, T_ENDIF, KANDR, COND) /* 45855 */ \
+D(ifdef, T_IFDEF, KANDR, COND | IF_COND) /* 22000 */ \
+D(if, T_IF, KANDR, COND | IF_COND) /* 18162 */ \
+D(else, T_ELSE, KANDR, COND) /* 9863 */ \
+D(ifndef, T_IFNDEF, KANDR, COND | IF_COND) /* 9675 */ \
+D(undef, T_UNDEF, KANDR, IN_I) /* 4837 */ \
+D(line, T_LINE, KANDR, IN_I) /* 2465 */ \
+D(elif, T_ELIF, STDC89, COND) /* 610 */ \
+D(error, T_ERROR, STDC89, 0) /* 475 */ \
+D(pragma, T_PRAGMA, STDC89, IN_I) /* 195 */ \
+D(warning, T_WARNING, EXTENSION, 0) /* 22 */ \
+D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL) /* 19 */ \
+D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \
+D(import, T_IMPORT, EXTENSION, INCL) /* 0 ObjC */ \
+D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \
+D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \
+SCCS_ENTRY /* 0 SVR4? */
+
+/* #sccs is not always recognized. */
#ifdef SCCS_DIRECTIVE
-static int do_sccs PARAMS ((cpp_reader *, const struct directive *));
-#endif
-static int do_assert PARAMS ((cpp_reader *, const struct directive *));
-static int do_unassert PARAMS ((cpp_reader *, const struct directive *));
-static int do_warning PARAMS ((cpp_reader *, const struct directive *));
-static enum cpp_token null_underflow PARAMS ((cpp_reader *));
-static int null_cleanup PARAMS ((cpp_buffer *, cpp_reader *));
-static int skip_comment PARAMS ((cpp_reader *, int));
-static int copy_comment PARAMS ((cpp_reader *, int));
-static void copy_rest_of_line PARAMS ((cpp_reader *));
-static int handle_directive PARAMS ((cpp_reader *));
-static void pass_thru_directive PARAMS ((const U_CHAR *, size_t, cpp_reader *,
- const struct directive *));
-static enum cpp_token get_directive_token PARAMS ((cpp_reader *));
-static int read_line_number PARAMS ((cpp_reader *, int *));
-static void cpp_print_file_and_line PARAMS ((cpp_reader *));
-static void v_cpp_error PARAMS ((cpp_reader *, const char *, va_list));
-static void v_cpp_warning PARAMS ((cpp_reader *, const char *, va_list));
-static void v_cpp_error_with_line PARAMS ((cpp_reader *, int, int,
- const char *, va_list));
-static void v_cpp_warning_with_line PARAMS ((cpp_reader *, int, int, const char *, va_list));
-static U_CHAR *detect_if_not_defined PARAMS ((cpp_reader *));
-static int consider_directive_while_skipping PARAMS ((cpp_reader *, IF_STACK_FRAME *));
-
-/* Here is the actual list of #-directives.
- This table is ordered by frequency of occurrence; the numbers
- at the end are directive counts from all the source code I have
- lying around (egcs and libc CVS as of 1999-05-18, plus grub-0.5.91,
- linux-2.2.9, and pcmcia-cs-3.0.9). */
-
-static const struct directive directive_table[] = {
- /* In C89 */
- { 6, do_define, "define", T_DEFINE }, /* 270554 */
- { 7, do_include, "include", T_INCLUDE }, /* 52262 */
- { 5, do_endif, "endif", T_ENDIF }, /* 45855 */
- { 5, do_xifdef, "ifdef", T_IFDEF }, /* 22000 */
- { 2, do_if, "if", T_IF }, /* 18162 */
- { 4, do_else, "else", T_ELSE }, /* 9863 */
- { 6, do_xifdef, "ifndef", T_IFNDEF }, /* 9675 */
- { 5, do_undef, "undef", T_UNDEF }, /* 4837 */
- { 4, do_line, "line", T_LINE }, /* 2465 */
- { 4, do_elif, "elif", T_ELIF }, /* 610 */
- { 5, do_error, "error", T_ERROR }, /* 475 */
- { 6, do_pragma, "pragma", T_PRAGMA }, /* 195 */
-
- /* Extensions. All deprecated except #warning and #include_next. */
- { 7, do_warning, "warning", T_WARNING }, /* 22 - GNU */
- { 12, do_include, "include_next", T_INCLUDE_NEXT }, /* 19 - GNU */
- { 5, do_ident, "ident", T_IDENT }, /* 11 - SVR4 */
- { 6, do_include, "import", T_IMPORT }, /* 0 - ObjC */
- { 6, do_assert, "assert", T_ASSERT }, /* 0 - SVR4 */
- { 8, do_unassert, "unassert", T_UNASSERT }, /* 0 - SVR4 */
-#ifdef SCCS_DIRECTIVE
- { 4, do_sccs, "sccs", T_SCCS }, /* 0 - SVR2? */
+# define SCCS_ENTRY D(sccs, T_SCCS, EXTENSION, 0)
+#else
+# define SCCS_ENTRY /* nothing */
#endif
- { -1, 0, "", T_UNUSED }
-};
-/* Place into PFILE a quoted string representing the string SRC.
- Caller must reserve enough space in pfile->token_buffer. */
+/* Use the table to generate a series of prototypes, an enum for the
+ directive names, and an array of directive handlers. */
-void
-quote_string (pfile, src)
- cpp_reader *pfile;
- const char *src;
-{
- U_CHAR c;
-
- CPP_PUTC_Q (pfile, '\"');
- for (;;)
- switch ((c = *src++))
- {
- default:
- if (ISPRINT (c))
- CPP_PUTC_Q (pfile, c);
- else
- {
- sprintf ((char *)CPP_PWRITTEN (pfile), "\\%03o", c);
- CPP_ADJUST_WRITTEN (pfile, 4);
- }
- break;
-
- case '\"':
- case '\\':
- CPP_PUTC_Q (pfile, '\\');
- CPP_PUTC_Q (pfile, c);
- break;
-
- case '\0':
- CPP_PUTC_Q (pfile, '\"');
- CPP_NUL_TERMINATE_Q (pfile);
- return;
- }
-}
+/* The directive-processing functions are declared to return int
+ instead of void, because some old compilers have trouble with
+ pointers to functions returning void. */
-/* Re-allocates PFILE->token_buffer so it will hold at least N more chars. */
+/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
+#define D(name, t, o, f) static void CONCAT2(do_,name) PARAMS ((cpp_reader *));
+DIRECTIVE_TABLE
+#undef D
-void
-cpp_grow_buffer (pfile, n)
- cpp_reader *pfile;
- long n;
+#define D(n, tag, o, f) tag,
+enum
{
- long old_written = CPP_WRITTEN (pfile);
- pfile->token_buffer_size = n + 2 * pfile->token_buffer_size;
- pfile->token_buffer = (U_CHAR *)
- xrealloc(pfile->token_buffer, pfile->token_buffer_size);
- CPP_SET_WRITTEN (pfile, old_written);
-}
-
-/* Process the string STR as if it appeared as the body of a #define
- If STR is just an identifier, define it with value 1.
- If STR has anything after the identifier, then it should
- be identifier=definition. */
+ DIRECTIVE_TABLE
+ N_DIRECTIVES
+};
+#undef D
-void
-cpp_define (pfile, str)
- cpp_reader *pfile;
- U_CHAR *str;
+/* Don't invoke CONCAT2 with any whitespace or K&R cc will fail. */
+#define D(name, t, origin, flags) \
+{ CONCAT2(do_,name), (const U_CHAR *) STRINGX(name), \
+ sizeof STRINGX(name) - 1, origin, flags },
+static const directive dtable[] =
{
- U_CHAR *buf, *p;
- size_t count;
+DIRECTIVE_TABLE
+};
+#undef D
+#undef DIRECTIVE_TABLE
- /* Copy the entire option so we can modify it. */
- count = strlen (str) + 3;
- buf = (U_CHAR *) alloca (count);
- memcpy (buf, str, count - 2);
- /* Change the first "=" in the string to a space. If there is none,
- tack " 1" on the end. */
- p = (U_CHAR *) strchr (buf, '=');
- if (p)
- {
- *p = ' ';
- count -= 2;
- }
- else
- strcpy (&buf[count-3], " 1");
-
- if (cpp_push_buffer (pfile, buf, count - 1) != NULL)
- {
- do_define (pfile, NULL);
- cpp_pop_buffer (pfile);
- }
-}
+#define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
-/* Process the string STR as if it appeared as the body of a #assert. */
-void
-cpp_assert (pfile, str)
+/* Skip any remaining tokens in a directive. */
+static void
+skip_rest_of_line (pfile)
cpp_reader *pfile;
- U_CHAR *str;
-{
- if (cpp_push_buffer (pfile, str, strlen (str)) != NULL)
- {
- do_assert (pfile, NULL);
- cpp_pop_buffer (pfile);
- }
-}
-
-
-static enum cpp_token
-null_underflow (pfile)
- cpp_reader *pfile ATTRIBUTE_UNUSED;
{
- return CPP_EOF;
-}
+ /* Discard all stacked contexts. */
+ while (pfile->context != &pfile->base_context)
+ _cpp_pop_context (pfile);
-static int
-null_cleanup (pbuf, pfile)
- cpp_buffer *pbuf ATTRIBUTE_UNUSED;
- cpp_reader *pfile ATTRIBUTE_UNUSED;
-{
- return 0;
+ /* Sweep up all tokens remaining on the line. */
+ if (! SEEN_EOL ())
+ while (_cpp_lex_token (pfile)->type != CPP_EOF)
+ ;
}
-/* Skip a comment - C, C++, or Chill style. M is the first character
- of the comment marker. If this really is a comment, skip to its
- end and return ' '. If we hit end-of-file before end-of-comment,
- return EOF. If this is not a comment, return M (which will be
- '/' or '-'). */
-
-static int
-skip_comment (pfile, m)
+/* Ensure there are no stray tokens at the end of a directive. */
+static void
+check_eol (pfile)
cpp_reader *pfile;
- int m;
{
- if (m == '/' && PEEKC() == '*')
- {
- int c, prev_c = -1;
- long line, col;
-
- FORWARD(1);
- cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
- for (;;)
- {
- c = GETC ();
- if (c == EOF)
- {
- cpp_error_with_line (pfile, line, col, "unterminated comment");
- return EOF;
- }
- else if (c == '\n' || c == '\r')
- /* \r cannot be a macro escape marker here. */
- CPP_BUMP_LINE (pfile);
- else if (c == '/' && prev_c == '*')
- return ' ';
- else if (c == '*' && prev_c == '/'
- && CPP_OPTIONS (pfile)->warn_comments)
- cpp_warning (pfile, "`/*' within comment");
-
- prev_c = c;
- }
- }
- else if ((m == '/' && PEEKC() == '/'
- && CPP_OPTIONS (pfile)->cplusplus_comments)
- || (m == '-' && PEEKC() == '-'
- && CPP_OPTIONS (pfile)->chill))
- {
- FORWARD(1);
- for (;;)
- {
- int c = GETC ();
- if (c == EOF)
- return ' '; /* Allow // to be terminated by EOF. */
- if (c == '\n')
- {
- /* Don't consider final '\n' to be part of comment. */
- FORWARD(-1);
- return ' ';
- }
- else if (c == '\r')
- /* \r cannot be a macro escape marker here. */
- CPP_BUMP_LINE (pfile);
- }
- }
- else
- return m;
+ if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
+ cpp_pedwarn (pfile, "extra tokens at end of #%s directive",
+ pfile->directive->name);
}
-/* Identical to skip_comment except that it copies the comment into the
- token_buffer. This is used if put_out_comments. */
-static int
-copy_comment (pfile, m)
+/* Called when entering a directive, _Pragma or command-line directive. */
+static void
+start_directive (pfile)
cpp_reader *pfile;
- int m;
{
- if (m == '/' && PEEKC() == '*')
- {
- int c, prev_c = -1;
- long line, col;
-
- CPP_PUTC (pfile, '/');
- CPP_PUTC (pfile, '*');
- FORWARD(1);
- cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
- for (;;)
- {
- c = GETC ();
- if (c == EOF)
- {
- cpp_error_with_line (pfile, line, col, "unterminated comment");
- /* We must pretend this was a legitimate comment, so that the
- output in token_buffer is not passed back tagged CPP_POP. */
- return ' ';
- }
- else if (c == '\r')
- {
- /* \r cannot be a macro escape marker here. */
- CPP_BUMP_LINE (pfile);
- continue;
- }
-
- CPP_PUTC (pfile, c);
- if (c == '\n')
- {
- pfile->lineno++;
- CPP_BUMP_LINE (pfile);
- }
- else if (c == '/' && prev_c == '*')
- return ' ';
- else if (c == '*' && prev_c == '/'
- && CPP_OPTIONS (pfile)->warn_comments)
- cpp_warning (pfile, "`/*' within comment");
+ /* Setup in-directive state. */
+ pfile->state.in_directive = 1;
+ pfile->state.save_comments = 0;
- prev_c = c;
- }
- }
- else if ((m == '/' && PEEKC() == '/'
- && CPP_OPTIONS (pfile)->cplusplus_comments)
- || (m == '-' && PEEKC() == '-'
- && CPP_OPTIONS (pfile)->chill))
- {
- CPP_PUTC (pfile, m);
- CPP_PUTC (pfile, m);
- FORWARD(1);
- for (;;)
- {
- int c = GETC ();
- if (c == EOF)
- return ' '; /* Allow line comments to be terminated by EOF. */
- else if (c == '\n')
- {
- /* Don't consider final '\n' to be part of comment. */
- FORWARD(-1);
- return ' ';
- }
- else if (c == '\r')
- /* \r cannot be a macro escape marker here. */
- CPP_BUMP_LINE (pfile);
-
- CPP_PUTC (pfile, c);
- }
- }
- else
- return m;
+ /* Some handlers need the position of the # for diagnostics. */
+ pfile->directive_line = pfile->line;
}
-
-/* Skip whitespace \-newline and comments. Does not macro-expand. */
-
-void
-cpp_skip_hspace (pfile)
+/* Called when leaving a directive, _Pragma or command-line directive. */
+static void
+end_directive (pfile, skip_line)
cpp_reader *pfile;
+ int skip_line;
{
- int c;
- while (1)
+ /* We don't skip for an assembler #. */
+ if (skip_line)
{
- c = GETC();
- if (c == EOF)
- return;
- else if (is_hspace(c))
- {
- if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "%s in preprocessing directive",
- c == '\f' ? "formfeed" : "vertical tab");
- }
- else if (c == '\r')
- {
- /* \r is a backslash-newline marker if !has_escapes, and
- a deletable-whitespace or no-reexpansion marker otherwise. */
- if (CPP_BUFFER (pfile)->has_escapes)
- {
- if (PEEKC() == ' ')
- FORWARD(1);
- else
- break;
- }
- else
- CPP_BUFFER (pfile)->lineno++;
- }
- else if (c == '/' || c == '-')
+ skip_rest_of_line (pfile);
+ if (!pfile->keep_tokens)
{
- c = skip_comment (pfile, c);
- if (c == EOF)
- return;
- else if (c != ' ')
- break;
+ pfile->cur_run = &pfile->base_run;
+ pfile->cur_token = pfile->base_run.base;
}
- else
- break;
}
- FORWARD(-1);
-}
-/* Read the rest of the current line.
- The line is appended to PFILE's output buffer. */
+ /* Restore state. */
+ pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
+ pfile->state.in_directive = 0;
+ pfile->state.angled_headers = 0;
+ pfile->state.line_extension = 0;
+ pfile->directive = 0;
+}
+/* Output diagnostics for a directive DIR. INDENTED is non-zero if
+ the '#' was indented. */
static void
-copy_rest_of_line (pfile)
+directive_diagnostics (pfile, dir, indented)
cpp_reader *pfile;
+ const directive *dir;
+ int indented;
{
- for (;;)
+ if (pfile->state.line_extension)
+ {
+ if (CPP_PEDANTIC (pfile)
+ && ! pfile->state.skipping)
+ cpp_pedwarn (pfile, "style of line directive is a GCC extension");
+ }
+ else
{
- int c = GETC();
- switch (c)
+ /* Issue -pedantic warnings for extensions. */
+ if (CPP_PEDANTIC (pfile)
+ && ! pfile->state.skipping
+ && dir->origin == EXTENSION)
+ cpp_pedwarn (pfile, "#%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
+ compilers, directives added by C89 must have their #
+ indented, and directives present in traditional C must not.
+ This is true even of directives in skipped conditional
+ blocks. #elif cannot be used at all. */
+ if (CPP_WTRADITIONAL (pfile))
{
- case '\n':
- FORWARD(-1);
- case EOF:
- CPP_NUL_TERMINATE (pfile);
- return;
-
- case '\r':
- if (CPP_BUFFER (pfile)->has_escapes)
- break;
- else
- {
- CPP_BUFFER (pfile)->lineno++;
- continue;
- }
- case '\'':
- case '\"':
- parse_string (pfile, c);
- continue;
- case '/':
- if (PEEKC() == '*' && CPP_TRADITIONAL (pfile))
- {
- CPP_PUTS (pfile, "/**/", 4);
- skip_comment (pfile, c);
- continue;
- }
- /* else fall through */
- case '-':
- c = skip_comment (pfile, c);
- break;
-
- case '\f':
- case '\v':
- if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "%s in preprocessing directive",
- c == '\f' ? "formfeed" : "vertical tab");
- break;
-
+ if (dir == &dtable[T_ELIF])
+ cpp_warning (pfile, "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);
+ else if (!indented && dir->origin != KANDR)
+ cpp_warning (pfile,
+ "suggest hiding #%s from traditional C with an indented #",
+ dir->name);
}
- CPP_PUTC (pfile, c);
}
}
-/* FIXME: It is almost definitely a performance win to make this do
- the scan itself. >75% of calls to copy_r_o_l are from here or
- skip_if_group, which means the common case is to copy stuff into the
- token_buffer only to discard it. */
-void
-skip_rest_of_line (pfile)
- cpp_reader *pfile;
-{
- long old = CPP_WRITTEN (pfile);
- copy_rest_of_line (pfile);
- CPP_SET_WRITTEN (pfile, old);
-}
-
-/* Handle a possible # directive.
- '#' has already been read. */
-
-static int
-handle_directive (pfile)
+/* Check if we have a known directive. INDENTED is non-zero if the
+ '#' of the directive was indented. This function is in this file
+ to save unnecessarily exporting dtable etc. to cpplex.c. Returns
+ non-zero if the line of tokens has been handled, zero if we should
+ continue processing the line. */
+int
+_cpp_handle_directive (pfile, indented)
cpp_reader *pfile;
+ int indented;
{
- int c;
- register const struct directive *kt;
- int ident_length;
- U_CHAR *ident;
- long old_written = CPP_WRITTEN (pfile);
+ const directive *dir = 0;
+ const cpp_token *dname;
+ bool was_parsing_args = pfile->state.parsing_args;
+ int skip = 1;
- cpp_skip_hspace (pfile);
-
- c = PEEKC ();
- if (c >= '0' && c <= '9')
+ if (was_parsing_args)
{
- /* Handle # followed by a line number. Complain about using that
- form if we're being pedantic, but not if this is regurgitated
- input (preprocessed or fed back in by the C++ frontend). */
- if (CPP_PEDANTIC (pfile)
- && ! CPP_PREPROCESSED (pfile)
- && ! CPP_BUFFER (pfile)->manual_pop)
- cpp_pedwarn (pfile, "`#' followed by integer");
- do_line (pfile, NULL);
- return 1;
+ if (CPP_OPTION (pfile, pedantic))
+ cpp_pedwarn (pfile,
+ "embedding a directive within macro arguments is not portable");
+ pfile->state.parsing_args = 0;
+ pfile->state.prevent_expansion = 0;
}
+ start_directive (pfile);
+ dname = _cpp_lex_token (pfile);
- /* Now find the directive name. */
- CPP_PUTC (pfile, '#');
- parse_name (pfile, GETC());
- ident = pfile->token_buffer + old_written + 1;
- ident_length = CPP_PWRITTEN (pfile) - ident;
- if (ident_length == 0)
+ if (dname->type == CPP_NAME)
{
- /* A line of just `#' becomes blank. */
- if (PEEKC() == '\n')
- return 1;
- else
- return 0;
+ if (dname->val.node->directive_index)
+ dir = &dtable[dname->val.node->directive_index - 1];
}
-
- /*
- * Decode the keyword and call the appropriate expansion
- * routine, after moving the input pointer up to the next line.
- */
- for (kt = directive_table; ; kt++)
+ /* We do not recognise the # followed by a number extension in
+ assembler code. */
+ else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
{
- if (kt->length <= 0)
- return 0;
- if (kt->length == ident_length
- && !strncmp (kt->name, ident, ident_length))
- break;
+ dir = &dtable[T_LINE];
+ pfile->state.line_extension = 1;
}
- CPP_SET_WRITTEN (pfile, old_written);
- (*kt->func) (pfile, kt);
-
- return 1;
-}
-
-/* Pass a directive through to the output file.
- BUF points to the contents of the directive, as a contiguous string.
- LEN is the length of the string pointed to by BUF.
- KEYWORD is the keyword-table entry for the directive. */
-
-static void
-pass_thru_directive (buf, len, pfile, keyword)
- const U_CHAR *buf;
- size_t len;
- cpp_reader *pfile;
- const struct directive *keyword;
-{
- register unsigned keyword_length = keyword->length;
-
- CPP_RESERVE (pfile, 1 + keyword_length + len);
- CPP_PUTC_Q (pfile, '#');
- CPP_PUTS_Q (pfile, keyword->name, keyword_length);
- if (len != 0 && buf[0] != ' ')
- CPP_PUTC_Q (pfile, ' ');
- CPP_PUTS_Q (pfile, buf, len);
-}
-
-/* Check a purported macro name SYMNAME, and yield its length. */
-
-int
-check_macro_name (pfile, symname)
- cpp_reader *pfile;
- const U_CHAR *symname;
-{
- const U_CHAR *p;
- int sym_length;
-
- for (p = symname; is_idchar(*p); p++)
- ;
- sym_length = p - symname;
- if (sym_length == 0
- || (sym_length == 1 && *symname == 'L' && (*p == '\'' || *p == '"')))
- cpp_error (pfile, "invalid macro name");
- else if (!is_idstart(*symname)
- || (! strncmp (symname, "defined", 7) && sym_length == 7)) {
- U_CHAR *msg; /* what pain... */
- msg = (U_CHAR *) alloca (sym_length + 1);
- bcopy (symname, msg, sym_length);
- msg[sym_length] = 0;
- cpp_error (pfile, "invalid macro name `%s'", msg);
- }
- return sym_length;
-}
-
-/* Process a #define command.
- KEYWORD is the keyword-table entry for #define,
- or NULL for a "predefined" macro,
- or the keyword-table entry for #pragma in the case of a #pragma poison. */
-
-static int
-do_define (pfile, keyword)
- cpp_reader *pfile;
- const struct directive *keyword;
-{
- int hashcode;
- MACRODEF mdef;
- HASHNODE *hp;
- long here;
- U_CHAR *macro, *buf, *end;
- enum node_type new_type;
-
- here = CPP_WRITTEN (pfile);
- copy_rest_of_line (pfile);
-
- if (keyword == NULL || keyword->type == T_DEFINE)
- new_type = T_MACRO;
- else
- new_type = T_POISON;
-
- /* Copy out the line so we can pop the token buffer. */
- buf = pfile->token_buffer + here;
- end = CPP_PWRITTEN (pfile);
- macro = (U_CHAR *) alloca (end - buf + 1);
- bcopy (buf, macro, end - buf + 1);
- end = macro + (end - buf);
-
- CPP_SET_WRITTEN (pfile, here);
+ if (dir)
+ {
+ /* If we have a directive that is not an opening conditional,
+ invalidate any control macro. */
+ if (! (dir->flags & IF_COND))
+ pfile->mi_valid = false;
- mdef = create_definition (macro, end, pfile, keyword == NULL);
- if (mdef.defn == 0)
- return 0;
+ /* Kluge alert. In order to be sure that code like this
- hashcode = hashf (mdef.symnam, mdef.symlen, HASHSIZE);
+ #define HASH #
+ HASH define foo bar
- if ((hp = cpp_lookup (pfile, mdef.symnam, mdef.symlen, hashcode)) != NULL)
- {
- int ok = 0;
- /* Redefining a precompiled key is ok. */
- if (hp->type == T_PCSTRING)
- ok = 1;
- /* Redefining a poisoned identifier is even worse than `not ok'. */
- else if (hp->type == T_POISON)
- ok = -1;
- /* Redefining a macro is ok if the definitions are the same. */
- else if (hp->type == T_MACRO)
- ok = ! compare_defs (pfile, mdef.defn, hp->value.defn);
- /* Redefining a constant is ok with -D. */
- else if (hp->type == T_CONST || hp->type == T_STDC)
- ok = ! CPP_OPTIONS (pfile)->done_initializing;
- /* Print the warning or error if it's not ok. */
- if (ok <= 0)
+ does not cause '#define foo bar' to get executed when
+ compiled with -save-temps, we recognize directives in
+ -fpreprocessed mode only if the # is in column 1. cppmacro.c
+ puts a space in front of any '#' at the start of a macro. */
+ if (CPP_OPTION (pfile, preprocessed)
+ && (indented || !(dir->flags & IN_I)))
{
- if (hp->type == T_POISON)
- cpp_error (pfile, "redefining poisoned `%.*s'",
- mdef.symlen, mdef.symnam);
- else
- cpp_pedwarn (pfile, "`%.*s' redefined", mdef.symlen, mdef.symnam);
- if (hp->type == T_MACRO)
- cpp_pedwarn_with_file_and_line (pfile, hp->value.defn->file,
- hp->value.defn->line,
- "this is the location of the previous definition");
+ skip = 0;
+ dir = 0;
}
- if (hp->type != T_POISON)
+ else
{
- /* Replace the old definition. */
- hp->type = new_type;
- hp->value.defn = mdef.defn;
+ /* In failed conditional groups, all non-conditional
+ directives are ignored. Before doing that, whether
+ skipping or not, we should lex angle-bracketed headers
+ correctly, and maybe output some diagnostics. */
+ pfile->state.angled_headers = dir->flags & INCL;
+ if (! CPP_OPTION (pfile, preprocessed))
+ directive_diagnostics (pfile, dir, indented);
+ if (pfile->state.skipping && !(dir->flags & COND))
+ dir = 0;
}
}
+ else if (dname->type == CPP_EOF)
+ ; /* CPP_EOF is the "null directive". */
else
- cpp_install (pfile, mdef.symnam, mdef.symlen, new_type,
- (char *) mdef.defn, hashcode);
-
- if (keyword != NULL && keyword->type == T_DEFINE)
{
- if (CPP_OPTIONS (pfile)->debug_output
- || CPP_OPTIONS (pfile)->dump_macros == dump_definitions)
- dump_definition (pfile, mdef);
- else if (CPP_OPTIONS (pfile)->dump_macros == dump_names)
- pass_thru_directive (mdef.symnam, mdef.symlen, pfile, keyword);
+ /* An unknown directive. Don't complain about it in assembly
+ source: we don't know where the comments are, and # may
+ introduce assembler pseudo-ops. Don't complain about invalid
+ directives in skipped conditional groups (6.10 p4). */
+ if (CPP_OPTION (pfile, lang) == CLK_ASM)
+ skip = 0;
+ else if (!pfile->state.skipping)
+ cpp_error (pfile, "invalid preprocessing directive #%s",
+ cpp_token_as_text (pfile, dname));
}
- return 0;
-}
-
-
-/* Allocate a new cpp_buffer for PFILE, and push it on the input buffer stack.
- If BUFFER != NULL, then use the LENGTH characters in BUFFER
- as the new input buffer.
- Return the new buffer, or NULL on failure. */
-
-cpp_buffer *
-cpp_push_buffer (pfile, buffer, length)
- cpp_reader *pfile;
- U_CHAR *buffer;
- long length;
-{
- cpp_buffer *buf = CPP_BUFFER (pfile);
- cpp_buffer *new;
- if (++pfile->buffer_stack_depth == CPP_STACK_MAX)
+ if (dir)
{
- cpp_fatal (pfile, "macro or `#include' recursion too deep");
- return NULL;
+ pfile->directive = dir;
+ (*pfile->directive->handler) (pfile);
}
+ else if (skip == 0)
+ _cpp_backup_tokens (pfile, 1);
- new = (cpp_buffer *) xcalloc (1, sizeof (cpp_buffer));
-
- new->if_stack = pfile->if_stack;
- new->cleanup = null_cleanup;
- new->underflow = null_underflow;
- new->buf = new->cur = buffer;
- new->alimit = new->rlimit = buffer + length;
- new->prev = buf;
- new->mark = -1;
-
- CPP_BUFFER (pfile) = new;
- return new;
-}
-
-cpp_buffer *
-cpp_pop_buffer (pfile)
- cpp_reader *pfile;
-{
- cpp_buffer *buf = CPP_BUFFER (pfile);
- (*buf->cleanup) (buf, pfile);
- CPP_BUFFER (pfile) = CPP_PREV_BUFFER (buf);
- free (buf);
- pfile->buffer_stack_depth--;
- return CPP_BUFFER (pfile);
-}
-
-/* Scan until CPP_BUFFER (PFILE) is exhausted into PFILE->token_buffer.
- Pop the buffer when done. */
-
-void
-cpp_scan_buffer (pfile)
- cpp_reader *pfile;
-{
- cpp_buffer *buffer = CPP_BUFFER (pfile);
- enum cpp_token token;
- if (CPP_OPTIONS (pfile)->no_output)
+ end_directive (pfile, skip);
+ if (was_parsing_args)
{
- long old_written = CPP_WRITTEN (pfile);
- /* In no-output mode, we can ignore everything but directives. */
- for (;;)
- {
- if (! pfile->only_seen_white)
- skip_rest_of_line (pfile);
- token = cpp_get_token (pfile);
- if (token == CPP_EOF) /* Should not happen ... */
- break;
- if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
- {
- if (CPP_PREV_BUFFER (CPP_BUFFER (pfile))
- != CPP_NULL_BUFFER (pfile))
- cpp_pop_buffer (pfile);
- break;
- }
- }
- CPP_SET_WRITTEN (pfile, old_written);
- }
- else
- {
- for (;;)
- {
- token = cpp_get_token (pfile);
- if (token == CPP_EOF) /* Should not happen ... */
- break;
- if (token == CPP_POP && CPP_BUFFER (pfile) == buffer)
- {
- if (CPP_PREV_BUFFER (CPP_BUFFER (pfile))
- != CPP_NULL_BUFFER (pfile))
- cpp_pop_buffer (pfile);
- break;
- }
- }
+ /* Restore state when within macro args. */
+ pfile->state.parsing_args = 2;
+ pfile->state.prevent_expansion = 1;
+ pfile->buffer->saved_flags |= PREV_WHITE;
}
+ return skip;
}
-/*
- * Rescan a string (which may have escape marks) into pfile's buffer.
- * Place the result in pfile->token_buffer.
- *
- * The input is copied before it is scanned, so it is safe to pass
- * it something from the token_buffer that will get overwritten
- * (because it follows CPP_WRITTEN). This is used by do_include.
- */
-
-void
-cpp_expand_to_buffer (pfile, buf, length)
+/* Directive handler wrapper used by the command line option
+ processor. */
+static void
+run_directive (pfile, dir_no, buf, count)
+ cpp_reader *pfile;
+ int dir_no;
+ const char *buf;
+ size_t count;
+{
+ cpp_push_buffer (pfile, (const U_CHAR *) buf, count,
+ /* from_stage3 */ true, 1);
+ start_directive (pfile);
+ /* We don't want a leading # to be interpreted as a directive. */
+ pfile->buffer->saved_flags = 0;
+ pfile->directive = &dtable[dir_no];
+ (void) (*pfile->directive->handler) (pfile);
+ end_directive (pfile, 1);
+ _cpp_pop_buffer (pfile);
+}
+
+/* Checks for validity the macro name in #define, #undef, #ifdef and
+ #ifndef directives. */
+static cpp_hashnode *
+lex_macro_node (pfile)
cpp_reader *pfile;
- const U_CHAR *buf;
- int length;
{
- register cpp_buffer *ip;
- U_CHAR *buf1;
- int save_no_output;
+ cpp_hashnode *node;
+ const cpp_token *token = _cpp_lex_token (pfile);
+
+ /* The token immediately after #define must be an identifier. That
+ identifier may not be "defined", per C99 6.10.8p4.
+ In C++, it may not be any of the "named operators" either,
+ per C++98 [lex.digraph], [lex.key].
+ Finally, the identifier may not have been poisoned. (In that case
+ the lexer has issued the error message for us.) */
+
+ if (token->type != CPP_NAME)
+ {
+ if (token->type == CPP_EOF)
+ cpp_error (pfile, "no macro name given in #%s directive",
+ pfile->directive->name);
+ else if (token->flags & NAMED_OP)
+ cpp_error (pfile,
+ "\"%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");
- if (length < 0)
- {
- cpp_fatal (pfile, "internal error: length < 0 in cpp_expand_to_buffer");
- return;
+ return 0;
}
- /* Set up the input on the input stack. */
-
- buf1 = (U_CHAR *) alloca (length + 1);
- memcpy (buf1, buf, length);
- buf1[length] = 0;
-
- ip = cpp_push_buffer (pfile, buf1, length);
- if (ip == NULL)
- return;
- ip->has_escapes = 1;
-
- /* Scan the input, create the output. */
- save_no_output = CPP_OPTIONS (pfile)->no_output;
- CPP_OPTIONS (pfile)->no_output = 0;
- cpp_scan_buffer (pfile);
- CPP_OPTIONS (pfile)->no_output = save_no_output;
-
- CPP_NUL_TERMINATE (pfile);
-}
+ node = token->val.node;
+ if (node->flags & NODE_POISONED)
+ return 0;
-void
-cpp_buf_line_and_col (pbuf, linep, colp)
- register cpp_buffer *pbuf;
- long *linep, *colp;
-{
- if (pbuf)
- {
- *linep = pbuf->lineno;
- if (colp)
- *colp = pbuf->cur - pbuf->line_base;
- }
- else
+ if (node == pfile->spec_nodes.n_defined)
{
- *linep = 0;
- if (colp)
- *colp = 0;
+ cpp_error (pfile, "\"%s\" cannot be used as a macro name",
+ NODE_NAME (node));
+ return 0;
}
-}
-/* Return the cpp_buffer that corresponds to a file (not a macro). */
+ return node;
+}
-cpp_buffer *
-cpp_file_buffer (pfile)
+/* Process a #define directive. Most work is done in cppmacro.c. */
+static void
+do_define (pfile)
cpp_reader *pfile;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
+ cpp_hashnode *node = lex_macro_node (pfile);
- for ( ; ip != CPP_NULL_BUFFER (pfile); ip = CPP_PREV_BUFFER (ip))
- if (ip->fname != NULL)
- return ip;
- return NULL;
+ if (node)
+ {
+ if (_cpp_create_definition (pfile, node))
+ if (pfile->cb.define)
+ (*pfile->cb.define) (pfile, pfile->directive_line, node);
+ }
}
-/*
- * write out a #line command, for instance, after an #include file.
- * FILE_CHANGE says whether we are entering a file, leaving, or neither.
- */
-
-void
-output_line_command (pfile, file_change)
+/* Handle #undef. Mark the identifier NT_VOID in the hash table. */
+static void
+do_undef (pfile)
cpp_reader *pfile;
- enum file_change_code file_change;
{
- long line;
- cpp_buffer *ip = CPP_BUFFER (pfile);
-
- if (ip->fname == NULL)
- return;
+ cpp_hashnode *node = lex_macro_node (pfile);
- if (CPP_OPTIONS (pfile)->no_line_commands
- || CPP_OPTIONS (pfile)->no_output)
- return;
-
- cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, NULL);
-
- /* If the current file has not changed, we omit the #line if it would
- appear to be a no-op, and we output a few newlines instead
- if we want to increase the line number by a small amount.
- We cannot do this if pfile->lineno is zero, because that means we
- haven't output any line commands yet. (The very first line command
- output is a `same_file' command.) */
- if (file_change == same_file && pfile->lineno != 0)
+ /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified identifier
+ is not currently defined as a macro name. */
+ if (node && node->type == NT_MACRO)
{
- if (line == pfile->lineno)
- return;
+ if (pfile->cb.undef)
+ (*pfile->cb.undef) (pfile, pfile->directive_line, node);
- /* If the inherited line number is a little too small,
- output some newlines instead of a #line command. */
- if (line > pfile->lineno && line < pfile->lineno + 8)
- {
- CPP_RESERVE (pfile, 20);
- while (line > pfile->lineno)
- {
- CPP_PUTC_Q (pfile, '\n');
- pfile->lineno++;
- }
- return;
- }
- }
+ if (node->flags & NODE_WARN)
+ cpp_warning (pfile, "undefining \"%s\"", NODE_NAME (node));
- CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50);
- CPP_PUTS_Q (pfile, "# ", 2);
-
- sprintf ((char *) CPP_PWRITTEN (pfile), "%ld ", line);
- CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
-
- quote_string (pfile, ip->nominal_fname);
- if (file_change != same_file)
- {
- CPP_PUTC_Q (pfile, ' ');
- CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
+ _cpp_free_definition (node);
}
- /* Tell cc1 if following text comes from a system header file. */
- if (ip->system_header_p)
- {
- CPP_PUTC_Q (pfile, ' ');
- CPP_PUTC_Q (pfile, '3');
- }
-#ifndef NO_IMPLICIT_EXTERN_C
- /* Tell cc1plus if following text should be treated as C. */
- if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus)
- {
- CPP_PUTC_Q (pfile, ' ');
- CPP_PUTC_Q (pfile, '4');
- }
-#endif
- CPP_PUTC_Q (pfile, '\n');
- pfile->lineno = line;
+ check_eol (pfile);
}
-
-/* Like cpp_get_token, except that it does not read past end-of-line.
- Also, horizontal space is skipped, and macros are popped. */
-
-static enum cpp_token
-get_directive_token (pfile)
+/* Helper routine used by parse_include. Reinterpret the current line
+ as an h-char-sequence (< ... >); we are looking at the first token
+ after the <. Returns the header as a token, or NULL on failure. */
+static const cpp_token *
+glue_header_name (pfile)
cpp_reader *pfile;
{
+ cpp_token *header = NULL;
+ const cpp_token *token;
+ unsigned char *buffer;
+ size_t len, total_len = 0, capacity = 1024;
+
+ /* To avoid lexed tokens overwriting our glued name, we can only
+ allocate from the string pool once we've lexed everything. */
+ buffer = (unsigned char *) xmalloc (capacity);
for (;;)
{
- long old_written = CPP_WRITTEN (pfile);
- enum cpp_token token;
- cpp_skip_hspace (pfile);
- if (PEEKC () == '\n')
- return CPP_VSPACE;
token = cpp_get_token (pfile);
- switch (token)
- {
- case CPP_POP:
- if (! CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
- return token;
- /* ... else fall though ... */
- case CPP_HSPACE: case CPP_COMMENT:
- CPP_SET_WRITTEN (pfile, old_written);
- break;
- default:
- return token;
- }
- }
-}
-\f
-/* Handle #include and #import.
- This function expects to see "fname" or <fname> on the input.
-
- The input is normally in part of the output_buffer following
- CPP_WRITTEN, and will get overwritten by output_line_command.
- I.e. in input file specification has been popped by handle_directive.
- This is safe. */
-
-static int
-do_include (pfile, keyword)
- cpp_reader *pfile;
- const struct directive *keyword;
-{
- int importing = (keyword->type == T_IMPORT);
- int skip_dirs = (keyword->type == T_INCLUDE_NEXT);
- int angle_brackets = 0; /* 0 for "...", 1 for <...> */
- int before; /* included before? */
- long flen;
- unsigned char *ftok;
- cpp_buffer *fp;
-
- enum cpp_token token;
-
- /* Chain of dirs to search */
- struct include_hash *ihash;
- struct file_name_list *search_start;
-
- long old_written = CPP_WRITTEN (pfile);
-
- int fd;
- if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
- {
- if (importing)
- cpp_pedwarn (pfile, "ANSI C does not allow `#import'");
- if (skip_dirs)
- cpp_pedwarn (pfile, "ANSI C does not allow `#include_next'");
- }
+ if (token->type == CPP_GREATER || token->type == CPP_EOF)
+ break;
- if (importing && CPP_OPTIONS (pfile)->warn_import
- && !CPP_OPTIONS (pfile)->inhibit_warnings
- && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
- {
- pfile->import_warning = 1;
- cpp_warning (pfile,
- "#import is obsolete, use an #ifndef wrapper in the header file");
- }
+ len = cpp_token_len (token);
+ if (total_len + len > capacity)
+ {
+ capacity = (capacity + len) * 2;
+ buffer = (unsigned char *) xrealloc (buffer, capacity);
+ }
- pfile->parsing_include_directive++;
- token = get_directive_token (pfile);
- pfile->parsing_include_directive--;
+ if (token->flags & PREV_WHITE)
+ buffer[total_len++] = ' ';
- if (token == CPP_STRING)
- {
- if (pfile->token_buffer[old_written] == '<')
- angle_brackets = 1;
+ total_len = cpp_spell_token (pfile, token, &buffer[total_len]) - buffer;
}
-#ifdef VMS
- else if (token == CPP_NAME)
- {
- /* Support '#include xyz' like VAX-C. It is taken as
- '#include <xyz.h>' and generates a warning. */
- cpp_warning (pfile,
- "`#include filename' is obsolete, use `#include <filename.h>'");
- angle_brackets = 1;
- /* Append the missing `.h' to the name. */
- CPP_PUTS (pfile, ".h", 2);
- }
-#endif
+ if (token->type == CPP_EOF)
+ cpp_error (pfile, "missing terminating > character");
else
{
- cpp_error (pfile,
- "`#%s' expects \"FILENAME\" or <FILENAME>", keyword->name);
- CPP_SET_WRITTEN (pfile, old_written);
- skip_rest_of_line (pfile);
- return 0;
- }
-
- flen = CPP_WRITTEN (pfile) - old_written;
- ftok = (unsigned char *) alloca (flen + 1);
- memcpy (ftok, pfile->token_buffer + old_written, flen);
- ftok[flen] = '\0';
-
- if (get_directive_token (pfile) != CPP_VSPACE)
- {
- cpp_error (pfile, "junk at end of `#include'");
- skip_rest_of_line (pfile);
- }
-
- CPP_SET_WRITTEN (pfile, old_written);
-
- if (flen == 0)
- {
- cpp_error (pfile, "empty file name in `#%s'", keyword->name);
- return 0;
- }
-
- if (CPP_OPTIONS (pfile)->dump_includes)
- pass_thru_directive (ftok,
- flen
-#ifdef VMS
- - ((token == CPP_NAME) ? 2 : 0)
-#endif
- , pfile, keyword);
+ unsigned char *token_mem = _cpp_unaligned_alloc (pfile, total_len + 1);
+ memcpy (token_mem, buffer, total_len);
+ token_mem[total_len] = '\0';
-#ifdef VMS
- if (token == CPP_STRING)
-#endif
- {
- ftok++;
- flen -= 2;
- ftok[flen] = '\0';
+ header = _cpp_temp_token (pfile);
+ header->type = CPP_HEADER_NAME;
+ header->flags = 0;
+ header->val.str.len = total_len;
+ header->val.str.text = token_mem;
}
- search_start = 0;
+ free ((PTR) buffer);
+ return header;
+}
- for (fp = CPP_BUFFER (pfile);
- fp != CPP_NULL_BUFFER (pfile);
- fp = CPP_PREV_BUFFER (fp))
- if (fp->fname != NULL)
- break;
+/* Returns the header string of #include, #include_next, #import and
+ #pragma dependency. Returns NULL on error. */
+static const cpp_token *
+parse_include (pfile)
+ cpp_reader *pfile;
+{
+ const unsigned char *dir;
+ const cpp_token *header;
- if (fp == CPP_NULL_BUFFER (pfile))
- {
- cpp_fatal (pfile, "cpp internal error: fp == NULL_BUFFER in do_include");
- return 0;
- }
-
- /* For #include_next, skip in the search path past the dir in which the
- containing file was found. Treat files specified using an absolute path
- as if there are no more directories to search. Treat the primary source
- file like any other included source, but generate a warning. */
- if (skip_dirs && CPP_PREV_BUFFER(fp) != CPP_NULL_BUFFER (pfile))
- {
- if (fp->ihash->foundhere != ABSOLUTE_PATH)
- search_start = fp->ihash->foundhere->next;
- }
+ if (pfile->directive == &dtable[T_PRAGMA])
+ dir = U"pragma dependency";
else
- {
- if (skip_dirs)
- cpp_warning (pfile, "#include_next in primary source file");
-
- if (angle_brackets)
- search_start = CPP_OPTIONS (pfile)->bracket_include;
- else
- {
- if (!CPP_OPTIONS (pfile)->ignore_srcdir)
- {
- if (fp)
- search_start = fp->actual_dir;
- }
- else
- search_start = CPP_OPTIONS (pfile)->quote_include;
- }
- }
+ dir = pfile->directive->name;
- if (!search_start)
+ /* Allow macro expansion. */
+ header = cpp_get_token (pfile);
+ if (header->type != CPP_STRING && header->type != CPP_HEADER_NAME)
{
- cpp_error (pfile, "No include path in which to find %s", ftok);
- return 0;
- }
-
- fd = find_include_file (pfile, ftok, search_start, &ihash, &before);
-
- if (fd == -2)
- return 0;
-
- if (fd == -1)
- {
- if (CPP_OPTIONS (pfile)->print_deps_missing_files
- && CPP_PRINT_DEPS (pfile) > (angle_brackets ||
- (pfile->system_include_depth > 0)))
- {
- if (!angle_brackets)
- deps_output (pfile, ftok, ' ');
- else
- {
- char *p;
- struct file_name_list *ptr;
- /* If requested as a system header, assume it belongs in
- the first system header directory. */
- if (CPP_OPTIONS (pfile)->bracket_include)
- ptr = CPP_OPTIONS (pfile)->bracket_include;
- else
- ptr = CPP_OPTIONS (pfile)->quote_include;
-
- p = (char *) alloca (strlen (ptr->name)
- + strlen (ftok) + 2);
- if (*ptr->name != '\0')
- {
- strcpy (p, ptr->name);
- strcat (p, "/");
- }
- strcat (p, ftok);
- deps_output (pfile, p, ' ');
- }
+ if (header->type != CPP_LESS)
+ {
+ cpp_error (pfile, "#%s expects \"FILENAME\" or <FILENAME>", dir);
+ return NULL;
}
- /* If -M was specified, and this header file won't be added to
- the dependency list, then don't count this as an error,
- because 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. */
- else if (CPP_PRINT_DEPS (pfile)
- && (CPP_PRINT_DEPS (pfile)
- <= (angle_brackets || (pfile->system_include_depth > 0))))
- cpp_warning (pfile, "No include path in which to find %s", ftok);
- else
- cpp_error_from_errno (pfile, ftok);
-
- return 0;
- }
-
- /* For -M, add the file to the dependencies on its first inclusion. */
- if (!before && (CPP_PRINT_DEPS (pfile)
- > (angle_brackets || (pfile->system_include_depth > 0))))
- deps_output (pfile, ihash->name, ' ');
-
- /* Handle -H option. */
- if (CPP_OPTIONS(pfile)->print_include_names)
- {
- fp = CPP_BUFFER (pfile);
- while ((fp = CPP_PREV_BUFFER (fp)) != CPP_NULL_BUFFER (pfile))
- putc ('.', stderr);
- fprintf (stderr, " %s\n", ihash->name);
- }
- /* Actually process the file */
-
- if (importing)
- ihash->control_macro = "";
-
- if (cpp_push_buffer (pfile, NULL, 0) == NULL)
- {
- close (fd);
- return 0;
+ header = glue_header_name (pfile);
+ if (header == NULL)
+ return header;
}
-
- if (angle_brackets)
- pfile->system_include_depth++; /* Decremented in file_cleanup. */
- if (finclude (pfile, fd, ihash))
+ if (header->val.str.len == 0)
{
- output_line_command (pfile, enter_file);
- pfile->only_seen_white = 2;
+ cpp_error (pfile, "empty file name in #%s", dir);
+ return NULL;
}
- return 0;
+ return header;
}
-/* Subroutine of do_line. Read next token from PFILE without adding it to
- the output buffer. If it is a number between 1 and 4, store it in *NUM
- and return 1; otherwise, return 0 and complain if we aren't at the end
- of the directive. */
-
-static int
-read_line_number (pfile, num)
+/* Handle #include, #include_next and #import. */
+static void
+do_include_common (pfile, type)
cpp_reader *pfile;
- int *num;
+ enum include_type type;
{
- long save_written = CPP_WRITTEN (pfile);
- U_CHAR *p = pfile->token_buffer + save_written;
- enum cpp_token token = get_directive_token (pfile);
- CPP_SET_WRITTEN (pfile, save_written);
+ const cpp_token *header;
- if (token == CPP_NUMBER && *p >= '1' && *p <= '4' && p[1] == '\0')
+ /* For #include_next, if this is the primary source file, warn and
+ use the normal search logic. */
+ if (type == IT_INCLUDE_NEXT && ! pfile->buffer->prev)
{
- *num = p[0] - '0';
- return 1;
+ cpp_warning (pfile, "#include_next in primary source file");
+ type = IT_INCLUDE;
}
- else
+ else if (type == IT_IMPORT && CPP_OPTION (pfile, warn_import))
{
- if (token != CPP_VSPACE && token != CPP_EOF && token != CPP_POP)
- cpp_error (pfile, "invalid format `#line' command");
- return 0;
- }
-}
-
-/* Interpret #line command.
- Note that the filename string (if any) is treated as if it were an
- include filename. That means no escape handling. */
-
-static int
-do_line (pfile, keyword)
- cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
-{
- cpp_buffer *ip = CPP_BUFFER (pfile);
- int new_lineno;
- long old_written = CPP_WRITTEN (pfile);
- enum file_change_code file_change = same_file;
- enum cpp_token token;
- char *x;
-
- token = get_directive_token (pfile);
-
- if (token != CPP_NUMBER)
- {
- cpp_error (pfile, "token after `#line' is not an integer");
- goto bad_line_directive;
+ CPP_OPTION (pfile, warn_import) = 0;
+ cpp_warning (pfile,
+ "#import is obsolete, use an #ifndef wrapper in the header file");
}
- new_lineno = strtol (pfile->token_buffer + old_written, &x, 10);
- if (x[0] != '\0')
+ header = parse_include (pfile);
+ if (header)
{
- cpp_error (pfile, "token after `#line' is not an integer");
- goto bad_line_directive;
- }
- CPP_SET_WRITTEN (pfile, old_written);
-
- if (CPP_PEDANTIC (pfile) && new_lineno <= 0)
- cpp_pedwarn (pfile, "line number out of range in `#line' command");
-
- token = get_directive_token (pfile);
-
- if (token == CPP_STRING)
- {
- U_CHAR *fname = pfile->token_buffer + old_written + 1;
- U_CHAR *end_name = CPP_PWRITTEN (pfile) - 1;
- int action_number = 0;
-
- if (read_line_number (pfile, &action_number))
+ /* Prevent #include recursion. */
+ if (pfile->line_maps.depth >= CPP_STACK_MAX)
+ cpp_fatal (pfile, "#include nested too deeply");
+ else
{
- if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "garbage at end of `#line' command");
-
- if (action_number == 1)
- {
- file_change = enter_file;
- read_line_number (pfile, &action_number);
- }
- else if (action_number == 2)
- {
- file_change = leave_file;
- read_line_number (pfile, &action_number);
- }
- if (action_number == 3)
- {
- ip->system_header_p = 1;
- read_line_number (pfile, &action_number);
- }
- if (action_number == 4)
- {
- ip->system_header_p = 2;
- read_line_number (pfile, &action_number);
- }
+ check_eol (pfile);
+ /* Get out of macro context, if we are. */
+ skip_rest_of_line (pfile);
+ if (pfile->cb.include)
+ (*pfile->cb.include) (pfile, pfile->directive_line,
+ pfile->directive->name, header);
+
+ _cpp_execute_include (pfile, header, type);
}
-
- *end_name = '\0';
-
- if (strcmp (fname, ip->nominal_fname))
- {
- const char *newname, *oldname;
- if (!strcmp (fname, ip->fname))
- newname = ip->fname;
- else if (ip->last_nominal_fname
- && !strcmp (fname, ip->last_nominal_fname))
- newname = ip->last_nominal_fname;
- else
- newname = xstrdup (fname);
-
- oldname = ip->nominal_fname;
- ip->nominal_fname = newname;
-
- if (ip->last_nominal_fname
- && ip->last_nominal_fname != oldname
- && ip->last_nominal_fname != newname
- && ip->last_nominal_fname != ip->fname)
- free ((void *) ip->last_nominal_fname);
-
- if (newname == ip->fname)
- ip->last_nominal_fname = NULL;
- else
- ip->last_nominal_fname = oldname;
- }
- }
- else if (token != CPP_VSPACE && token != CPP_EOF)
- {
- cpp_error (pfile, "token after `#line %d' is not a string", new_lineno);
- goto bad_line_directive;
}
-
- /* 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. */
- ip->lineno = new_lineno - 1;
- CPP_SET_WRITTEN (pfile, old_written);
- output_line_command (pfile, file_change);
- return 0;
-
- bad_line_directive:
- skip_rest_of_line (pfile);
- CPP_SET_WRITTEN (pfile, old_written);
- return 0;
}
-/* Remove the definition of a symbol from the symbol table.
- According to the C standard, it is not an error to undef
- something that has no definitions. */
-static int
-do_undef (pfile, keyword)
+static void
+do_include (pfile)
cpp_reader *pfile;
- const struct directive *keyword;
-{
- int sym_length;
- HASHNODE *hp;
- U_CHAR *buf, *name, *limit;
- int c;
- long here = CPP_WRITTEN (pfile);
- enum cpp_token token;
-
- cpp_skip_hspace (pfile);
- c = GETC();
- if (! is_idstart(c))
- {
- cpp_error (pfile, "token after #undef is not an identifier");
- skip_rest_of_line (pfile);
- return 1;
- }
-
- parse_name (pfile, c);
- buf = pfile->token_buffer + here;
- limit = CPP_PWRITTEN(pfile);
-
- /* Copy out the token so we can pop the token buffer. */
- name = (U_CHAR *) alloca (limit - buf + 1);
- bcopy(buf, name, limit - buf);
- name[limit - buf] = '\0';
-
- token = get_directive_token (pfile);
- if (token != CPP_VSPACE && token != CPP_POP)
- {
- cpp_pedwarn (pfile, "junk on line after #undef");
- skip_rest_of_line (pfile);
- }
-
- CPP_SET_WRITTEN (pfile, here);
-
- sym_length = check_macro_name (pfile, buf);
-
- while ((hp = cpp_lookup (pfile, name, sym_length, -1)) != NULL)
- {
- /* If we are generating additional info for debugging (with -g) we
- need to pass through all effective #undef commands. */
- if (CPP_OPTIONS (pfile)->debug_output && keyword)
- pass_thru_directive (name, sym_length, pfile, keyword);
- if (hp->type == T_POISON)
- cpp_error (pfile, "cannot undefine poisoned `%s'", hp->name);
- else
- {
- if (hp->type != T_MACRO)
- cpp_warning (pfile, "undefining `%s'", hp->name);
- delete_macro (hp);
- }
- }
-
- return 0;
+{
+ do_include_common (pfile, IT_INCLUDE);
}
-/* Wrap do_undef for -U processing. */
-void
-cpp_undef (pfile, macro)
+static void
+do_import (pfile)
cpp_reader *pfile;
- U_CHAR *macro;
{
- if (cpp_push_buffer (pfile, macro, strlen (macro)))
- {
- do_undef (pfile, NULL);
- cpp_pop_buffer (pfile);
- }
+ do_include_common (pfile, IT_IMPORT);
}
-\f
-/*
- * Report an error detected by the program we are processing.
- * Use the text of the line in the error message.
- * (We use error because it prints the filename & line#.)
- */
-
-static int
-do_error (pfile, keyword)
+static void
+do_include_next (pfile)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
{
- long here = CPP_WRITTEN (pfile);
- U_CHAR *text;
- copy_rest_of_line (pfile);
- text = pfile->token_buffer + here;
- SKIP_WHITE_SPACE(text);
-
- cpp_error (pfile, "#error %s", text);
- CPP_SET_WRITTEN (pfile, here);
- return 0;
+ do_include_common (pfile, IT_INCLUDE_NEXT);
}
-/*
- * Report a warning detected by the program we are processing.
- * Use the text of the line in the warning message, then continue.
- */
-
-static int
-do_warning (pfile, keyword)
+/* Subroutine of do_line. Read possible flags after file name. LAST
+ is the last flag seen; 0 if this is the first flag. Return the flag
+ if it is valid, 0 at the end of the directive. Otherwise complain. */
+static unsigned int
+read_flag (pfile, last)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
+ unsigned int last;
{
- U_CHAR *text;
- long here = CPP_WRITTEN(pfile);
- copy_rest_of_line (pfile);
- text = pfile->token_buffer + here;
- SKIP_WHITE_SPACE(text);
+ const cpp_token *token = _cpp_lex_token (pfile);
+
+ if (token->type == CPP_NUMBER && token->val.str.len == 1)
+ {
+ unsigned int flag = token->val.str.text[0] - '0';
- if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
- cpp_pedwarn (pfile, "ANSI C does not allow `#warning'");
+ if (flag > last && flag <= 4
+ && (flag != 4 || last == 3)
+ && (flag != 2 || last == 0))
+ return flag;
+ }
- /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
- if -pedantic-errors is given, #warning should cause an error. */
- cpp_pedwarn (pfile, "#warning %s", text);
- CPP_SET_WRITTEN (pfile, here);
+ if (token->type != CPP_EOF)
+ cpp_error (pfile, "invalid flag \"%s\" in line directive",
+ cpp_token_as_text (pfile, token));
return 0;
}
-/* Report program identification.
- This is not precisely what cccp does with #ident, however I believe
- it matches `closely enough' (behavior is identical as long as there
- are no macros on the #ident line, which is pathological in my opinion). */
-
+/* Another subroutine of do_line. Convert a number in STR, of length
+ LEN, to binary; store it in NUMP, and return 0 if the number was
+ well-formed, 1 if not. Temporary, hopefully. */
static int
-do_ident (pfile, keyword)
- cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
+strtoul_for_line (str, len, nump)
+ const U_CHAR *str;
+ unsigned int len;
+ unsigned long *nump;
{
- /* Allow #ident in system headers, since that's not user's fault. */
- if (CPP_PEDANTIC (pfile) && !CPP_BUFFER (pfile)->system_header_p)
- cpp_pedwarn (pfile, "ANSI C does not allow `#ident'");
-
- CPP_PUTS (pfile, "#ident ", 7);
- cpp_skip_hspace (pfile);
- copy_rest_of_line (pfile);
-
+ unsigned long reg = 0;
+ U_CHAR c;
+ while (len--)
+ {
+ c = *str++;
+ if (!ISDIGIT (c))
+ return 1;
+ reg *= 10;
+ reg += c - '0';
+ }
+ *nump = reg;
return 0;
}
-/* Just check for some recognized pragmas that need validation here,
- and leave the text in the token buffer to be output. */
-
-static int
-do_pragma (pfile, keyword)
+/* Interpret #line command.
+ Note that the filename string (if any) is treated as if it were an
+ include filename. That means no escape handling. */
+static void
+do_line (pfile)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
{
- long here;
- U_CHAR *buf;
+ const cpp_token *token;
+ const char *new_file = pfile->map->to_file;
+ unsigned long new_lineno;
+ unsigned int cap, new_sysp = pfile->map->sysp;
+ enum lc_reason reason = LC_RENAME;
- CPP_PUTS (pfile, "#pragma ", 8);
- cpp_skip_hspace (pfile);
-
- here = CPP_WRITTEN (pfile);
- copy_rest_of_line (pfile);
- buf = pfile->token_buffer + here;
-
- if (!strncmp (buf, "once", 4))
- {
- cpp_buffer *ip = NULL;
-
- /* Allow #pragma once in system headers, since that's not the user's
- fault. */
- if (!CPP_BUFFER (pfile)->system_header_p)
- cpp_warning (pfile, "`#pragma once' is obsolete");
-
- for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
- {
- if (ip == CPP_NULL_BUFFER (pfile))
- return 0;
- if (ip->fname != NULL)
- break;
- }
+ /* C99 raised the minimum limit on #line numbers. */
+ cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
- if (CPP_PREV_BUFFER (ip) == CPP_NULL_BUFFER (pfile))
- cpp_warning (pfile, "`#pragma once' outside include file");
- else
- ip->ihash->control_macro = ""; /* never repeat */
- }
- else if (!strncmp (buf, "implementation", 14))
- {
- /* Be quiet about `#pragma implementation' for a file only if it hasn't
- been included yet. */
- struct include_hash *ptr;
- U_CHAR *p = buf + 14, *fname, *fcopy;
- SKIP_WHITE_SPACE (p);
- if (*p == '\n' || *p != '\"')
- return 0;
-
- fname = p + 1;
- p = (U_CHAR *) index (fname, '\"');
-
- fcopy = (U_CHAR *) alloca (p - fname + 1);
- bcopy (fname, fcopy, p - fname);
- fcopy[p-fname] = '\0';
-
- ptr = include_hash (pfile, fcopy, 0);
- if (ptr)
- cpp_warning (pfile,
- "`#pragma implementation' for `%s' appears after file is included",
- fcopy);
- }
- else if (!strncmp (buf, "poison", 6))
+ /* Putting this in _cpp_handle_directive risks two calls to
+ _cpp_backup_tokens in some circumstances, which can segfault. */
+ if (pfile->state.line_extension)
+ _cpp_backup_tokens (pfile, 1);
+
+ /* #line commands expand macros. */
+ token = cpp_get_token (pfile);
+ if (token->type != CPP_NUMBER
+ || strtoul_for_line (token->val.str.text, token->val.str.len,
+ &new_lineno))
{
- /* Poison these symbols so that all subsequent usage produces an
- error message. */
- U_CHAR *p = buf + 6;
- size_t plen;
- U_CHAR *syms;
- int writeit;
-
- SKIP_WHITE_SPACE (p);
- plen = strlen(p) + 1;
-
- syms = (U_CHAR *) alloca (plen);
- memcpy (syms, p, plen);
-
- /* As a rule, don't include #pragma poison commands in output,
- unless the user asks for them. */
- writeit = (CPP_OPTIONS (pfile)->debug_output
- || CPP_OPTIONS (pfile)->dump_macros == dump_definitions
- || CPP_OPTIONS (pfile)->dump_macros == dump_names);
-
- if (writeit)
- CPP_SET_WRITTEN (pfile, here);
- else
- CPP_SET_WRITTEN (pfile, here-8);
+ cpp_error (pfile, "\"%s\" after #line is not a positive integer",
+ cpp_token_as_text (pfile, token));
+ return;
+ }
- if (writeit)
- {
- CPP_RESERVE (pfile, plen + 7);
- CPP_PUTS_Q (pfile, "poison", 7);
- }
+ if (CPP_PEDANTIC (pfile) && ! pfile->state.line_extension
+ && (new_lineno == 0 || new_lineno > cap))
+ cpp_pedwarn (pfile, "line number out of range");
+
+ token = cpp_get_token (pfile);
+ if (token->type == CPP_STRING)
+ {
+ new_file = (const char *) token->val.str.text;
- while (*syms != '\0')
+ /* Only accept flags for the # 55 form. */
+ if (pfile->state.line_extension)
{
- U_CHAR *end = syms;
-
- while (is_idchar(*end))
- end++;
+ int flag;
- if (!is_hspace(*end) && *end != '\0')
+ new_sysp = 0;
+ flag = read_flag (pfile, 0);
+ if (flag == 1)
{
- cpp_error (pfile, "invalid #pragma poison directive");
- return 1;
+ reason = LC_ENTER;
+ /* Fake an include for cpp_included (). */
+ _cpp_fake_include (pfile, new_file);
+ flag = read_flag (pfile, flag);
}
-
- if (cpp_push_buffer (pfile, syms, end - syms) != NULL)
+ else if (flag == 2)
{
- do_define (pfile, keyword);
- cpp_pop_buffer (pfile);
+ reason = LC_LEAVE;
+ flag = read_flag (pfile, flag);
}
- if (writeit)
+ if (flag == 3)
{
- CPP_PUTC_Q (pfile, ' ');
- CPP_PUTS_Q (pfile, syms, end - syms);
+ new_sysp = 1;
+ flag = read_flag (pfile, flag);
+ if (flag == 4)
+ new_sysp = 2;
}
- syms = end;
- SKIP_WHITE_SPACE (syms);
}
+ check_eol (pfile);
+ }
+ else if (token->type != CPP_EOF)
+ {
+ cpp_error (pfile, "\"%s\" is not a valid filename",
+ cpp_token_as_text (pfile, token));
+ return;
}
- return 0;
+ skip_rest_of_line (pfile);
+ _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
}
-#ifdef SCCS_DIRECTIVE
-/* Just ignore #sccs, on systems where we define it at all. */
-
-static int
-do_sccs (pfile, keyword)
+/* Arrange the file_change callback. pfile->line has changed to
+ FILE_LINE of TO_FILE, for reason REASON. SYSP is 1 for a system
+ header, 2 for a system header that needs to be extern "C" protected,
+ and zero otherwise. */
+void
+_cpp_do_file_change (pfile, reason, to_file, file_line, sysp)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
+ enum lc_reason reason;
+ const char *to_file;
+ unsigned int file_line;
+ unsigned int sysp;
{
- if (CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "ANSI C does not allow `#sccs'");
- skip_rest_of_line (pfile);
- return 0;
-}
-#endif
-\f
+ pfile->map = add_line_map (&pfile->line_maps, reason, sysp,
+ pfile->line, to_file, file_line);
-/* We've found an `#if' directive. If the only thing before it in
- this file is white space, and if it is of the form
- `#if ! defined SYMBOL', then SYMBOL is a possible controlling macro
- for inclusion of this file. (See redundant_include_p in cppfiles.c
- for an explanation of controlling macros.) If so, return a
- malloc'd copy of SYMBOL. Otherwise, return NULL. */
+ if (pfile->cb.file_change)
+ (*pfile->cb.file_change) (pfile, pfile->map);
+}
-static U_CHAR *
-detect_if_not_defined (pfile)
+/* Report a warning or error detected by the program we are
+ processing. Use the directive's tokens in the error message. */
+static void
+do_diagnostic (pfile, code, print_dir)
cpp_reader *pfile;
+ enum error_type code;
+ int print_dir;
{
- U_CHAR *control_macro = 0;
-
- if (pfile->only_seen_white == 2)
+ if (_cpp_begin_message (pfile, code, 0, 0))
{
- char *ident;
- enum cpp_token token;
- int base_offset;
- int token_offset;
- int need_rparen = 0;
-
- /* Save state required for restore. */
- pfile->no_macro_expand++;
- parse_set_mark (pfile);
- base_offset = CPP_WRITTEN (pfile);
-
- /* Look for `!', */
- if (get_directive_token (pfile) != CPP_OTHER
- || CPP_WRITTEN (pfile) != (size_t) base_offset + 1
- || CPP_PWRITTEN (pfile)[-1] != '!')
- goto restore;
-
- /* ...then `defined', */
- token_offset = CPP_WRITTEN (pfile);
- token = get_directive_token (pfile);
- if (token != CPP_NAME)
- goto restore;
- ident = pfile->token_buffer + token_offset;
- CPP_NUL_TERMINATE (pfile);
- if (strcmp (ident, "defined"))
- goto restore;
-
- /* ...then an optional '(' and the name, */
- token_offset = CPP_WRITTEN (pfile);
- token = get_directive_token (pfile);
- if (token == CPP_LPAREN)
- {
- token_offset = CPP_WRITTEN (pfile);
- token = get_directive_token (pfile);
- if (token != CPP_NAME)
- goto restore;
- need_rparen = 1;
- }
- else if (token != CPP_NAME)
- goto restore;
-
- ident = pfile->token_buffer + token_offset;
- CPP_NUL_TERMINATE (pfile);
-
- /* ...then the ')', if necessary, */
- if ((!need_rparen || get_directive_token (pfile) == CPP_RPAREN)
- /* ...and make sure there's nothing else on the line. */
- && get_directive_token (pfile) == CPP_VSPACE)
- control_macro = xstrdup (ident);
-
- restore:
- CPP_SET_WRITTEN (pfile, base_offset);
- pfile->no_macro_expand--;
- parse_goto_mark (pfile);
+ if (print_dir)
+ fprintf (stderr, "#%s ", pfile->directive->name);
+ pfile->state.prevent_expansion++;
+ cpp_output_line (pfile, stderr);
+ pfile->state.prevent_expansion--;
}
-
- return control_macro;
}
-/*
- * handle #if command by
- * 1) inserting special `defined' keyword into the hash table
- * that gets turned into 0 or 1 by special_symbol (thus,
- * if the luser has a symbol called `defined' already, it won't
- * work inside the #if command)
- * 2) rescan the input into a temporary output buffer
- * 3) pass the output buffer to the yacc parser and collect a value
- * 4) clean up the mess left from steps 1 and 2.
- * 5) call conditional_skip to skip til the next #endif (etc.),
- * or not, depending on the value from step 3.
- */
-
-static int
-do_if (pfile, keyword)
+static void
+do_error (pfile)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
{
- U_CHAR *control_macro = detect_if_not_defined (pfile);
- HOST_WIDEST_INT value = eval_if_expression (pfile);
- conditional_skip (pfile, value == 0, T_IF, control_macro);
- return 0;
+ do_diagnostic (pfile, ERROR, 1);
}
-/*
- * handle a #elif directive by not changing if_stack either.
- * see the comment above do_else.
- */
-
-static int
-do_elif (pfile, keyword)
+static void
+do_warning (pfile)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
{
- if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
- cpp_error (pfile, "`#elif' not within a conditional");
- return 0;
- } else {
- if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
- cpp_error (pfile, "`#elif' after `#else'");
-#if 0
- fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
-#endif
- if (pfile->if_stack->fname != NULL && CPP_BUFFER (pfile)->fname != NULL
- && strcmp (pfile->if_stack->fname,
- CPP_BUFFER (pfile)->nominal_fname) != 0)
- fprintf (stderr, ", file %s", pfile->if_stack->fname);
- fprintf (stderr, ")\n");
- }
- pfile->if_stack->type = T_ELIF;
- }
-
- if (pfile->if_stack->if_succeeded)
- skip_if_group (pfile);
- else {
- HOST_WIDEST_INT value = eval_if_expression (pfile);
- if (value == 0)
- skip_if_group (pfile);
- else {
- ++pfile->if_stack->if_succeeded; /* continue processing input */
- output_line_command (pfile, same_file);
- }
- }
- return 0;
+ /* We want #warning diagnostics to be emitted in system headers too. */
+ do_diagnostic (pfile, WARNING_SYSHDR, 1);
}
-/*
- * evaluate a #if expression in BUF, of length LENGTH,
- * then parse the result as a C expression and return the value as an int.
- */
-
-static HOST_WIDEST_INT
-eval_if_expression (pfile)
+/* Report program identification. */
+static void
+do_ident (pfile)
cpp_reader *pfile;
{
- HOST_WIDEST_INT value;
- long old_written = CPP_WRITTEN (pfile);
+ const cpp_token *str = cpp_get_token (pfile);
- pfile->pcp_inside_if = 1;
- value = cpp_parse_expr (pfile);
- pfile->pcp_inside_if = 0;
+ if (str->type != CPP_STRING)
+ cpp_error (pfile, "invalid #ident directive");
+ else if (pfile->cb.ident)
+ (*pfile->cb.ident) (pfile, pfile->directive_line, &str->val.str);
- CPP_SET_WRITTEN (pfile, old_written); /* Pop */
-
- return value;
+ check_eol (pfile);
}
-/*
- * routine to handle ifdef/ifndef. Try to look up the symbol,
- * then do or don't skip to the #endif/#else/#elif depending
- * on what directive is actually being processed.
- */
+/* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the
+ matching entry, or NULL if none is found. The returned entry could
+ be the start of a namespace chain, or a pragma. */
+static struct pragma_entry *
+lookup_pragma_entry (chain, pragma)
+ struct pragma_entry *chain;
+ const cpp_hashnode *pragma;
+{
+ while (chain && chain->pragma != pragma)
+ chain = chain->next;
-static int
-do_xifdef (pfile, keyword)
+ return chain;
+}
+
+/* Create and insert a pragma entry for NAME at the beginning of a
+ singly-linked CHAIN. If handler is NULL, it is a namespace,
+ otherwise it is a pragma and its handler. */
+static struct pragma_entry *
+insert_pragma_entry (pfile, chain, pragma, handler)
cpp_reader *pfile;
- const struct directive *keyword;
-{
- int skip;
- cpp_buffer *ip = CPP_BUFFER (pfile);
- U_CHAR *ident;
- int ident_length;
- enum cpp_token token;
- int start_of_file = 0;
- U_CHAR *control_macro = 0;
- int old_written = CPP_WRITTEN (pfile);
-
- /* Detect a #ifndef at start of file (not counting comments). */
- if (ip->fname != 0 && keyword->type == T_IFNDEF)
- start_of_file = pfile->only_seen_white == 2;
-
- pfile->no_macro_expand++;
- token = get_directive_token (pfile);
- pfile->no_macro_expand--;
-
- ident = pfile->token_buffer + old_written;
- ident_length = CPP_WRITTEN (pfile) - old_written;
- CPP_SET_WRITTEN (pfile, old_written); /* Pop */
-
- if (token == CPP_VSPACE || token == CPP_POP || token == CPP_EOF)
- {
- skip = (keyword->type == T_IFDEF);
- if (! CPP_TRADITIONAL (pfile))
- cpp_pedwarn (pfile, "`#%s' with no argument", keyword->name);
- }
- else if (token == CPP_NAME)
+ struct pragma_entry **chain;
+ const cpp_hashnode *pragma;
+ pragma_cb handler;
+{
+ struct pragma_entry *new;
+
+ new = (struct pragma_entry *)
+ _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
+ new->pragma = pragma;
+ if (handler)
{
- HASHNODE *hp = cpp_lookup (pfile, ident, ident_length, -1);
- skip = (hp == NULL) ^ (keyword->type == T_IFNDEF);
- if (start_of_file && !skip)
- {
- control_macro = (U_CHAR *) xmalloc (ident_length + 1);
- bcopy (ident, control_macro, ident_length + 1);
- }
- if (hp != NULL && hp->type == T_POISON)
- {
- cpp_error (pfile, "attempt to use poisoned `%s'", hp->name);
- skip = !skip;
- }
+ new->is_nspace = 0;
+ new->u.handler = handler;
}
else
{
- skip = (keyword->type == T_IFDEF);
- if (! CPP_TRADITIONAL (pfile))
- cpp_error (pfile, "`#%s' with invalid argument", keyword->name);
- }
-
- if (!CPP_TRADITIONAL (pfile))
- { int c;
- cpp_skip_hspace (pfile);
- c = PEEKC ();
- if (c != EOF && c != '\n')
- cpp_pedwarn (pfile, "garbage at end of `#%s' argument", keyword->name);
+ new->is_nspace = 1;
+ new->u.space = NULL;
}
- skip_rest_of_line (pfile);
-#if 0
- if (pcp_outfile) {
- /* Output a precondition for this macro. */
- if (hp && hp->value.defn->predefined)
- fprintf (pcp_outfile, "#define %s\n", hp->name);
- else {
- U_CHAR *cp = buf;
- fprintf (pcp_outfile, "#undef ");
- while (is_idchar(*cp)) /* Ick! */
- fputc (*cp++, pcp_outfile);
- putc ('\n', pcp_outfile);
- }
-#endif
-
- conditional_skip (pfile, skip, T_IF, control_macro);
- return 0;
+ new->next = *chain;
+ *chain = new;
+ return new;
}
-/* Push TYPE on stack; then, if SKIP is nonzero, skip ahead.
- If this is a #ifndef starting at the beginning of a file,
- CONTROL_MACRO is the macro name tested by the #ifndef.
- Otherwise, CONTROL_MACRO is 0. */
-
-static void
-conditional_skip (pfile, skip, type, control_macro)
+/* Register a pragma NAME in namespace SPACE. If SPACE is null, it
+ goes in the global namespace. HANDLER is the handler it will call,
+ which must be non-NULL. */
+void
+cpp_register_pragma (pfile, space, name, handler)
cpp_reader *pfile;
- int skip;
- enum node_type type;
- U_CHAR *control_macro;
-{
- IF_STACK_FRAME *temp;
-
- temp = (IF_STACK_FRAME *) xcalloc (1, sizeof (IF_STACK_FRAME));
- temp->fname = CPP_BUFFER (pfile)->nominal_fname;
- temp->lineno = CPP_BUFFER (pfile)->lineno;
- temp->next = pfile->if_stack;
- temp->control_macro = control_macro;
- pfile->if_stack = temp;
-
- pfile->if_stack->type = type;
-
- if (skip != 0) {
- skip_if_group (pfile);
- return;
- } else {
- ++pfile->if_stack->if_succeeded;
- output_line_command (pfile, same_file);
- }
+ const char *space;
+ const char *name;
+ pragma_cb handler;
+{
+ struct pragma_entry **chain = &pfile->pragmas;
+ struct pragma_entry *entry;
+ const cpp_hashnode *node;
+
+ if (!handler)
+ abort ();
+
+ if (space)
+ {
+ node = cpp_lookup (pfile, U space, strlen (space));
+ entry = lookup_pragma_entry (*chain, node);
+ if (!entry)
+ entry = insert_pragma_entry (pfile, chain, node, NULL);
+ else if (!entry->is_nspace)
+ goto clash;
+ chain = &entry->u.space;
+ }
+
+ /* Check for duplicates. */
+ node = cpp_lookup (pfile, U name, strlen (name));
+ entry = lookup_pragma_entry (*chain, node);
+ if (entry)
+ {
+ if (entry->is_nspace)
+ clash:
+ cpp_ice (pfile,
+ "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);
+ else
+ cpp_ice (pfile, "#pragma %s is already registered", name);
+ }
+ else
+ insert_pragma_entry (pfile, chain, node, handler);
}
-/* Subroutine of skip_if_group. Examine one preprocessing directive and
- return 0 if skipping should continue, 1 if it should halt. Also
- adjusts the if_stack as appropriate.
- The `#' has been read, but not the identifier. */
-
-static int
-consider_directive_while_skipping (pfile, stack)
- cpp_reader *pfile;
- IF_STACK_FRAME *stack;
-{
- long ident_len, ident;
- const struct directive *kt;
- IF_STACK_FRAME *temp;
-
- cpp_skip_hspace (pfile);
-
- ident = CPP_WRITTEN (pfile);
- parse_name (pfile, GETC());
- ident_len = CPP_WRITTEN (pfile) - ident;
-
- CPP_SET_WRITTEN (pfile, ident);
-
- for (kt = directive_table; kt->length >= 0; kt++)
- if (kt->length == ident_len
- && strncmp (pfile->token_buffer + ident, kt->name, kt->length) == 0)
- switch (kt->type)
- {
- case T_IF:
- case T_IFDEF:
- case T_IFNDEF:
- temp = (IF_STACK_FRAME *) xmalloc (sizeof (IF_STACK_FRAME));
- temp->next = pfile->if_stack;
- pfile->if_stack = temp;
- temp->fname = CPP_BUFFER(pfile)->nominal_fname;
- temp->type = kt->type;
- return 0;
-
- case T_ELSE:
- if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack)
- validate_else (pfile, "#else");
- /* fall through */
- case T_ELIF:
- if (pfile->if_stack->type == T_ELSE)
- cpp_error (pfile, "`%s' after `#else'", kt->name);
-
- if (pfile->if_stack == stack)
- return 1;
- else
- {
- pfile->if_stack->type = kt->type;
- return 0;
- }
-
- case T_ENDIF:
- if (CPP_PEDANTIC (pfile) && pfile->if_stack != stack)
- validate_else (pfile, "#endif");
-
- if (pfile->if_stack == stack)
- return 1;
-
- temp = pfile->if_stack;
- pfile->if_stack = temp->next;
- free (temp);
- return 0;
-
- default:
- return 0;
- }
+/* Register the pragmas the preprocessor itself handles. */
+void
+_cpp_init_internal_pragmas (pfile)
+ cpp_reader *pfile;
+{
+ /* Pragmas in the global namespace. */
+ cpp_register_pragma (pfile, 0, "poison", do_pragma_poison);
+ cpp_register_pragma (pfile, 0, "once", do_pragma_once);
- /* Don't let erroneous code go by. */
- if (!CPP_OPTIONS (pfile)->lang_asm && CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "invalid preprocessor directive name");
- return 0;
+ /* New GCC-specific pragmas should be put in the GCC namespace. */
+ cpp_register_pragma (pfile, "GCC", "poison", do_pragma_poison);
+ cpp_register_pragma (pfile, "GCC", "system_header", do_pragma_system_header);
+ cpp_register_pragma (pfile, "GCC", "dependency", do_pragma_dependency);
}
-/* skip to #endif, #else, or #elif. adjust line numbers, etc.
- * leaves input ptr at the sharp sign found.
- */
+/* Pragmata handling. We handle some, and pass the rest on to the
+ front end. C99 defines three pragmas and says that no macro
+ expansion is to be performed on them; whether or not macro
+ expansion happens for other pragmas is implementation defined.
+ This implementation never macro-expands the text after #pragma. */
static void
-skip_if_group (pfile)
- cpp_reader *pfile;
+do_pragma (pfile)
+ cpp_reader *pfile;
{
- int c;
- IF_STACK_FRAME *save_if_stack = pfile->if_stack; /* don't pop past here */
- U_CHAR *beg_of_line;
- long old_written;
+ const struct pragma_entry *p = NULL;
+ const cpp_token *token;
+ unsigned int count = 1;
- if (CPP_OPTIONS (pfile)->output_conditionals)
- {
- CPP_PUTS (pfile, "#failed\n", 8);
- pfile->lineno++;
- output_line_command (pfile, same_file);
- }
+ pfile->state.prevent_expansion++;
- old_written = CPP_WRITTEN (pfile);
-
- for (;;)
+ token = cpp_get_token (pfile);
+ if (token->type == CPP_NAME)
{
- beg_of_line = CPP_BUFFER (pfile)->cur;
-
- if (! CPP_TRADITIONAL (pfile))
- cpp_skip_hspace (pfile);
- c = GETC();
- if (c == '\n')
- {
- if (CPP_OPTIONS (pfile)->output_conditionals)
- CPP_PUTC (pfile, c);
- CPP_BUMP_LINE (pfile);
- continue;
- }
- else if (c == '#')
- {
- if (consider_directive_while_skipping (pfile, save_if_stack))
- break;
- }
- else if (c == EOF)
- return; /* Caller will issue error. */
-
- FORWARD(-1);
- if (CPP_OPTIONS (pfile)->output_conditionals)
- {
- CPP_PUTS (pfile, beg_of_line, CPP_BUFFER (pfile)->cur - beg_of_line);
- copy_rest_of_line (pfile);
- }
- else
+ p = lookup_pragma_entry (pfile->pragmas, token->val.node);
+ if (p && p->is_nspace)
{
- copy_rest_of_line (pfile);
- CPP_SET_WRITTEN (pfile, old_written); /* discard it */
+ count = 2;
+ token = cpp_get_token (pfile);
+ if (token->type == CPP_NAME)
+ p = lookup_pragma_entry (p->u.space, token->val.node);
+ else
+ p = NULL;
}
+ }
- c = GETC();
- if (c == EOF)
- return; /* Caller will issue error. */
- else
- {
- /* \n */
- if (CPP_OPTIONS (pfile)->output_conditionals)
- {
- CPP_PUTC (pfile, c);
- pfile->lineno++;
- }
- CPP_BUMP_LINE (pfile);
- }
- }
+ /* FIXME. This is an awful kludge to get the front ends to update
+ their notion of line number for diagnostic purposes. The line
+ number should be passed to the handler and they should do it
+ themselves. Stand-alone CPP must ignore us, otherwise it will
+ prefix the directive with spaces, hence the 1. Ugh. */
+ if (pfile->cb.line_change)
+ (*pfile->cb.line_change)(pfile, token, 1);
- /* Back up to the beginning of this line. Caller will process the
- directive. */
- CPP_BUFFER (pfile)->cur = beg_of_line;
- pfile->only_seen_white = 1;
- if (CPP_OPTIONS (pfile)->output_conditionals)
+ if (p)
+ (*p->u.handler) (pfile);
+ else if (pfile->cb.def_pragma)
{
- CPP_PUTS (pfile, "#endfailed\n", 11);
- pfile->lineno++;
+ _cpp_backup_tokens (pfile, count);
+ (*pfile->cb.def_pragma) (pfile, pfile->directive_line);
}
-}
-/*
- * handle a #else directive. Do this by just continuing processing
- * without changing if_stack ; this is so that the error message
- * for missing #endif's etc. will point to the original #if. It
- * is possible that something different would be better.
- */
+ pfile->state.prevent_expansion--;
+}
-static int
-do_else (pfile, keyword)
+/* Handle #pragma once. */
+static void
+do_pragma_once (pfile)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
-
- if (CPP_PEDANTIC (pfile))
- validate_else (pfile, "#else");
- skip_rest_of_line (pfile);
+ cpp_warning (pfile, "#pragma once is obsolete");
+
+ if (pfile->buffer->prev == NULL)
+ cpp_warning (pfile, "#pragma once in main file");
+ else
+ _cpp_never_reread (pfile->buffer->inc);
- if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack) {
- cpp_error (pfile, "`#else' not within a conditional");
- return 0;
- } else {
- /* #ifndef can't have its special treatment for containing the whole file
- if it has a #else clause. */
- pfile->if_stack->control_macro = 0;
-
- if (pfile->if_stack->type != T_IF && pfile->if_stack->type != T_ELIF) {
- cpp_error (pfile, "`#else' after `#else'");
- fprintf (stderr, " (matches line %d", pfile->if_stack->lineno);
- if (strcmp (pfile->if_stack->fname, ip->nominal_fname) != 0)
- fprintf (stderr, ", file %s", pfile->if_stack->fname);
- fprintf (stderr, ")\n");
- }
- pfile->if_stack->type = T_ELSE;
- }
-
- if (pfile->if_stack->if_succeeded)
- skip_if_group (pfile);
- else {
- ++pfile->if_stack->if_succeeded; /* continue processing input */
- output_line_command (pfile, same_file);
- }
- return 0;
+ check_eol (pfile);
}
-/*
- * unstack after #endif command
- */
-
-static int
-do_endif (pfile, keyword)
+/* Handle #pragma poison, to poison one or more identifiers so that
+ the lexer produces a hard error for each subsequent usage. */
+static void
+do_pragma_poison (pfile)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
{
- if (CPP_PEDANTIC (pfile))
- validate_else (pfile, "#endif");
- skip_rest_of_line (pfile);
+ const cpp_token *tok;
+ cpp_hashnode *hp;
- if (pfile->if_stack == CPP_BUFFER (pfile)->if_stack)
- cpp_error (pfile, "`#endif' not within a conditional");
- else
+ pfile->state.poisoned_ok = 1;
+ for (;;)
{
- IF_STACK_FRAME *temp = pfile->if_stack;
- pfile->if_stack = temp->next;
- if (temp->control_macro != 0)
+ tok = _cpp_lex_token (pfile);
+ if (tok->type == CPP_EOF)
+ break;
+ if (tok->type != CPP_NAME)
{
- /* This #endif matched a #ifndef at the start of the file.
- See if it is at the end of the file. */
- int c;
-
- parse_set_mark (pfile);
+ cpp_error (pfile, "invalid #pragma GCC poison directive");
+ break;
+ }
- for (;;)
- {
- cpp_skip_hspace (pfile);
- c = GETC ();
- if (c != '\n')
- break;
- }
- parse_goto_mark (pfile);
+ hp = tok->val.node;
+ if (hp->flags & NODE_POISONED)
+ continue;
- if (c == EOF)
- {
- /* This #endif ends a #ifndef
- that contains all of the file (aside from whitespace).
- Arrange not to include the file again
- if the macro that was tested is defined. */
- struct cpp_buffer *ip;
- for (ip = CPP_BUFFER (pfile); ; ip = CPP_PREV_BUFFER (ip))
- if (ip->fname != NULL)
- break;
- ip->ihash->control_macro = (char *) temp->control_macro;
- }
- }
- free (temp);
- output_line_command (pfile, same_file);
+ if (hp->type == NT_MACRO)
+ cpp_warning (pfile, "poisoning existing macro \"%s\"", NODE_NAME (hp));
+ _cpp_free_definition (hp);
+ hp->flags |= NODE_POISONED | NODE_DIAGNOSTIC;
}
- return 0;
+ pfile->state.poisoned_ok = 0;
}
-/* When an #else or #endif is found while skipping failed conditional,
- if -pedantic was specified, this is called to warn about text after
- the command name. P points to the first char after the command name. */
+/* Mark the current header as a system header. This will suppress
+ some categories of warnings (notably those from -pedantic). It is
+ intended for use in system libraries that cannot be implemented in
+ conforming C, but cannot be certain that their headers appear in a
+ system include directory. To prevent abuse, it is rejected in the
+ primary source file. */
+static void
+do_pragma_system_header (pfile)
+ cpp_reader *pfile;
+{
+ cpp_buffer *buffer = pfile->buffer;
+
+ if (buffer->prev == 0)
+ cpp_warning (pfile, "#pragma system_header ignored outside include file");
+ else
+ {
+ check_eol (pfile);
+ skip_rest_of_line (pfile);
+ cpp_make_system_header (pfile, 1, 0);
+ }
+}
+/* Check the modified date of the current include file against a specified
+ file. Issue a diagnostic, if the specified file is newer. We use this to
+ determine if a fixed header should be refixed. */
static void
-validate_else (pfile, directive)
+do_pragma_dependency (pfile)
cpp_reader *pfile;
- const char *directive;
{
- int c;
- cpp_skip_hspace (pfile);
- c = PEEKC ();
- if (c != EOF && c != '\n')
- cpp_pedwarn (pfile,
- "text following `%s' violates ANSI standard", directive);
+ const cpp_token *header;
+ int ordering;
+
+ header = parse_include (pfile);
+ if (!header)
+ return;
+
+ ordering = _cpp_compare_file_date (pfile, header);
+ if (ordering < 0)
+ cpp_warning (pfile, "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));
+ if (cpp_get_token (pfile)->type != CPP_EOF)
+ {
+ _cpp_backup_tokens (pfile, 1);
+ do_diagnostic (pfile, WARNING, 0);
+ }
+ }
}
-/* Convert T_IF, etc. to a string. Used in error messages. */
-static const char *
-if_directive_name (pfile, ifs)
+/* Get a token but skip padding. */
+static const cpp_token *
+get_token_no_padding (pfile)
cpp_reader *pfile;
- struct if_stack *ifs;
{
- switch (ifs->type)
+ for (;;)
{
- case T_IF: return "#if";
- case T_IFDEF: return "#ifdef";
- case T_IFNDEF: return "#ifndef";
- case T_ELIF: return "#elif";
- case T_ELSE: return "#else";
- default:
- cpp_fatal (pfile, "impossible if_stack->type value %d", ifs->type);
- return "unknown";
+ const cpp_token *result = cpp_get_token (pfile);
+ if (result->type != CPP_PADDING)
+ return result;
}
}
-/* Get the next token, and add it to the text in pfile->token_buffer.
- Return the kind of token we got. */
-
-enum cpp_token
-cpp_get_token (pfile)
+/* Check syntax is "(string-literal)". Returns the string on success,
+ or NULL on failure. */
+static const cpp_token *
+get__Pragma_string (pfile)
cpp_reader *pfile;
{
- register int c, c2, c3;
- enum cpp_token token;
- struct cpp_options *opts = CPP_OPTIONS (pfile);
+ const cpp_token *string;
- get_next:
- c = GETC();
- if (c == EOF)
- {
- handle_eof:
- if (CPP_BUFFER (pfile)->manual_pop)
- /* If we've been reading from redirected input, the
- frontend will pop the buffer. */
- return CPP_EOF;
- else if (CPP_BUFFER (pfile)->seen_eof)
- {
- if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)) == CPP_NULL_BUFFER (pfile))
- return CPP_EOF;
+ if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
+ return NULL;
- cpp_pop_buffer (pfile);
- goto get_next;
- }
- else
- {
- cpp_buffer *next_buf = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
- struct if_stack *ifs, *nifs;
+ string = get_token_no_padding (pfile);
+ if (string->type != CPP_STRING && string->type != CPP_WSTRING)
+ return NULL;
- /* Unwind the conditional stack and generate error messages. */
- for (ifs = pfile->if_stack;
- ifs != CPP_BUFFER (pfile)->if_stack;
- ifs = nifs)
- {
- cpp_error_with_line (pfile, ifs->lineno, -1,
- "unterminated `%s' conditional",
- if_directive_name (pfile, ifs));
+ if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
+ return NULL;
- nifs = ifs->next;
- free (ifs);
- }
- pfile->if_stack = ifs;
+ return string;
+}
- if (CPP_BUFFER (pfile)->nominal_fname
- && next_buf != CPP_NULL_BUFFER (pfile))
- {
- /* We're about to return from an #include file.
- Emit #line information now (as part of the CPP_POP) result.
- But the #line refers to the file we will pop to. */
- cpp_buffer *cur_buffer = CPP_BUFFER (pfile);
- CPP_BUFFER (pfile) = next_buf;
- pfile->input_stack_listing_current = 0;
- output_line_command (pfile, leave_file);
- CPP_BUFFER (pfile) = cur_buffer;
- }
+/* Destringize IN into a temporary buffer, by removing the first \ of
+ \" and \\ sequences, and process the result as a #pragma directive. */
+static void
+destringize_and_run (pfile, in)
+ cpp_reader *pfile;
+ const cpp_string *in;
+{
+ const unsigned char *src, *limit;
+ char *dest, *result;
- CPP_BUFFER (pfile)->seen_eof = 1;
- return CPP_POP;
- }
- }
- else
+ dest = result = alloca (in->len + 1);
+ for (src = in->text, limit = src + in->len; src < limit;)
{
- switch (c)
- {
- case '/':
- if (PEEKC () == '=')
- goto op2;
+ /* We know there is a character following the backslash. */
+ if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
+ src++;
+ *dest++ = *src++;
+ }
+ *dest = '\0';
- comment:
- if (opts->put_out_comments)
- c = copy_comment (pfile, c);
- else
- c = skip_comment (pfile, c);
- if (c == EOF)
- goto handle_eof;
- else if (c != ' ')
- goto randomchar;
-
- /* Comments are equivalent to spaces.
- For -traditional, a comment is equivalent to nothing. */
- if (opts->traditional || opts->put_out_comments)
- return CPP_COMMENT;
- else
- {
- CPP_PUTC (pfile, c);
- return CPP_HSPACE;
- }
-#if 0
- if (opts->for_lint) {
- U_CHAR *argbp;
- int cmdlen, arglen;
- char *lintcmd = get_lintcmd (ibp, limit, &argbp, &arglen, &cmdlen);
-
- if (lintcmd != NULL) {
- /* I believe it is always safe to emit this newline: */
- obp[-1] = '\n';
- bcopy ("#pragma lint ", (char *) obp, 13);
- obp += 13;
- bcopy (lintcmd, (char *) obp, cmdlen);
- obp += cmdlen;
-
- if (arglen != 0) {
- *(obp++) = ' ';
- bcopy (argbp, (char *) obp, arglen);
- obp += arglen;
- }
-
- /* OK, now bring us back to the state we were in before we entered
- this branch. We need #line because the newline for the pragma
- could mess things up. */
- output_line_command (pfile, same_file);
- *(obp++) = ' '; /* just in case, if comments are copied thru */
- *(obp++) = '/';
- }
- }
-#endif
+ run_directive (pfile, T_PRAGMA, result, dest - result);
+}
- case '#':
-#if 0
- /* If this is expanding a macro definition, don't recognize
- preprocessor directives. */
- if (ip->macro != 0)
- goto randomchar;
- /* If this is expand_into_temp_buffer, recognize them
- only after an actual newline at this level,
- not at the beginning of the input level. */
- if (ip->fname == 0 && beg_of_line == ip->buf)
- goto randomchar;
- if (ident_length)
- goto specialchar;
-#endif
+/* Handle the _Pragma operator. */
+void
+_cpp_do__Pragma (pfile)
+ cpp_reader *pfile;
+{
+ const cpp_token *string = get__Pragma_string (pfile);
- if (!pfile->only_seen_white)
- goto randomchar;
- if (handle_directive (pfile))
- return CPP_DIRECTIVE;
- pfile->only_seen_white = 0;
- return CPP_OTHER;
-
- case '\"':
- case '\'':
- string:
- parse_string (pfile, c);
- pfile->only_seen_white = 0;
- return c == '\'' ? CPP_CHAR : CPP_STRING;
-
- case '$':
- if (!opts->dollars_in_ident)
- goto randomchar;
- goto letter;
-
- case ':':
- if (opts->cplusplus && PEEKC () == ':')
- goto op2;
- goto randomchar;
-
- case '&':
- case '+':
- case '|':
- c2 = PEEKC ();
- if (c2 == c || c2 == '=')
- goto op2;
- goto randomchar;
-
- case '*':
- case '!':
- case '%':
- case '=':
- case '^':
- if (PEEKC () == '=')
- goto op2;
- goto randomchar;
-
- case '-':
- c2 = PEEKC ();
- if (c2 == '-' && opts->chill)
- goto comment; /* Chill style comment */
- if (c2 == '-' || c2 == '=')
- goto op2;
- if (c2 == '>')
- {
- if (opts->cplusplus && PEEKN (1) == '*')
- {
- /* In C++, there's a ->* operator. */
- token = CPP_OTHER;
- pfile->only_seen_white = 0;
- CPP_RESERVE (pfile, 4);
- CPP_PUTC_Q (pfile, c);
- CPP_PUTC_Q (pfile, GETC ());
- CPP_PUTC_Q (pfile, GETC ());
- CPP_NUL_TERMINATE_Q (pfile);
- return token;
- }
- goto op2;
- }
- goto randomchar;
+ if (!string)
+ cpp_error (pfile, "_Pragma takes a parenthesized string literal");
+ else
+ {
+ /* Ideally, we'd like
+ token1 _Pragma ("foo") token2
+ to be output as
+ token1
+ # 7 "file.c"
+ #pragma foo
+ # 7 "file.c"
+ token2
+ Getting these correct line markers is a little tricky. */
- case '<':
- if (pfile->parsing_include_directive)
- {
- for (;;)
- {
- CPP_PUTC (pfile, c);
- if (c == '>')
- break;
- c = GETC ();
- if (c == '\n' || c == EOF)
- {
- cpp_error (pfile,
- "missing '>' in `#include <FILENAME>'");
- break;
- }
- else if (c == '\r')
- {
- if (!CPP_BUFFER (pfile)->has_escapes)
- {
- /* Backslash newline is replaced by nothing. */
- CPP_ADJUST_WRITTEN (pfile, -1);
- CPP_BUMP_LINE (pfile);
- }
- else
- {
- /* We might conceivably get \r- or \r<space> in
- here. Just delete 'em. */
- int d = GETC();
- if (d != '-' && d != ' ')
- cpp_fatal (pfile,
- "internal error: unrecognized escape \\r%c",
- d);
- CPP_ADJUST_WRITTEN (pfile, -1);
- }
- }
- }
- return CPP_STRING;
- }
- /* else fall through */
- case '>':
- c2 = PEEKC ();
- if (c2 == '=')
- goto op2;
- /* GNU C++ supports MIN and MAX operators <? and >?. */
- if (c2 != c && (!opts->cplusplus || c2 != '?'))
- goto randomchar;
- FORWARD(1);
- CPP_RESERVE (pfile, 4);
- CPP_PUTC (pfile, c);
- CPP_PUTC (pfile, c2);
- c3 = PEEKC ();
- if (c3 == '=')
- CPP_PUTC_Q (pfile, GETC ());
- CPP_NUL_TERMINATE_Q (pfile);
- pfile->only_seen_white = 0;
- return CPP_OTHER;
-
- case '.':
- c2 = PEEKC ();
- if (ISDIGIT(c2))
- {
- CPP_RESERVE(pfile, 2);
- CPP_PUTC_Q (pfile, '.');
- c = GETC ();
- goto number;
- }
+ unsigned int orig_line = pfile->line;
+ destringize_and_run (pfile, &string->val.str);
+ pfile->line = orig_line;
+ pfile->buffer->saved_flags = BOL;
+ }
+}
- /* In C++ there's a .* operator. */
- if (opts->cplusplus && c2 == '*')
- goto op2;
+/* Just ignore #sccs, on systems where we define it at all. */
+#ifdef SCCS_DIRECTIVE
+static void
+do_sccs (pfile)
+ cpp_reader *pfile ATTRIBUTE_UNUSED;
+{
+}
+#endif
- if (c2 == '.' && PEEKN(1) == '.')
- {
- CPP_RESERVE(pfile, 4);
- CPP_PUTC_Q (pfile, '.');
- CPP_PUTC_Q (pfile, '.');
- CPP_PUTC_Q (pfile, '.');
- FORWARD (2);
- CPP_NUL_TERMINATE_Q (pfile);
- pfile->only_seen_white = 0;
- return CPP_3DOTS;
- }
- goto randomchar;
-
- op2:
- token = CPP_OTHER;
- pfile->only_seen_white = 0;
- CPP_RESERVE(pfile, 3);
- CPP_PUTC_Q (pfile, c);
- CPP_PUTC_Q (pfile, GETC ());
- CPP_NUL_TERMINATE_Q (pfile);
- return token;
-
- case 'L':
- c2 = PEEKC ();
- if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
- {
- CPP_PUTC (pfile, c);
- c = GETC ();
- goto string;
- }
- goto letter;
+/* Handle #ifdef. */
+static void
+do_ifdef (pfile)
+ cpp_reader *pfile;
+{
+ int skip = 1;
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- number:
- c2 = '.';
- for (;;)
- {
- CPP_RESERVE (pfile, 2);
- CPP_PUTC_Q (pfile, c);
- c = PEEKC ();
- if (c == EOF)
- break;
- if (!is_idchar(c) && c != '.'
- && ((c2 != 'e' && c2 != 'E'
- && ((c2 != 'p' && c2 != 'P') || CPP_C89 (pfile)))
- || (c != '+' && c != '-')))
- break;
- FORWARD(1);
- c2= c;
- }
- CPP_NUL_TERMINATE_Q (pfile);
- pfile->only_seen_white = 0;
- return CPP_NUMBER;
- case 'b': case 'c': case 'd': case 'h': case 'o':
- case 'B': case 'C': case 'D': case 'H': case 'O':
- if (opts->chill && PEEKC () == '\'')
- {
- pfile->only_seen_white = 0;
- CPP_RESERVE (pfile, 2);
- CPP_PUTC_Q (pfile, c);
- CPP_PUTC_Q (pfile, '\'');
- FORWARD(1);
- for (;;)
- {
- c = GETC();
- if (c == EOF)
- goto chill_number_eof;
- if (!is_idchar(c))
- break;
- CPP_PUTC (pfile, c);
- }
- if (c == '\'')
- {
- CPP_RESERVE (pfile, 2);
- CPP_PUTC_Q (pfile, c);
- CPP_NUL_TERMINATE_Q (pfile);
- return CPP_STRING;
- }
- else
- {
- FORWARD(-1);
- chill_number_eof:
- CPP_NUL_TERMINATE (pfile);
- return CPP_NUMBER;
- }
- }
- else
- goto letter;
- case '_':
- case 'a': case 'e': case 'f': case 'g': case 'i': case 'j':
- case 'k': case 'l': case 'm': case 'n': case 'p': case 'q':
- case 'r': case 's': case 't': case 'u': case 'v': case 'w':
- case 'x': case 'y': case 'z':
- case 'A': case 'E': case 'F': case 'G': case 'I': case 'J':
- case 'K': case 'M': case 'N': case 'P': case 'Q': case 'R':
- case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
- case 'Y': case 'Z':
- letter:
- {
- HASHNODE *hp;
- unsigned char *ident;
- int before_name_written = CPP_WRITTEN (pfile);
- int ident_len;
- parse_name (pfile, c);
- pfile->only_seen_white = 0;
- if (pfile->no_macro_expand)
- return CPP_NAME;
- ident = pfile->token_buffer + before_name_written;
- ident_len = CPP_PWRITTEN (pfile) - ident;
- hp = cpp_lookup (pfile, ident, ident_len, -1);
- if (!hp)
- return CPP_NAME;
- if (hp->type == T_DISABLED)
- {
- if (pfile->output_escapes)
- { /* Return "\r-IDENT", followed by '\0'. */
- int i;
- CPP_RESERVE (pfile, 3);
- ident = pfile->token_buffer + before_name_written;
- CPP_ADJUST_WRITTEN (pfile, 2);
- for (i = ident_len; i >= 0; i--) ident[i+2] = ident[i];
- ident[0] = '\r';
- ident[1] = '-';
- }
- return CPP_NAME;
- }
-
- /* If macro wants an arglist, verify that a '(' follows.
- first skip all whitespace, copying it to the output
- after the macro name. Then, if there is no '(',
- decide this is not a macro call and leave things that way. */
- if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
- {
- int is_macro_call, macbuf_whitespace = 0;
-
- parse_set_mark (pfile);
- for (;;)
- {
- cpp_skip_hspace (pfile);
- c = PEEKC ();
- is_macro_call = c == '(';
- if (c != EOF)
- {
- if (c != '\n')
- break;
- FORWARD (1);
- }
- else
- {
- if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
- {
- if (CPP_BUFFER (pfile)->mark !=
- (CPP_BUFFER (pfile)->cur
- - CPP_BUFFER (pfile)->buf))
- macbuf_whitespace = 1;
-
- /* The mark goes away automatically when
- the buffer is popped. */
- cpp_pop_buffer (pfile);
- parse_set_mark (pfile);
- }
- else
- break;
- }
- }
- if (!is_macro_call)
- {
- parse_goto_mark (pfile);
- if (macbuf_whitespace)
- CPP_PUTC (pfile, ' ');
- }
- else
- parse_clear_mark (pfile);
- if (!is_macro_call)
- return CPP_NAME;
- }
- /* This is now known to be a macro call.
- Expand the macro, reading arguments as needed,
- and push the expansion on the input stack. */
- macroexpand (pfile, hp);
- CPP_SET_WRITTEN (pfile, before_name_written);
- }
- goto get_next;
-
- case ' ': case '\t': case '\v':
- for (;;)
- {
- CPP_PUTC (pfile, c);
- c = PEEKC ();
- if (c == EOF || !is_hspace(c))
- break;
- FORWARD(1);
- }
- return CPP_HSPACE;
+ if (! pfile->state.skipping)
+ {
+ const cpp_hashnode *node = lex_macro_node (pfile);
- case '\r':
- if (CPP_BUFFER (pfile)->has_escapes)
- {
- c = GETC ();
- if (c == '-')
- {
- if (pfile->output_escapes)
- CPP_PUTS (pfile, "\r-", 2);
- parse_name (pfile, GETC ());
- return CPP_NAME;
- }
- else if (c == ' ')
- {
- CPP_RESERVE (pfile, 2);
- if (pfile->output_escapes)
- CPP_PUTC_Q (pfile, '\r');
- CPP_PUTC_Q (pfile, c);
- return CPP_HSPACE;
- }
- else
- {
- cpp_fatal (pfile,
- "internal error: unrecognized escape \\r%c", c);
- goto get_next;
- }
- }
- else
- {
- /* Backslash newline is ignored. */
- CPP_BUMP_LINE (pfile);
- goto get_next;
- }
+ if (node)
+ skip = node->type != NT_MACRO;
- case '\n':
- CPP_PUTC (pfile, c);
- if (pfile->only_seen_white == 0)
- pfile->only_seen_white = 1;
- CPP_BUMP_LINE (pfile);
- if (! CPP_OPTIONS (pfile)->no_line_commands)
- {
- pfile->lineno++;
- if (CPP_BUFFER (pfile)->lineno != pfile->lineno)
- output_line_command (pfile, same_file);
- }
- return CPP_VSPACE;
-
- case '(': token = CPP_LPAREN; goto char1;
- case ')': token = CPP_RPAREN; goto char1;
- case '{': token = CPP_LBRACE; goto char1;
- case '}': token = CPP_RBRACE; goto char1;
- case ',': token = CPP_COMMA; goto char1;
- case ';': token = CPP_SEMICOLON; goto char1;
-
- randomchar:
- default:
- token = CPP_OTHER;
- char1:
- pfile->only_seen_white = 0;
- CPP_PUTC (pfile, c);
- return token;
- }
+ if (node)
+ check_eol (pfile);
}
-}
-/* Like cpp_get_token, but skip spaces and comments. */
+ push_conditional (pfile, skip, T_IFDEF, 0);
+}
-enum cpp_token
-cpp_get_non_space_token (pfile)
+/* Handle #ifndef. */
+static void
+do_ifndef (pfile)
cpp_reader *pfile;
{
- int old_written = CPP_WRITTEN (pfile);
- for (;;)
+ int skip = 1;
+ const cpp_hashnode *node = 0;
+
+ if (! pfile->state.skipping)
{
- enum cpp_token token = cpp_get_token (pfile);
- if (token != CPP_COMMENT && token != CPP_POP
- && token != CPP_HSPACE && token != CPP_VSPACE)
- return token;
- CPP_SET_WRITTEN (pfile, old_written);
+ node = lex_macro_node (pfile);
+ if (node)
+ skip = node->type == NT_MACRO;
+
+ if (node)
+ check_eol (pfile);
}
-}
-/* Parse an identifier starting with C. */
+ push_conditional (pfile, skip, T_IFNDEF, node);
+}
+/* _cpp_parse_expr puts a macro in a "#if !defined ()" expression in
+ pfile->mi_ind_cmacro so we can handle multiple-include
+ optimisations. If macro expansion occurs in the expression, we
+ cannot treat it as a controlling conditional, since the expansion
+ could change in the future. That is handled by cpp_get_token. */
static void
-parse_name (pfile, c)
+do_if (pfile)
cpp_reader *pfile;
- int c;
{
- for (;;)
- {
- if (! is_idchar(c))
- {
- FORWARD (-1);
- break;
- }
+ int skip = 1;
- if (c == '$' && CPP_PEDANTIC (pfile))
- cpp_pedwarn (pfile, "`$' in identifier");
+ if (! pfile->state.skipping)
+ skip = _cpp_parse_expr (pfile) == 0;
- CPP_RESERVE(pfile, 2); /* One more for final NUL. */
- CPP_PUTC_Q (pfile, c);
- c = GETC();
- if (c == EOF)
- break;
- }
- CPP_NUL_TERMINATE_Q (pfile);
- return;
+ push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
}
-/* Parse a string starting with C. A single quoted string is treated
- like a double -- some programs (e.g., troff) are perverse this way.
- (However, a single quoted string is not allowed to extend over
- multiple lines.) */
+/* Flip skipping state if appropriate and continue without changing
+ if_stack; this is so that the error message for missing #endif's
+ etc. will point to the original #if. */
static void
-parse_string (pfile, c)
+do_else (pfile)
cpp_reader *pfile;
- int c;
{
- long start_line, start_column;
-
- cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs = buffer->if_stack;
- CPP_PUTC (pfile, c);
- while (1)
+ if (ifs == NULL)
+ cpp_error (pfile, "#else without #if");
+ else
{
- int cc = GETC();
- if (cc == EOF)
+ if (ifs->type == T_ELSE)
{
- if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
- {
- /* try harder: this string crosses a macro expansion
- boundary. This can happen naturally if -traditional.
- Otherwise, only -D can make a macro with an unmatched
- quote. */
- cpp_pop_buffer (pfile);
- continue;
- }
-
- cpp_error_with_line (pfile, start_line, start_column,
- "unterminated string or character constant");
- if (pfile->multiline_string_line != start_line
- && pfile->multiline_string_line != 0)
- cpp_error_with_line (pfile,
- pfile->multiline_string_line, -1,
- "possible real start of unterminated constant");
- pfile->multiline_string_line = 0;
- break;
+ cpp_error (pfile, "#else after #else");
+ cpp_error_with_line (pfile, ifs->line, 0,
+ "the conditional began here");
}
- CPP_PUTC (pfile, cc);
- switch (cc)
- {
- case '\n':
- CPP_BUMP_LINE (pfile);
- pfile->lineno++;
- /* Character constants may not extend over multiple lines.
- In ANSI, neither may strings. We accept multiline strings
- as an extension. */
- if (c == '\'')
- {
- cpp_error_with_line (pfile, start_line, start_column,
- "unterminated character constant");
- return;
- }
- if (CPP_PEDANTIC (pfile) && pfile->multiline_string_line == 0)
- {
- cpp_pedwarn_with_line (pfile, start_line, start_column,
- "string constant runs past end of line");
- }
- if (pfile->multiline_string_line == 0)
- pfile->multiline_string_line = start_line;
- break;
+ ifs->type = T_ELSE;
- case '\r':
- CPP_ADJUST_WRITTEN (pfile, -1);
- if (CPP_BUFFER (pfile)->has_escapes)
- {
- cpp_fatal (pfile,
- "internal error: \\r escape inside string constant");
- FORWARD(1);
- }
- else
- /* Backslash newline is replaced by nothing at all. */
- CPP_BUMP_LINE (pfile);
- break;
+ /* Skip any future (erroneous) #elses or #elifs. */
+ pfile->state.skipping = ifs->skip_elses;
+ ifs->skip_elses = true;
- case '\\':
- cc = GETC();
- if (cc != EOF)
- CPP_PUTC (pfile, cc);
- break;
+ /* Invalidate any controlling macro. */
+ ifs->mi_cmacro = 0;
- case '\"':
- case '\'':
- if (cc == c)
- return;
- break;
- }
+ /* Only check EOL if was not originally skipping. */
+ if (!ifs->was_skipping)
+ check_eol (pfile);
}
}
-/* Read an assertion into the token buffer, converting to
- canonical form: `#predicate(a n swe r)' The next non-whitespace
- character to read should be the first letter of the predicate.
- Returns 0 for syntax error, 1 for bare predicate, 2 for predicate
- with answer (see callers for why). In case of 0, an error has been
- printed. */
-static int
-parse_assertion (pfile)
+/* Handle a #elif directive by not changing if_stack either. See the
+ comment above do_else. */
+static void
+do_elif (pfile)
cpp_reader *pfile;
{
- int c, dropwhite;
- cpp_skip_hspace (pfile);
- c = PEEKC();
- if (! is_idstart(c))
- {
- cpp_error (pfile, "assertion predicate is not an identifier");
- return 0;
- }
- CPP_PUTC(pfile, '#');
- FORWARD(1);
- parse_name(pfile, c);
-
- c = PEEKC();
- if (c != '(')
- {
- if (is_hspace(c) || c == '\r')
- cpp_skip_hspace (pfile);
- c = PEEKC();
- }
- if (c != '(')
- return 1;
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs = buffer->if_stack;
- CPP_PUTC(pfile, '(');
- FORWARD(1);
- dropwhite = 1;
- while ((c = GETC()) != ')')
+ if (ifs == NULL)
+ cpp_error (pfile, "#elif without #if");
+ else
{
- if (is_space(c))
- {
- if (! dropwhite)
- {
- CPP_PUTC(pfile, ' ');
- dropwhite = 1;
- }
- }
- else if (c == '\n' || c == EOF)
+ if (ifs->type == T_ELSE)
{
- if (c == '\n') FORWARD(-1);
- cpp_error (pfile, "un-terminated assertion answer");
- return 0;
+ cpp_error (pfile, "#elif after #else");
+ cpp_error_with_line (pfile, ifs->line, 0,
+ "the conditional began here");
}
- else if (c == '\r')
- /* \r cannot be a macro escape here. */
- CPP_BUMP_LINE (pfile);
+ ifs->type = T_ELIF;
+
+ /* Only evaluate this if we aren't skipping elses. During
+ evaluation, set skipping to false to get lexer warnings. */
+ if (ifs->skip_elses)
+ pfile->state.skipping = 1;
else
{
- CPP_PUTC (pfile, c);
- dropwhite = 0;
+ pfile->state.skipping = 0;
+ pfile->state.skipping = ! _cpp_parse_expr (pfile);
+ ifs->skip_elses = ! pfile->state.skipping;
}
- }
- if (pfile->limit[-1] == ' ')
- pfile->limit[-1] = ')';
- else if (pfile->limit[-1] == '(')
- {
- cpp_error (pfile, "empty token sequence in assertion");
- return 0;
+ /* Invalidate any controlling macro. */
+ ifs->mi_cmacro = 0;
}
- else
- CPP_PUTC (pfile, ')');
-
- CPP_NUL_TERMINATE (pfile);
- return 2;
}
-static int
-do_assert (pfile, keyword)
+/* #endif pops the if stack and resets pfile->state.skipping. */
+static void
+do_endif (pfile)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
-{
- char *sym;
- int ret, c;
- HASHNODE *base, *this;
- int baselen, thislen;
-
- if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
- && !CPP_BUFFER (pfile)->system_header_p)
- cpp_pedwarn (pfile, "ANSI C does not allow `#assert'");
-
- cpp_skip_hspace (pfile);
- sym = (char *) CPP_PWRITTEN (pfile); /* remember where it starts */
- ret = parse_assertion (pfile);
- if (ret == 0)
- goto error;
- else if (ret == 1)
- {
- cpp_error (pfile, "missing token-sequence in `#assert'");
- goto error;
- }
+{
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs = buffer->if_stack;
- cpp_skip_hspace (pfile);
- c = PEEKC();
- if (c != EOF && c != '\n')
+ if (ifs == NULL)
+ cpp_error (pfile, "#endif without #if");
+ else
{
- cpp_error (pfile, "junk at end of `#assert'");
- goto error;
- }
+ /* Only check EOL if was not originally skipping. */
+ if (!ifs->was_skipping)
+ check_eol (pfile);
- thislen = strlen (sym);
- baselen = index (sym, '(') - sym;
- this = cpp_lookup (pfile, sym, thislen, -1);
- if (this)
- {
- cpp_warning (pfile, "`%s' re-asserted", sym);
- goto error;
+ /* If potential control macro, we go back outside again. */
+ if (ifs->next == 0 && ifs->mi_cmacro)
+ {
+ pfile->mi_valid = true;
+ pfile->mi_cmacro = ifs->mi_cmacro;
+ }
+
+ buffer->if_stack = ifs->next;
+ pfile->state.skipping = ifs->was_skipping;
+ obstack_free (&pfile->buffer_ob, ifs);
}
+}
- base = cpp_lookup (pfile, sym, baselen, -1);
- if (! base)
- base = cpp_install (pfile, sym, baselen, T_ASSERT, 0, -1);
- else if (base->type != T_ASSERT)
- {
- /* Token clash - but with what?! */
- cpp_fatal (pfile,
- "cpp internal error: base->type != T_ASSERT in do_assert");
- goto error;
- }
-
- this = cpp_install (pfile, sym, thislen, T_ASSERT,
- (char *)base->value.aschain, -1);
- base->value.aschain = this;
-
- pfile->limit = (unsigned char *) sym; /* Pop */
- return 0;
+/* Push an if_stack entry for a preprocessor conditional, and set
+ pfile->state.skipping to SKIP. If TYPE indicates the conditional
+ is #if or #ifndef, CMACRO is a potentially controlling macro, and
+ we need to check here that we are at the top of the file. */
+static void
+push_conditional (pfile, skip, type, cmacro)
+ cpp_reader *pfile;
+ int skip;
+ int type;
+ const cpp_hashnode *cmacro;
+{
+ struct if_stack *ifs;
+ cpp_buffer *buffer = pfile->buffer;
+
+ ifs = xobnew (&pfile->buffer_ob, struct if_stack);
+ ifs->line = pfile->directive_line;
+ ifs->next = buffer->if_stack;
+ ifs->skip_elses = pfile->state.skipping || !skip;
+ ifs->was_skipping = pfile->state.skipping;
+ ifs->type = type;
+ /* This condition is effectively a test for top-of-file. */
+ if (pfile->mi_valid && pfile->mi_cmacro == 0)
+ ifs->mi_cmacro = cmacro;
+ else
+ ifs->mi_cmacro = 0;
- error:
- skip_rest_of_line (pfile);
- pfile->limit = (unsigned char *) sym; /* Pop */
- return 0;
+ pfile->state.skipping = skip;
+ buffer->if_stack = ifs;
}
+/* Read the tokens of the answer into the macro pool, in a directive
+ of type TYPE. Only commit the memory if we intend it as permanent
+ storage, i.e. the #assert case. Returns 0 on success, and sets
+ ANSWERP to point to the answer. */
static int
-do_unassert (pfile, keyword)
+parse_answer (pfile, answerp, type)
cpp_reader *pfile;
- const struct directive *keyword ATTRIBUTE_UNUSED;
+ struct answer **answerp;
+ int type;
{
- int c, ret;
- char *sym;
- long baselen, thislen;
- HASHNODE *base, *this, *next;
-
- if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing
- && !CPP_BUFFER (pfile)->system_header_p)
- cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'");
+ const cpp_token *paren;
+ struct answer *answer;
+ unsigned int acount;
- cpp_skip_hspace (pfile);
-
- sym = (char *) CPP_PWRITTEN (pfile); /* remember where it starts */
- ret = parse_assertion (pfile);
- if (ret == 0)
- goto error;
-
- cpp_skip_hspace (pfile);
- c = PEEKC ();
- if (c != EOF && c != '\n')
- cpp_error (pfile, "junk at end of `#unassert'");
+ /* In a conditional, it is legal to not have an open paren. We
+ should save the following token in this case. */
+ paren = cpp_get_token (pfile);
- thislen = strlen (sym);
- if (ret == 1)
+ /* If not a paren, see if we're OK. */
+ if (paren->type != CPP_OPEN_PAREN)
{
- base = cpp_lookup (pfile, sym, thislen, -1);
- if (! base)
- goto error; /* It isn't an error to #undef what isn't #defined,
- so it isn't an error to #unassert what isn't
- #asserted either. */
-
- for (this = base->value.aschain; this; this = next)
- {
- next = this->value.aschain;
- delete_macro (this);
+ /* In a conditional no answer is a test for any answer. It
+ could be followed by any token. */
+ if (type == T_IF)
+ {
+ _cpp_backup_tokens (pfile, 1);
+ return 0;
}
- delete_macro (base);
+
+ /* #unassert with no answer is valid - it removes all answers. */
+ if (type == T_UNASSERT && paren->type == CPP_EOF)
+ return 0;
+
+ cpp_error (pfile, "missing '(' after predicate");
+ return 1;
}
- else
+
+ for (acount = 0;; acount++)
{
- baselen = index (sym, '(') - sym;
- base = cpp_lookup (pfile, sym, baselen, -1);
- if (! base) goto error;
- this = cpp_lookup (pfile, sym, thislen, -1);
- if (! this) goto error;
+ size_t room_needed;
+ const cpp_token *token = cpp_get_token (pfile);
+ cpp_token *dest;
- next = base;
- while (next->value.aschain != this)
- next = next->value.aschain;
+ if (token->type == CPP_CLOSE_PAREN)
+ break;
+
+ if (token->type == CPP_EOF)
+ {
+ cpp_error (pfile, "missing ')' to complete answer");
+ return 1;
+ }
- next->value.aschain = this->value.aschain;
- delete_macro (this);
+ /* struct answer includes the space for one token. */
+ room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));
- if (base->value.aschain == NULL)
- delete_macro (base); /* Last answer for this predicate deleted. */
+ if (BUFF_ROOM (pfile->a_buff) < room_needed)
+ _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
+
+ dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
+ *dest = *token;
+
+ /* Drop whitespace at start, for answer equivalence purposes. */
+ if (acount == 0)
+ dest->flags &= ~PREV_WHITE;
}
-
- pfile->limit = (unsigned char *) sym; /* Pop */
- return 0;
- error:
- skip_rest_of_line (pfile);
- pfile->limit = (unsigned char *) sym; /* Pop */
- return 0;
-}
-/* Process STR as if it appeared as the body of an #unassert. */
-void
-cpp_unassert (pfile, str)
- cpp_reader *pfile;
- unsigned char *str;
-{
- if (cpp_push_buffer (pfile, str, strlen (str)) != NULL)
+ if (acount == 0)
{
- do_assert (pfile, NULL);
- cpp_pop_buffer (pfile);
+ cpp_error (pfile, "predicate's answer is empty");
+ return 1;
}
-}
-int
-cpp_read_check_assertion (pfile)
+ answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
+ answer->count = acount;
+ answer->next = NULL;
+ *answerp = answer;
+
+ return 0;
+}
+
+/* Parses an assertion directive of type TYPE, returning a pointer to
+ the hash node of the predicate, or 0 on error. If an answer was
+ supplied, it is placed in ANSWERP, otherwise it is set to 0. */
+static cpp_hashnode *
+parse_assertion (pfile, answerp, type)
cpp_reader *pfile;
+ struct answer **answerp;
+ int type;
{
- U_CHAR *name = CPP_PWRITTEN (pfile);
- int result;
- HASHNODE *hp;
-
- FORWARD (1); /* Skip '#' */
- cpp_skip_hspace (pfile);
- if (! parse_assertion (pfile))
- result = 0;
- else
+ cpp_hashnode *result = 0;
+ const cpp_token *predicate;
+
+ /* We don't expand predicates or answers. */
+ pfile->state.prevent_expansion++;
+
+ *answerp = 0;
+ predicate = cpp_get_token (pfile);
+ if (predicate->type == CPP_EOF)
+ cpp_error (pfile, "assertion without predicate");
+ else if (predicate->type != CPP_NAME)
+ cpp_error (pfile, "predicate must be an identifier");
+ else if (parse_answer (pfile, answerp, type) == 0)
{
- hp = cpp_lookup (pfile, name, CPP_PWRITTEN (pfile) - name, -1);
- result = (hp != 0);
+ unsigned int len = NODE_LEN (predicate->val.node);
+ unsigned char *sym = alloca (len + 1);
+
+ /* Prefix '#' to get it out of macro namespace. */
+ sym[0] = '#';
+ memcpy (sym + 1, NODE_NAME (predicate->val.node), len);
+ result = cpp_lookup (pfile, sym, len + 1);
}
- pfile->limit = name;
+ pfile->state.prevent_expansion--;
return result;
}
-/* Remember the current position of PFILE. */
-
-void
-parse_set_mark (pfile)
- cpp_reader *pfile;
+/* Returns a pointer to the pointer to CANDIDATE in the answer chain,
+ or a pointer to NULL if the answer is not in the chain. */
+static struct answer **
+find_answer (node, candidate)
+ cpp_hashnode *node;
+ const struct answer *candidate;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
- if (ip->mark != -1)
- cpp_fatal (pfile,
- "cpp internal error: ip->mark != -1 in parse_set_mark");
+ unsigned int i;
+ struct answer **result;
- ip->mark = ip->cur - ip->buf;
-}
+ for (result = &node->value.answers; *result; result = &(*result)->next)
+ {
+ struct answer *answer = *result;
-/* Clear the current mark - we no longer need it. */
+ if (answer->count == candidate->count)
+ {
+ for (i = 0; i < answer->count; i++)
+ if (! _cpp_equiv_tokens (&answer->first[i], &candidate->first[i]))
+ break;
-void
-parse_clear_mark (pfile)
- cpp_reader *pfile;
-{
- cpp_buffer *ip = CPP_BUFFER (pfile);
- if (ip->mark == -1)
- cpp_fatal (pfile,
- "cpp internal error: ip->mark == -1 in parse_clear_mark");
+ if (i == answer->count)
+ break;
+ }
+ }
- ip->mark = -1;
+ return result;
}
-/* Backup the current position of PFILE to that saved in its mark,
- and clear the mark. */
-
-void
-parse_goto_mark (pfile)
+/* Test an assertion within a preprocessor conditional. Returns
+ non-zero on failure, zero on success. On success, the result of
+ the test is written into VALUE. */
+int
+_cpp_test_assertion (pfile, value)
cpp_reader *pfile;
+ int *value;
{
- cpp_buffer *ip = CPP_BUFFER (pfile);
- if (ip->mark == -1)
- cpp_fatal (pfile,
- "cpp internal error: ip->mark == -1 in parse_goto_mark");
+ struct answer *answer;
+ cpp_hashnode *node;
- ip->cur = ip->buf + ip->mark;
- ip->mark = -1;
+ node = parse_assertion (pfile, &answer, T_IF);
+ if (node)
+ *value = (node->type == NT_ASSERTION &&
+ (answer == 0 || *find_answer (node, answer) != 0));
+
+ /* We don't commit the memory for the answer - it's temporary only. */
+ return node == 0;
}
+/* Handle #assert. */
static void
-cpp_print_file_and_line (pfile)
+do_assert (pfile)
cpp_reader *pfile;
{
- cpp_buffer *ip = cpp_file_buffer (pfile);
-
- if (ip != NULL)
+ struct answer *new_answer;
+ cpp_hashnode *node;
+
+ node = parse_assertion (pfile, &new_answer, T_ASSERT);
+ if (node)
{
- long line, col;
- cpp_buf_line_and_col (ip, &line, &col);
- cpp_file_line_for_message (pfile, ip->nominal_fname,
- line, pfile->show_column ? col : -1);
+ /* Place the new answer in the answer list. First check there
+ is not a duplicate. */
+ new_answer->next = 0;
+ if (node->type == NT_ASSERTION)
+ {
+ if (*find_answer (node, new_answer))
+ {
+ cpp_warning (pfile, "\"%s\" re-asserted", NODE_NAME (node) + 1);
+ return;
+ }
+ new_answer->next = node->value.answers;
+ }
+
+ node->type = NT_ASSERTION;
+ node->value.answers = new_answer;
+ BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)
+ + (new_answer->count - 1)
+ * sizeof (cpp_token));
+ check_eol (pfile);
}
}
+/* Handle #unassert. */
static void
-v_cpp_error (pfile, msgid, ap)
- cpp_reader *pfile;
- const char *msgid;
- va_list ap;
+do_unassert (pfile)
+ cpp_reader *pfile;
{
- cpp_print_containing_files (pfile);
- cpp_print_file_and_line (pfile);
- v_cpp_message (pfile, 1, msgid, ap);
-}
+ cpp_hashnode *node;
+ struct answer *answer;
+
+ node = parse_assertion (pfile, &answer, T_UNASSERT);
+ /* It isn't an error to #unassert something that isn't asserted. */
+ if (node && node->type == NT_ASSERTION)
+ {
+ if (answer)
+ {
+ struct answer **p = find_answer (node, answer), *temp;
-void
-cpp_error VPROTO ((cpp_reader * pfile, const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- cpp_reader *pfile;
- const char *msgid;
-#endif
- va_list ap;
+ /* Remove the answer from the list. */
+ temp = *p;
+ if (temp)
+ *p = temp->next;
- VA_START(ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- pfile = va_arg (ap, cpp_reader *);
- msgid = va_arg (ap, const char *);
-#endif
+ /* Did we free the last answer? */
+ if (node->value.answers == 0)
+ node->type = NT_VOID;
+
+ check_eol (pfile);
+ }
+ else
+ _cpp_free_definition (node);
+ }
- v_cpp_error (pfile, msgid, ap);
- va_end(ap);
+ /* We don't commit the memory for the answer - it's temporary only. */
}
-/* Print error message but don't count it. */
+/* These are for -D, -U, -A. */
-static void
-v_cpp_warning (pfile, msgid, ap)
- cpp_reader *pfile;
- const char *msgid;
- va_list ap;
+/* Process the string STR as if it appeared as the body of a #define.
+ If STR is just an identifier, define it with value 1.
+ If STR has anything after the identifier, then it should
+ be identifier=definition. */
+void
+cpp_define (pfile, str)
+ cpp_reader *pfile;
+ const char *str;
{
- if (CPP_OPTIONS (pfile)->inhibit_warnings)
- return;
+ char *buf, *p;
+ size_t count;
+
+ /* Copy the entire option so we can modify it.
+ Change the first "=" in the string to a space. If there is none,
+ tack " 1" on the end. */
- if (CPP_OPTIONS (pfile)->warnings_are_errors)
- pfile->errors++;
+ count = strlen (str);
+ buf = (char *) alloca (count + 3);
+ memcpy (buf, str, count);
+
+ p = strchr (str, '=');
+ if (p)
+ buf[p - str] = ' ';
+ else
+ {
+ buf[count++] = ' ';
+ buf[count++] = '1';
+ }
+ buf[count] = '\0';
- cpp_print_containing_files (pfile);
- cpp_print_file_and_line (pfile);
- v_cpp_message (pfile, 0, msgid, ap);
+ run_directive (pfile, T_DEFINE, buf, count);
}
+/* Slight variant of the above for use by initialize_builtins. */
void
-cpp_warning VPROTO ((cpp_reader * pfile, const char *msgid, ...))
+_cpp_define_builtin (pfile, str)
+ cpp_reader *pfile;
+ const char *str;
{
-#ifndef ANSI_PROTOTYPES
- cpp_reader *pfile;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- pfile = va_arg (ap, cpp_reader *);
- msgid = va_arg (ap, const char *);
-#endif
-
- v_cpp_warning (pfile, msgid, ap);
- va_end(ap);
+ run_directive (pfile, T_DEFINE, str, strlen (str));
}
-/* Print an error message and maybe count it. */
-
+/* Process MACRO as if it appeared as the body of an #undef. */
void
-cpp_pedwarn VPROTO ((cpp_reader * pfile, const char *msgid, ...))
+cpp_undef (pfile, macro)
+ cpp_reader *pfile;
+ const char *macro;
{
-#ifndef ANSI_PROTOTYPES
- cpp_reader *pfile;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- pfile = va_arg (ap, cpp_reader *);
- msgid = va_arg (ap, const char *);
-#endif
-
- if (CPP_OPTIONS (pfile)->pedantic_errors)
- v_cpp_error (pfile, msgid, ap);
- else
- v_cpp_warning (pfile, msgid, ap);
- va_end(ap);
+ run_directive (pfile, T_UNDEF, macro, strlen (macro));
}
-static void
-v_cpp_error_with_line (pfile, line, column, msgid, ap)
- cpp_reader * pfile;
- int line;
- int column;
- const char * msgid;
- va_list ap;
+/* Process the string STR as if it appeared as the body of a #assert. */
+void
+cpp_assert (pfile, str)
+ cpp_reader *pfile;
+ const char *str;
{
- cpp_buffer *ip = cpp_file_buffer (pfile);
-
- cpp_print_containing_files (pfile);
-
- if (ip != NULL)
- cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
-
- v_cpp_message (pfile, 1, msgid, ap);
+ handle_assertion (pfile, str, T_ASSERT);
}
+/* Process STR as if it appeared as the body of an #unassert. */
void
-cpp_error_with_line VPROTO ((cpp_reader * pfile, int line, int column,
- const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- cpp_reader *pfile;
- int line;
- int column;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- pfile = va_arg (ap, cpp_reader *);
- line = va_arg (ap, int);
- column = va_arg (ap, int);
- msgid = va_arg (ap, const char *);
-#endif
-
- v_cpp_error_with_line(pfile, line, column, msgid, ap);
- va_end(ap);
-}
+cpp_unassert (pfile, str)
+ cpp_reader *pfile;
+ const char *str;
+{
+ handle_assertion (pfile, str, T_UNASSERT);
+}
+/* Common code for cpp_assert (-A) and cpp_unassert (-A-). */
static void
-v_cpp_warning_with_line (pfile, line, column, msgid, ap)
- cpp_reader * pfile;
- int line;
- int column;
- const char *msgid;
- va_list ap;
+handle_assertion (pfile, str, type)
+ cpp_reader *pfile;
+ const char *str;
+ int type;
{
- cpp_buffer *ip;
-
- if (CPP_OPTIONS (pfile)->inhibit_warnings)
- return;
+ size_t count = strlen (str);
+ const char *p = strchr (str, '=');
- if (CPP_OPTIONS (pfile)->warnings_are_errors)
- pfile->errors++;
-
- cpp_print_containing_files (pfile);
-
- ip = cpp_file_buffer (pfile);
-
- if (ip != NULL)
- cpp_file_line_for_message (pfile, ip->nominal_fname, line, column);
+ if (p)
+ {
+ /* Copy the entire option so we can modify it. Change the first
+ "=" in the string to a '(', and tack a ')' on the end. */
+ char *buf = (char *) alloca (count + 2);
- v_cpp_message (pfile, 0, msgid, ap);
-}
+ memcpy (buf, str, count);
+ buf[p - str] = '(';
+ buf[count++] = ')';
+ buf[count] = '\0';
+ str = buf;
+ }
-void
-cpp_warning_with_line VPROTO ((cpp_reader * pfile, int line, int column,
- const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- cpp_reader *pfile;
- int line;
- int column;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- pfile = va_arg (ap, cpp_reader *);
- line = va_arg (ap, int);
- column = va_arg (ap, int);
- msgid = va_arg (ap, const char *);
-#endif
+ run_directive (pfile, type, str, count);
+}
- v_cpp_warning_with_line (pfile, line, column, msgid, ap);
- va_end(ap);
+/* The number of errors for a given reader. */
+unsigned int
+cpp_errors (pfile)
+ cpp_reader *pfile;
+{
+ return pfile->errors;
}
-void
-cpp_pedwarn_with_line VPROTO ((cpp_reader * pfile, int line, int column,
- const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- cpp_reader *pfile;
- int line;
- int column;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- pfile = va_arg (ap, cpp_reader *);
- line = va_arg (ap, int);
- column = va_arg (ap, int);
- msgid = va_arg (ap, const char *);
-#endif
+/* The options structure. */
+cpp_options *
+cpp_get_options (pfile)
+ cpp_reader *pfile;
+{
+ return &pfile->opts;
+}
- if (CPP_OPTIONS (pfile)->pedantic_errors)
- v_cpp_error_with_line (pfile, column, line, msgid, ap);
- else
- v_cpp_warning_with_line (pfile, line, column, msgid, ap);
- va_end(ap);
+/* The callbacks structure. */
+cpp_callbacks *
+cpp_get_callbacks (pfile)
+ cpp_reader *pfile;
+{
+ return &pfile->cb;
}
-/* Report a warning (or an error if pedantic_errors)
- giving specified file name and line number, not current. */
+/* The line map set. */
+const struct line_maps *
+cpp_get_line_maps (pfile)
+ cpp_reader *pfile;
+{
+ return &pfile->line_maps;
+}
+/* Copy the given callbacks structure to our own. */
void
-cpp_pedwarn_with_file_and_line VPROTO ((cpp_reader *pfile, const char *file,
- int line, const char *msgid, ...))
-{
-#ifndef ANSI_PROTOTYPES
- cpp_reader *pfile;
- const char *file;
- int line;
- const char *msgid;
-#endif
- va_list ap;
-
- VA_START (ap, msgid);
-
-#ifndef ANSI_PROTOTYPES
- pfile = va_arg (ap, cpp_reader *);
- file = va_arg (ap, const char *);
- line = va_arg (ap, int);
- msgid = va_arg (ap, const char *);
-#endif
-
- if (!CPP_OPTIONS (pfile)->pedantic_errors
- && CPP_OPTIONS (pfile)->inhibit_warnings)
- return;
- if (file != NULL)
- cpp_file_line_for_message (pfile, file, line, -1);
- v_cpp_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors, msgid, ap);
- va_end(ap);
+cpp_set_callbacks (pfile, cb)
+ cpp_reader *pfile;
+ cpp_callbacks *cb;
+{
+ pfile->cb = *cb;
}
-/* my_strerror - return the descriptive text associated with an
- `errno' code. */
-
-static const char *
-my_strerror (errnum)
- int errnum;
+/* Push a new buffer on the buffer stack. Returns the new buffer; it
+ doesn't fail. It does not generate a file change call back; that
+ is the responsibility of the caller. */
+cpp_buffer *
+cpp_push_buffer (pfile, buffer, len, from_stage3, return_at_eof)
+ cpp_reader *pfile;
+ const U_CHAR *buffer;
+ size_t len;
+ int from_stage3;
+ int return_at_eof;
{
- const char *result;
-
-#ifndef VMS
-#ifndef HAVE_STRERROR
- result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0);
-#else
- result = strerror (errnum);
-#endif
-#else /* VMS */
- /* VAXCRTL's strerror() takes an optional second argument, which only
- matters when the first argument is EVMSERR. However, it's simplest
- just to pass it unconditionally. `vaxc$errno' is declared in
- <errno.h>, and maintained by the library in parallel with `errno'.
- We assume that caller's `errnum' either matches the last setting of
- `errno' by the library or else does not have the value `EVMSERR'. */
-
- result = strerror (errnum, vaxc$errno);
-#endif
+ cpp_buffer *new = xobnew (&pfile->buffer_ob, cpp_buffer);
- if (!result)
- result = "errno = ?";
+ /* Clears, amongst other things, if_stack and mi_cmacro. */
+ memset (new, 0, sizeof (cpp_buffer));
- return result;
-}
+ new->line_base = new->buf = new->cur = buffer;
+ new->rlimit = buffer + len;
+ new->from_stage3 = from_stage3;
+ new->prev = pfile->buffer;
+ new->return_at_eof = return_at_eof;
+ new->saved_flags = BOL;
-/* Error including a message from `errno'. */
+ pfile->buffer = new;
-void
-cpp_error_from_errno (pfile, name)
- cpp_reader *pfile;
- const char *name;
-{
- cpp_message_from_errno (pfile, 1, name);
+ return new;
}
+/* If called from do_line, pops a single buffer. Otherwise pops all
+ buffers until a real file is reached. Generates appropriate
+ call-backs. */
void
-cpp_message_from_errno (pfile, is_error, name)
+_cpp_pop_buffer (pfile)
cpp_reader *pfile;
- int is_error;
- const char *name;
{
- int e = errno;
- cpp_buffer *ip = cpp_file_buffer (pfile);
+ cpp_buffer *buffer = pfile->buffer;
+ struct if_stack *ifs;
+ bool pushed = false;
+
+ /* 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,
+ "unterminated #%s", dtable[ifs->type].name);
- cpp_print_containing_files (pfile);
+ /* In case of a missing #endif. */
+ pfile->state.skipping = 0;
- if (ip != NULL)
- cpp_file_line_for_message (pfile, ip->nominal_fname, ip->lineno, -1);
+ /* Update the reader's buffer before _cpp_do_file_change. */
+ pfile->buffer = buffer->prev;
- cpp_message (pfile, is_error, "%s: %s", name, my_strerror (e));
+ if (buffer->inc)
+ pushed = _cpp_pop_file_buffer (pfile, buffer->inc);
+
+ if (!pushed)
+ obstack_free (&pfile->buffer_ob, buffer);
}
+/* Enter all recognised directives in the hash table. */
void
-cpp_perror_with_name (pfile, name)
+_cpp_init_directives (pfile)
cpp_reader *pfile;
- const char *name;
{
- cpp_message (pfile, 1, "%s: %s: %s", progname, name, my_strerror (errno));
-}
+ unsigned int i;
+ cpp_hashnode *node;
-/* TODO:
- * No pre-compiled header file support.
- *
- * Possibly different enum token codes for each C/C++ token.
- *
- * Find and cleanup remaining uses of static variables,
- *
- * Support -dM flag (dump_all_macros).
- *
- * Support for_lint flag.
- */
+ for (i = 0; i < (unsigned int) N_DIRECTIVES; i++)
+ {
+ node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);
+ node->directive_index = i + 1;
+ }
+}
OSDN Git Service
