X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=libcpp%2Fdirectives.c;h=0eea67d133c81d54c373f1268cb53af78cae5111;hb=fb73e4871a6684641ce4376b7a67b5f1094d3297;hp=10d080bee4429174dce821ac32caa7d0fad2ecae;hpb=a095c1b560cd722cac898454150f94c438e7ef4c;p=pf3gnuchains%2Fgcc-fork.git diff --git a/libcpp/directives.c b/libcpp/directives.c index 10d080bee44..0eea67d133c 100644 --- a/libcpp/directives.c +++ b/libcpp/directives.c @@ -1,6 +1,6 @@ /* CPP Library. (Directive handling.) Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + 1999, 2000, 2001, 2002, 2003, 2004, 2005 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 @@ -17,7 +17,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software -Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "config.h" #include "system.h" @@ -46,9 +46,12 @@ struct pragma_entry const cpp_hashnode *pragma; /* Name and length. */ bool is_nspace; bool is_internal; + bool is_deferred; + bool allow_expansion; union { pragma_cb handler; struct pragma_entry *space; + unsigned int ident; } u; }; @@ -94,7 +97,7 @@ static void end_directive (cpp_reader *, int); static void directive_diagnostics (cpp_reader *, const directive *, int); static void run_directive (cpp_reader *, int, const char *, size_t); static char *glue_header_name (cpp_reader *); -static const char *parse_include (cpp_reader *, int *); +static const char *parse_include (cpp_reader *, int *, const cpp_token ***); static void push_conditional (cpp_reader *, int, int, const cpp_hashnode *); static unsigned int read_flag (cpp_reader *, unsigned int); static int strtoul_for_line (const uchar *, unsigned int, unsigned long *); @@ -104,13 +107,6 @@ static int undefine_macros (cpp_reader *, cpp_hashnode *, void *); static void do_include_common (cpp_reader *, enum include_type); static struct pragma_entry *lookup_pragma_entry (struct pragma_entry *, const cpp_hashnode *); -static struct pragma_entry *insert_pragma_entry (cpp_reader *, - struct pragma_entry **, - const cpp_hashnode *, - pragma_cb, - bool); -static void register_pragma (cpp_reader *, const char *, const char *, - pragma_cb, bool); static int count_registered_pragmas (struct pragma_entry *); static char ** save_registered_pragmas (struct pragma_entry *, char **); static char ** restore_registered_pragmas (cpp_reader *, struct pragma_entry *, @@ -156,7 +152,10 @@ D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \ D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \ D(assert, T_ASSERT, EXTENSION, 0) /* 0 SVR4 */ \ D(unassert, T_UNASSERT, EXTENSION, 0) /* 0 SVR4 */ \ -D(sccs, T_SCCS, EXTENSION, 0) /* 0 SVR4? */ +D(sccs, T_SCCS, EXTENSION, IN_I) /* 0 SVR4? */ + +/* #sccs is synonymous with #ident. */ +#define do_sccs do_ident /* Use the table to generate a series of prototypes, an enum for the directive names, and an array of directive handlers. */ @@ -216,6 +215,46 @@ check_eol (cpp_reader *pfile) pfile->directive->name); } +/* Ensure there are no stray tokens other than comments at the end of + a directive, and gather the comments. */ +static const cpp_token ** +check_eol_return_comments (cpp_reader *pfile) +{ + size_t c; + size_t capacity = 8; + const cpp_token **buf; + + buf = XNEWVEC (const cpp_token *, capacity); + c = 0; + if (! SEEN_EOL ()) + { + while (1) + { + const cpp_token *tok; + + tok = _cpp_lex_token (pfile); + if (tok->type == CPP_EOF) + break; + if (tok->type != CPP_COMMENT) + cpp_error (pfile, CPP_DL_PEDWARN, + "extra tokens at end of #%s directive", + pfile->directive->name); + else + { + if (c + 1 >= capacity) + { + capacity *= 2; + buf = XRESIZEVEC (const cpp_token *, buf, capacity); + } + buf[c] = tok; + ++c; + } + } + } + buf[c] = NULL; + return buf; +} + /* Called when entering a directive, _Pragma or command-line directive. */ static void start_directive (cpp_reader *pfile) @@ -233,7 +272,9 @@ start_directive (cpp_reader *pfile) static void end_directive (cpp_reader *pfile, int skip_line) { - if (CPP_OPTION (pfile, traditional)) + if (pfile->state.in_deferred_pragma) + ; + else if (CPP_OPTION (pfile, traditional)) { /* Revert change of prepare_directive_trad. */ pfile->state.prevent_expansion--; @@ -325,7 +366,7 @@ directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented) /* Check if we have a known directive. INDENTED is nonzero if the '#' of the directive was indented. This function is in this file - to save unnecessarily exporting dtable etc. to cpplex.c. Returns + to save unnecessarily exporting dtable etc. to lex.c. Returns nonzero if the line of tokens has been handled, zero if we should continue processing the line. */ int @@ -381,7 +422,7 @@ _cpp_handle_directive (cpp_reader *pfile, int indented) 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 + -fpreprocessed mode only if the # is in column 1. macro.c puts a space in front of any '#' at the start of a macro. */ if (CPP_OPTION (pfile, preprocessed) && (indented || !(dir->flags & IN_I))) @@ -446,9 +487,6 @@ run_directive (cpp_reader *pfile, int dir_no, const char *buf, size_t count) { cpp_push_buffer (pfile, (const uchar *) buf, count, /* from_stage3 */ true); - /* Disgusting hack. */ - if (dir_no == T_PRAGMA && pfile->buffer->prev) - pfile->buffer->file = pfile->buffer->prev->file; start_directive (pfile); /* This is a short-term fix to prevent a leading '#' being @@ -460,8 +498,6 @@ run_directive (cpp_reader *pfile, int dir_no, const char *buf, size_t count) prepare_directive_trad (pfile); pfile->directive->handler (pfile); end_directive (pfile, 1); - if (dir_no == T_PRAGMA) - pfile->buffer->file = NULL; _cpp_pop_buffer (pfile); } @@ -502,7 +538,7 @@ lex_macro_node (cpp_reader *pfile) return NULL; } -/* Process a #define directive. Most work is done in cppmacro.c. */ +/* Process a #define directive. Most work is done in macro.c. */ static void do_define (cpp_reader *pfile) { @@ -584,7 +620,7 @@ glue_header_name (cpp_reader *pfile) /* To avoid lexed tokens overwriting our glued name, we can only allocate from the string pool once we've lexed everything. */ - buffer = xmalloc (capacity); + buffer = XNEWVEC (char, capacity); for (;;) { token = get_token_no_padding (pfile); @@ -601,13 +637,14 @@ glue_header_name (cpp_reader *pfile) if (total_len + len > capacity) { capacity = (capacity + len) * 2; - buffer = xrealloc (buffer, capacity); + buffer = XRESIZEVEC (char, buffer, capacity); } if (token->flags & PREV_WHITE) buffer[total_len++] = ' '; - total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len]) + total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len], + true) - (uchar *) buffer); } @@ -619,7 +656,8 @@ glue_header_name (cpp_reader *pfile) #pragma dependency. The string is malloced and the caller should free it. Returns NULL on error. */ static const char * -parse_include (cpp_reader *pfile, int *pangle_brackets) +parse_include (cpp_reader *pfile, int *pangle_brackets, + const cpp_token ***buf) { char *fname; const cpp_token *header; @@ -628,7 +666,7 @@ parse_include (cpp_reader *pfile, int *pangle_brackets) header = get_token_no_padding (pfile); if (header->type == CPP_STRING || header->type == CPP_HEADER_NAME) { - fname = xmalloc (header->val.str.len - 1); + fname = XNEWVEC (char, header->val.str.len - 1); memcpy (fname, header->val.str.text + 1, header->val.str.len - 2); fname[header->val.str.len - 2] = '\0'; *pangle_brackets = header->type == CPP_HEADER_NAME; @@ -652,7 +690,15 @@ parse_include (cpp_reader *pfile, int *pangle_brackets) return NULL; } - check_eol (pfile); + if (buf == NULL || CPP_OPTION (pfile, discard_comments)) + check_eol (pfile); + else + { + /* If we are not discarding comments, then gather them while + doing the eol check. */ + *buf = check_eol_return_comments (pfile); + } + return fname; } @@ -662,10 +708,29 @@ do_include_common (cpp_reader *pfile, enum include_type type) { const char *fname; int angle_brackets; + const cpp_token **buf = NULL; - fname = parse_include (pfile, &angle_brackets); + /* Re-enable saving of comments if requested, so that the include + callback can dump comments which follow #include. */ + pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments); + + fname = parse_include (pfile, &angle_brackets, &buf); if (!fname) + { + if (buf) + XDELETEVEC (buf); + return; + } + + if (!*fname) + { + cpp_error (pfile, CPP_DL_ERROR, "empty filename in #%s", + pfile->directive->name); + XDELETEVEC (fname); + if (buf) + XDELETEVEC (buf); return; + } /* Prevent #include recursion. */ if (pfile->line_table->depth >= CPP_STACK_MAX) @@ -677,12 +742,15 @@ do_include_common (cpp_reader *pfile, enum include_type type) if (pfile->cb.include) pfile->cb.include (pfile, pfile->directive_line, - pfile->directive->name, fname, angle_brackets); + pfile->directive->name, fname, angle_brackets, + buf); _cpp_stack_include (pfile, fname, angle_brackets, type); } - free ((void *) fname); + XDELETEVEC (fname); + if (buf) + XDELETEVEC (buf); } static void @@ -766,6 +834,11 @@ do_line (cpp_reader *pfile) { const struct line_maps *line_table = pfile->line_table; const struct line_map *map = &line_table->maps[line_table->used - 1]; + + /* skip_rest_of_line() may cause line table to be realloc()ed so note down + sysp right now. */ + + unsigned char map_sysp = map->sysp; const cpp_token *token; const char *new_file = map->to_file; unsigned long new_lineno; @@ -806,7 +879,7 @@ do_line (cpp_reader *pfile) skip_rest_of_line (pfile); _cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno, - map->sysp); + map_sysp); } /* Interpret the # 44 "file" [flags] notation, which has slightly @@ -938,7 +1011,8 @@ do_ident (cpp_reader *pfile) const cpp_token *str = cpp_get_token (pfile); if (str->type != CPP_STRING) - cpp_error (pfile, CPP_DL_ERROR, "invalid #ident directive"); + cpp_error (pfile, CPP_DL_ERROR, "invalid #%s directive", + pfile->directive->name); else if (pfile->cb.ident) pfile->cb.ident (pfile, pfile->directive_line, &str->val.str); @@ -957,105 +1031,155 @@ lookup_pragma_entry (struct pragma_entry *chain, const cpp_hashnode *pragma) 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. If INTERNAL is true - this pragma is being inserted by libcpp itself. */ +/* Create and insert a blank pragma entry at the beginning of a + singly-linked CHAIN. */ static struct pragma_entry * -insert_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain, - const cpp_hashnode *pragma, pragma_cb handler, - bool internal) +new_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain) { - struct pragma_entry *new; + struct pragma_entry *new_entry; - new = (struct pragma_entry *) + new_entry = (struct pragma_entry *) _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry)); - new->pragma = pragma; - if (handler) - { - new->is_nspace = 0; - new->u.handler = handler; - } - else - { - new->is_nspace = 1; - new->u.space = NULL; - } - new->is_internal = internal; - new->next = *chain; - *chain = new; - return new; + memset (new_entry, 0, sizeof (struct pragma_entry)); + new_entry->next = *chain; + + *chain = new_entry; + return new_entry; } /* 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. INTERNAL is true if this is a pragma - registered by cpplib itself, false if it is registered via - cpp_register_pragma */ -static void -register_pragma (cpp_reader *pfile, const char *space, const char *name, - pragma_cb handler, bool internal) + goes in the global namespace. */ +static struct pragma_entry * +register_pragma_1 (cpp_reader *pfile, const char *space, const char *name, + bool allow_name_expansion) { 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, internal); + { + entry = new_pragma_entry (pfile, chain); + entry->pragma = node; + entry->is_nspace = true; + entry->allow_expansion = allow_name_expansion; + } else if (!entry->is_nspace) goto clash; + else if (entry->allow_expansion != allow_name_expansion) + { + cpp_error (pfile, CPP_DL_ICE, + "registering pragmas in namespace \"%s\" with mismatched " + "name expansion", space); + return NULL; + } chain = &entry->u.space; } + else if (allow_name_expansion) + { + cpp_error (pfile, CPP_DL_ICE, + "registering pragma \"%s\" with name expansion " + "and no namespace", name); + return NULL; + } /* Check for duplicates. */ node = cpp_lookup (pfile, U name, strlen (name)); entry = lookup_pragma_entry (*chain, node); - if (entry) + if (entry == NULL) { - if (entry->is_nspace) - clash: - cpp_error (pfile, CPP_DL_ICE, - "registering \"%s\" as both a pragma and a pragma namespace", - NODE_NAME (node)); - else if (space) - cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered", - space, name); - else - cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name); + entry = new_pragma_entry (pfile, chain); + entry->pragma = node; + return entry; } + + if (entry->is_nspace) + clash: + cpp_error (pfile, CPP_DL_ICE, + "registering \"%s\" as both a pragma and a pragma namespace", + NODE_NAME (node)); + else if (space) + cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered", + space, name); else - insert_pragma_entry (pfile, chain, node, handler, internal); + cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name); + + return NULL; +} + +/* Register a cpplib internal pragma SPACE NAME with HANDLER. */ +static void +register_pragma_internal (cpp_reader *pfile, const char *space, + const char *name, pragma_cb handler) +{ + struct pragma_entry *entry; + + entry = register_pragma_1 (pfile, space, name, false); + entry->is_internal = true; + entry->u.handler = handler; } /* 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. This function is exported from libcpp. */ + which must be non-NULL. If ALLOW_EXPANSION is set, allow macro + expansion while parsing pragma NAME. This function is exported + from libcpp. */ void cpp_register_pragma (cpp_reader *pfile, const char *space, const char *name, - pragma_cb handler) + pragma_cb handler, bool allow_expansion) { - register_pragma (pfile, space, name, handler, false); + struct pragma_entry *entry; + + if (!handler) + { + cpp_error (pfile, CPP_DL_ICE, "registering pragma with NULL handler"); + return; + } + + entry = register_pragma_1 (pfile, space, name, false); + if (entry) + { + entry->allow_expansion = allow_expansion; + entry->u.handler = handler; + } } +/* Similarly, but create mark the pragma for deferred processing. + When found, a CPP_PRAGMA token will be insertted into the stream + with IDENT in the token->u.pragma slot. */ +void +cpp_register_deferred_pragma (cpp_reader *pfile, const char *space, + const char *name, unsigned int ident, + bool allow_expansion, bool allow_name_expansion) +{ + struct pragma_entry *entry; + + entry = register_pragma_1 (pfile, space, name, allow_name_expansion); + if (entry) + { + entry->is_deferred = true; + entry->allow_expansion = allow_expansion; + entry->u.ident = ident; + } +} + /* Register the pragmas the preprocessor itself handles. */ void _cpp_init_internal_pragmas (cpp_reader *pfile) { /* Pragmas in the global namespace. */ - register_pragma (pfile, 0, "once", do_pragma_once, true); + register_pragma_internal (pfile, 0, "once", do_pragma_once); /* New GCC-specific pragmas should be put in the GCC namespace. */ - register_pragma (pfile, "GCC", "poison", do_pragma_poison, true); - register_pragma (pfile, "GCC", "system_header", do_pragma_system_header, true); - register_pragma (pfile, "GCC", "dependency", do_pragma_dependency, true); + register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison); + register_pragma_internal (pfile, "GCC", "system_header", + do_pragma_system_header); + register_pragma_internal (pfile, "GCC", "dependency", do_pragma_dependency); } /* Return the number of registered pragmas in PE. */ @@ -1083,9 +1207,9 @@ save_registered_pragmas (struct pragma_entry *pe, char **sd) { if (pe->is_nspace) sd = save_registered_pragmas (pe->u.space, sd); - *sd++ = xmemdup (HT_STR (&pe->pragma->ident), - HT_LEN (&pe->pragma->ident), - HT_LEN (&pe->pragma->ident) + 1); + *sd++ = (char *) xmemdup (HT_STR (&pe->pragma->ident), + HT_LEN (&pe->pragma->ident), + HT_LEN (&pe->pragma->ident) + 1); } return sd; } @@ -1133,11 +1257,9 @@ _cpp_restore_pragma_names (cpp_reader *pfile, char **saved) 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. - - The library user has the option of deferring execution of - #pragmas not handled by cpplib, in which case they are converted - to CPP_PRAGMA tokens and inserted into the output stream. */ + This implementation allows for a mix of both, since GCC did not + traditionally macro expand its (few) pragmas, whereas OpenMP + specifies that macro expansion should happen. */ static void do_pragma (cpp_reader *pfile) { @@ -1145,11 +1267,6 @@ do_pragma (cpp_reader *pfile) const cpp_token *token, *pragma_token = pfile->cur_token; unsigned int count = 1; - /* Save the current position so that defer_pragmas mode can - copy the entire current line to a string. It will not work - to use _cpp_backup_tokens as that does not reverse buffer->cur. */ - const uchar *line_start = CPP_BUFFER (pfile)->cur; - pfile->state.prevent_expansion++; token = cpp_get_token (pfile); @@ -1158,49 +1275,45 @@ do_pragma (cpp_reader *pfile) p = lookup_pragma_entry (pfile->pragmas, token->val.node); if (p && p->is_nspace) { - count = 2; + bool allow_name_expansion = p->allow_expansion; + if (allow_name_expansion) + pfile->state.prevent_expansion--; token = cpp_get_token (pfile); if (token->type == CPP_NAME) p = lookup_pragma_entry (p->u.space, token->val.node); else p = NULL; + if (allow_name_expansion) + pfile->state.prevent_expansion++; + count = 2; } } if (p) { - if (p->is_internal || !CPP_OPTION (pfile, defer_pragmas)) + if (p->is_deferred) + { + pfile->directive_result.src_loc = pragma_token->src_loc; + pfile->directive_result.type = CPP_PRAGMA; + pfile->directive_result.flags = pragma_token->flags; + pfile->directive_result.val.pragma = p->u.ident; + pfile->state.in_deferred_pragma = true; + pfile->state.pragma_allow_expansion = p->allow_expansion; + if (!p->allow_expansion) + pfile->state.prevent_expansion++; + } + else { - /* Since the handler below doesn't get the line number, that it - might need for diagnostics, make sure it has the right + /* Since the handler below doesn't get the line number, that + it might need for diagnostics, make sure it has the right numbers in place. */ if (pfile->cb.line_change) (*pfile->cb.line_change) (pfile, pragma_token, false); + if (p->allow_expansion) + pfile->state.prevent_expansion--; (*p->u.handler) (pfile); - } - else - { - /* Squirrel away the pragma text. Pragmas are - newline-terminated. */ - const uchar *line_end; - uchar *s; - cpp_string body; - cpp_token *ptok; - - line_end = ustrchr (line_start, '\n'); - - body.len = (line_end - line_start) + 1; - s = _cpp_unaligned_alloc (pfile, body.len + 1); - memcpy (s, line_start, body.len); - s[body.len] = '\0'; - body.text = s; - - /* Create a CPP_PRAGMA token. */ - ptok = &pfile->directive_result; - ptok->src_loc = pragma_token->src_loc; - ptok->type = CPP_PRAGMA; - ptok->flags = pragma_token->flags | NO_EXPAND; - ptok->val.str = body; + if (p->allow_expansion) + pfile->state.prevent_expansion++; } } else if (pfile->cb.def_pragma) @@ -1288,7 +1401,7 @@ do_pragma_dependency (cpp_reader *pfile) const char *fname; int angle_brackets, ordering; - fname = parse_include (pfile, &angle_brackets); + fname = parse_include (pfile, &angle_brackets, NULL); if (!fname) return; @@ -1348,8 +1461,13 @@ destringize_and_run (cpp_reader *pfile, const cpp_string *in) { const unsigned char *src, *limit; char *dest, *result; + cpp_context *saved_context; + cpp_token *saved_cur_token; + tokenrun *saved_cur_run; + cpp_token *toks; + int count; - dest = result = alloca (in->len - 1); + dest = result = (char *) alloca (in->len - 1); src = in->text + 1 + (in->text[0] == 'L'); limit = in->text + in->len - 1; while (src < limit) @@ -1369,36 +1487,81 @@ destringize_and_run (cpp_reader *pfile, const cpp_string *in) Something like line-at-a-time lexing should remove the need for this. */ - { - cpp_context *saved_context = pfile->context; - cpp_token *saved_cur_token = pfile->cur_token; - tokenrun *saved_cur_run = pfile->cur_run; - - pfile->context = XNEW (cpp_context); - pfile->context->macro = 0; - pfile->context->prev = 0; - run_directive (pfile, T_PRAGMA, result, dest - result); - XDELETE (pfile->context); - pfile->context = saved_context; - pfile->cur_token = saved_cur_token; - pfile->cur_run = saved_cur_run; - } + saved_context = pfile->context; + saved_cur_token = pfile->cur_token; + saved_cur_run = pfile->cur_run; + + pfile->context = XNEW (cpp_context); + pfile->context->macro = 0; + pfile->context->prev = 0; + + /* Inline run_directive, since we need to delay the _cpp_pop_buffer + until we've read all of the tokens that we want. */ + cpp_push_buffer (pfile, (const uchar *) result, dest - result, + /* from_stage3 */ true); + /* ??? Antique Disgusting Hack. What does this do? */ + if (pfile->buffer->prev) + pfile->buffer->file = pfile->buffer->prev->file; + + start_directive (pfile); + _cpp_clean_line (pfile); + do_pragma (pfile); + end_directive (pfile, 1); - /* See above comment. For the moment, we'd like + /* We always insert at least one token, the directive result. It'll + either be a CPP_PADDING or a CPP_PRAGMA. In the later case, we + need to insert *all* of the tokens, including the CPP_PRAGMA_EOL. */ + + /* If we're not handling the pragma internally, read all of the tokens from + the string buffer now, while the string buffer is still installed. */ + /* ??? Note that the token buffer allocated here is leaked. It's not clear + to me what the true lifespan of the tokens are. It would appear that + the lifespan is the entire parse of the main input stream, in which case + this may not be wrong. */ + if (pfile->directive_result.type == CPP_PRAGMA) + { + int maxcount; - token1 _Pragma ("foo") token2 + count = 1; + maxcount = 50; + toks = XNEWVEC (cpp_token, maxcount); + toks[0] = pfile->directive_result; - to be output as + do + { + if (count == maxcount) + { + maxcount = maxcount * 3 / 2; + toks = XRESIZEVEC (cpp_token, toks, maxcount); + } + toks[count++] = *cpp_get_token (pfile); + } + while (toks[count-1].type != CPP_PRAGMA_EOL); + } + else + { + count = 1; + toks = XNEW (cpp_token); + toks[0] = pfile->directive_result; + + /* If we handled the entire pragma internally, make sure we get the + line number correct for the next token. */ + if (pfile->cb.line_change) + pfile->cb.line_change (pfile, pfile->cur_token, false); + } + + /* Finish inlining run_directive. */ + pfile->buffer->file = NULL; + _cpp_pop_buffer (pfile); - token1 - # 7 "file.c" - #pragma foo - # 7 "file.c" - token2 + /* Reset the old macro state before ... */ + XDELETE (pfile->context); + pfile->context = saved_context; + pfile->cur_token = saved_cur_token; + pfile->cur_run = saved_cur_run; - Getting the line markers is a little tricky. */ - if (pfile->cb.line_change) - pfile->cb.line_change (pfile, pfile->cur_token, false); + /* ... inserting the new tokens we collected. */ + _cpp_push_token_context (pfile, NULL, toks, count); } /* Handle the _Pragma operator. */ @@ -1415,39 +1578,6 @@ _cpp_do__Pragma (cpp_reader *pfile) "_Pragma takes a parenthesized string literal"); } -/* Handle a pragma that the front end deferred until now. */ -void -cpp_handle_deferred_pragma (cpp_reader *pfile, const cpp_string *s) -{ - cpp_context *saved_context = pfile->context; - cpp_token *saved_cur_token = pfile->cur_token; - tokenrun *saved_cur_run = pfile->cur_run; - bool saved_defer_pragmas = CPP_OPTION (pfile, defer_pragmas); - void (*saved_line_change) (cpp_reader *, const cpp_token *, int) - = pfile->cb.line_change; - - pfile->context = XNEW (cpp_context); - pfile->context->macro = 0; - pfile->context->prev = 0; - pfile->cb.line_change = NULL; - CPP_OPTION (pfile, defer_pragmas) = false; - - run_directive (pfile, T_PRAGMA, (const char *)s->text, s->len); - - XDELETE (pfile->context); - pfile->context = saved_context; - pfile->cur_token = saved_cur_token; - pfile->cur_run = saved_cur_run; - pfile->cb.line_change = saved_line_change; - CPP_OPTION (pfile, defer_pragmas) = saved_defer_pragmas; -} - -/* Ignore #sccs on all systems. */ -static void -do_sccs (cpp_reader *pfile ATTRIBUTE_UNUSED) -{ -} - /* Handle #ifdef. */ static void do_ifdef (cpp_reader *pfile) @@ -1730,7 +1860,7 @@ parse_assertion (cpp_reader *pfile, struct answer **answerp, int type) else if (parse_answer (pfile, answerp, type) == 0) { unsigned int len = NODE_LEN (predicate->val.node); - unsigned char *sym = alloca (len + 1); + unsigned char *sym = (unsigned char *) alloca (len + 1); /* Prefix '#' to get it out of macro namespace. */ sym[0] = '#'; @@ -1825,7 +1955,8 @@ do_assert (cpp_reader *pfile) if (pfile->hash_table->alloc_subobject) { struct answer *temp_answer = new_answer; - new_answer = pfile->hash_table->alloc_subobject (answer_size); + new_answer = (struct answer *) pfile->hash_table->alloc_subobject + (answer_size); memcpy (new_answer, temp_answer, answer_size); } else @@ -1887,7 +2018,7 @@ cpp_define (cpp_reader *pfile, const char *str) tack " 1" on the end. */ count = strlen (str); - buf = alloca (count + 3); + buf = (char *) alloca (count + 3); memcpy (buf, str, count); p = strchr (str, '='); @@ -1908,7 +2039,7 @@ void _cpp_define_builtin (cpp_reader *pfile, const char *str) { size_t len = strlen (str); - char *buf = alloca (len + 1); + char *buf = (char *) alloca (len + 1); memcpy (buf, str, len); buf[len] = '\n'; run_directive (pfile, T_DEFINE, buf, len); @@ -1919,7 +2050,7 @@ void cpp_undef (cpp_reader *pfile, const char *macro) { size_t len = strlen (macro); - char *buf = alloca (len + 1); + char *buf = (char *) alloca (len + 1); memcpy (buf, macro, len); buf[len] = '\n'; run_directive (pfile, T_UNDEF, buf, len); @@ -1948,7 +2079,7 @@ handle_assertion (cpp_reader *pfile, const char *str, int type) /* 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 = alloca (count + 2); + char *buf = (char *) alloca (count + 2); memcpy (buf, str, count); if (p) @@ -2006,20 +2137,20 @@ cpp_buffer * cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len, int from_stage3) { - cpp_buffer *new = XOBNEW (&pfile->buffer_ob, cpp_buffer); + cpp_buffer *new_buffer = XOBNEW (&pfile->buffer_ob, cpp_buffer); /* Clears, amongst other things, if_stack and mi_cmacro. */ - memset (new, 0, sizeof (cpp_buffer)); + memset (new_buffer, 0, sizeof (cpp_buffer)); - new->next_line = new->buf = buffer; - new->rlimit = buffer + len; - new->from_stage3 = from_stage3; - new->prev = pfile->buffer; - new->need_line = true; + new_buffer->next_line = new_buffer->buf = buffer; + new_buffer->rlimit = buffer + len; + new_buffer->from_stage3 = from_stage3; + new_buffer->prev = pfile->buffer; + new_buffer->need_line = true; - pfile->buffer = new; + pfile->buffer = new_buffer; - return new; + return new_buffer; } /* Pops a single buffer, with a file change call-back if appropriate.