+2000-10-30 Neil Booth <neilb@earthling.net>
+
+ * cppfiles.c (stack_include_file): Check for stacked contexts
+ here.
+ * cpphash.h (_cpp_do__Pragma): New prototype.
+ * cppinit.c (cpp_reader_init): Add _Pragma keyword to hash table.
+
+ * cpplex.c (skip_escaped_newlines): Only process trigraphs and
+ escaped newlines if !(buffer->from_stage3).
+ (_cpp_lex_token): Warn about missing newlines iff
+ !buffer->from_stage3.
+
+ * cpplib.c (get__Pragma_string, destringize,
+ _cpp_do__Pragma): New functions.
+ (run_directive): Set output_line for _Pragma to avoid line
+ markers in output. Set from_stage3 and prevent macro expansion
+ for _Pragma and command-line options. Check buffer exhaustion.
+ (cpp_push_buffer): Don't check for stacked macro contexts, as
+ this is perfectly legitimate for _Pragma. Move the check to
+ stack_include_file instead. Set from_stage3 iff buffer is
+ preprocessed input.
+
+ * cpplib.h (struct cpp_buffer): Make warned_cplusplus_comments
+ unsigned. New boolean from_stage3.
+ (struct spec_nodes): Add n__Pragma.
+
+ * cppmacro.c (enter_macro_context): Flip sense of return value.
+ (_cpp_get_token): Handle _Pragma operator.
+
2000-10-30 Phil Edwards <pme@sources.redhat.com>
* gcc.texi: The C++ standard isn't "draft" anymore.
{
cpp_buffer *fp;
+ if (pfile->context->prev)
+ cpp_ice (pfile, "attempt to push file buffer with contexts stacked");
+
if (DO_NOT_REREAD (inc))
return 0;
extern int _cpp_test_assertion PARAMS ((cpp_reader *, int *));
extern int _cpp_handle_directive PARAMS ((cpp_reader *, int));
extern void _cpp_define_builtin PARAMS ((cpp_reader *, const char *));
+extern void _cpp_do__Pragma PARAMS ((cpp_reader *));
extern void _cpp_init_stacks PARAMS ((cpp_reader *));
extern void _cpp_cleanup_stacks PARAMS ((cpp_reader *));
extern void _cpp_init_internal_pragmas PARAMS ((cpp_reader *));
s = &pfile->spec_nodes;
s->n_L = cpp_lookup (pfile, DSC("L"));
s->n_defined = cpp_lookup (pfile, DSC("defined"));
+ s->n__Pragma = cpp_lookup (pfile, DSC("_Pragma"));
s->n__STRICT_ANSI__ = cpp_lookup (pfile, DSC("__STRICT_ANSI__"));
s->n__CHAR_UNSIGNED__ = cpp_lookup (pfile, DSC("__CHAR_UNSIGNED__"));
s->n__VA_ARGS__ = cpp_lookup (pfile, DSC("__VA_ARGS__"));
/* Skips any escaped newlines introduced by NEXT, which is either a
'?' or a '\\'. Returns the next character, which will also have
- been placed in buffer->read_ahead. */
+ been placed in buffer->read_ahead. This routine performs
+ preprocessing stages 1 and 2 of the ISO C standard. */
static cppchar_t
skip_escaped_newlines (buffer, next)
cpp_buffer *buffer;
cppchar_t next;
{
- cppchar_t next1;
- const unsigned char *saved_cur;
- int space;
-
- do
+ /* Only do this if we apply stages 1 and 2. */
+ if (!buffer->from_stage3)
{
- if (buffer->cur == buffer->rlimit)
- break;
-
- SAVE_STATE ();
- if (next == '?')
+ cppchar_t next1;
+ const unsigned char *saved_cur;
+ int space;
+
+ do
{
- next1 = *buffer->cur++;
- if (next1 != '?' || buffer->cur == buffer->rlimit)
+ if (buffer->cur == buffer->rlimit)
+ break;
+
+ SAVE_STATE ();
+ if (next == '?')
{
- RESTORE_STATE ();
- break;
+ next1 = *buffer->cur++;
+ if (next1 != '?' || buffer->cur == buffer->rlimit)
+ {
+ RESTORE_STATE ();
+ break;
+ }
+
+ next1 = *buffer->cur++;
+ if (!_cpp_trigraph_map[next1]
+ || !trigraph_ok (buffer->pfile, next1))
+ {
+ RESTORE_STATE ();
+ break;
+ }
+
+ /* We have a full trigraph here. */
+ next = _cpp_trigraph_map[next1];
+ if (next != '\\' || buffer->cur == buffer->rlimit)
+ break;
+ SAVE_STATE ();
+ }
+
+ /* We have a backslash, and room for at least one more character. */
+ space = 0;
+ do
+ {
+ next1 = *buffer->cur++;
+ if (!is_nvspace (next1))
+ break;
+ space = 1;
}
+ while (buffer->cur < buffer->rlimit);
- next1 = *buffer->cur++;
- if (!_cpp_trigraph_map[next1] || !trigraph_ok (buffer->pfile, next1))
+ if (!is_vspace (next1))
{
RESTORE_STATE ();
break;
}
- /* We have a full trigraph here. */
- next = _cpp_trigraph_map[next1];
- if (next != '\\' || buffer->cur == buffer->rlimit)
- break;
- SAVE_STATE ();
- }
+ if (space)
+ cpp_warning (buffer->pfile,
+ "backslash and newline separated by space");
- /* We have a backslash, and room for at least one more character. */
- space = 0;
- do
- {
- next1 = *buffer->cur++;
- if (!is_nvspace (next1))
- break;
- space = 1;
- }
- while (buffer->cur < buffer->rlimit);
-
- if (!is_vspace (next1))
- {
- RESTORE_STATE ();
- break;
+ next = handle_newline (buffer, next1);
+ if (next == EOF)
+ cpp_pedwarn (buffer->pfile, "backslash-newline at end of file");
}
-
- if (space)
- cpp_warning (buffer->pfile,
- "backslash and newline separated by space");
-
- next = handle_newline (buffer, next1);
- if (next == EOF)
- cpp_pedwarn (buffer->pfile, "backslash-newline at end of file");
+ while (next == '\\' || next == '?');
}
- while (next == '\\' || next == '?');
buffer->read_ahead = next;
return next;
{
case EOF:
/* Non-empty files should end in a newline. Ignore for command
- line - we get e.g. -A options with no trailing \n. */
- if (pfile->lexer_pos.col != 0 && pfile->done_initializing)
+ line and _Pragma buffers. */
+ if (pfile->lexer_pos.col != 0 && !buffer->from_stage3)
cpp_pedwarn (pfile, "no newline at end of file");
pfile->state.skip_newlines = 1;
result->type = CPP_EOF;
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 int get__Pragma_string PARAMS ((cpp_reader *, cpp_token *));
+static unsigned char *destringize PARAMS ((const cpp_string *,
+ unsigned int *));
static int parse_answer PARAMS ((cpp_reader *, struct answer **, int));
static cpp_hashnode *parse_assertion PARAMS ((cpp_reader *, struct answer **,
int));
size_t count;
const char *name;
{
- if (cpp_push_buffer (pfile, (const U_CHAR *)buf, count) != NULL)
+ if (cpp_push_buffer (pfile, (const U_CHAR *) buf, count) != NULL)
{
const struct directive *dir = &dtable[dir_no];
CPP_BUFFER (pfile)->nominal_fname = name;
else
CPP_BUFFER (pfile)->nominal_fname = _("<command line>");
- CPP_BUFFER (pfile)->lineno = (unsigned int)-1;
+ /* A kludge to avoid line markers for _Pragma. */
+ if (dir_no == T_PRAGMA)
+ pfile->lexer_pos.output_line = CPP_BUFFER (pfile)->prev->lineno;
+
+ /* For _Pragma, the text is passed through preprocessing stage 3
+ only, i.e. no trigraphs, no escaped newline removal, and no
+ macro expansion. Do the same for command-line directives. */
+ pfile->buffer->from_stage3 = 1;
pfile->state.in_directive = 1;
pfile->directive = dir;
+ pfile->state.prevent_expansion++;
(void) (*dir->handler) (pfile);
+ pfile->state.prevent_expansion--;
pfile->directive = 0;
pfile->state.in_directive = 0;
skip_rest_of_line (pfile);
+ if (pfile->buffer->cur != pfile->buffer->rlimit)
+ cpp_error (pfile, "extra text after end of #%s directive",
+ dtable[dir_no].name);
cpp_pop_buffer (pfile);
}
}
}
}
+/* Check syntax is "(string-literal)". Returns 0 on success. */
+static int
+get__Pragma_string (pfile, string)
+ cpp_reader *pfile;
+ cpp_token *string;
+{
+ cpp_token paren;
+
+ cpp_get_token (pfile, &paren);
+ if (paren.type != CPP_OPEN_PAREN)
+ return 1;
+
+ cpp_get_token (pfile, string);
+ if (string->type != CPP_STRING && string->type != CPP_WSTRING)
+ return 1;
+
+ cpp_get_token (pfile, &paren);
+ return paren.type != CPP_CLOSE_PAREN;
+}
+
+/* Returns a malloced buffer containing a destringized cpp_string by
+ removing the first \ of \" and \\ sequences. */
+static unsigned char *
+destringize (in, len)
+ const cpp_string *in;
+ unsigned int *len;
+{
+ const unsigned char *src, *limit;
+ unsigned char *dest, *result;
+
+ dest = result = (unsigned char *) xmalloc (in->len);
+ for (src = in->text, limit = src + in->len; src < limit;)
+ {
+ /* We know there is a character following the backslash. */
+ if (*src == '\\' && (src[1] == '\\' || src[1] == '"'))
+ src++;
+ *dest++ = *src++;
+ }
+
+ *len = dest - result;
+ return result;
+}
+
+void
+_cpp_do__Pragma (pfile)
+ cpp_reader *pfile;
+{
+ cpp_token string;
+ unsigned char *buffer;
+ unsigned int len;
+
+ if (get__Pragma_string (pfile, &string))
+ {
+ cpp_error (pfile, "_Pragma takes a parenthesized string literal");
+ return;
+ }
+
+ buffer = destringize (&string.val.str, &len);
+ run_directive (pfile, T_PRAGMA, (char *) buffer, len, _("<_Pragma>"));
+ free ((PTR) buffer);
+}
+
/* Just ignore #sccs, on systems where we define it at all. */
#ifdef SCCS_DIRECTIVE
static void
return NULL;
}
- if (pfile->context->prev)
- {
- cpp_ice (pfile, "buffer pushed with contexts stacked");
- skip_rest_of_line (pfile);
- }
-
new = xobnew (pfile->buffer_ob, cpp_buffer);
/* Clears, amongst other things, if_stack and mi_cmacro. */
memset (new, 0, sizeof (cpp_buffer));
new->rlimit = buffer + length;
new->prev = buf;
new->pfile = pfile;
+ /* Preprocessed files don't do trigraph and escaped newline processing. */
+ new->from_stage3 = CPP_OPTION (pfile, preprocessed);
/* No read ahead or extra char initially. */
new->read_ahead = EOF;
new->extra_char = EOF;
The warning happens only for C89 extended mode with -pedantic on,
or for -Wtraditional, and only once per file (otherwise it would
be far too noisy). */
- char warned_cplusplus_comments;
+ unsigned char warned_cplusplus_comments;
+
+ /* True if we don't process trigraphs and escaped newlines. True
+ for preprocessed input, command line directives, and _Pragma
+ buffers. */
+ unsigned char from_stage3;
};
/* Maximum nesting of cpp_buffers. We use a static limit, partly for
{
cpp_hashnode *n_L; /* L"str" */
cpp_hashnode *n_defined; /* defined operator */
+ cpp_hashnode *n__Pragma; /* _Pragma operator */
cpp_hashnode *n__STRICT_ANSI__; /* STDC_0_IN_SYSTEM_HEADERS */
cpp_hashnode *n__CHAR_UNSIGNED__; /* plain char is unsigned */
cpp_hashnode *n__VA_ARGS__; /* C99 vararg macros */
/* Push the context of a macro onto the context stack. TOKEN is the
macro name. If we can successfully start expanding the macro,
- TOKEN is replaced with the first token of the expansion. */
+ TOKEN is replaced with the first token of the expansion, and we
+ return non-zero. */
static int
enter_macro_context (pfile, token)
cpp_reader *pfile;
if (macro->disabled)
{
token->flags |= NO_EXPAND;
- return 1;
+ return 0;
}
/* Save the position of the outermost macro invocation. */
{
if (!pfile->context->prev)
unlock_pools (pfile);
- return 1;
+ return 0;
}
/* Now push its context. */
/* Disable the macro within its expansion. */
macro->disabled = 1;
- return 0;
+ return 1;
}
/* Move to the next context. Create one if there is none. */
cpp_reader *pfile;
cpp_token *token;
{
+ next_token:
for (;;)
{
cpp_context *context = pfile->context;
if (token->flags & PASTE_LEFT)
paste_all_tokens (pfile, token);
- if (token->type != CPP_NAME
- || token->val.node->type != NT_MACRO
- || pfile->state.prevent_expansion
- || token->flags & NO_EXPAND)
+ if (token->type != CPP_NAME)
break;
- /* Macros, built-in or not, invalidate controlling macros. */
- pfile->mi_state = MI_FAILED;
-
- if (token->val.node->flags & NODE_BUILTIN)
+ /* Handle macros and the _Pragma operator. */
+ if (token->val.node->type == NT_MACRO
+ && !pfile->state.prevent_expansion
+ && !(token->flags & NO_EXPAND))
{
- builtin_macro (pfile, token);
- break;
+ /* Macros invalidate controlling macros. */
+ pfile->mi_state = MI_FAILED;
+
+ if (token->val.node->flags & NODE_BUILTIN)
+ {
+ builtin_macro (pfile, token);
+ break;
+ }
+
+ if (enter_macro_context (pfile, token))
+ continue;
}
- else if (enter_macro_context (pfile, token))
+
+ if (token->val.node != pfile->spec_nodes.n__Pragma)
break;
+
+ /* Invalidate controlling macros. */
+ pfile->mi_state = MI_FAILED;
+ _cpp_do__Pragma (pfile);
+ goto next_token;
}
}
projects / thirdparty / gcc.git / commitdiff
