X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;ds=sidebyside;f=libcpp%2Fdirectives.c;h=77da485cda1dc65dafbe78d1fc2cc6b311d36516;hb=09c759aaf6da911aa1a44898d2b84121991bced9;hp=370f4ff5b0d3884706008bfd181173e18ede8e28;hpb=536a48ee34f51eb42e2130b46210d7976d343303;p=pf3gnuchains%2Fgcc-fork.git diff --git a/libcpp/directives.c b/libcpp/directives.c index 370f4ff5b0d..77da485cda1 100644 --- a/libcpp/directives.c +++ b/libcpp/directives.c @@ -1,14 +1,14 @@ /* CPP Library. (Directive handling.) Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, - 2007, 2008 Free Software Foundation, Inc. + 2007, 2008, 2009 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 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the -Free Software Foundation; either version 2, or (at your option) any +Free Software Foundation; either version 3, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,8 +17,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ +along with this program; see the file COPYING3. If not see +. */ #include "config.h" #include "system.h" @@ -32,7 +32,7 @@ Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ struct if_stack { struct if_stack *next; - unsigned int line; /* Line where condition started. */ + linenum_type 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. */ @@ -92,18 +92,19 @@ struct directive /* Forward declarations. */ static void skip_rest_of_line (cpp_reader *); -static void check_eol (cpp_reader *); +static void check_eol (cpp_reader *, bool); static void start_directive (cpp_reader *); static void prepare_directive_trad (cpp_reader *); 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 *, const cpp_token ***); +static const char *parse_include (cpp_reader *, int *, const cpp_token ***, + source_location *); 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 *); -static void do_diagnostic (cpp_reader *, int, int); +static bool strtolinenum (const uchar *, size_t, linenum_type *, bool *); +static void do_diagnostic (cpp_reader *, int, int, int); static cpp_hashnode *lex_macro_node (cpp_reader *, bool); static int undefine_macros (cpp_reader *, cpp_hashnode *, void *); static void do_include_common (cpp_reader *, enum include_type); @@ -121,10 +122,12 @@ static void do_linemarker (cpp_reader *); static const cpp_token *get_token_no_padding (cpp_reader *); static const cpp_token *get__Pragma_string (cpp_reader *); static void destringize_and_run (cpp_reader *, const cpp_string *); -static int parse_answer (cpp_reader *, struct answer **, int); +static int parse_answer (cpp_reader *, struct answer **, int, source_location); static cpp_hashnode *parse_assertion (cpp_reader *, struct answer **, int); static struct answer ** find_answer (cpp_hashnode *, const struct answer *); static void handle_assertion (cpp_reader *, const char *, int); +static void do_pragma_push_macro (cpp_reader *); +static void do_pragma_pop_macro (cpp_reader *); /* This is the table of directive handlers. It is ordered by frequency of occurrence; the numbers at the end are directive @@ -150,11 +153,11 @@ 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 | EXPAND) /* 19 */ \ -D(ident, T_IDENT, EXTENSION, IN_I | DEPRECATED) /* 11 */ \ +D(ident, T_IDENT, EXTENSION, IN_I) /* 11 */ \ D(import, T_IMPORT, EXTENSION, INCL | EXPAND) /* 0 ObjC */ \ D(assert, T_ASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \ D(unassert, T_UNASSERT, EXTENSION, DEPRECATED) /* 0 SVR4 */ \ -D(sccs, T_SCCS, EXTENSION, IN_I | DEPRECATED) /* 0 SVR4? */ +D(sccs, T_SCCS, EXTENSION, IN_I) /* 0 SVR4? */ /* #sccs is synonymous with #ident. */ #define do_sccs do_ident @@ -208,11 +211,14 @@ skip_rest_of_line (cpp_reader *pfile) ; } -/* Ensure there are no stray tokens at the end of a directive. */ +/* Ensure there are no stray tokens at the end of a directive. If + EXPAND is true, tokens macro-expanding to nothing are allowed. */ static void -check_eol (cpp_reader *pfile) +check_eol (cpp_reader *pfile, bool expand) { - if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF) + if (! SEEN_EOL () && (expand + ? cpp_get_token (pfile) + : _cpp_lex_token (pfile))->type != CPP_EOF) cpp_error (pfile, CPP_DL_PEDWARN, "extra tokens at end of #%s directive", pfile->directive->name); } @@ -349,8 +355,8 @@ directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented) else if (((dir->flags & DEPRECATED) != 0 || (dir == &dtable[T_IMPORT] && !CPP_OPTION (pfile, objc))) && CPP_OPTION (pfile, warn_deprecated)) - cpp_error (pfile, CPP_DL_WARNING, "#%s is a deprecated GCC extension", - dir->name); + cpp_warning (pfile, CPP_W_DEPRECATED, + "#%s is a deprecated GCC extension", dir->name); } /* Traditionally, a directive is ignored unless its # is in @@ -362,16 +368,16 @@ directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented) if (CPP_WTRADITIONAL (pfile)) { if (dir == &dtable[T_ELIF]) - cpp_error (pfile, CPP_DL_WARNING, - "suggest not using #elif in traditional C"); + cpp_warning (pfile, CPP_W_TRADITIONAL, + "suggest not using #elif in traditional C"); else if (indented && dir->origin == KANDR) - cpp_error (pfile, CPP_DL_WARNING, - "traditional C ignores #%s with the # indented", - dir->name); + cpp_warning (pfile, CPP_W_TRADITIONAL, + "traditional C ignores #%s with the # indented", + dir->name); else if (!indented && dir->origin != KANDR) - cpp_error (pfile, CPP_DL_WARNING, - "suggest hiding #%s from traditional C with an indented #", - dir->name); + cpp_warning (pfile, CPP_W_TRADITIONAL, + "suggest hiding #%s from traditional C with an indented #", + dir->name); } } @@ -405,8 +411,8 @@ _cpp_handle_directive (cpp_reader *pfile, int indented) if (dname->type == CPP_NAME) { - if (dname->val.node->is_directive) - dir = &dtable[dname->val.node->directive_index]; + if (dname->val.node.node->is_directive) + dir = &dtable[dname->val.node.node->directive_index]; } /* We do not recognize the # followed by a number extension in assembler code. */ @@ -535,7 +541,7 @@ lex_macro_node (cpp_reader *pfile, bool is_def_or_undef) if (token->type == CPP_NAME) { - cpp_hashnode *node = token->val.node; + cpp_hashnode *node = token->val.node.node; if (is_def_or_undef && node == pfile->spec_nodes.n_defined) cpp_error (pfile, CPP_DL_ERROR, @@ -546,7 +552,7 @@ lex_macro_node (cpp_reader *pfile, bool is_def_or_undef) else if (token->flags & NAMED_OP) cpp_error (pfile, CPP_DL_ERROR, "\"%s\" cannot be used as a macro name as it is an operator in C++", - NODE_NAME (token->val.node)); + NODE_NAME (token->val.node.node)); else if (token->type == CPP_EOF) cpp_error (pfile, CPP_DL_ERROR, "no macro name given in #%s directive", pfile->directive->name); @@ -609,7 +615,7 @@ do_undef (cpp_reader *pfile) } } - check_eol (pfile); + check_eol (pfile, false); } /* Undefine a single macro/assertion/whatever. */ @@ -680,17 +686,21 @@ glue_header_name (cpp_reader *pfile) /* Returns the file name of #include, #include_next, #import and #pragma dependency. The string is malloced and the caller should - free it. Returns NULL on error. */ + free it. Returns NULL on error. LOCATION is the source location + of the file name. */ + static const char * parse_include (cpp_reader *pfile, int *pangle_brackets, - const cpp_token ***buf) + const cpp_token ***buf, source_location *location) { char *fname; const cpp_token *header; /* Allow macro expansion. */ header = get_token_no_padding (pfile); - if (header->type == CPP_STRING || header->type == CPP_HEADER_NAME) + *location = header->src_loc; + if ((header->type == CPP_STRING && header->val.str.text[0] != 'R') + || header->type == CPP_HEADER_NAME) { fname = XNEWVEC (char, header->val.str.len - 1); memcpy (fname, header->val.str.text + 1, header->val.str.len - 2); @@ -721,7 +731,7 @@ parse_include (cpp_reader *pfile, int *pangle_brackets, /* This pragma allows extra tokens after the file name. */ } else if (buf == NULL || CPP_OPTION (pfile, discard_comments)) - check_eol (pfile); + check_eol (pfile, true); else { /* If we are not discarding comments, then gather them while @@ -739,12 +749,13 @@ do_include_common (cpp_reader *pfile, enum include_type type) const char *fname; int angle_brackets; const cpp_token **buf = NULL; + source_location location; /* 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); + fname = parse_include (pfile, &angle_brackets, &buf, &location); if (!fname) { if (buf) @@ -754,8 +765,9 @@ do_include_common (cpp_reader *pfile, enum include_type type) if (!*fname) { - cpp_error (pfile, CPP_DL_ERROR, "empty filename in #%s", - pfile->directive->name); + cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0, + "empty filename in #%s", + pfile->directive->name); XDELETEVEC (fname); if (buf) XDELETEVEC (buf); @@ -837,23 +849,30 @@ read_flag (cpp_reader *pfile, unsigned int last) } /* Subroutine of do_line and do_linemarker. 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 -strtoul_for_line (const uchar *str, unsigned int len, long unsigned int *nump) + of length LEN, to binary; store it in NUMP, and return false if the + number was well-formed, true if not. WRAPPED is set to true if the + number did not fit into 'unsigned long'. */ +static bool +strtolinenum (const uchar *str, size_t len, linenum_type *nump, bool *wrapped) { - unsigned long reg = 0; + linenum_type reg = 0; + linenum_type reg_prev = 0; + uchar c; + *wrapped = false; while (len--) { c = *str++; if (!ISDIGIT (c)) - return 1; + return true; reg *= 10; reg += c - '0'; + if (reg < reg_prev) + *wrapped = true; + reg_prev = reg; } *nump = reg; - return 0; + return false; } /* Interpret #line command. @@ -871,16 +890,17 @@ do_line (cpp_reader *pfile) unsigned char map_sysp = map->sysp; const cpp_token *token; const char *new_file = map->to_file; - unsigned long new_lineno; + linenum_type new_lineno; /* C99 raised the minimum limit on #line numbers. */ - unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767; + linenum_type cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767; + bool wrapped; /* #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)) + || strtolinenum (token->val.str.text, token->val.str.len, + &new_lineno, &wrapped)) { if (token->type == CPP_EOF) cpp_error (pfile, CPP_DL_ERROR, "unexpected end of file after #line"); @@ -891,17 +911,19 @@ do_line (cpp_reader *pfile) return; } - if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap)) + if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap || wrapped)) cpp_error (pfile, CPP_DL_PEDWARN, "line number out of range"); + else if (wrapped) + cpp_error (pfile, CPP_DL_WARNING, "line number out of range"); token = cpp_get_token (pfile); if (token->type == CPP_STRING) { cpp_string s = { 0, 0 }; if (cpp_interpret_string_notranslate (pfile, &token->val.str, 1, - &s, false)) + &s, CPP_STRING)) new_file = (const char *)s.text; - check_eol (pfile); + check_eol (pfile, true); } else if (token->type != CPP_EOF) { @@ -911,7 +933,7 @@ do_line (cpp_reader *pfile) } skip_rest_of_line (pfile); - _cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno, + _cpp_do_file_change (pfile, LC_RENAME_VERBATIM, new_file, new_lineno, map_sysp); } @@ -925,10 +947,11 @@ do_linemarker (cpp_reader *pfile) const struct line_map *map = &line_table->maps[line_table->used - 1]; const cpp_token *token; const char *new_file = map->to_file; - unsigned long new_lineno; + linenum_type new_lineno; unsigned int new_sysp = map->sysp; - enum lc_reason reason = LC_RENAME; + enum lc_reason reason = LC_RENAME_VERBATIM; int flag; + bool wrapped; /* Back up so we can get the number again. Putting this in _cpp_handle_directive risks two calls to _cpp_backup_tokens in @@ -938,8 +961,8 @@ do_linemarker (cpp_reader *pfile) /* #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)) + || strtolinenum (token->val.str.text, token->val.str.len, + &new_lineno, &wrapped)) { /* Unlike #line, there does not seem to be a way to get an EOF here. So, it should be safe to always spell the token. */ @@ -954,7 +977,7 @@ do_linemarker (cpp_reader *pfile) { cpp_string s = { 0, 0 }; if (cpp_interpret_string_notranslate (pfile, &token->val.str, - 1, &s, false)) + 1, &s, CPP_STRING)) new_file = (const char *)s.text; new_sysp = 0; @@ -980,7 +1003,7 @@ do_linemarker (cpp_reader *pfile) } pfile->buffer->sysp = new_sysp; - check_eol (pfile); + check_eol (pfile, false); } else if (token->type != CPP_EOF) { @@ -990,6 +1013,14 @@ do_linemarker (cpp_reader *pfile) } skip_rest_of_line (pfile); + + /* Compensate for the increment in linemap_add that occurs in + _cpp_do_file_change. We're currently at the start of the line + *following* the #line directive. A separate source_location for this + location makes no sense (until we do the LC_LEAVE), and + complicates LAST_SOURCE_LINE_LOCATION. */ + pfile->line_table->highest_location--; + _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp); } @@ -999,7 +1030,7 @@ do_linemarker (cpp_reader *pfile) and zero otherwise. */ void _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason, - const char *to_file, unsigned int file_line, + const char *to_file, linenum_type file_line, unsigned int sysp) { const struct line_map *map = linemap_add (pfile->line_table, reason, sysp, @@ -1014,7 +1045,7 @@ _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason, /* 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 (cpp_reader *pfile, int code, int print_dir) +do_diagnostic (cpp_reader *pfile, int code, int reason, int print_dir) { const unsigned char *dir_name; unsigned char *line; @@ -1028,21 +1059,26 @@ do_diagnostic (cpp_reader *pfile, int code, int print_dir) line = cpp_output_line_to_string (pfile, dir_name); pfile->state.prevent_expansion--; - cpp_error_with_line (pfile, code, src_loc, 0, "%s", line); + if (code == CPP_DL_WARNING_SYSHDR && reason) + cpp_warning_with_line_syshdr (pfile, reason, src_loc, 0, "%s", line); + else if (code == CPP_DL_WARNING && reason) + cpp_warning_with_line (pfile, reason, src_loc, 0, "%s", line); + else + cpp_error_with_line (pfile, code, src_loc, 0, "%s", line); free (line); } static void do_error (cpp_reader *pfile) { - do_diagnostic (pfile, CPP_DL_ERROR, 1); + do_diagnostic (pfile, CPP_DL_ERROR, 0, 1); } static void do_warning (cpp_reader *pfile) { /* We want #warning diagnostics to be emitted in system headers too. */ - do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, 1); + do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, CPP_W_WARNING_DIRECTIVE, 1); } /* Report program identification. */ @@ -1057,7 +1093,7 @@ do_ident (cpp_reader *pfile) else if (pfile->cb.ident) pfile->cb.ident (pfile, pfile->directive_line, &str->val.str); - check_eol (pfile); + check_eol (pfile, false); } /* Lookup a PRAGMA name in a singly-linked CHAIN. Returns the @@ -1215,6 +1251,8 @@ _cpp_init_internal_pragmas (cpp_reader *pfile) { /* Pragmas in the global namespace. */ register_pragma_internal (pfile, 0, "once", do_pragma_once); + register_pragma_internal (pfile, 0, "push_macro", do_pragma_push_macro); + register_pragma_internal (pfile, 0, "pop_macro", do_pragma_pop_macro); /* New GCC-specific pragmas should be put in the GCC namespace. */ register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison); @@ -1315,7 +1353,7 @@ do_pragma (cpp_reader *pfile) ns_token = *token; if (token->type == CPP_NAME) { - p = lookup_pragma_entry (pfile->pragmas, token->val.node); + p = lookup_pragma_entry (pfile->pragmas, token->val.node.node); if (p && p->is_nspace) { bool allow_name_expansion = p->allow_expansion; @@ -1323,7 +1361,7 @@ do_pragma (cpp_reader *pfile) pfile->state.prevent_expansion--; token = cpp_get_token (pfile); if (token->type == CPP_NAME) - p = lookup_pragma_entry (p->u.space, token->val.node); + p = lookup_pragma_entry (p->u.space, token->val.node.node); else p = NULL; if (allow_name_expansion) @@ -1390,10 +1428,100 @@ do_pragma_once (cpp_reader *pfile) if (cpp_in_primary_file (pfile)) cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file"); - check_eol (pfile); + check_eol (pfile, false); _cpp_mark_file_once_only (pfile, pfile->buffer->file); } +/* Handle #pragma push_macro(STRING). */ +static void +do_pragma_push_macro (cpp_reader *pfile) +{ + char *macroname, *dest; + const char *limit, *src; + const cpp_token *txt; + struct def_pragma_macro *c; + + txt = get__Pragma_string (pfile); + if (!txt) + { + source_location src_loc = pfile->cur_token[-1].src_loc; + cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0, + "invalid #pragma push_macro directive"); + check_eol (pfile, false); + skip_rest_of_line (pfile); + return; + } + dest = macroname = (char *) alloca (txt->val.str.len + 2); + src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L')); + limit = (const char *) (txt->val.str.text + txt->val.str.len - 1); + while (src < limit) + { + /* We know there is a character following the backslash. */ + if (*src == '\\' && (src[1] == '\\' || src[1] == '"')) + src++; + *dest++ = *src++; + } + *dest = 0; + check_eol (pfile, false); + skip_rest_of_line (pfile); + c = XNEW (struct def_pragma_macro); + c->name = XNEWVAR (char, strlen (macroname) + 1); + strcpy (c->name, macroname); + c->next = pfile->pushed_macros; + c->value = cpp_push_definition (pfile, c->name); + pfile->pushed_macros = c; +} + +/* Handle #pragma pop_macro(STRING). */ +static void +do_pragma_pop_macro (cpp_reader *pfile) +{ + char *macroname, *dest; + const char *limit, *src; + const cpp_token *txt; + struct def_pragma_macro *l = NULL, *c = pfile->pushed_macros; + txt = get__Pragma_string (pfile); + if (!txt) + { + source_location src_loc = pfile->cur_token[-1].src_loc; + cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0, + "invalid #pragma pop_macro directive"); + check_eol (pfile, false); + skip_rest_of_line (pfile); + return; + } + dest = macroname = (char *) alloca (txt->val.str.len + 2); + src = (const char *) (txt->val.str.text + 1 + (txt->val.str.text[0] == 'L')); + limit = (const char *) (txt->val.str.text + txt->val.str.len - 1); + while (src < limit) + { + /* We know there is a character following the backslash. */ + if (*src == '\\' && (src[1] == '\\' || src[1] == '"')) + src++; + *dest++ = *src++; + } + *dest = 0; + check_eol (pfile, false); + skip_rest_of_line (pfile); + + while (c != NULL) + { + if (!strcmp (c->name, macroname)) + { + if (!l) + pfile->pushed_macros = c->next; + else + l->next = c->next; + cpp_pop_definition (pfile, c->name, c->value); + free (c->name); + free (c); + break; + } + l = c; + c = c->next; + } +} + /* Handle #pragma GCC poison, to poison one or more identifiers so that the lexer produces a hard error for each subsequent usage. */ static void @@ -1415,7 +1543,7 @@ do_pragma_poison (cpp_reader *pfile) break; } - hp = tok->val.node; + hp = tok->val.node.node; if (hp->flags & NODE_POISONED) continue; @@ -1442,7 +1570,7 @@ do_pragma_system_header (cpp_reader *pfile) "#pragma system_header ignored outside include file"); else { - check_eol (pfile); + check_eol (pfile, false); skip_rest_of_line (pfile); cpp_make_system_header (pfile, 1, 0); } @@ -1456,8 +1584,9 @@ do_pragma_dependency (cpp_reader *pfile) { const char *fname; int angle_brackets, ordering; + source_location location; - fname = parse_include (pfile, &angle_brackets, NULL); + fname = parse_include (pfile, &angle_brackets, NULL, &location); if (!fname) return; @@ -1471,7 +1600,7 @@ do_pragma_dependency (cpp_reader *pfile) if (cpp_get_token (pfile)->type != CPP_EOF) { _cpp_backup_tokens (pfile, 1); - do_diagnostic (pfile, CPP_DL_WARNING, 0); + do_diagnostic (pfile, CPP_DL_WARNING, 0, 0); } } @@ -1508,7 +1637,8 @@ get__Pragma_string (cpp_reader *pfile) if (string->type == CPP_EOF) _cpp_backup_tokens (pfile, 1); if (string->type != CPP_STRING && string->type != CPP_WSTRING - && string->type != CPP_STRING32 && string->type != CPP_STRING16) + && string->type != CPP_STRING32 && string->type != CPP_STRING16 + && string->type != CPP_UTF8STRING) return NULL; paren = get_token_no_padding (pfile); @@ -1683,7 +1813,9 @@ do_ifdef (cpp_reader *pfile) pfile->cb.used_undef (pfile, pfile->directive_line, node); } } - check_eol (pfile); + if (pfile->cb.used) + pfile->cb.used (pfile, pfile->directive_line, node); + check_eol (pfile, false); } } @@ -1719,7 +1851,9 @@ do_ifndef (cpp_reader *pfile) pfile->cb.used_undef (pfile, pfile->directive_line, node); } } - check_eol (pfile); + if (pfile->cb.used) + pfile->cb.used (pfile, pfile->directive_line, node); + check_eol (pfile, false); } } @@ -1772,7 +1906,7 @@ do_else (cpp_reader *pfile) /* Only check EOL if was not originally skipping. */ if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels)) - check_eol (pfile); + check_eol (pfile, false); } } @@ -1833,7 +1967,7 @@ do_endif (cpp_reader *pfile) { /* Only check EOL if was not originally skipping. */ if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels)) - check_eol (pfile); + check_eol (pfile, false); /* If potential control macro, we go back outside again. */ if (ifs->next == 0 && ifs->mi_cmacro) @@ -1878,9 +2012,11 @@ push_conditional (cpp_reader *pfile, int skip, int type, /* 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. */ + ANSWERP to point to the answer. PRED_LOC is the location of the + predicate. */ static int -parse_answer (cpp_reader *pfile, struct answer **answerp, int type) +parse_answer (cpp_reader *pfile, struct answer **answerp, int type, + source_location pred_loc) { const cpp_token *paren; struct answer *answer; @@ -1905,7 +2041,8 @@ parse_answer (cpp_reader *pfile, struct answer **answerp, int type) if (type == T_UNASSERT && paren->type == CPP_EOF) return 0; - cpp_error (pfile, CPP_DL_ERROR, "missing '(' after predicate"); + cpp_error_with_line (pfile, CPP_DL_ERROR, pred_loc, 0, + "missing '(' after predicate"); return 1; } @@ -1969,15 +2106,16 @@ parse_assertion (cpp_reader *pfile, struct answer **answerp, int type) if (predicate->type == CPP_EOF) cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate"); else if (predicate->type != CPP_NAME) - cpp_error (pfile, CPP_DL_ERROR, "predicate must be an identifier"); - else if (parse_answer (pfile, answerp, type) == 0) + cpp_error_with_line (pfile, CPP_DL_ERROR, predicate->src_loc, 0, + "predicate must be an identifier"); + else if (parse_answer (pfile, answerp, type, predicate->src_loc) == 0) { - unsigned int len = NODE_LEN (predicate->val.node); + unsigned int len = NODE_LEN (predicate->val.node.node); unsigned char *sym = (unsigned char *) alloca (len + 1); /* Prefix '#' to get it out of macro namespace. */ sym[0] = '#'; - memcpy (sym + 1, NODE_NAME (predicate->val.node), len); + memcpy (sym + 1, NODE_NAME (predicate->val.node.node), len); result = cpp_lookup (pfile, sym, len + 1); } @@ -2077,7 +2215,7 @@ do_assert (cpp_reader *pfile) node->type = NT_ASSERTION; node->value.answers = new_answer; - check_eol (pfile); + check_eol (pfile, false); } } @@ -2105,7 +2243,7 @@ do_unassert (cpp_reader *pfile) if (node->value.answers == 0) node->type = NT_VOID; - check_eol (pfile); + check_eol (pfile, false); } else _cpp_free_definition (node); @@ -2123,7 +2261,8 @@ do_unassert (cpp_reader *pfile) void cpp_define (cpp_reader *pfile, const char *str) { - char *buf, *p; + char *buf; + const char *p; size_t count; /* Copy the entire option so we can modify it. @@ -2189,28 +2328,11 @@ cpp_undef (cpp_reader *pfile, const char *macro) run_directive (pfile, T_UNDEF, buf, len); } -/* Like lex_macro_node, but read the input from STR. */ -static cpp_hashnode * -lex_macro_node_from_str (cpp_reader *pfile, const char *str) -{ - size_t len = strlen (str); - uchar *buf = (uchar *) alloca (len + 1); - cpp_hashnode *node; - - memcpy (buf, str, len); - buf[len] = '\n'; - cpp_push_buffer (pfile, buf, len, true); - node = lex_macro_node (pfile, true); - _cpp_pop_buffer (pfile); - - return node; -} - /* If STR is a defined macro, return its definition node, else return NULL. */ cpp_macro * cpp_push_definition (cpp_reader *pfile, const char *str) { - cpp_hashnode *node = lex_macro_node_from_str (pfile, str); + cpp_hashnode *node = _cpp_lex_identifier (pfile, str); if (node && node->type == NT_MACRO) return node->value.macro; else @@ -2222,7 +2344,7 @@ cpp_push_definition (cpp_reader *pfile, const char *str) void cpp_pop_definition (cpp_reader *pfile, const char *str, cpp_macro *dfn) { - cpp_hashnode *node = lex_macro_node_from_str (pfile, str); + cpp_hashnode *node = _cpp_lex_identifier (pfile, str); if (node == NULL) return; @@ -2288,13 +2410,6 @@ handle_assertion (cpp_reader *pfile, const char *str, int type) run_directive (pfile, type, str, count); } -/* The number of errors for a given reader. */ -unsigned int -cpp_errors (cpp_reader *pfile) -{ - return pfile->errors; -} - /* The options structure. */ cpp_options * cpp_get_options (cpp_reader *pfile)