diff options
Diffstat (limited to 'contrib/gcc/cpplex.c')
| -rw-r--r-- | contrib/gcc/cpplex.c | 778 |
1 files changed, 422 insertions, 356 deletions
diff --git a/contrib/gcc/cpplex.c b/contrib/gcc/cpplex.c index eea6a9e..7db6b24 100644 --- a/contrib/gcc/cpplex.c +++ b/contrib/gcc/cpplex.c @@ -25,13 +25,6 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "cpplib.h" #include "cpphash.h" -/* MULTIBYTE_CHARS support only works for native compilers. - ??? Ideally what we want is to model widechar support after - the current floating point support. */ -#ifdef CROSS_COMPILE -#undef MULTIBYTE_CHARS -#endif - #ifdef MULTIBYTE_CHARS #include "mbchar.h" #include <locale.h> @@ -77,17 +70,18 @@ static int skip_line_comment PARAMS ((cpp_reader *)); static void adjust_column PARAMS ((cpp_reader *)); static int skip_whitespace PARAMS ((cpp_reader *, cppchar_t)); static cpp_hashnode *parse_identifier PARAMS ((cpp_reader *)); -static cpp_hashnode *parse_identifier_slow PARAMS ((cpp_reader *, - const U_CHAR *)); -static void parse_number PARAMS ((cpp_reader *, cpp_string *, cppchar_t, int)); -static int unescaped_terminator_p PARAMS ((cpp_reader *, const U_CHAR *)); +static uchar *parse_slow PARAMS ((cpp_reader *, const uchar *, int, + unsigned int *)); +static void parse_number PARAMS ((cpp_reader *, cpp_string *, int)); +static int unescaped_terminator_p PARAMS ((cpp_reader *, const uchar *)); static void parse_string PARAMS ((cpp_reader *, cpp_token *, cppchar_t)); -static void unterminated PARAMS ((cpp_reader *, int)); static bool trigraph_p PARAMS ((cpp_reader *)); -static void save_comment PARAMS ((cpp_reader *, cpp_token *, const U_CHAR *)); +static void save_comment PARAMS ((cpp_reader *, cpp_token *, const uchar *, + cppchar_t)); +static bool continue_after_nul PARAMS ((cpp_reader *)); static int name_p PARAMS ((cpp_reader *, const cpp_string *)); static int maybe_read_ucs PARAMS ((cpp_reader *, const unsigned char **, - const unsigned char *, unsigned int *)); + const unsigned char *, cppchar_t *)); static tokenrun *next_tokenrun PARAMS ((tokenrun *)); static unsigned int hex_digit_value PARAMS ((unsigned int)); @@ -105,7 +99,7 @@ cpp_ideq (token, string) if (token->type != CPP_NAME) return 0; - return !ustrcmp (NODE_NAME (token->val.node), (const U_CHAR *) string); + return !ustrcmp (NODE_NAME (token->val.node), (const uchar *) string); } /* Call when meeting a newline, assumed to be in buffer->cur[-1]. @@ -118,7 +112,7 @@ handle_newline (pfile) cpp_buffer *buffer = pfile->buffer; /* Handle CR-LF and LF-CR. Most other implementations (e.g. java) - only accept CR-LF; maybe we should fall back to that behaviour? */ + only accept CR-LF; maybe we should fall back to that behavior? */ if (buffer->cur[-1] + buffer->cur[0] == '\r' + '\n') buffer->cur++; @@ -132,7 +126,7 @@ handle_newline (pfile) the second '?'. Warn if necessary, and returns true if the sequence forms a - trigraph and the trigraph should be honoured. */ + trigraph and the trigraph should be honored. */ static bool trigraph_p (pfile) cpp_reader *pfile; @@ -150,16 +144,17 @@ trigraph_p (pfile) if (CPP_OPTION (pfile, warn_trigraphs) && !pfile->state.lexing_comment) { if (accept) - cpp_warning_with_line (pfile, pfile->line, CPP_BUF_COL (buffer) - 1, - "trigraph ??%c converted to %c", - (int) from_char, - (int) _cpp_trigraph_map[from_char]); + cpp_error_with_line (pfile, DL_WARNING, + pfile->line, CPP_BUF_COL (buffer) - 1, + "trigraph ??%c converted to %c", + (int) from_char, + (int) _cpp_trigraph_map[from_char]); else if (buffer->cur != buffer->last_Wtrigraphs) { buffer->last_Wtrigraphs = buffer->cur; - cpp_warning_with_line (pfile, pfile->line, - CPP_BUF_COL (buffer) - 1, - "trigraph ??%c ignored", (int) from_char); + cpp_error_with_line (pfile, DL_WARNING, + pfile->line, CPP_BUF_COL (buffer) - 1, + "trigraph ??%c ignored", (int) from_char); } } @@ -215,13 +210,15 @@ skip_escaped_newlines (pfile) if (saved_cur != buffer->cur - 1 && !pfile->state.lexing_comment) - cpp_warning (pfile, "backslash and newline separated by space"); + cpp_error (pfile, DL_WARNING, + "backslash and newline separated by space"); handle_newline (pfile); buffer->backup_to = buffer->cur; if (buffer->cur == buffer->rlimit) { - cpp_pedwarn (pfile, "backslash-newline at end of file"); + cpp_error (pfile, DL_PEDWARN, + "backslash-newline at end of file"); next = EOF; } else @@ -250,12 +247,12 @@ get_effective_char (pfile) if (__builtin_expect (next == '?' || next == '\\', 0)) next = skip_escaped_newlines (pfile); - return next; + return next; } /* Skip a C-style block comment. We find the end of the comment by seeing if an asterisk is before every '/' we encounter. Returns - non-zero if comment terminated by EOF, zero otherwise. */ + nonzero if comment terminated by EOF, zero otherwise. */ static int skip_block_comment (pfile) cpp_reader *pfile; @@ -285,9 +282,9 @@ skip_block_comment (pfile) Don't bother to get it right across escaped newlines. */ if (CPP_OPTION (pfile, warn_comments) && buffer->cur[0] == '*' && buffer->cur[1] != '/') - cpp_warning_with_line (pfile, - pfile->line, CPP_BUF_COL (buffer), - "\"/*\" within comment"); + cpp_error_with_line (pfile, DL_WARNING, + pfile->line, CPP_BUF_COL (buffer), + "\"/*\" within comment"); } else if (is_vspace (c)) handle_newline (pfile); @@ -300,7 +297,7 @@ skip_block_comment (pfile) } /* Skip a C++ line comment, leaving buffer->cur pointing to the - terminating newline. Handles escaped newlines. Returns non-zero + terminating newline. Handles escaped newlines. Returns nonzero if a multiline comment. */ static int skip_line_comment (pfile) @@ -309,14 +306,39 @@ skip_line_comment (pfile) cpp_buffer *buffer = pfile->buffer; unsigned int orig_line = pfile->line; cppchar_t c; +#ifdef MULTIBYTE_CHARS + wchar_t wc; + int char_len; +#endif pfile->state.lexing_comment = 1; +#ifdef MULTIBYTE_CHARS + /* Reset multibyte conversion state. */ + (void) local_mbtowc (NULL, NULL, 0); +#endif do { if (buffer->cur == buffer->rlimit) goto at_eof; +#ifdef MULTIBYTE_CHARS + char_len = local_mbtowc (&wc, (const char *) buffer->cur, + buffer->rlimit - buffer->cur); + if (char_len == -1) + { + cpp_error (pfile, DL_WARNING, + "ignoring invalid multibyte character"); + char_len = 1; + c = *buffer->cur++; + } + else + { + buffer->cur += char_len; + c = wc; + } +#else c = *buffer->cur++; +#endif if (c == '?' || c == '\\') c = skip_escaped_newlines (pfile); } @@ -370,15 +392,15 @@ skip_whitespace (pfile, c) return 0; if (!warned) { - cpp_warning (pfile, "null character(s) ignored"); + cpp_error (pfile, DL_WARNING, "null character(s) ignored"); warned = 1; } } else if (pfile->state.in_directive && CPP_PEDANTIC (pfile)) - cpp_pedwarn_with_line (pfile, pfile->line, - CPP_BUF_COL (buffer), - "%s in preprocessing directive", - c == '\f' ? "form feed" : "vertical tab"); + cpp_error_with_line (pfile, DL_PEDWARN, pfile->line, + CPP_BUF_COL (buffer), + "%s in preprocessing directive", + c == '\f' ? "form feed" : "vertical tab"); c = *buffer->cur++; } @@ -402,7 +424,7 @@ name_p (pfile, string) if (!is_idchar (string->text[i])) return 0; - return 1; + return 1; } /* Parse an identifier, skipping embedded backslash-newlines. This is @@ -412,13 +434,13 @@ name_p (pfile, string) seen:unseen identifiers in normal code; the distribution is Poisson-like). Second most common case is a new identifier, not split and no dollar sign. The other possibilities are rare and - have been relegated to parse_identifier_slow. */ + have been relegated to parse_slow. */ static cpp_hashnode * parse_identifier (pfile) cpp_reader *pfile; { cpp_hashnode *result; - const U_CHAR *cur; + const uchar *cur, *base; /* Fast-path loop. Skim over a normal identifier. N.B. ISIDNUM does not include $. */ @@ -428,13 +450,19 @@ parse_identifier (pfile) /* Check for slow-path cases. */ if (*cur == '?' || *cur == '\\' || *cur == '$') - result = parse_identifier_slow (pfile, cur); + { + unsigned int len; + + base = parse_slow (pfile, cur, 0, &len); + result = (cpp_hashnode *) + ht_lookup (pfile->hash_table, base, len, HT_ALLOCED); + } else { - const U_CHAR *base = pfile->buffer->cur - 1; + base = pfile->buffer->cur - 1; + pfile->buffer->cur = cur; result = (cpp_hashnode *) ht_lookup (pfile->hash_table, base, cur - base, HT_ALLOC); - pfile->buffer->cur = cur; } /* Rarely, identifiers require diagnostics when lexed. @@ -444,59 +472,78 @@ parse_identifier (pfile) { /* It is allowed to poison the same identifier twice. */ if ((result->flags & NODE_POISONED) && !pfile->state.poisoned_ok) - cpp_error (pfile, "attempt to use poisoned \"%s\"", + cpp_error (pfile, DL_ERROR, "attempt to use poisoned \"%s\"", NODE_NAME (result)); /* Constraint 6.10.3.5: __VA_ARGS__ should only appear in the replacement list of a variadic macro. */ if (result == pfile->spec_nodes.n__VA_ARGS__ && !pfile->state.va_args_ok) - cpp_pedwarn (pfile, + cpp_error (pfile, DL_PEDWARN, "__VA_ARGS__ can only appear in the expansion of a C99 variadic macro"); } return result; } -/* Slow path. This handles identifiers which have been split, and - identifiers which contain dollar signs. The part of the identifier - from PFILE->buffer->cur-1 to CUR has already been scanned. */ -static cpp_hashnode * -parse_identifier_slow (pfile, cur) +/* Slow path. This handles numbers and identifiers which have been + split, or contain dollar signs. The part of the token from + PFILE->buffer->cur-1 to CUR has already been scanned. NUMBER_P is + 1 if it's a number, and 2 if it has a leading period. Returns a + pointer to the token's NUL-terminated spelling in permanent + storage, and sets PLEN to its length. */ +static uchar * +parse_slow (pfile, cur, number_p, plen) cpp_reader *pfile; - const U_CHAR *cur; + const uchar *cur; + int number_p; + unsigned int *plen; { cpp_buffer *buffer = pfile->buffer; - const U_CHAR *base = buffer->cur - 1; + const uchar *base = buffer->cur - 1; struct obstack *stack = &pfile->hash_table->stack; - unsigned int c, saw_dollar = 0, len; + unsigned int c, prevc, saw_dollar = 0; + + /* Place any leading period. */ + if (number_p == 2) + obstack_1grow (stack, '.'); /* Copy the part of the token which is known to be okay. */ obstack_grow (stack, base, cur - base); /* Now process the part which isn't. We are looking at one of '$', '\\', or '?' on entry to this loop. */ + prevc = cur[-1]; c = *cur++; buffer->cur = cur; - do + for (;;) { - while (is_idchar (c)) - { - obstack_1grow (stack, c); + /* Potential escaped newline? */ + buffer->backup_to = buffer->cur - 1; + if (c == '?' || c == '\\') + c = skip_escaped_newlines (pfile); - if (c == '$') - saw_dollar++; + if (!is_idchar (c)) + { + if (!number_p) + break; + if (c != '.' && !VALID_SIGN (c, prevc)) + break; + } - c = *buffer->cur++; - } + /* Handle normal identifier characters in this loop. */ + do + { + prevc = c; + obstack_1grow (stack, c); - /* Potential escaped newline? */ - buffer->backup_to = buffer->cur - 1; - if (c != '?' && c != '\\') - break; - c = skip_escaped_newlines (pfile); + if (c == '$') + saw_dollar++; + + c = *buffer->cur++; + } + while (is_idchar (c)); } - while (is_idchar (c)); /* Step back over the unwanted char. */ BACKUP (); @@ -505,94 +552,48 @@ parse_identifier_slow (pfile, cur) accepted as an extension. Don't warn about it in skipped conditional blocks. */ if (saw_dollar && CPP_PEDANTIC (pfile) && ! pfile->state.skipping) - cpp_pedwarn (pfile, "'$' character(s) in identifier"); + cpp_error (pfile, DL_PEDWARN, "'$' character(s) in identifier or number"); - /* Identifiers are null-terminated. */ - len = obstack_object_size (stack); + /* Identifiers and numbers are null-terminated. */ + *plen = obstack_object_size (stack); obstack_1grow (stack, '\0'); - - return (cpp_hashnode *) - ht_lookup (pfile->hash_table, obstack_finish (stack), len, HT_ALLOCED); + return obstack_finish (stack); } /* Parse a number, beginning with character C, skipping embedded - backslash-newlines. LEADING_PERIOD is non-zero if there was a "." + backslash-newlines. LEADING_PERIOD is nonzero if there was a "." before C. Place the result in NUMBER. */ static void -parse_number (pfile, number, c, leading_period) +parse_number (pfile, number, leading_period) cpp_reader *pfile; cpp_string *number; - cppchar_t c; int leading_period; { - cpp_buffer *buffer = pfile->buffer; - unsigned char *dest, *limit; + const uchar *cur; - dest = BUFF_FRONT (pfile->u_buff); - limit = BUFF_LIMIT (pfile->u_buff); + /* Fast-path loop. Skim over a normal number. + N.B. ISIDNUM does not include $. */ + cur = pfile->buffer->cur; + while (ISIDNUM (*cur) || *cur == '.' || VALID_SIGN (*cur, cur[-1])) + cur++; - /* Place a leading period. */ - if (leading_period) - { - if (dest == limit) - { - _cpp_extend_buff (pfile, &pfile->u_buff, 1); - dest = BUFF_FRONT (pfile->u_buff); - limit = BUFF_LIMIT (pfile->u_buff); - } - *dest++ = '.'; - } - - do + /* Check for slow-path cases. */ + if (*cur == '?' || *cur == '\\' || *cur == '$') + number->text = parse_slow (pfile, cur, 1 + leading_period, &number->len); + else { - do - { - /* Need room for terminating null. */ - if ((size_t) (limit - dest) < 2) - { - size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff); - _cpp_extend_buff (pfile, &pfile->u_buff, 2); - dest = BUFF_FRONT (pfile->u_buff) + len_so_far; - limit = BUFF_LIMIT (pfile->u_buff); - } - *dest++ = c; - - c = *buffer->cur++; - } - while (is_numchar (c) || c == '.' || VALID_SIGN (c, dest[-1])); - - /* Potential escaped newline? */ - buffer->backup_to = buffer->cur - 1; - if (c != '?' && c != '\\') - break; - c = skip_escaped_newlines (pfile); - } - while (is_numchar (c) || c == '.' || VALID_SIGN (c, dest[-1])); - - /* Step back over the unwanted char. */ - BACKUP (); - - /* Null-terminate the number. */ - *dest = '\0'; + const uchar *base = pfile->buffer->cur - 1; + uchar *dest; - number->text = BUFF_FRONT (pfile->u_buff); - number->len = dest - number->text; - BUFF_FRONT (pfile->u_buff) = dest + 1; -} + number->len = cur - base + leading_period; + dest = _cpp_unaligned_alloc (pfile, number->len + 1); + dest[number->len] = '\0'; + number->text = dest; -/* Subroutine of parse_string. Emits error for unterminated strings. */ -static void -unterminated (pfile, term) - cpp_reader *pfile; - int term; -{ - cpp_error (pfile, "missing terminating %c character", term); - - if (term == '\"' && pfile->mls_line && pfile->mls_line != pfile->line) - { - cpp_error_with_line (pfile, pfile->mls_line, pfile->mls_col, - "possible start of unterminated string literal"); - pfile->mls_line = 0; + if (leading_period) + *dest++ = '.'; + memcpy (dest, base, cur - base); + pfile->buffer->cur = cur; } } @@ -622,7 +623,6 @@ unescaped_terminator_p (pfile, dest) name. Handles embedded trigraphs and escaped newlines. The stored string is guaranteed NUL-terminated, but it is not guaranteed that this is the first NUL since embedded NULs are preserved. - Multi-line strings are allowed, but they are deprecated. When this function returns, buffer->cur points to the next character to be processed. */ @@ -635,11 +635,19 @@ parse_string (pfile, token, terminator) cpp_buffer *buffer = pfile->buffer; unsigned char *dest, *limit; cppchar_t c; - bool warned_nulls = false, warned_multi = false; + bool warned_nulls = false; +#ifdef MULTIBYTE_CHARS + wchar_t wc; + int char_len; +#endif dest = BUFF_FRONT (pfile->u_buff); limit = BUFF_LIMIT (pfile->u_buff); +#ifdef MULTIBYTE_CHARS + /* Reset multibyte conversion state. */ + (void) local_mbtowc (NULL, NULL, 0); +#endif for (;;) { /* We need room for another char, possibly the terminating NUL. */ @@ -651,8 +659,26 @@ parse_string (pfile, token, terminator) limit = BUFF_LIMIT (pfile->u_buff); } - /* Handle trigraphs, escaped newlines etc. */ +#ifdef MULTIBYTE_CHARS + char_len = local_mbtowc (&wc, (const char *) buffer->cur, + buffer->rlimit - buffer->cur); + if (char_len == -1) + { + cpp_error (pfile, DL_WARNING, + "ignoring invalid multibyte character"); + char_len = 1; + c = *buffer->cur++; + } + else + { + buffer->cur += char_len; + c = wc; + } +#else c = *buffer->cur++; +#endif + + /* Handle trigraphs, escaped newlines etc. */ if (c == '?' || c == '\\') c = skip_escaped_newlines (pfile); @@ -663,57 +689,37 @@ parse_string (pfile, token, terminator) } else if (is_vspace (c)) { - /* In assembly language, silently terminate string and - character literals at end of line. This is a kludge - around not knowing where comments are. */ - if (CPP_OPTION (pfile, lang) == CLK_ASM && terminator != '>') - { - buffer->cur--; - break; - } - - /* Character constants and header names may not extend over - multiple lines. In Standard C, neither may strings. - Unfortunately, we accept multiline strings as an - extension, except in #include family directives. */ - if (terminator != '"' || pfile->state.angled_headers) - { - unterminated (pfile, terminator); - buffer->cur--; - break; - } - - if (!warned_multi) - { - warned_multi = true; - cpp_pedwarn (pfile, "multi-line string literals are deprecated"); - } - - if (pfile->mls_line == 0) - { - pfile->mls_line = token->line; - pfile->mls_col = token->col; - } - - handle_newline (pfile); - c = '\n'; + /* No string literal may extend over multiple lines. In + assembly language, suppress the error except for <> + includes. This is a kludge around not knowing where + comments are. */ + unterminated: + if (CPP_OPTION (pfile, lang) != CLK_ASM || terminator == '>') + cpp_error (pfile, DL_ERROR, "missing terminating %c character", + (int) terminator); + buffer->cur--; + break; } else if (c == '\0') { if (buffer->cur - 1 == buffer->rlimit) - { - unterminated (pfile, terminator); - buffer->cur--; - break; - } + goto unterminated; if (!warned_nulls) { warned_nulls = true; - cpp_warning (pfile, "null character(s) preserved in literal"); + cpp_error (pfile, DL_WARNING, + "null character(s) preserved in literal"); } } - - *dest++ = c; +#ifdef MULTIBYTE_CHARS + if (char_len > 1) + { + for ( ; char_len > 0; --char_len) + *dest++ = (*buffer->cur - char_len); + } + else +#endif + *dest++ = c; } *dest = '\0'; @@ -725,28 +731,46 @@ parse_string (pfile, token, terminator) /* The stored comment includes the comment start and any terminator. */ static void -save_comment (pfile, token, from) +save_comment (pfile, token, from, type) cpp_reader *pfile; cpp_token *token; const unsigned char *from; + cppchar_t type; { unsigned char *buffer; - unsigned int len; - + unsigned int len, clen; + len = pfile->buffer->cur - from + 1; /* + 1 for the initial '/'. */ /* C++ comments probably (not definitely) have moved past a new line, which we don't want to save in the comment. */ if (is_vspace (pfile->buffer->cur[-1])) len--; - buffer = _cpp_unaligned_alloc (pfile, len); - + + /* If we are currently in a directive, then we need to store all + C++ comments as C comments internally, and so we need to + allocate a little extra space in that case. + + Note that the only time we encounter a directive here is + when we are saving comments in a "#define". */ + clen = (pfile->state.in_directive && type == '/') ? len + 2 : len; + + buffer = _cpp_unaligned_alloc (pfile, clen); + token->type = CPP_COMMENT; - token->val.str.len = len; + token->val.str.len = clen; token->val.str.text = buffer; buffer[0] = '/'; memcpy (buffer + 1, from, len - 1); + + /* Finish conversion to a C comment, if necessary. */ + if (pfile->state.in_directive && type == '/') + { + buffer[1] = '*'; + buffer[clen - 2] = '*'; + buffer[clen - 1] = '/'; + } } /* Allocate COUNT tokens for RUN. */ @@ -828,7 +852,10 @@ _cpp_lex_token (pfile) /* Is this a directive. If _cpp_handle_directive returns false, it is an assembler #. */ if (result->type == CPP_HASH - && !pfile->state.parsing_args + /* 6.10.3 p 11: Directives in a list of macro arguments + gives undefined behavior. This implementation + handles the directive as normal. */ + && pfile->state.parsing_args != 1 && _cpp_handle_directive (pfile, result->flags & PREV_WHITE)) continue; if (pfile->cb.line_change && !pfile->state.skipping) @@ -851,6 +878,57 @@ _cpp_lex_token (pfile) return result; } +/* A NUL terminates the current buffer. For ISO preprocessing this is + EOF, but for traditional preprocessing it indicates we need a line + refill. Returns TRUE to continue preprocessing a new buffer, FALSE + to return a CPP_EOF to the caller. */ +static bool +continue_after_nul (pfile) + cpp_reader *pfile; +{ + cpp_buffer *buffer = pfile->buffer; + bool more = false; + + buffer->saved_flags = BOL; + if (CPP_OPTION (pfile, traditional)) + { + if (pfile->state.in_directive) + return false; + + _cpp_remove_overlay (pfile); + more = _cpp_read_logical_line_trad (pfile); + _cpp_overlay_buffer (pfile, pfile->out.base, + pfile->out.cur - pfile->out.base); + pfile->line = pfile->out.first_line; + } + else + { + /* Stop parsing arguments with a CPP_EOF. When we finally come + back here, do the work of popping the buffer. */ + if (!pfile->state.parsing_args) + { + if (buffer->cur != buffer->line_base) + { + /* Non-empty files should end in a newline. Don't warn + for command line and _Pragma buffers. */ + if (!buffer->from_stage3) + cpp_error (pfile, DL_PEDWARN, "no newline at end of file"); + handle_newline (pfile); + } + + /* Similarly, finish an in-progress directive with CPP_EOF + before popping the buffer. */ + if (!pfile->state.in_directive && buffer->prev) + { + more = !buffer->return_at_eof; + _cpp_pop_buffer (pfile); + } + } + } + + return more; +} + #define IF_NEXT_IS(CHAR, THEN_TYPE, ELSE_TYPE) \ do { \ if (get_effective_char (pfile) == CHAR) \ @@ -901,30 +979,10 @@ _cpp_lex_direct (pfile) if (skip_whitespace (pfile, c)) goto skipped_white; - /* EOF. */ + /* End of buffer. */ buffer->cur--; - buffer->saved_flags = BOL; - if (!pfile->state.parsing_args && !pfile->state.in_directive) - { - if (buffer->cur != buffer->line_base) - { - /* Non-empty files should end in a newline. Don't warn - for command line and _Pragma buffers. */ - if (!buffer->from_stage3) - cpp_pedwarn (pfile, "no newline at end of file"); - handle_newline (pfile); - } - - /* Don't pop the last buffer. */ - if (buffer->prev) - { - unsigned char stop = buffer->return_at_eof; - - _cpp_pop_buffer (pfile); - if (!stop) - goto fresh_line; - } - } + if (continue_after_nul (pfile)) + goto fresh_line; result->type = CPP_EOF; break; @@ -975,24 +1033,24 @@ _cpp_lex_direct (pfile) case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': result->type = CPP_NUMBER; - parse_number (pfile, &result->val.str, c, 0); + parse_number (pfile, &result->val.str, 0); break; case 'L': /* 'L' may introduce wide characters or strings. */ - { - const unsigned char *pos = buffer->cur; + { + const unsigned char *pos = buffer->cur; - c = get_effective_char (pfile); - if (c == '\'' || c == '"') - { - result->type = (c == '"' ? CPP_WSTRING: CPP_WCHAR); - parse_string (pfile, result, c); - break; - } - buffer->cur = pos; - } - /* Fall through. */ + c = get_effective_char (pfile); + if (c == '\'' || c == '"') + { + result->type = (c == '"' ? CPP_WSTRING: CPP_WCHAR); + parse_string (pfile, result, c); + break; + } + buffer->cur = pos; + } + /* Fall through. */ start_ident: case '_': @@ -1031,7 +1089,7 @@ _cpp_lex_direct (pfile) if (c == '*') { if (skip_block_comment (pfile)) - cpp_error (pfile, "unterminated comment"); + cpp_error (pfile, DL_ERROR, "unterminated comment"); } else if (c == '/' && (CPP_OPTION (pfile, cplusplus_comments) || CPP_IN_SYSTEM_HEADER (pfile))) @@ -1041,15 +1099,15 @@ _cpp_lex_direct (pfile) if (CPP_OPTION (pfile, lang) == CLK_GNUC89 && CPP_PEDANTIC (pfile) && ! buffer->warned_cplusplus_comments) { - cpp_pedwarn (pfile, - "C++ style comments are not allowed in ISO C89"); - cpp_pedwarn (pfile, - "(this will be reported only once per input file)"); + cpp_error (pfile, DL_PEDWARN, + "C++ style comments are not allowed in ISO C90"); + cpp_error (pfile, DL_PEDWARN, + "(this will be reported only once per input file)"); buffer->warned_cplusplus_comments = 1; } if (skip_line_comment (pfile) && CPP_OPTION (pfile, warn_comments)) - cpp_warning (pfile, "multi-line comment"); + cpp_error (pfile, DL_WARNING, "multi-line comment"); } else if (c == '=') { @@ -1070,7 +1128,7 @@ _cpp_lex_direct (pfile) } /* Save the comment as a token in its own right. */ - save_comment (pfile, result, comment_start); + save_comment (pfile, result, comment_start, c); break; case '<': @@ -1168,7 +1226,7 @@ _cpp_lex_direct (pfile) else if (ISDIGIT (c)) { result->type = CPP_NUMBER; - parse_number (pfile, &result->val.str, c, 1); + parse_number (pfile, &result->val.str, 1); } else if (c == '*' && CPP_OPTION (pfile, cplusplus)) result->type = CPP_DOT_STAR; @@ -1225,7 +1283,7 @@ _cpp_lex_direct (pfile) result->type = CPP_AND; } break; - + case '|': c = get_effective_char (pfile); if (c == '|') @@ -1271,7 +1329,7 @@ _cpp_lex_direct (pfile) case '}': result->type = CPP_CLOSE_BRACE; break; case ';': result->type = CPP_SEMICOLON; break; - /* @ is a punctuator in Objective C. */ + /* @ is a punctuator in Objective-C. */ case '@': result->type = CPP_ATSIGN; break; case '$': @@ -1332,7 +1390,7 @@ cpp_spell_token (pfile, token, buffer) goto spell_ident; else spelling = TOKEN_NAME (token); - + while ((c = *spelling++) != '\0') *buffer++ = c; } @@ -1364,7 +1422,8 @@ cpp_spell_token (pfile, token, buffer) case CPP_WCHAR: left = '\''; right = '\''; tag = 'L'; break; case CPP_HEADER_NAME: left = '<'; right = '>'; tag = '\0'; break; default: - cpp_ice (pfile, "unknown string token %s\n", TOKEN_NAME (token)); + cpp_error (pfile, DL_ICE, "unknown string token %s\n", + TOKEN_NAME (token)); return buffer; } if (tag) *buffer++ = tag; @@ -1376,7 +1435,7 @@ cpp_spell_token (pfile, token, buffer) break; case SPELL_NONE: - cpp_ice (pfile, "unspellable token %s", TOKEN_NAME (token)); + cpp_error (pfile, DL_ICE, "unspellable token %s", TOKEN_NAME (token)); break; } @@ -1621,7 +1680,7 @@ maybe_read_ucs (pfile, pstr, limit, pc) cpp_reader *pfile; const unsigned char **pstr; const unsigned char *limit; - unsigned int *pc; + cppchar_t *pc; { const unsigned char *p = *pstr; unsigned int code = 0; @@ -1632,13 +1691,14 @@ maybe_read_ucs (pfile, pstr, limit, pc) return 1; if (CPP_WTRADITIONAL (pfile)) - cpp_warning (pfile, "the meaning of '\\%c' varies with -traditional", c); + cpp_error (pfile, DL_WARNING, + "the meaning of '\\%c' is different in traditional C", c); length = (c == 'u' ? 4: 8); if ((size_t) (limit - p) < length) { - cpp_error (pfile, "incomplete universal-character-name"); + cpp_error (pfile, DL_ERROR, "incomplete universal-character-name"); /* Skip to the end to avoid more diagnostics. */ p = limit; } @@ -1651,7 +1711,7 @@ maybe_read_ucs (pfile, pstr, limit, pc) code = (code << 4) + hex_digit_value (c); else { - cpp_error (pfile, + cpp_error (pfile, DL_ERROR, "non-hex digit '%c' in universal-character-name", c); /* We shouldn't skip in case there are multibyte chars. */ break; @@ -1660,7 +1720,7 @@ maybe_read_ucs (pfile, pstr, limit, pc) } #ifdef TARGET_EBCDIC - cpp_error (pfile, "universal-character-name on EBCDIC target"); + cpp_error (pfile, DL_ERROR, "universal-character-name on EBCDIC target"); code = 0x3f; /* EBCDIC invalid character */ #else /* True extended characters are OK. */ @@ -1674,7 +1734,7 @@ maybe_read_ucs (pfile, pstr, limit, pc) ; /* Don't give another error if one occurred above. */ else if (length == 0) - cpp_error (pfile, "universal-character-name out of range"); + cpp_error (pfile, DL_ERROR, "universal-character-name out of range"); #endif *pstr = p; @@ -1682,25 +1742,33 @@ maybe_read_ucs (pfile, pstr, limit, pc) return 0; } -/* Interpret an escape sequence, and return its value. PSTR points to - the input pointer, which is just after the backslash. LIMIT is how - much text we have. MASK is a bitmask for the precision for the - destination type (char or wchar_t). TRADITIONAL, if true, does not - interpret escapes that did not exist in traditional C. - - Handles all relevant diagnostics. */ -unsigned int -cpp_parse_escape (pfile, pstr, limit, mask, traditional) +/* Returns the value of an escape sequence, truncated to the correct + target precision. PSTR points to the input pointer, which is just + after the backslash. LIMIT is how much text we have. WIDE is true + if the escape sequence is part of a wide character constant or + string literal. Handles all relevant diagnostics. */ +cppchar_t +cpp_parse_escape (pfile, pstr, limit, wide) cpp_reader *pfile; const unsigned char **pstr; const unsigned char *limit; - unsigned HOST_WIDE_INT mask; - int traditional; + int wide; { int unknown = 0; const unsigned char *str = *pstr; - unsigned int c = *str++; + cppchar_t c, mask; + unsigned int width; + + if (wide) + width = CPP_OPTION (pfile, wchar_precision); + else + width = CPP_OPTION (pfile, char_precision); + if (width < BITS_PER_CPPCHAR_T) + mask = ((cppchar_t) 1 << width) - 1; + else + mask = ~0; + c = *str++; switch (c) { case '\\': case '\'': case '"': case '?': break; @@ -1719,58 +1787,61 @@ cpp_parse_escape (pfile, pstr, limit, mask, traditional) case 'a': if (CPP_WTRADITIONAL (pfile)) - cpp_warning (pfile, "the meaning of '\\a' varies with -traditional"); - if (!traditional) - c = TARGET_BELL; + cpp_error (pfile, DL_WARNING, + "the meaning of '\\a' is different in traditional C"); + c = TARGET_BELL; break; case 'e': case 'E': if (CPP_PEDANTIC (pfile)) - cpp_pedwarn (pfile, "non-ISO-standard escape sequence, '\\%c'", c); + cpp_error (pfile, DL_PEDWARN, + "non-ISO-standard escape sequence, '\\%c'", (int) c); c = TARGET_ESC; break; - + case 'u': case 'U': unknown = maybe_read_ucs (pfile, &str, limit, &c); break; case 'x': if (CPP_WTRADITIONAL (pfile)) - cpp_warning (pfile, "the meaning of '\\x' varies with -traditional"); + cpp_error (pfile, DL_WARNING, + "the meaning of '\\x' is different in traditional C"); - if (!traditional) - { - unsigned int i = 0, overflow = 0; - int digits_found = 0; + { + cppchar_t i = 0, overflow = 0; + int digits_found = 0; - while (str < limit) - { - c = *str; - if (! ISXDIGIT (c)) - break; - str++; - overflow |= i ^ (i << 4 >> 4); - i = (i << 4) + hex_digit_value (c); - digits_found = 1; - } + while (str < limit) + { + c = *str; + if (! ISXDIGIT (c)) + break; + str++; + overflow |= i ^ (i << 4 >> 4); + i = (i << 4) + hex_digit_value (c); + digits_found = 1; + } - if (!digits_found) - cpp_error (pfile, "\\x used with no following hex digits"); + if (!digits_found) + cpp_error (pfile, DL_ERROR, + "\\x used with no following hex digits"); - if (overflow | (i != (i & mask))) - { - cpp_pedwarn (pfile, "hex escape sequence out of range"); - i &= mask; - } - c = i; - } + if (overflow | (i != (i & mask))) + { + cpp_error (pfile, DL_PEDWARN, + "hex escape sequence out of range"); + i &= mask; + } + c = i; + } break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': { - unsigned int i = c - '0'; - int count = 0; + size_t count = 0; + cppchar_t i = c - '0'; while (str < limit && ++count < 3) { @@ -1783,7 +1854,8 @@ cpp_parse_escape (pfile, pstr, limit, mask, traditional) if (i != (i & mask)) { - cpp_pedwarn (pfile, "octal escape sequence out of range"); + cpp_error (pfile, DL_PEDWARN, + "octal escape sequence out of range"); i &= mask; } c = i; @@ -1798,45 +1870,40 @@ cpp_parse_escape (pfile, pstr, limit, mask, traditional) if (unknown) { if (ISGRAPH (c)) - cpp_pedwarn (pfile, "unknown escape sequence '\\%c'", c); + cpp_error (pfile, DL_PEDWARN, + "unknown escape sequence '\\%c'", (int) c); else - cpp_pedwarn (pfile, "unknown escape sequence: '\\%03o'", c); + cpp_error (pfile, DL_PEDWARN, + "unknown escape sequence: '\\%03o'", (int) c); } if (c > mask) - cpp_pedwarn (pfile, "escape sequence out of range for character"); + { + cpp_error (pfile, DL_PEDWARN, "escape sequence out of range for its type"); + c &= mask; + } *pstr = str; return c; } -#ifndef MAX_CHAR_TYPE_SIZE -#define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE -#endif - -#ifndef MAX_WCHAR_TYPE_SIZE -#define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE -#endif - /* Interpret a (possibly wide) character constant in TOKEN. - WARN_MULTI warns about multi-character charconsts, if not - TRADITIONAL. TRADITIONAL also indicates not to interpret escapes - that did not exist in traditional C. PCHARS_SEEN points to a - variable that is filled in with the number of characters seen. */ -HOST_WIDE_INT -cpp_interpret_charconst (pfile, token, warn_multi, traditional, pchars_seen) + WARN_MULTI warns about multi-character charconsts. PCHARS_SEEN + points to a variable that is filled in with the number of + characters seen, and UNSIGNEDP to a variable that indicates whether + the result has signed type. */ +cppchar_t +cpp_interpret_charconst (pfile, token, pchars_seen, unsignedp) cpp_reader *pfile; const cpp_token *token; - int warn_multi; - int traditional; unsigned int *pchars_seen; + int *unsignedp; { const unsigned char *str = token->val.str.text; const unsigned char *limit = str + token->val.str.len; unsigned int chars_seen = 0; - unsigned int width, max_chars, c; - unsigned HOST_WIDE_INT mask; - HOST_WIDE_INT result = 0; + size_t width, max_chars; + cppchar_t c, mask, result = 0; bool unsigned_p; #ifdef MULTIBYTE_CHARS @@ -1846,20 +1913,21 @@ cpp_interpret_charconst (pfile, token, warn_multi, traditional, pchars_seen) /* Width in bits. */ if (token->type == CPP_CHAR) { - width = MAX_CHAR_TYPE_SIZE; - unsigned_p = CPP_OPTION (pfile, signed_char) == 0; + width = CPP_OPTION (pfile, char_precision); + max_chars = CPP_OPTION (pfile, int_precision) / width; + unsigned_p = CPP_OPTION (pfile, unsigned_char); } else { - width = MAX_WCHAR_TYPE_SIZE; - unsigned_p = WCHAR_UNSIGNED; + width = CPP_OPTION (pfile, wchar_precision); + max_chars = 1; + unsigned_p = CPP_OPTION (pfile, unsigned_wchar); } - if (width < HOST_BITS_PER_WIDE_INT) - mask = ((unsigned HOST_WIDE_INT) 1 << width) - 1; + if (width < BITS_PER_CPPCHAR_T) + mask = ((cppchar_t) 1 << width) - 1; else mask = ~0; - max_chars = HOST_BITS_PER_WIDE_INT / width; while (str < limit) { @@ -1870,7 +1938,8 @@ cpp_interpret_charconst (pfile, token, warn_multi, traditional, pchars_seen) char_len = local_mbtowc (&wc, str, limit - str); if (char_len == -1) { - cpp_warning (pfile, "ignoring invalid multibyte character"); + cpp_error (pfile, DL_WARNING, + "ignoring invalid multibyte character"); c = *str++; } else @@ -1883,46 +1952,56 @@ cpp_interpret_charconst (pfile, token, warn_multi, traditional, pchars_seen) #endif if (c == '\\') - c = cpp_parse_escape (pfile, &str, limit, mask, traditional); + c = cpp_parse_escape (pfile, &str, limit, token->type == CPP_WCHAR); #ifdef MAP_CHARACTER if (ISPRINT (c)) c = MAP_CHARACTER (c); #endif - - /* Merge character into result; ignore excess chars. */ - if (++chars_seen <= max_chars) - { - if (width < HOST_BITS_PER_WIDE_INT) - result = (result << width) | (c & mask); - else - result = c; - } + + chars_seen++; + + /* Truncate the character, scale the result and merge the two. */ + c &= mask; + if (width < BITS_PER_CPPCHAR_T) + result = (result << width) | c; + else + result = c; } if (chars_seen == 0) - cpp_error (pfile, "empty character constant"); - else if (chars_seen > max_chars) + cpp_error (pfile, DL_ERROR, "empty character constant"); + else if (chars_seen > 1) { - chars_seen = max_chars; - cpp_warning (pfile, "character constant too long"); + /* Multichar charconsts are of type int and therefore signed. */ + unsigned_p = 0; + + if (chars_seen > max_chars) + { + chars_seen = max_chars; + cpp_error (pfile, DL_WARNING, + "character constant too long for its type"); + } + else if (CPP_OPTION (pfile, warn_multichar)) + cpp_error (pfile, DL_WARNING, "multi-character character constant"); } - else if (chars_seen > 1 && !traditional && warn_multi) - cpp_warning (pfile, "multi-character character constant"); - /* If relevant type is signed, sign-extend the constant. */ - if (chars_seen) + /* Sign-extend or truncate the constant to cppchar_t. The value is + in WIDTH bits, but for multi-char charconsts it's value is the + full target type's width. */ + if (chars_seen > 1) + width *= max_chars; + if (width < BITS_PER_CPPCHAR_T) { - unsigned int nbits = chars_seen * width; - - mask = (unsigned HOST_WIDE_INT) ~0 >> (HOST_BITS_PER_WIDE_INT - nbits); - if (unsigned_p || ((result >> (nbits - 1)) & 1) == 0) + mask = ((cppchar_t) 1 << width) - 1; + if (unsigned_p || !(result & (1 << (width - 1)))) result &= mask; else result |= ~mask; } *pchars_seen = chars_seen; + *unsignedp = unsigned_p; return result; } @@ -1941,19 +2020,6 @@ cpp_interpret_charconst (pfile, token, warn_multi, traditional, pchars_seen) #error BUFF_SIZE_UPPER_BOUND must be at least as large as MIN_BUFF_SIZE! #endif -struct dummy -{ - char c; - union - { - double d; - int *p; - } u; -}; - -#define DEFAULT_ALIGNMENT (offsetof (struct dummy, u)) -#define CPP_ALIGN(size, align) (((size) + ((align) - 1)) & ~((align) - 1)) - /* Create a new allocation buffer. Place the control block at the end of the buffer, so that buffer overflows will cause immediate chaos. */ static _cpp_buff * @@ -1965,7 +2031,7 @@ new_buff (len) if (len < MIN_BUFF_SIZE) len = MIN_BUFF_SIZE; - len = CPP_ALIGN (len, DEFAULT_ALIGNMENT); + len = CPP_ALIGN (len); base = xmalloc (len + sizeof (_cpp_buff)); result = (_cpp_buff *) (base + len); |
