Bug Summary

File:build/libcpp/lex.c
Warning:line 1889, column 8
4th function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name lex.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/libcpp -resource-dir /usr/lib64/clang/13.0.0 -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/backward -internal-isystem /usr/lib64/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -fdeprecated-macro -fdebug-compilation-dir=/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/libcpp -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-11-20-133755-20252-1/report-jX6ZfM.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c

1/* CPP Library - lexical analysis.
2 Copyright (C) 2000-2021 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994-95.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
6 Broken out to separate file, Zack Weinberg, Mar 2000
7
8This program is free software; you can redistribute it and/or modify it
9under the terms of the GNU General Public License as published by the
10Free Software Foundation; either version 3, or (at your option) any
11later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22#include "config.h"
23#include "system.h"
24#include "cpplib.h"
25#include "internal.h"
26
27enum spell_type
28{
29 SPELL_OPERATOR = 0,
30 SPELL_IDENT,
31 SPELL_LITERAL,
32 SPELL_NONE
33};
34
35struct token_spelling
36{
37 enum spell_type category;
38 const unsigned char *name;
39};
40
41static const unsigned char *const digraph_spellings[] =
42{ UC(const uchar *)"%:", UC(const uchar *)"%:%:", UC(const uchar *)"<:", UC(const uchar *)":>", UC(const uchar *)"<%", UC(const uchar *)"%>" };
43
44#define OP(e, s) { SPELL_OPERATOR, UC(const uchar *) s },
45#define TK(e, s) { SPELL_ ## s, UC(const uchar *) #e },
46static const struct token_spelling token_spellings[N_TTYPES] = { TTYPE_TABLEOP(EQ, "=") OP(NOT, "!") OP(GREATER, ">") OP(LESS, "<")
OP(PLUS, "+") OP(MINUS, "-") OP(MULT, "*") OP(DIV, "/") OP(MOD
, "%") OP(AND, "&") OP(OR, "|") OP(XOR, "^") OP(RSHIFT, ">>"
) OP(LSHIFT, "<<") OP(COMPL, "~") OP(AND_AND, "&&"
) OP(OR_OR, "||") OP(QUERY, "?") OP(COLON, ":") OP(COMMA, ","
) OP(OPEN_PAREN, "(") OP(CLOSE_PAREN, ")") TK((-1), NONE) OP(
EQ_EQ, "==") OP(NOT_EQ, "!=") OP(GREATER_EQ, ">=") OP(LESS_EQ
, "<=") OP(SPACESHIP, "<=>") OP(PLUS_EQ, "+=") OP(MINUS_EQ
, "-=") OP(MULT_EQ, "*=") OP(DIV_EQ, "/=") OP(MOD_EQ, "%=") OP
(AND_EQ, "&=") OP(OR_EQ, "|=") OP(XOR_EQ, "^=") OP(RSHIFT_EQ
, ">>=") OP(LSHIFT_EQ, "<<=") OP(HASH, "#") OP(PASTE
, "##") OP(OPEN_SQUARE, "[") OP(CLOSE_SQUARE, "]") OP(OPEN_BRACE
, "{") OP(CLOSE_BRACE, "}") OP(SEMICOLON, ";") OP(ELLIPSIS, "..."
) OP(PLUS_PLUS, "++") OP(MINUS_MINUS, "--") OP(DEREF, "->"
) OP(DOT, ".") OP(SCOPE, "::") OP(DEREF_STAR, "->*") OP(DOT_STAR
, ".*") OP(ATSIGN, "@") TK(NAME, IDENT) TK(AT_NAME, IDENT) TK
(NUMBER, LITERAL) TK(CHAR, LITERAL) TK(WCHAR, LITERAL) TK(CHAR16
, LITERAL) TK(CHAR32, LITERAL) TK(UTF8CHAR, LITERAL) TK(OTHER
, LITERAL) TK(STRING, LITERAL) TK(WSTRING, LITERAL) TK(STRING16
, LITERAL) TK(STRING32, LITERAL) TK(UTF8STRING, LITERAL) TK(OBJC_STRING
, LITERAL) TK(HEADER_NAME, LITERAL) TK(CHAR_USERDEF, LITERAL)
TK(WCHAR_USERDEF, LITERAL) TK(CHAR16_USERDEF, LITERAL) TK(CHAR32_USERDEF
, LITERAL) TK(UTF8CHAR_USERDEF, LITERAL) TK(STRING_USERDEF, LITERAL
) TK(WSTRING_USERDEF, LITERAL) TK(STRING16_USERDEF, LITERAL) TK
(STRING32_USERDEF, LITERAL) TK(UTF8STRING_USERDEF,LITERAL) TK
(COMMENT, LITERAL) TK(MACRO_ARG, NONE) TK(PRAGMA, NONE) TK(PRAGMA_EOL
, NONE) TK(PADDING, NONE)
};
47#undef OP
48#undef TK
49
50#define TOKEN_SPELL(token)(token_spellings[(token)->type].category) (token_spellings[(token)->type].category)
51#define TOKEN_NAME(token)(token_spellings[(token)->type].name) (token_spellings[(token)->type].name)
52
53static void add_line_note (cpp_buffer *, const uchar *, unsigned int);
54static int skip_line_comment (cpp_reader *);
55static void skip_whitespace (cpp_reader *, cppchar_t);
56static void lex_string (cpp_reader *, cpp_token *, const uchar *);
57static void save_comment (cpp_reader *, cpp_token *, const uchar *, cppchar_t);
58static void store_comment (cpp_reader *, cpp_token *);
59static void create_literal (cpp_reader *, cpp_token *, const uchar *,
60 unsigned int, enum cpp_ttype);
61static bool warn_in_comment (cpp_reader *, _cpp_line_note *);
62static int name_p (cpp_reader *, const cpp_string *);
63static tokenrun *next_tokenrun (tokenrun *);
64
65static _cpp_buff *new_buff (size_t);
66
67
68/* Utility routine:
69
70 Compares, the token TOKEN to the NUL-terminated string STRING.
71 TOKEN must be a CPP_NAME. Returns 1 for equal, 0 for unequal. */
72int
73cpp_ideq (const cpp_token *token, const char *string)
74{
75 if (token->type != CPP_NAME)
76 return 0;
77
78 return !ustrcmp (NODE_NAME (token->val.node.node)(((&(token->val.node.node)->ident))->str), (const uchar *) string);
79}
80
81/* Record a note TYPE at byte POS into the current cleaned logical
82 line. */
83static void
84add_line_note (cpp_buffer *buffer, const uchar *pos, unsigned int type)
85{
86 if (buffer->notes_used == buffer->notes_cap)
87 {
88 buffer->notes_cap = buffer->notes_cap * 2 + 200;
89 buffer->notes = XRESIZEVEC (_cpp_line_note, buffer->notes,((_cpp_line_note *) xrealloc ((void *) (buffer->notes), sizeof
(_cpp_line_note) * (buffer->notes_cap)))
90 buffer->notes_cap)((_cpp_line_note *) xrealloc ((void *) (buffer->notes), sizeof
(_cpp_line_note) * (buffer->notes_cap)))
;
91 }
92
93 buffer->notes[buffer->notes_used].pos = pos;
94 buffer->notes[buffer->notes_used].type = type;
95 buffer->notes_used++;
96}
97
98
99/* Fast path to find line special characters using optimized character
100 scanning algorithms. Anything complicated falls back to the slow
101 path below. Since this loop is very hot it's worth doing these kinds
102 of optimizations.
103
104 One of the paths through the ifdefs should provide
105
106 const uchar *search_line_fast (const uchar *s, const uchar *end);
107
108 Between S and END, search for \n, \r, \\, ?. Return a pointer to
109 the found character.
110
111 Note that the last character of the buffer is *always* a newline,
112 as forced by _cpp_convert_input. This fact can be used to avoid
113 explicitly looking for the end of the buffer. */
114
115/* Configure gives us an ifdef test. */
116#ifndef WORDS_BIGENDIAN0
117#define WORDS_BIGENDIAN0 0
118#endif
119
120/* We'd like the largest integer that fits into a register. There's nothing
121 in <stdint.h> that gives us that. For most hosts this is unsigned long,
122 but MS decided on an LLP64 model. Thankfully when building with GCC we
123 can get the "real" word size. */
124#ifdef __GNUC__4
125typedef unsigned int word_type __attribute__((__mode__(__word__)));
126#else
127typedef unsigned long word_type;
128#endif
129
130/* The code below is only expecting sizes 4 or 8.
131 Die at compile-time if this expectation is violated. */
132typedef char check_word_type_size
133 [(sizeof(word_type) == 8 || sizeof(word_type) == 4) * 2 - 1];
134
135/* Return X with the first N bytes forced to values that won't match one
136 of the interesting characters. Note that NUL is not interesting. */
137
138static inline word_type
139acc_char_mask_misalign (word_type val, unsigned int n)
140{
141 word_type mask = -1;
142 if (WORDS_BIGENDIAN0)
143 mask >>= n * 8;
144 else
145 mask <<= n * 8;
146 return val & mask;
147}
148
149/* Return X replicated to all byte positions within WORD_TYPE. */
150
151static inline word_type
152acc_char_replicate (uchar x)
153{
154 word_type ret;
155
156 ret = (x << 24) | (x << 16) | (x << 8) | x;
157 if (sizeof(word_type) == 8)
158 ret = (ret << 16 << 16) | ret;
159 return ret;
160}
161
162/* Return non-zero if some byte of VAL is (probably) C. */
163
164static inline word_type
165acc_char_cmp (word_type val, word_type c)
166{
167#if defined(__GNUC__4) && defined(__alpha__)
168 /* We can get exact results using a compare-bytes instruction.
169 Get (val == c) via (0 >= (val ^ c)). */
170 return __builtin_alpha_cmpbge (0, val ^ c);
171#else
172 word_type magic = 0x7efefefeU;
173 if (sizeof(word_type) == 8)
174 magic = (magic << 16 << 16) | 0xfefefefeU;
175 magic |= 1;
176
177 val ^= c;
178 return ((val + magic) ^ ~val) & ~magic;
179#endif
180}
181
182/* Given the result of acc_char_cmp is non-zero, return the index of
183 the found character. If this was a false positive, return -1. */
184
185static inline int
186acc_char_index (word_type cmp ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
187 word_type val ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
188{
189#if defined(__GNUC__4) && defined(__alpha__) && !WORDS_BIGENDIAN0
190 /* The cmpbge instruction sets *bits* of the result corresponding to
191 matches in the bytes with no false positives. */
192 return __builtin_ctzl (cmp);
193#else
194 unsigned int i;
195
196 /* ??? It would be nice to force unrolling here,
197 and have all of these constants folded. */
198 for (i = 0; i < sizeof(word_type); ++i)
199 {
200 uchar c;
201 if (WORDS_BIGENDIAN0)
202 c = (val >> (sizeof(word_type) - i - 1) * 8) & 0xff;
203 else
204 c = (val >> i * 8) & 0xff;
205
206 if (c == '\n' || c == '\r' || c == '\\' || c == '?')
207 return i;
208 }
209
210 return -1;
211#endif
212}
213
214/* A version of the fast scanner using bit fiddling techniques.
215
216 For 32-bit words, one would normally perform 16 comparisons and
217 16 branches. With this algorithm one performs 24 arithmetic
218 operations and one branch. Whether this is faster with a 32-bit
219 word size is going to be somewhat system dependent.
220
221 For 64-bit words, we eliminate twice the number of comparisons
222 and branches without increasing the number of arithmetic operations.
223 It's almost certainly going to be a win with 64-bit word size. */
224
225static const uchar * search_line_acc_char (const uchar *, const uchar *)
226 ATTRIBUTE_UNUSED__attribute__ ((__unused__));
227
228static const uchar *
229search_line_acc_char (const uchar *s, const uchar *end ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
230{
231 const word_type repl_nl = acc_char_replicate ('\n');
232 const word_type repl_cr = acc_char_replicate ('\r');
233 const word_type repl_bs = acc_char_replicate ('\\');
234 const word_type repl_qm = acc_char_replicate ('?');
235
236 unsigned int misalign;
237 const word_type *p;
238 word_type val, t;
239
240 /* Align the buffer. Mask out any bytes from before the beginning. */
241 p = (word_type *)((uintptr_t)s & -sizeof(word_type));
242 val = *p;
243 misalign = (uintptr_t)s & (sizeof(word_type) - 1);
244 if (misalign)
245 val = acc_char_mask_misalign (val, misalign);
246
247 /* Main loop. */
248 while (1)
249 {
250 t = acc_char_cmp (val, repl_nl);
251 t |= acc_char_cmp (val, repl_cr);
252 t |= acc_char_cmp (val, repl_bs);
253 t |= acc_char_cmp (val, repl_qm);
254
255 if (__builtin_expect (t != 0, 0))
256 {
257 int i = acc_char_index (t, val);
258 if (i >= 0)
259 return (const uchar *)p + i;
260 }
261
262 val = *++p;
263 }
264}
265
266/* Disable on Solaris 2/x86 until the following problem can be properly
267 autoconfed:
268
269 The Solaris 10+ assembler tags objects with the instruction set
270 extensions used, so SSE4.2 executables cannot run on machines that
271 don't support that extension. */
272
273#if (GCC_VERSION(4 * 1000 + 2) >= 4005) && (__GNUC__4 >= 5 || !defined(__PIC__)) && (defined(__i386__) || defined(__x86_64__1)) && !(defined(__sun__) && defined(__svr4__))
274
275/* Replicated character data to be shared between implementations.
276 Recall that outside of a context with vector support we can't
277 define compatible vector types, therefore these are all defined
278 in terms of raw characters. */
279static const char repl_chars[4][16] __attribute__((aligned(16))) = {
280 { '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n',
281 '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n' },
282 { '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r',
283 '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r' },
284 { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\',
285 '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' },
286 { '?', '?', '?', '?', '?', '?', '?', '?',
287 '?', '?', '?', '?', '?', '?', '?', '?' },
288};
289
290/* A version of the fast scanner using MMX vectorized byte compare insns.
291
292 This uses the PMOVMSKB instruction which was introduced with "MMX2",
293 which was packaged into SSE1; it is also present in the AMD MMX
294 extension. Mark the function as using "sse" so that we emit a real
295 "emms" instruction, rather than the 3dNOW "femms" instruction. */
296
297static const uchar *
298#ifndef __SSE__1
299__attribute__((__target__("sse")))
300#endif
301search_line_mmx (const uchar *s, const uchar *end ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
302{
303 typedef char v8qi __attribute__ ((__vector_size__ (8)));
304 typedef int __m64 __attribute__ ((__vector_size__ (8), __may_alias__));
305
306 const v8qi repl_nl = *(const v8qi *)repl_chars[0];
307 const v8qi repl_cr = *(const v8qi *)repl_chars[1];
308 const v8qi repl_bs = *(const v8qi *)repl_chars[2];
309 const v8qi repl_qm = *(const v8qi *)repl_chars[3];
310
311 unsigned int misalign, found, mask;
312 const v8qi *p;
313 v8qi data, t, c;
314
315 /* Align the source pointer. While MMX doesn't generate unaligned data
316 faults, this allows us to safely scan to the end of the buffer without
317 reading beyond the end of the last page. */
318 misalign = (uintptr_t)s & 7;
319 p = (const v8qi *)((uintptr_t)s & -8);
320 data = *p;
321
322 /* Create a mask for the bytes that are valid within the first
323 16-byte block. The Idea here is that the AND with the mask
324 within the loop is "free", since we need some AND or TEST
325 insn in order to set the flags for the branch anyway. */
326 mask = -1u << misalign;
327
328 /* Main loop processing 8 bytes at a time. */
329 goto start;
330 do
331 {
332 data = *++p;
333 mask = -1;
334
335 start:
336 t = __builtin_ia32_pcmpeqb(data, repl_nl);
337 c = __builtin_ia32_pcmpeqb(data, repl_cr);
338 t = (v8qi) __builtin_ia32_por ((__m64)t, (__m64)c);
339 c = __builtin_ia32_pcmpeqb(data, repl_bs);
340 t = (v8qi) __builtin_ia32_por ((__m64)t, (__m64)c);
341 c = __builtin_ia32_pcmpeqb(data, repl_qm);
342 t = (v8qi) __builtin_ia32_por ((__m64)t, (__m64)c);
343 found = __builtin_ia32_pmovmskb (t);
344 found &= mask;
345 }
346 while (!found);
347
348 __builtin_ia32_emms ();
349
350 /* FOUND contains 1 in bits for which we matched a relevant
351 character. Conversion to the byte index is trivial. */
352 found = __builtin_ctz(found);
353 return (const uchar *)p + found;
354}
355
356/* A version of the fast scanner using SSE2 vectorized byte compare insns. */
357
358static const uchar *
359#ifndef __SSE2__1
360__attribute__((__target__("sse2")))
361#endif
362search_line_sse2 (const uchar *s, const uchar *end ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
363{
364 typedef char v16qi __attribute__ ((__vector_size__ (16)));
365
366 const v16qi repl_nl = *(const v16qi *)repl_chars[0];
367 const v16qi repl_cr = *(const v16qi *)repl_chars[1];
368 const v16qi repl_bs = *(const v16qi *)repl_chars[2];
369 const v16qi repl_qm = *(const v16qi *)repl_chars[3];
370
371 unsigned int misalign, found, mask;
372 const v16qi *p;
373 v16qi data, t;
374
375 /* Align the source pointer. */
376 misalign = (uintptr_t)s & 15;
377 p = (const v16qi *)((uintptr_t)s & -16);
378 data = *p;
379
380 /* Create a mask for the bytes that are valid within the first
381 16-byte block. The Idea here is that the AND with the mask
382 within the loop is "free", since we need some AND or TEST
383 insn in order to set the flags for the branch anyway. */
384 mask = -1u << misalign;
385
386 /* Main loop processing 16 bytes at a time. */
387 goto start;
388 do
389 {
390 data = *++p;
391 mask = -1;
392
393 start:
394 t = data == repl_nl;
395 t |= data == repl_cr;
396 t |= data == repl_bs;
397 t |= data == repl_qm;
398 found = __builtin_ia32_pmovmskb128 (t);
399 found &= mask;
400 }
401 while (!found);
402
403 /* FOUND contains 1 in bits for which we matched a relevant
404 character. Conversion to the byte index is trivial. */
405 found = __builtin_ctz(found);
406 return (const uchar *)p + found;
407}
408
409#ifdef HAVE_SSE41
410/* A version of the fast scanner using SSE 4.2 vectorized string insns. */
411
412static const uchar *
413#ifndef __SSE4_2__
414__attribute__((__target__("sse4.2")))
415#endif
416search_line_sse42 (const uchar *s, const uchar *end)
417{
418 typedef char v16qi __attribute__ ((__vector_size__ (16)));
419 static const v16qi search = { '\n', '\r', '?', '\\' };
420
421 uintptr_t si = (uintptr_t)s;
422 uintptr_t index;
423
424 /* Check for unaligned input. */
425 if (si & 15)
426 {
427 v16qi sv;
428
429 if (__builtin_expect (end - s < 16, 0)
430 && __builtin_expect ((si & 0xfff) > 0xff0, 0))
431 {
432 /* There are less than 16 bytes left in the buffer, and less
433 than 16 bytes left on the page. Reading 16 bytes at this
434 point might generate a spurious page fault. Defer to the
435 SSE2 implementation, which already handles alignment. */
436 return search_line_sse2 (s, end);
437 }
438
439 /* ??? The builtin doesn't understand that the PCMPESTRI read from
440 memory need not be aligned. */
441 sv = __builtin_ia32_loaddqu ((const char *) s);
442 index = __builtin_ia32_pcmpestri128 (search, 4, sv, 16, 0);
443
444 if (__builtin_expect (index < 16, 0))
445 goto found;
446
447 /* Advance the pointer to an aligned address. We will re-scan a
448 few bytes, but we no longer need care for reading past the
449 end of a page, since we're guaranteed a match. */
450 s = (const uchar *)((si + 15) & -16);
451 }
452
453 /* Main loop, processing 16 bytes at a time. */
454#ifdef __GCC_ASM_FLAG_OUTPUTS__1
455 while (1)
456 {
457 char f;
458
459 /* By using inline assembly instead of the builtin,
460 we can use the result, as well as the flags set. */
461 __asm ("%vpcmpestri\t$0, %2, %3"
462 : "=c"(index), "=@ccc"(f)
463 : "m"(*s), "x"(search), "a"(4), "d"(16));
464 if (f)
465 break;
466
467 s += 16;
468 }
469#else
470 s -= 16;
471 /* By doing the whole loop in inline assembly,
472 we can make proper use of the flags set. */
473 __asm ( ".balign 16\n"
474 "0: add $16, %1\n"
475 " %vpcmpestri\t$0, (%1), %2\n"
476 " jnc 0b"
477 : "=&c"(index), "+r"(s)
478 : "x"(search), "a"(4), "d"(16));
479#endif
480
481 found:
482 return s + index;
483}
484
485#else
486/* Work around out-dated assemblers without sse4 support. */
487#define search_line_sse42 search_line_sse2
488#endif
489
490/* Check the CPU capabilities. */
491
492#include "../gcc/config/i386/cpuid.h"
493
494typedef const uchar * (*search_line_fast_type) (const uchar *, const uchar *);
495static search_line_fast_type search_line_fastsearch_line_acc_char;
496
497#define HAVE_init_vectorized_lexer 1
498static inline void
499init_vectorized_lexer (void)
500{
501 unsigned dummy, ecx = 0, edx = 0;
502 search_line_fast_type impl = search_line_acc_char;
503 int minimum = 0;
504
505#if defined(__SSE4_2__)
506 minimum = 3;
507#elif defined(__SSE2__1)
508 minimum = 2;
509#elif defined(__SSE__1)
510 minimum = 1;
511#endif
512
513 if (minimum == 3)
514 impl = search_line_sse42;
515 else if (__get_cpuid (1, &dummy, &dummy, &ecx, &edx) || minimum == 2)
516 {
517 if (minimum == 3 || (ecx & bit_SSE4_2))
518 impl = search_line_sse42;
519 else if (minimum == 2 || (edx & bit_SSE2))
520 impl = search_line_sse2;
521 else if (minimum == 1 || (edx & bit_SSE))
522 impl = search_line_mmx;
523 }
524 else if (__get_cpuid (0x80000001, &dummy, &dummy, &dummy, &edx))
525 {
526 if (minimum == 1
527 || (edx & (bit_MMXEXT | bit_CMOV)) == (bit_MMXEXT | bit_CMOV))
528 impl = search_line_mmx;
529 }
530
531 search_line_fastsearch_line_acc_char = impl;
532}
533
534#elif (GCC_VERSION(4 * 1000 + 2) >= 4005) && defined(_ARCH_PWR8) && defined(__ALTIVEC__)
535
536/* A vection of the fast scanner using AltiVec vectorized byte compares
537 and VSX unaligned loads (when VSX is available). This is otherwise
538 the same as the AltiVec version. */
539
540ATTRIBUTE_NO_SANITIZE_UNDEFINED
541static const uchar *
542search_line_fastsearch_line_acc_char (const uchar *s, const uchar *end ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
543{
544 typedef __attribute__((altivec(vector))) unsigned char vc;
545
546 const vc repl_nl = {
547 '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n',
548 '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'
549 };
550 const vc repl_cr = {
551 '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r',
552 '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r'
553 };
554 const vc repl_bs = {
555 '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\',
556 '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\'
557 };
558 const vc repl_qm = {
559 '?', '?', '?', '?', '?', '?', '?', '?',
560 '?', '?', '?', '?', '?', '?', '?', '?',
561 };
562 const vc zero = { 0 };
563
564 vc data, t;
565
566 /* Main loop processing 16 bytes at a time. */
567 do
568 {
569 vc m_nl, m_cr, m_bs, m_qm;
570
571 data = __builtin_vec_vsx_ld (0, s);
572 s += 16;
573
574 m_nl = (vc) __builtin_vec_cmpeq(data, repl_nl);
575 m_cr = (vc) __builtin_vec_cmpeq(data, repl_cr);
576 m_bs = (vc) __builtin_vec_cmpeq(data, repl_bs);
577 m_qm = (vc) __builtin_vec_cmpeq(data, repl_qm);
578 t = (m_nl | m_cr) | (m_bs | m_qm);
579
580 /* T now contains 0xff in bytes for which we matched one of the relevant
581 characters. We want to exit the loop if any byte in T is non-zero.
582 Below is the expansion of vec_any_ne(t, zero). */
583 }
584 while (!__builtin_vec_vcmpeq_p(/*__CR6_LT_REV*/3, t, zero));
585
586 /* Restore s to to point to the 16 bytes we just processed. */
587 s -= 16;
588
589 {
590#define N (sizeof(vc) / sizeof(long))
591
592 union {
593 vc v;
594 /* Statically assert that N is 2 or 4. */
595 unsigned long l[(N == 2 || N == 4) ? N : -1];
596 } u;
597 unsigned long l, i = 0;
598
599 u.v = t;
600
601 /* Find the first word of T that is non-zero. */
602 switch (N)
603 {
604 case 4:
605 l = u.l[i++];
606 if (l != 0)
607 break;
608 s += sizeof(unsigned long);
609 l = u.l[i++];
610 if (l != 0)
611 break;
612 s += sizeof(unsigned long);
613 /* FALLTHRU */
614 case 2:
615 l = u.l[i++];
616 if (l != 0)
617 break;
618 s += sizeof(unsigned long);
619 l = u.l[i];
620 }
621
622 /* L now contains 0xff in bytes for which we matched one of the
623 relevant characters. We can find the byte index by finding
624 its bit index and dividing by 8. */
625#ifdef __BIG_ENDIAN__
626 l = __builtin_clzl(l) >> 3;
627#else
628 l = __builtin_ctzl(l) >> 3;
629#endif
630 return s + l;
631
632#undef N
633 }
634}
635
636#elif (GCC_VERSION(4 * 1000 + 2) >= 4005) && defined(__ALTIVEC__) && defined (__BIG_ENDIAN__)
637
638/* A vection of the fast scanner using AltiVec vectorized byte compares.
639 This cannot be used for little endian because vec_lvsl/lvsr are
640 deprecated for little endian and the code won't work properly. */
641/* ??? Unfortunately, attribute(target("altivec")) is not yet supported,
642 so we can't compile this function without -maltivec on the command line
643 (or implied by some other switch). */
644
645static const uchar *
646search_line_fastsearch_line_acc_char (const uchar *s, const uchar *end ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
647{
648 typedef __attribute__((altivec(vector))) unsigned char vc;
649
650 const vc repl_nl = {
651 '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n',
652 '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'
653 };
654 const vc repl_cr = {
655 '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r',
656 '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r'
657 };
658 const vc repl_bs = {
659 '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\',
660 '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\'
661 };
662 const vc repl_qm = {
663 '?', '?', '?', '?', '?', '?', '?', '?',
664 '?', '?', '?', '?', '?', '?', '?', '?',
665 };
666 const vc ones = {
667 -1, -1, -1, -1, -1, -1, -1, -1,
668 -1, -1, -1, -1, -1, -1, -1, -1,
669 };
670 const vc zero = { 0 };
671
672 vc data, mask, t;
673
674 /* Altivec loads automatically mask addresses with -16. This lets us
675 issue the first load as early as possible. */
676 data = __builtin_vec_ld(0, (const vc *)s);
677
678 /* Discard bytes before the beginning of the buffer. Do this by
679 beginning with all ones and shifting in zeros according to the
680 mis-alignment. The LVSR instruction pulls the exact shift we
681 want from the address. */
682 mask = __builtin_vec_lvsr(0, s);
683 mask = __builtin_vec_perm(zero, ones, mask);
684 data &= mask;
685
686 /* While altivec loads mask addresses, we still need to align S so
687 that the offset we compute at the end is correct. */
688 s = (const uchar *)((uintptr_t)s & -16);
689
690 /* Main loop processing 16 bytes at a time. */
691 goto start;
692 do
693 {
694 vc m_nl, m_cr, m_bs, m_qm;
695
696 s += 16;
697 data = __builtin_vec_ld(0, (const vc *)s);
698
699 start:
700 m_nl = (vc) __builtin_vec_cmpeq(data, repl_nl);
701 m_cr = (vc) __builtin_vec_cmpeq(data, repl_cr);
702 m_bs = (vc) __builtin_vec_cmpeq(data, repl_bs);
703 m_qm = (vc) __builtin_vec_cmpeq(data, repl_qm);
704 t = (m_nl | m_cr) | (m_bs | m_qm);
705
706 /* T now contains 0xff in bytes for which we matched one of the relevant
707 characters. We want to exit the loop if any byte in T is non-zero.
708 Below is the expansion of vec_any_ne(t, zero). */
709 }
710 while (!__builtin_vec_vcmpeq_p(/*__CR6_LT_REV*/3, t, zero));
711
712 {
713#define N (sizeof(vc) / sizeof(long))
714
715 union {
716 vc v;
717 /* Statically assert that N is 2 or 4. */
718 unsigned long l[(N == 2 || N == 4) ? N : -1];
719 } u;
720 unsigned long l, i = 0;
721
722 u.v = t;
723
724 /* Find the first word of T that is non-zero. */
725 switch (N)
726 {
727 case 4:
728 l = u.l[i++];
729 if (l != 0)
730 break;
731 s += sizeof(unsigned long);
732 l = u.l[i++];
733 if (l != 0)
734 break;
735 s += sizeof(unsigned long);
736 /* FALLTHROUGH */
737 case 2:
738 l = u.l[i++];
739 if (l != 0)
740 break;
741 s += sizeof(unsigned long);
742 l = u.l[i];
743 }
744
745 /* L now contains 0xff in bytes for which we matched one of the
746 relevant characters. We can find the byte index by finding
747 its bit index and dividing by 8. */
748 l = __builtin_clzl(l) >> 3;
749 return s + l;
750
751#undef N
752 }
753}
754
755#elif defined (__ARM_NEON) && defined (__ARM_64BIT_STATE)
756#include "arm_neon.h"
757
758/* This doesn't have to be the exact page size, but no system may use
759 a size smaller than this. ARMv8 requires a minimum page size of
760 4k. The impact of being conservative here is a small number of
761 cases will take the slightly slower entry path into the main
762 loop. */
763
764#define AARCH64_MIN_PAGE_SIZE 4096
765
766static const uchar *
767search_line_fastsearch_line_acc_char (const uchar *s, const uchar *end ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
768{
769 const uint8x16_t repl_nl = vdupq_n_u8 ('\n');
770 const uint8x16_t repl_cr = vdupq_n_u8 ('\r');
771 const uint8x16_t repl_bs = vdupq_n_u8 ('\\');
772 const uint8x16_t repl_qm = vdupq_n_u8 ('?');
773 const uint8x16_t xmask = (uint8x16_t) vdupq_n_u64 (0x8040201008040201ULL);
774
775#ifdef __ARM_BIG_ENDIAN
776 const int16x8_t shift = {8, 8, 8, 8, 0, 0, 0, 0};
777#else
778 const int16x8_t shift = {0, 0, 0, 0, 8, 8, 8, 8};
779#endif
780
781 unsigned int found;
782 const uint8_t *p;
783 uint8x16_t data;
784 uint8x16_t t;
785 uint16x8_t m;
786 uint8x16_t u, v, w;
787
788 /* Align the source pointer. */
789 p = (const uint8_t *)((uintptr_t)s & -16);
790
791 /* Assuming random string start positions, with a 4k page size we'll take
792 the slow path about 0.37% of the time. */
793 if (__builtin_expect ((AARCH64_MIN_PAGE_SIZE
794 - (((uintptr_t) s) & (AARCH64_MIN_PAGE_SIZE - 1)))
795 < 16, 0))
796 {
797 /* Slow path: the string starts near a possible page boundary. */
798 uint32_t misalign, mask;
799
800 misalign = (uintptr_t)s & 15;
801 mask = (-1u << misalign) & 0xffff;
802 data = vld1q_u8 (p);
803 t = vceqq_u8 (data, repl_nl);
804 u = vceqq_u8 (data, repl_cr);
805 v = vorrq_u8 (t, vceqq_u8 (data, repl_bs));
806 w = vorrq_u8 (u, vceqq_u8 (data, repl_qm));
807 t = vorrq_u8 (v, w);
808 t = vandq_u8 (t, xmask);
809 m = vpaddlq_u8 (t);
810 m = vshlq_u16 (m, shift);
811 found = vaddvq_u16 (m);
812 found &= mask;
813 if (found)
814 return (const uchar*)p + __builtin_ctz (found);
815 }
816 else
817 {
818 data = vld1q_u8 ((const uint8_t *) s);
819 t = vceqq_u8 (data, repl_nl);
820 u = vceqq_u8 (data, repl_cr);
821 v = vorrq_u8 (t, vceqq_u8 (data, repl_bs));
822 w = vorrq_u8 (u, vceqq_u8 (data, repl_qm));
823 t = vorrq_u8 (v, w);
824 if (__builtin_expect (vpaddd_u64 ((uint64x2_t)t) != 0, 0))
825 goto done;
826 }
827
828 do
829 {
830 p += 16;
831 data = vld1q_u8 (p);
832 t = vceqq_u8 (data, repl_nl);
833 u = vceqq_u8 (data, repl_cr);
834 v = vorrq_u8 (t, vceqq_u8 (data, repl_bs));
835 w = vorrq_u8 (u, vceqq_u8 (data, repl_qm));
836 t = vorrq_u8 (v, w);
837 } while (!vpaddd_u64 ((uint64x2_t)t));
838
839done:
840 /* Now that we've found the terminating substring, work out precisely where
841 we need to stop. */
842 t = vandq_u8 (t, xmask);
843 m = vpaddlq_u8 (t);
844 m = vshlq_u16 (m, shift);
845 found = vaddvq_u16 (m);
846 return (((((uintptr_t) p) < (uintptr_t) s) ? s : (const uchar *)p)
847 + __builtin_ctz (found));
848}
849
850#elif defined (__ARM_NEON)
851#include "arm_neon.h"
852
853static const uchar *
854search_line_fastsearch_line_acc_char (const uchar *s, const uchar *end ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
855{
856 const uint8x16_t repl_nl = vdupq_n_u8 ('\n');
857 const uint8x16_t repl_cr = vdupq_n_u8 ('\r');
858 const uint8x16_t repl_bs = vdupq_n_u8 ('\\');
859 const uint8x16_t repl_qm = vdupq_n_u8 ('?');
860 const uint8x16_t xmask = (uint8x16_t) vdupq_n_u64 (0x8040201008040201ULL);
861
862 unsigned int misalign, found, mask;
863 const uint8_t *p;
864 uint8x16_t data;
865
866 /* Align the source pointer. */
867 misalign = (uintptr_t)s & 15;
868 p = (const uint8_t *)((uintptr_t)s & -16);
869 data = vld1q_u8 (p);
870
871 /* Create a mask for the bytes that are valid within the first
872 16-byte block. The Idea here is that the AND with the mask
873 within the loop is "free", since we need some AND or TEST
874 insn in order to set the flags for the branch anyway. */
875 mask = (-1u << misalign) & 0xffff;
876
877 /* Main loop, processing 16 bytes at a time. */
878 goto start;
879
880 do
881 {
882 uint8x8_t l;
883 uint16x4_t m;
884 uint32x2_t n;
885 uint8x16_t t, u, v, w;
886
887 p += 16;
888 data = vld1q_u8 (p);
889 mask = 0xffff;
890
891 start:
892 t = vceqq_u8 (data, repl_nl);
893 u = vceqq_u8 (data, repl_cr);
894 v = vorrq_u8 (t, vceqq_u8 (data, repl_bs));
895 w = vorrq_u8 (u, vceqq_u8 (data, repl_qm));
896 t = vandq_u8 (vorrq_u8 (v, w), xmask);
897 l = vpadd_u8 (vget_low_u8 (t), vget_high_u8 (t));
898 m = vpaddl_u8 (l);
899 n = vpaddl_u16 (m);
900
901 found = vget_lane_u32 ((uint32x2_t) vorr_u64 ((uint64x1_t) n,
902 vshr_n_u64 ((uint64x1_t) n, 24)), 0);
903 found &= mask;
904 }
905 while (!found);
906
907 /* FOUND contains 1 in bits for which we matched a relevant
908 character. Conversion to the byte index is trivial. */
909 found = __builtin_ctz (found);
910 return (const uchar *)p + found;
911}
912
913#else
914
915/* We only have one accelerated alternative. Use a direct call so that
916 we encourage inlining. */
917
918#define search_line_fastsearch_line_acc_char search_line_acc_char
919
920#endif
921
922/* Initialize the lexer if needed. */
923
924void
925_cpp_init_lexer (void)
926{
927#ifdef HAVE_init_vectorized_lexer
928 init_vectorized_lexer ();
929#endif
930}
931
932/* Returns with a logical line that contains no escaped newlines or
933 trigraphs. This is a time-critical inner loop. */
934void
935_cpp_clean_line (cpp_reader *pfile)
936{
937 cpp_buffer *buffer;
938 const uchar *s;
939 uchar c, *d, *p;
940
941 buffer = pfile->buffer;
942 buffer->cur_note = buffer->notes_used = 0;
943 buffer->cur = buffer->line_base = buffer->next_line;
944 buffer->need_line = false;
945 s = buffer->next_line;
946
947 if (!buffer->from_stage3)
948 {
949 const uchar *pbackslash = NULL__null;
950
951 /* Fast path. This is the common case of an un-escaped line with
952 no trigraphs. The primary win here is by not writing any
953 data back to memory until we have to. */
954 while (1)
955 {
956 /* Perform an optimized search for \n, \r, \\, ?. */
957 s = search_line_fastsearch_line_acc_char (s, buffer->rlimit);
958
959 c = *s;
960 if (c == '\\')
961 {
962 /* Record the location of the backslash and continue. */
963 pbackslash = s++;
964 }
965 else if (__builtin_expect (c == '?', 0))
966 {
967 if (__builtin_expect (s[1] == '?', false)
968 && _cpp_trigraph_map[s[2]])
969 {
970 /* Have a trigraph. We may or may not have to convert
971 it. Add a line note regardless, for -Wtrigraphs. */
972 add_line_note (buffer, s, s[2]);
973 if (CPP_OPTION (pfile, trigraphs)((pfile)->opts.trigraphs))
974 {
975 /* We do, and that means we have to switch to the
976 slow path. */
977 d = (uchar *) s;
978 *d = _cpp_trigraph_map[s[2]];
979 s += 2;
980 goto slow_path;
981 }
982 }
983 /* Not a trigraph. Continue on fast-path. */
984 s++;
985 }
986 else
987 break;
988 }
989
990 /* This must be \r or \n. We're either done, or we'll be forced
991 to write back to the buffer and continue on the slow path. */
992 d = (uchar *) s;
993
994 if (__builtin_expect (s == buffer->rlimit, false))
995 goto done;
996
997 /* DOS line ending? */
998 if (__builtin_expect (c == '\r', false) && s[1] == '\n')
999 {
1000 s++;
1001 if (s == buffer->rlimit)
1002 goto done;
1003 }
1004
1005 if (__builtin_expect (pbackslash == NULL__null, true))
1006 goto done;
1007
1008 /* Check for escaped newline. */
1009 p = d;
1010 while (is_nvspace (p[-1])(_sch_istable[(p[-1]) & 0xff] & (unsigned short)(_sch_isnvsp
))
)
1011 p--;
1012 if (p - 1 != pbackslash)
1013 goto done;
1014
1015 /* Have an escaped newline; process it and proceed to
1016 the slow path. */
1017 add_line_note (buffer, p - 1, p != d ? ' ' : '\\');
1018 d = p - 2;
1019 buffer->next_line = p - 1;
1020
1021 slow_path:
1022 while (1)
1023 {
1024 c = *++s;
1025 *++d = c;
1026
1027 if (c == '\n' || c == '\r')
1028 {
1029 /* Handle DOS line endings. */
1030 if (c == '\r' && s != buffer->rlimit && s[1] == '\n')
1031 s++;
1032 if (s == buffer->rlimit)
1033 break;
1034
1035 /* Escaped? */
1036 p = d;
1037 while (p != buffer->next_line && is_nvspace (p[-1])(_sch_istable[(p[-1]) & 0xff] & (unsigned short)(_sch_isnvsp
))
)
1038 p--;
1039 if (p == buffer->next_line || p[-1] != '\\')
1040 break;
1041
1042 add_line_note (buffer, p - 1, p != d ? ' ': '\\');
1043 d = p - 2;
1044 buffer->next_line = p - 1;
1045 }
1046 else if (c == '?' && s[1] == '?' && _cpp_trigraph_map[s[2]])
1047 {
1048 /* Add a note regardless, for the benefit of -Wtrigraphs. */
1049 add_line_note (buffer, d, s[2]);
1050 if (CPP_OPTION (pfile, trigraphs)((pfile)->opts.trigraphs))
1051 {
1052 *d = _cpp_trigraph_map[s[2]];
1053 s += 2;
1054 }
1055 }
1056 }
1057 }
1058 else
1059 {
1060 while (*s != '\n' && *s != '\r')
1061 s++;
1062 d = (uchar *) s;
1063
1064 /* Handle DOS line endings. */
1065 if (*s == '\r' && s + 1 != buffer->rlimit && s[1] == '\n')
1066 s++;
1067 }
1068
1069 done:
1070 *d = '\n';
1071 /* A sentinel note that should never be processed. */
1072 add_line_note (buffer, d + 1, '\n');
1073 buffer->next_line = s + 1;
1074}
1075
1076/* Return true if the trigraph indicated by NOTE should be warned
1077 about in a comment. */
1078static bool
1079warn_in_comment (cpp_reader *pfile, _cpp_line_note *note)
1080{
1081 const uchar *p;
1082
1083 /* Within comments we don't warn about trigraphs, unless the
1084 trigraph forms an escaped newline, as that may change
1085 behavior. */
1086 if (note->type != '/')
1087 return false;
1088
1089 /* If -trigraphs, then this was an escaped newline iff the next note
1090 is coincident. */
1091 if (CPP_OPTION (pfile, trigraphs)((pfile)->opts.trigraphs))
1092 return note[1].pos == note->pos;
1093
1094 /* Otherwise, see if this forms an escaped newline. */
1095 p = note->pos + 3;
1096 while (is_nvspace (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isnvsp
))
)
1097 p++;
1098
1099 /* There might have been escaped newlines between the trigraph and the
1100 newline we found. Hence the position test. */
1101 return (*p == '\n' && p < note[1].pos);
1102}
1103
1104/* Process the notes created by add_line_note as far as the current
1105 location. */
1106void
1107_cpp_process_line_notes (cpp_reader *pfile, int in_comment)
1108{
1109 cpp_buffer *buffer = pfile->buffer;
1110
1111 for (;;)
1112 {
1113 _cpp_line_note *note = &buffer->notes[buffer->cur_note];
1114 unsigned int col;
1115
1116 if (note->pos > buffer->cur)
1117 break;
1118
1119 buffer->cur_note++;
1120 col = CPP_BUF_COLUMN (buffer, note->pos + 1)((note->pos + 1) - (buffer)->line_base);
1121
1122 if (note->type == '\\' || note->type == ' ')
1123 {
1124 if (note->type == ' ' && !in_comment)
1125 cpp_error_with_line (pfile, CPP_DL_WARNING, pfile->line_table->highest_line, col,
1126 "backslash and newline separated by space");
1127
1128 if (buffer->next_line > buffer->rlimit)
1129 {
1130 cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->line_table->highest_line, col,
1131 "backslash-newline at end of file");
1132 /* Prevent "no newline at end of file" warning. */
1133 buffer->next_line = buffer->rlimit;
1134 }
1135
1136 buffer->line_base = note->pos;
1137 CPP_INCREMENT_LINE (pfile, 0)do { const class line_maps *line_table = pfile->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (pfile->line_table,
line + 1, 0); } while (0)
;
1138 }
1139 else if (_cpp_trigraph_map[note->type])
1140 {
1141 if (CPP_OPTION (pfile, warn_trigraphs)((pfile)->opts.warn_trigraphs)
1142 && (!in_comment || warn_in_comment (pfile, note)))
1143 {
1144 if (CPP_OPTION (pfile, trigraphs)((pfile)->opts.trigraphs))
1145 cpp_warning_with_line (pfile, CPP_W_TRIGRAPHS,
1146 pfile->line_table->highest_line, col,
1147 "trigraph ??%c converted to %c",
1148 note->type,
1149 (int) _cpp_trigraph_map[note->type]);
1150 else
1151 {
1152 cpp_warning_with_line
1153 (pfile, CPP_W_TRIGRAPHS,
1154 pfile->line_table->highest_line, col,
1155 "trigraph ??%c ignored, use -trigraphs to enable",
1156 note->type);
1157 }
1158 }
1159 }
1160 else if (note->type == 0)
1161 /* Already processed in lex_raw_string. */;
1162 else
1163 abort ()fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 1163, __FUNCTION__)
;
1164 }
1165}
1166
1167namespace bidi {
1168 enum class kind {
1169 NONE, LRE, RLE, LRO, RLO, LRI, RLI, FSI, PDF, PDI, LTR, RTL
1170 };
1171
1172 /* All the UTF-8 encodings of bidi characters start with E2. */
1173 constexpr uchar utf8_start = 0xe2;
1174
1175 struct context
1176 {
1177 context () {}
1178 context (location_t loc, kind k, bool pdf, bool ucn)
1179 : m_loc (loc), m_kind (k), m_pdf (pdf), m_ucn (ucn)
1180 {
1181 }
1182
1183 kind get_pop_kind () const
1184 {
1185 return m_pdf ? kind::PDF : kind::PDI;
1186 }
1187 bool ucn_p () const
1188 {
1189 return m_ucn;
1190 }
1191
1192 location_t m_loc;
1193 kind m_kind;
1194 unsigned m_pdf : 1;
1195 unsigned m_ucn : 1;
1196 };
1197
1198 /* A vector holding currently open bidi contexts. We use a char for
1199 each context, its LSB is 1 if it represents a PDF context, 0 if it
1200 represents a PDI context. The next bit is 1 if this context was open
1201 by a bidi character written as a UCN, and 0 when it was UTF-8. */
1202 semi_embedded_vec <context, 16> vec;
1203
1204 /* Close the whole comment/identifier/string literal/character constant
1205 context. */
1206 void on_close ()
1207 {
1208 vec.truncate (0);
1209 }
1210
1211 /* Pop the last element in the vector. */
1212 void pop ()
1213 {
1214 unsigned int len = vec.count ();
1215 gcc_checking_assert (len > 0)((void)(!(len > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 1215, __FUNCTION__), 0 : 0))
;
1216 vec.truncate (len - 1);
1217 }
1218
1219 /* Return the pop kind of the context of the Ith element. */
1220 kind pop_kind_at (unsigned int i)
1221 {
1222 return vec[i].get_pop_kind ();
1223 }
1224
1225 /* Return the pop kind of the context that is currently opened. */
1226 kind current_ctx ()
1227 {
1228 unsigned int len = vec.count ();
1229 if (len == 0)
1230 return kind::NONE;
1231 return vec[len - 1].get_pop_kind ();
1232 }
1233
1234 /* Return true if the current context comes from a UCN origin, that is,
1235 the bidi char which started this bidi context was written as a UCN. */
1236 bool current_ctx_ucn_p ()
1237 {
1238 unsigned int len = vec.count ();
1239 gcc_checking_assert (len > 0)((void)(!(len > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 1239, __FUNCTION__), 0 : 0))
;
1240 return vec[len - 1].m_ucn;
1241 }
1242
1243 location_t current_ctx_loc ()
1244 {
1245 unsigned int len = vec.count ();
1246 gcc_checking_assert (len > 0)((void)(!(len > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 1246, __FUNCTION__), 0 : 0))
;
1247 return vec[len - 1].m_loc;
1248 }
1249
1250 /* We've read a bidi char, update the current vector as necessary.
1251 LOC is only valid when K is not kind::NONE. */
1252 void on_char (kind k, bool ucn_p, location_t loc)
1253 {
1254 switch (k)
1255 {
1256 case kind::LRE:
1257 case kind::RLE:
1258 case kind::LRO:
1259 case kind::RLO:
1260 vec.push (context (loc, k, true, ucn_p));
1261 break;
1262 case kind::LRI:
1263 case kind::RLI:
1264 case kind::FSI:
1265 vec.push (context (loc, k, false, ucn_p));
1266 break;
1267 /* PDF terminates the scope of the last LRE, RLE, LRO, or RLO
1268 whose scope has not yet been terminated. */
1269 case kind::PDF:
1270 if (current_ctx () == kind::PDF)
1271 pop ();
1272 break;
1273 /* PDI terminates the scope of the last LRI, RLI, or FSI whose
1274 scope has not yet been terminated, as well as the scopes of
1275 any subsequent LREs, RLEs, LROs, or RLOs whose scopes have not
1276 yet been terminated. */
1277 case kind::PDI:
1278 for (int i = vec.count () - 1; i >= 0; --i)
1279 if (pop_kind_at (i) == kind::PDI)
1280 {
1281 vec.truncate (i);
1282 break;
1283 }
1284 break;
1285 case kind::LTR:
1286 case kind::RTL:
1287 /* These aren't popped by a PDF/PDI. */
1288 break;
1289 [[likely]] case kind::NONE:
1290 break;
1291 default:
1292 abort ()fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 1292, __FUNCTION__)
;
1293 }
1294 }
1295
1296 /* Return a descriptive string for K. */
1297 const char *to_str (kind k)
1298 {
1299 switch (k)
1300 {
1301 case kind::LRE:
1302 return "U+202A (LEFT-TO-RIGHT EMBEDDING)";
1303 case kind::RLE:
1304 return "U+202B (RIGHT-TO-LEFT EMBEDDING)";
1305 case kind::LRO:
1306 return "U+202D (LEFT-TO-RIGHT OVERRIDE)";
1307 case kind::RLO:
1308 return "U+202E (RIGHT-TO-LEFT OVERRIDE)";
1309 case kind::LRI:
1310 return "U+2066 (LEFT-TO-RIGHT ISOLATE)";
1311 case kind::RLI:
1312 return "U+2067 (RIGHT-TO-LEFT ISOLATE)";
1313 case kind::FSI:
1314 return "U+2068 (FIRST STRONG ISOLATE)";
1315 case kind::PDF:
1316 return "U+202C (POP DIRECTIONAL FORMATTING)";
1317 case kind::PDI:
1318 return "U+2069 (POP DIRECTIONAL ISOLATE)";
1319 case kind::LTR:
1320 return "U+200E (LEFT-TO-RIGHT MARK)";
1321 case kind::RTL:
1322 return "U+200F (RIGHT-TO-LEFT MARK)";
1323 default:
1324 abort ()fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 1324, __FUNCTION__)
;
1325 }
1326 }
1327}
1328
1329/* Get location_t for the range of bytes [START, START + NUM_BYTES)
1330 within the current line in FILE, with the caret at START. */
1331
1332static location_t
1333get_location_for_byte_range_in_cur_line (cpp_reader *pfile,
1334 const unsigned char *const start,
1335 size_t num_bytes)
1336{
1337 gcc_checking_assert (num_bytes > 0)((void)(!(num_bytes > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 1337, __FUNCTION__), 0 : 0))
;
1338
1339 /* CPP_BUF_COLUMN and linemap_position_for_column both refer
1340 to offsets in bytes, but CPP_BUF_COLUMN is 0-based,
1341 whereas linemap_position_for_column is 1-based. */
1342
1343 /* Get 0-based offsets within the line. */
1344 size_t start_offset = CPP_BUF_COLUMN (pfile->buffer, start)((start) - (pfile->buffer)->line_base);
1345 size_t end_offset = start_offset + num_bytes - 1;
1346
1347 /* Now convert to location_t, where "columns" are 1-based byte offsets. */
1348 location_t start_loc = linemap_position_for_column (pfile->line_table,
1349 start_offset + 1);
1350 location_t end_loc = linemap_position_for_column (pfile->line_table,
1351 end_offset + 1);
1352
1353 if (start_loc == end_loc)
1354 return start_loc;
1355
1356 source_range src_range;
1357 src_range.m_start = start_loc;
1358 src_range.m_finish = end_loc;
1359 location_t combined_loc = COMBINE_LOCATION_DATA (pfile->line_table,
1360 start_loc,
1361 src_range,
1362 NULL__null);
1363 return combined_loc;
1364}
1365
1366/* Parse a sequence of 3 bytes starting with P and return its bidi code. */
1367
1368static bidi::kind
1369get_bidi_utf8_1 (const unsigned char *const p)
1370{
1371 gcc_checking_assert (p[0] == bidi::utf8_start)((void)(!(p[0] == bidi::utf8_start) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 1371, __FUNCTION__), 0 : 0))
;
1372
1373 if (p[1] == 0x80)
1374 switch (p[2])
1375 {
1376 case 0xaa:
1377 return bidi::kind::LRE;
1378 case 0xab:
1379 return bidi::kind::RLE;
1380 case 0xac:
1381 return bidi::kind::PDF;
1382 case 0xad:
1383 return bidi::kind::LRO;
1384 case 0xae:
1385 return bidi::kind::RLO;
1386 case 0x8e:
1387 return bidi::kind::LTR;
1388 case 0x8f:
1389 return bidi::kind::RTL;
1390 default:
1391 break;
1392 }
1393 else if (p[1] == 0x81)
1394 switch (p[2])
1395 {
1396 case 0xa6:
1397 return bidi::kind::LRI;
1398 case 0xa7:
1399 return bidi::kind::RLI;
1400 case 0xa8:
1401 return bidi::kind::FSI;
1402 case 0xa9:
1403 return bidi::kind::PDI;
1404 default:
1405 break;
1406 }
1407
1408 return bidi::kind::NONE;
1409}
1410
1411/* Parse a sequence of 3 bytes starting with P and return its bidi code.
1412 If the kind is not NONE, write the location to *OUT.*/
1413
1414static bidi::kind
1415get_bidi_utf8 (cpp_reader *pfile, const unsigned char *const p, location_t *out)
1416{
1417 bidi::kind result = get_bidi_utf8_1 (p);
1418 if (result
21.1
'result' is equal to NONE
21.1
'result' is equal to NONE
!= bidi::kind::NONE)
22
Taking false branch
1419 {
1420 /* We have a sequence of 3 bytes starting at P. */
1421 *out = get_location_for_byte_range_in_cur_line (pfile, p, 3);
1422 }
1423 return result;
23
Returning without writing to '*out'
1424}
1425
1426/* Parse a UCN where P points just past \u or \U and return its bidi code. */
1427
1428static bidi::kind
1429get_bidi_ucn_1 (const unsigned char *p, bool is_U)
1430{
1431 /* 6.4.3 Universal Character Names
1432 \u hex-quad
1433 \U hex-quad hex-quad
1434 where \unnnn means \U0000nnnn. */
1435
1436 if (is_U)
1437 {
1438 if (p[0] != '0' || p[1] != '0' || p[2] != '0' || p[3] != '0')
1439 return bidi::kind::NONE;
1440 /* Skip 4B so we can treat \u and \U the same below. */
1441 p += 4;
1442 }
1443
1444 /* All code points we are looking for start with 20xx. */
1445 if (p[0] != '2' || p[1] != '0')
1446 return bidi::kind::NONE;
1447 else if (p[2] == '2')
1448 switch (p[3])
1449 {
1450 case 'a':
1451 case 'A':
1452 return bidi::kind::LRE;
1453 case 'b':
1454 case 'B':
1455 return bidi::kind::RLE;
1456 case 'c':
1457 case 'C':
1458 return bidi::kind::PDF;
1459 case 'd':
1460 case 'D':
1461 return bidi::kind::LRO;
1462 case 'e':
1463 case 'E':
1464 return bidi::kind::RLO;
1465 default:
1466 break;
1467 }
1468 else if (p[2] == '6')
1469 switch (p[3])
1470 {
1471 case '6':
1472 return bidi::kind::LRI;
1473 case '7':
1474 return bidi::kind::RLI;
1475 case '8':
1476 return bidi::kind::FSI;
1477 case '9':
1478 return bidi::kind::PDI;
1479 default:
1480 break;
1481 }
1482 else if (p[2] == '0')
1483 switch (p[3])
1484 {
1485 case 'e':
1486 case 'E':
1487 return bidi::kind::LTR;
1488 case 'f':
1489 case 'F':
1490 return bidi::kind::RTL;
1491 default:
1492 break;
1493 }
1494
1495 return bidi::kind::NONE;
1496}
1497
1498/* Parse a UCN where P points just past \u or \U and return its bidi code.
1499 If the kind is not NONE, write the location to *OUT.*/
1500
1501static bidi::kind
1502get_bidi_ucn (cpp_reader *pfile, const unsigned char *p, bool is_U,
1503 location_t *out)
1504{
1505 bidi::kind result = get_bidi_ucn_1 (p, is_U);
1506 if (result != bidi::kind::NONE)
1507 {
1508 const unsigned char *start = p - 2;
1509 size_t num_bytes = 2 + (is_U ? 8 : 4);
1510 *out = get_location_for_byte_range_in_cur_line (pfile, start, num_bytes);
1511 }
1512 return result;
1513}
1514
1515/* Subclass of rich_location for reporting on unpaired UTF-8
1516 bidirectional control character(s).
1517 Escape the source lines on output, and show all unclosed
1518 bidi context, labelling everything. */
1519
1520class unpaired_bidi_rich_location : public rich_location
1521{
1522 public:
1523 class custom_range_label : public range_label
1524 {
1525 public:
1526 label_text get_text (unsigned range_idx) const FINAL OVERRIDE
1527 {
1528 /* range 0 is the primary location; each subsequent range i + 1
1529 is for bidi::vec[i]. */
1530 if (range_idx > 0)
1531 {
1532 const bidi::context &ctxt (bidi::vec[range_idx - 1]);
1533 return label_text::borrow (bidi::to_str (ctxt.m_kind));
1534 }
1535 else
1536 return label_text::borrow (_("end of bidirectional context")dgettext ("cpplib", "end of bidirectional context"));
1537 }
1538 };
1539
1540 unpaired_bidi_rich_location (cpp_reader *pfile, location_t loc)
1541 : rich_location (pfile->line_table, loc, &m_custom_label)
1542 {
1543 set_escape_on_output (true);
1544 for (unsigned i = 0; i < bidi::vec.count (); i++)
1545 add_range (bidi::vec[i].m_loc,
1546 SHOW_RANGE_WITHOUT_CARET,
1547 &m_custom_label);
1548 }
1549
1550 private:
1551 custom_range_label m_custom_label;
1552};
1553
1554/* We're closing a bidi context, that is, we've encountered a newline,
1555 are closing a C-style comment, or are at the end of a string literal,
1556 character constant, or identifier. Warn if this context was not
1557 properly terminated by a PDI or PDF. P points to the last character
1558 in this context. */
1559
1560static void
1561maybe_warn_bidi_on_close (cpp_reader *pfile, const uchar *p)
1562{
1563 if (CPP_OPTION (pfile, cpp_warn_bidirectional)((pfile)->opts.cpp_warn_bidirectional) == bidirectional_unpaired
1564 && bidi::vec.count () > 0)
1565 {
1566 const location_t loc
1567 = linemap_position_for_column (pfile->line_table,
1568 CPP_BUF_COLUMN (pfile->buffer, p)((p) - (pfile->buffer)->line_base));
1569 unpaired_bidi_rich_location rich_loc (pfile, loc);
1570 /* cpp_callbacks doesn't yet have a way to handle singular vs plural
1571 forms of a diagnostic, so fake it for now. */
1572 if (bidi::vec.count () > 1)
1573 cpp_warning_at (pfile, CPP_W_BIDIRECTIONAL, &rich_loc,
1574 "unpaired UTF-8 bidirectional control characters "
1575 "detected");
1576 else
1577 cpp_warning_at (pfile, CPP_W_BIDIRECTIONAL, &rich_loc,
1578 "unpaired UTF-8 bidirectional control character "
1579 "detected");
1580 }
1581 /* We're done with this context. */
1582 bidi::on_close ();
1583}
1584
1585/* We're at the beginning or in the middle of an identifier/comment/string
1586 literal/character constant. Warn if we've encountered a bidi character.
1587 KIND says which bidi control character it was; UCN_P is true iff this bidi
1588 control character was written as a UCN. LOC is the location of the
1589 character, but is only valid if KIND != bidi::kind::NONE. */
1590
1591static void
1592maybe_warn_bidi_on_char (cpp_reader *pfile, bidi::kind kind,
1593 bool ucn_p, location_t loc)
1594{
1595 if (__builtin_expect (kind == bidi::kind::NONE, 1))
1596 return;
1597
1598 const auto warn_bidi = CPP_OPTION (pfile, cpp_warn_bidirectional)((pfile)->opts.cpp_warn_bidirectional);
1599
1600 if (warn_bidi != bidirectional_none)
1601 {
1602 rich_location rich_loc (pfile->line_table, loc);
1603 rich_loc.set_escape_on_output (true);
1604
1605 /* It seems excessive to warn about a PDI/PDF that is closing
1606 an opened context because we've already warned about the
1607 opening character. Except warn when we have a UCN x UTF-8
1608 mismatch. */
1609 if (kind == bidi::current_ctx ())
1610 {
1611 if (warn_bidi == bidirectional_unpaired
1612 && bidi::current_ctx_ucn_p () != ucn_p)
1613 {
1614 rich_loc.add_range (bidi::current_ctx_loc ());
1615 cpp_warning_at (pfile, CPP_W_BIDIRECTIONAL, &rich_loc,
1616 "UTF-8 vs UCN mismatch when closing "
1617 "a context by \"%s\"", bidi::to_str (kind));
1618 }
1619 }
1620 else if (warn_bidi == bidirectional_any)
1621 {
1622 if (kind == bidi::kind::PDF || kind == bidi::kind::PDI)
1623 cpp_warning_at (pfile, CPP_W_BIDIRECTIONAL, &rich_loc,
1624 "\"%s\" is closing an unopened context",
1625 bidi::to_str (kind));
1626 else
1627 cpp_warning_at (pfile, CPP_W_BIDIRECTIONAL, &rich_loc,
1628 "found problematic Unicode character \"%s\"",
1629 bidi::to_str (kind));
1630 }
1631 }
1632 /* We're done with this context. */
1633 bidi::on_char (kind, ucn_p, loc);
1634}
1635
1636/* Skip a C-style block comment. We find the end of the comment by
1637 seeing if an asterisk is before every '/' we encounter. Returns
1638 nonzero if comment terminated by EOF, zero otherwise.
1639
1640 Buffer->cur points to the initial asterisk of the comment. */
1641bool
1642_cpp_skip_block_comment (cpp_reader *pfile)
1643{
1644 cpp_buffer *buffer = pfile->buffer;
1645 const uchar *cur = buffer->cur;
1646 uchar c;
1647 const bool warn_bidi_p = pfile->warn_bidi_p ();
1648
1649 cur++;
1650 if (*cur == '/')
1651 cur++;
1652
1653 for (;;)
1654 {
1655 /* People like decorating comments with '*', so check for '/'
1656 instead for efficiency. */
1657 c = *cur++;
1658
1659 if (c == '/')
1660 {
1661 if (cur[-2] == '*')
1662 {
1663 if (warn_bidi_p)
1664 maybe_warn_bidi_on_close (pfile, cur);
1665 break;
1666 }
1667
1668 /* Warn about potential nested comments, but not if the '/'
1669 comes immediately before the true comment delimiter.
1670 Don't bother to get it right across escaped newlines. */
1671 if (CPP_OPTION (pfile, warn_comments)((pfile)->opts.warn_comments)
1672 && cur[0] == '*' && cur[1] != '/')
1673 {
1674 buffer->cur = cur;
1675 cpp_warning_with_line (pfile, CPP_W_COMMENTS,
1676 pfile->line_table->highest_line,
1677 CPP_BUF_COL (buffer)(((buffer)->cur) - (buffer)->line_base),
1678 "\"/*\" within comment");
1679 }
1680 }
1681 else if (c == '\n')
1682 {
1683 unsigned int cols;
1684 buffer->cur = cur - 1;
1685 if (warn_bidi_p)
1686 maybe_warn_bidi_on_close (pfile, cur);
1687 _cpp_process_line_notes (pfile, true);
1688 if (buffer->next_line >= buffer->rlimit)
1689 return true;
1690 _cpp_clean_line (pfile);
1691
1692 cols = buffer->next_line - buffer->line_base;
1693 CPP_INCREMENT_LINE (pfile, cols)do { const class line_maps *line_table = pfile->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (pfile->line_table,
line + 1, cols); } while (0)
;
1694
1695 cur = buffer->cur;
1696 }
1697 /* If this is a beginning of a UTF-8 encoding, it might be
1698 a bidirectional control character. */
1699 else if (__builtin_expect (c == bidi::utf8_start, 0) && warn_bidi_p)
1700 {
1701 location_t loc;
1702 bidi::kind kind = get_bidi_utf8 (pfile, cur - 1, &loc);
1703 maybe_warn_bidi_on_char (pfile, kind, /*ucn_p=*/false, loc);
1704 }
1705 }
1706
1707 buffer->cur = cur;
1708 _cpp_process_line_notes (pfile, true);
1709 return false;
1710}
1711
1712/* Skip a C++ line comment, leaving buffer->cur pointing to the
1713 terminating newline. Handles escaped newlines. Returns nonzero
1714 if a multiline comment. */
1715static int
1716skip_line_comment (cpp_reader *pfile)
1717{
1718 cpp_buffer *buffer = pfile->buffer;
1719 location_t orig_line = pfile->line_table->highest_line;
1720 const bool warn_bidi_p = pfile->warn_bidi_p ();
1721
1722 if (!warn_bidi_p)
1723 while (*buffer->cur != '\n')
1724 buffer->cur++;
1725 else
1726 {
1727 while (*buffer->cur != '\n'
1728 && *buffer->cur != bidi::utf8_start)
1729 buffer->cur++;
1730 if (__builtin_expect (*buffer->cur == bidi::utf8_start, 0))
1731 {
1732 while (*buffer->cur != '\n')
1733 {
1734 if (__builtin_expect (*buffer->cur == bidi::utf8_start, 0))
1735 {
1736 location_t loc;
1737 bidi::kind kind = get_bidi_utf8 (pfile, buffer->cur, &loc);
1738 maybe_warn_bidi_on_char (pfile, kind, /*ucn_p=*/false, loc);
1739 }
1740 buffer->cur++;
1741 }
1742 maybe_warn_bidi_on_close (pfile, buffer->cur);
1743 }
1744 }
1745
1746 _cpp_process_line_notes (pfile, true);
1747 return orig_line != pfile->line_table->highest_line;
1748}
1749
1750/* Skips whitespace, saving the next non-whitespace character. */
1751static void
1752skip_whitespace (cpp_reader *pfile, cppchar_t c)
1753{
1754 cpp_buffer *buffer = pfile->buffer;
1755 bool saw_NUL = false;
1756
1757 do
1758 {
1759 /* Horizontal space always OK. */
1760 if (c == ' ' || c == '\t')
1761 ;
1762 /* Just \f \v or \0 left. */
1763 else if (c == '\0')
1764 saw_NUL = true;
1765 else if (pfile->state.in_directive && CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic))
1766 cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->line_table->highest_line,
1767 CPP_BUF_COL (buffer)(((buffer)->cur) - (buffer)->line_base),
1768 "%s in preprocessing directive",
1769 c == '\f' ? "form feed" : "vertical tab");
1770
1771 c = *buffer->cur++;
1772 }
1773 /* We only want non-vertical space, i.e. ' ' \t \f \v \0. */
1774 while (is_nvspace (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isnvsp
))
);
1775
1776 if (saw_NUL)
1777 {
1778 encoding_rich_location rich_loc (pfile);
1779 cpp_error_at (pfile, CPP_DL_WARNING, &rich_loc,
1780 "null character(s) ignored");
1781 }
1782
1783 buffer->cur--;
1784}
1785
1786/* See if the characters of a number token are valid in a name (no
1787 '.', '+' or '-'). */
1788static int
1789name_p (cpp_reader *pfile, const cpp_string *string)
1790{
1791 unsigned int i;
1792
1793 for (i = 0; i < string->len; i++)
1794 if (!is_idchar (string->text[i])((_sch_istable[(string->text[i]) & 0xff] & (unsigned
short)(_sch_isidnum)) || ((string->text[i]) == '$' &&
((pfile)->opts.dollars_in_ident)))
)
1795 return 0;
1796
1797 return 1;
1798}
1799
1800/* After parsing an identifier or other sequence, produce a warning about
1801 sequences not in NFC/NFKC. */
1802static void
1803warn_about_normalization (cpp_reader *pfile,
1804 const cpp_token *token,
1805 const struct normalize_state *s)
1806{
1807 if (CPP_OPTION (pfile, warn_normalize)((pfile)->opts.warn_normalize) < NORMALIZE_STATE_RESULT (s)((s)->level)
1808 && !pfile->state.skipping)
1809 {
1810 location_t loc = token->src_loc;
1811
1812 /* If possible, create a location range for the token. */
1813 if (loc >= RESERVED_LOCATION_COUNT
1814 && token->type != CPP_EOF
1815 /* There must be no line notes to process. */
1816 && (!(pfile->buffer->cur
1817 >= pfile->buffer->notes[pfile->buffer->cur_note].pos
1818 && !pfile->overlaid_buffer)))
1819 {
1820 source_range tok_range;
1821 tok_range.m_start = loc;
1822 tok_range.m_finish
1823 = linemap_position_for_column (pfile->line_table,
1824 CPP_BUF_COLUMN (pfile->buffer,((pfile->buffer->cur) - (pfile->buffer)->line_base
)
1825 pfile->buffer->cur)((pfile->buffer->cur) - (pfile->buffer)->line_base
)
);
1826 loc = COMBINE_LOCATION_DATA (pfile->line_table,
1827 loc, tok_range, NULL__null);
1828 }
1829
1830 encoding_rich_location rich_loc (pfile, loc);
1831
1832 /* Make sure that the token is printed using UCNs, even
1833 if we'd otherwise happily print UTF-8. */
1834 unsigned char *buf = XNEWVEC (unsigned char, cpp_token_len (token))((unsigned char *) xmalloc (sizeof (unsigned char) * (cpp_token_len
(token))))
;
1835 size_t sz;
1836
1837 sz = cpp_spell_token (pfile, token, buf, false) - buf;
1838 if (NORMALIZE_STATE_RESULT (s)((s)->level) == normalized_C)
1839 cpp_warning_at (pfile, CPP_W_NORMALIZE, &rich_loc,
1840 "`%.*s' is not in NFKC", (int) sz, buf);
1841 else if (CPP_OPTION (pfile, cxx23_identifiers)((pfile)->opts.cxx23_identifiers))
1842 cpp_pedwarning_at (pfile, CPP_W_NORMALIZE, &rich_loc,
1843 "`%.*s' is not in NFC", (int) sz, buf);
1844 else
1845 cpp_warning_at (pfile, CPP_W_NORMALIZE, &rich_loc,
1846 "`%.*s' is not in NFC", (int) sz, buf);
1847 free (buf);
1848 }
1849}
1850
1851static const cppchar_t utf8_signifier = 0xC0;
1852
1853/* Returns TRUE if the sequence starting at buffer->cur is valid in
1854 an identifier. FIRST is TRUE if this starts an identifier. */
1855
1856static bool
1857forms_identifier_p (cpp_reader *pfile, int first,
1858 struct normalize_state *state)
1859{
1860 cpp_buffer *buffer = pfile->buffer;
1861 const bool warn_bidi_p = pfile->warn_bidi_p ();
8
Calling 'cpp_reader::warn_bidi_p'
11
Returning from 'cpp_reader::warn_bidi_p'
1862
1863 if (*buffer->cur == '$')
12
Assuming the condition is false
13
Taking false branch
1864 {
1865 if (!CPP_OPTION (pfile, dollars_in_ident)((pfile)->opts.dollars_in_ident))
1866 return false;
1867
1868 buffer->cur++;
1869 if (CPP_OPTION (pfile, warn_dollars)((pfile)->opts.warn_dollars) && !pfile->state.skipping)
1870 {
1871 CPP_OPTION (pfile, warn_dollars)((pfile)->opts.warn_dollars) = 0;
1872 cpp_error (pfile, CPP_DL_PEDWARN, "'$' in identifier or number");
1873 }
1874
1875 return true;
1876 }
1877
1878 /* Is this a syntactically valid UCN or a valid UTF-8 char? */
1879 if (CPP_OPTION (pfile, extended_identifiers)((pfile)->opts.extended_identifiers))
14
Assuming field 'extended_identifiers' is not equal to 0
15
Taking true branch
1880 {
1881 cppchar_t s;
1882 if (*buffer->cur >= utf8_signifier)
16
Assuming the condition is true
17
Taking true branch
1883 {
1884 if (__builtin_expect (*buffer->cur == bidi::utf8_start, 0)
18
Assuming the condition is true
19
Taking true branch
1885 && warn_bidi_p
18.1
'warn_bidi_p' is true
18.1
'warn_bidi_p' is true
)
1886 {
1887 location_t loc;
20
'loc' declared without an initial value
1888 bidi::kind kind = get_bidi_utf8 (pfile, buffer->cur, &loc);
21
Calling 'get_bidi_utf8'
24
Returning from 'get_bidi_utf8'
1889 maybe_warn_bidi_on_char (pfile, kind, /*ucn_p=*/false, loc);
25
4th function call argument is an uninitialized value
1890 }
1891 if (_cpp_valid_utf8 (pfile, &buffer->cur, buffer->rlimit, 1 + !first,
1892 state, &s))
1893 return true;
1894 }
1895 else if (*buffer->cur == '\\'
1896 && (buffer->cur[1] == 'u' || buffer->cur[1] == 'U'))
1897 {
1898 buffer->cur += 2;
1899 if (warn_bidi_p)
1900 {
1901 location_t loc;
1902 bidi::kind kind = get_bidi_ucn (pfile,
1903 buffer->cur,
1904 buffer->cur[-1] == 'U',
1905 &loc);
1906 maybe_warn_bidi_on_char (pfile, kind, /*ucn_p=*/true, loc);
1907 }
1908 if (_cpp_valid_ucn (pfile, &buffer->cur, buffer->rlimit, 1 + !first,
1909 state, &s, NULL__null, NULL__null))
1910 return true;
1911 buffer->cur -= 2;
1912 }
1913 }
1914
1915 return false;
1916}
1917
1918/* Helper function to issue error about improper __VA_OPT__ use. */
1919static void
1920maybe_va_opt_error (cpp_reader *pfile)
1921{
1922 if (CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic) && !CPP_OPTION (pfile, va_opt)((pfile)->opts.va_opt))
1923 {
1924 /* __VA_OPT__ should not be accepted at all, but allow it in
1925 system headers. */
1926 if (!_cpp_in_system_header (pfile))
1927 cpp_error (pfile, CPP_DL_PEDWARN,
1928 "__VA_OPT__ is not available until C++20");
1929 }
1930 else if (!pfile->state.va_args_ok)
1931 {
1932 /* __VA_OPT__ should only appear in the replacement list of a
1933 variadic macro. */
1934 cpp_error (pfile, CPP_DL_PEDWARN,
1935 "__VA_OPT__ can only appear in the expansion"
1936 " of a C++20 variadic macro");
1937 }
1938}
1939
1940/* Helper function to get the cpp_hashnode of the identifier BASE. */
1941static cpp_hashnode *
1942lex_identifier_intern (cpp_reader *pfile, const uchar *base)
1943{
1944 cpp_hashnode *result;
1945 const uchar *cur;
1946 unsigned int len;
1947 unsigned int hash = HT_HASHSTEP (0, *base)((0) * 67 + ((*base) - 113));;
1948
1949 cur = base + 1;
1950 while (ISIDNUM (*cur)(_sch_istable[(*cur) & 0xff] & (unsigned short)(_sch_isidnum
))
)
1951 {
1952 hash = HT_HASHSTEP (hash, *cur)((hash) * 67 + ((*cur) - 113));;
1953 cur++;
1954 }
1955 len = cur - base;
1956 hash = HT_HASHFINISH (hash, len)((hash) + (len));
1957 result = CPP_HASHNODE (ht_lookup_with_hash (pfile->hash_table,((cpp_hashnode *) (ht_lookup_with_hash (pfile->hash_table,
base, len, hash, HT_ALLOC)))
1958 base, len, hash, HT_ALLOC))((cpp_hashnode *) (ht_lookup_with_hash (pfile->hash_table,
base, len, hash, HT_ALLOC)))
;
1959
1960 /* Rarely, identifiers require diagnostics when lexed. */
1961 if (__builtin_expect ((result->flags & NODE_DIAGNOSTIC(1 << 2))
1962 && !pfile->state.skipping, 0))
1963 {
1964 /* It is allowed to poison the same identifier twice. */
1965 if ((result->flags & NODE_POISONED(1 << 1)) && !pfile->state.poisoned_ok)
1966 cpp_error (pfile, CPP_DL_ERROR, "attempt to use poisoned \"%s\"",
1967 NODE_NAME (result)(((&(result)->ident))->str));
1968
1969 /* Constraint 6.10.3.5: __VA_ARGS__ should only appear in the
1970 replacement list of a variadic macro. */
1971 if (result == pfile->spec_nodes.n__VA_ARGS__
1972 && !pfile->state.va_args_ok)
1973 {
1974 if (CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus))
1975 cpp_error (pfile, CPP_DL_PEDWARN,
1976 "__VA_ARGS__ can only appear in the expansion"
1977 " of a C++11 variadic macro");
1978 else
1979 cpp_error (pfile, CPP_DL_PEDWARN,
1980 "__VA_ARGS__ can only appear in the expansion"
1981 " of a C99 variadic macro");
1982 }
1983
1984 if (result == pfile->spec_nodes.n__VA_OPT__)
1985 maybe_va_opt_error (pfile);
1986
1987 /* For -Wc++-compat, warn about use of C++ named operators. */
1988 if (result->flags & NODE_WARN_OPERATOR(1 << 7))
1989 cpp_warning (pfile, CPP_W_CXX_OPERATOR_NAMES,
1990 "identifier \"%s\" is a special operator name in C++",
1991 NODE_NAME (result)(((&(result)->ident))->str));
1992 }
1993
1994 return result;
1995}
1996
1997/* Get the cpp_hashnode of an identifier specified by NAME in
1998 the current cpp_reader object. If none is found, NULL is returned. */
1999cpp_hashnode *
2000_cpp_lex_identifier (cpp_reader *pfile, const char *name)
2001{
2002 cpp_hashnode *result;
2003 result = lex_identifier_intern (pfile, (uchar *) name);
2004 return result;
2005}
2006
2007/* Lex an identifier starting at BUFFER->CUR - 1. */
2008static cpp_hashnode *
2009lex_identifier (cpp_reader *pfile, const uchar *base, bool starts_ucn,
2010 struct normalize_state *nst, cpp_hashnode **spelling)
2011{
2012 cpp_hashnode *result;
2013 const uchar *cur;
2014 unsigned int len;
2015 unsigned int hash = HT_HASHSTEP (0, *base)((0) * 67 + ((*base) - 113));;
2016 const bool warn_bidi_p = pfile->warn_bidi_p ();
2017
2018 cur = pfile->buffer->cur;
2019 if (! starts_ucn)
2020 {
2021 while (ISIDNUM (*cur)(_sch_istable[(*cur) & 0xff] & (unsigned short)(_sch_isidnum
))
)
2022 {
2023 hash = HT_HASHSTEP (hash, *cur)((hash) * 67 + ((*cur) - 113));;
2024 cur++;
2025 }
2026 NORMALIZE_STATE_UPDATE_IDNUM (nst, *(cur - 1))((nst)->previous = (*(cur - 1)), (nst)->prev_class = 0);
2027 }
2028 pfile->buffer->cur = cur;
2029 if (starts_ucn || forms_identifier_p (pfile, false, nst))
2030 {
2031 /* Slower version for identifiers containing UCNs
2032 or extended chars (including $). */
2033 do {
2034 while (ISIDNUM (*pfile->buffer->cur)(_sch_istable[(*pfile->buffer->cur) & 0xff] & (
unsigned short)(_sch_isidnum))
)
2035 {
2036 NORMALIZE_STATE_UPDATE_IDNUM (nst, *pfile->buffer->cur)((nst)->previous = (*pfile->buffer->cur), (nst)->
prev_class = 0)
;
2037 pfile->buffer->cur++;
2038 }
2039 } while (forms_identifier_p (pfile, false, nst));
2040 if (warn_bidi_p)
2041 maybe_warn_bidi_on_close (pfile, pfile->buffer->cur);
2042 result = _cpp_interpret_identifier (pfile, base,
2043 pfile->buffer->cur - base);
2044 *spelling = cpp_lookup (pfile, base, pfile->buffer->cur - base);
2045 }
2046 else
2047 {
2048 len = cur - base;
2049 hash = HT_HASHFINISH (hash, len)((hash) + (len));
2050
2051 result = CPP_HASHNODE (ht_lookup_with_hash (pfile->hash_table,((cpp_hashnode *) (ht_lookup_with_hash (pfile->hash_table,
base, len, hash, HT_ALLOC)))
2052 base, len, hash, HT_ALLOC))((cpp_hashnode *) (ht_lookup_with_hash (pfile->hash_table,
base, len, hash, HT_ALLOC)))
;
2053 *spelling = result;
2054 }
2055
2056 /* Rarely, identifiers require diagnostics when lexed. */
2057 if (__builtin_expect ((result->flags & NODE_DIAGNOSTIC(1 << 2))
2058 && !pfile->state.skipping, 0))
2059 {
2060 /* It is allowed to poison the same identifier twice. */
2061 if ((result->flags & NODE_POISONED(1 << 1)) && !pfile->state.poisoned_ok)
2062 cpp_error (pfile, CPP_DL_ERROR, "attempt to use poisoned \"%s\"",
2063 NODE_NAME (result)(((&(result)->ident))->str));
2064
2065 /* Constraint 6.10.3.5: __VA_ARGS__ should only appear in the
2066 replacement list of a variadic macro. */
2067 if (result == pfile->spec_nodes.n__VA_ARGS__
2068 && !pfile->state.va_args_ok)
2069 {
2070 if (CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus))
2071 cpp_error (pfile, CPP_DL_PEDWARN,
2072 "__VA_ARGS__ can only appear in the expansion"
2073 " of a C++11 variadic macro");
2074 else
2075 cpp_error (pfile, CPP_DL_PEDWARN,
2076 "__VA_ARGS__ can only appear in the expansion"
2077 " of a C99 variadic macro");
2078 }
2079
2080 /* __VA_OPT__ should only appear in the replacement list of a
2081 variadic macro. */
2082 if (result == pfile->spec_nodes.n__VA_OPT__)
2083 maybe_va_opt_error (pfile);
2084
2085 /* For -Wc++-compat, warn about use of C++ named operators. */
2086 if (result->flags & NODE_WARN_OPERATOR(1 << 7))
2087 cpp_warning (pfile, CPP_W_CXX_OPERATOR_NAMES,
2088 "identifier \"%s\" is a special operator name in C++",
2089 NODE_NAME (result)(((&(result)->ident))->str));
2090 }
2091
2092 return result;
2093}
2094
2095/* Lex a number to NUMBER starting at BUFFER->CUR - 1. */
2096static void
2097lex_number (cpp_reader *pfile, cpp_string *number,
2098 struct normalize_state *nst)
2099{
2100 const uchar *cur;
2101 const uchar *base;
2102 uchar *dest;
2103
2104 base = pfile->buffer->cur - 1;
2105 do
2106 {
2107 const uchar *adj_digit_sep = NULL__null;
2108 cur = pfile->buffer->cur;
2109
2110 /* N.B. ISIDNUM does not include $. */
2111 while (ISIDNUM (*cur)(_sch_istable[(*cur) & 0xff] & (unsigned short)(_sch_isidnum
))
2112 || (*cur == '.' && !DIGIT_SEP (cur[-1])((cur[-1]) == '\'' && ((pfile)->opts.digit_separators
))
)
2113 || DIGIT_SEP (*cur)((*cur) == '\'' && ((pfile)->opts.digit_separators
))
2114 || (VALID_SIGN (*cur, cur[-1])(((*cur) == '+' || (*cur) == '-') && ((cur[-1]) == 'e'
|| (cur[-1]) == 'E' || (((cur[-1]) == 'p' || (cur[-1]) == 'P'
) && ((pfile)->opts.extended_numbers))))
&& !DIGIT_SEP (cur[-2])((cur[-2]) == '\'' && ((pfile)->opts.digit_separators
))
))
2115 {
2116 NORMALIZE_STATE_UPDATE_IDNUM (nst, *cur)((nst)->previous = (*cur), (nst)->prev_class = 0);
2117 /* Adjacent digit separators do not form part of the pp-number syntax.
2118 However, they can safely be diagnosed here as an error, since '' is
2119 not a valid preprocessing token. */
2120 if (DIGIT_SEP (*cur)((*cur) == '\'' && ((pfile)->opts.digit_separators
))
&& DIGIT_SEP (cur[-1])((cur[-1]) == '\'' && ((pfile)->opts.digit_separators
))
&& !adj_digit_sep)
2121 adj_digit_sep = cur;
2122 cur++;
2123 }
2124 /* A number can't end with a digit separator. */
2125 while (cur > pfile->buffer->cur && DIGIT_SEP (cur[-1])((cur[-1]) == '\'' && ((pfile)->opts.digit_separators
))
)
2126 --cur;
2127 if (adj_digit_sep && adj_digit_sep < cur)
2128 cpp_error (pfile, CPP_DL_ERROR, "adjacent digit separators");
2129
2130 pfile->buffer->cur = cur;
2131 }
2132 while (forms_identifier_p (pfile, false, nst));
2133
2134 number->len = cur - base;
2135 dest = _cpp_unaligned_alloc (pfile, number->len + 1);
2136 memcpy (dest, base, number->len);
2137 dest[number->len] = '\0';
2138 number->text = dest;
2139}
2140
2141/* Create a token of type TYPE with a literal spelling. */
2142static void
2143create_literal (cpp_reader *pfile, cpp_token *token, const uchar *base,
2144 unsigned int len, enum cpp_ttype type)
2145{
2146 token->type = type;
2147 token->val.str.len = len;
2148 token->val.str.text = cpp_alloc_token_string (pfile, base, len);
2149}
2150
2151const uchar *
2152cpp_alloc_token_string (cpp_reader *pfile,
2153 const unsigned char *ptr, unsigned len)
2154{
2155 uchar *dest = _cpp_unaligned_alloc (pfile, len + 1);
2156
2157 dest[len] = 0;
2158 memcpy (dest, ptr, len);
2159 return dest;
2160}
2161
2162/* A pair of raw buffer pointers. The currently open one is [1], the
2163 first one is [0]. Used for string literal lexing. */
2164struct lit_accum {
2165 _cpp_buff *first;
2166 _cpp_buff *last;
2167 const uchar *rpos;
2168 size_t accum;
2169
2170 lit_accum ()
2171 : first (NULL__null), last (NULL__null), rpos (0), accum (0)
2172 {
2173 }
2174
2175 void append (cpp_reader *, const uchar *, size_t);
2176
2177 void read_begin (cpp_reader *);
2178 bool reading_p () const
2179 {
2180 return rpos != NULL__null;
2181 }
2182 char read_char ()
2183 {
2184 char c = *rpos++;
2185 if (rpos == BUFF_FRONT (last)((last)->cur))
2186 rpos = NULL__null;
2187 return c;
2188 }
2189};
2190
2191/* Subroutine of lex_raw_string: Append LEN chars from BASE to the buffer
2192 sequence from *FIRST_BUFF_P to LAST_BUFF_P. */
2193
2194void
2195lit_accum::append (cpp_reader *pfile, const uchar *base, size_t len)
2196{
2197 if (!last)
2198 /* Starting. */
2199 first = last = _cpp_get_buff (pfile, len);
2200 else if (len > BUFF_ROOM (last)(size_t) ((last)->limit - (last)->cur))
2201 {
2202 /* There is insufficient room in the buffer. Copy what we can,
2203 and then either extend or create a new one. */
2204 size_t room = BUFF_ROOM (last)(size_t) ((last)->limit - (last)->cur);
2205 memcpy (BUFF_FRONT (last)((last)->cur), base, room);
2206 BUFF_FRONT (last)((last)->cur) += room;
2207 base += room;
2208 len -= room;
2209 accum += room;
2210
2211 gcc_checking_assert (!rpos)((void)(!(!rpos) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 2211, __FUNCTION__), 0 : 0))
;
2212
2213 last = _cpp_append_extend_buff (pfile, last, len);
2214 }
2215
2216 memcpy (BUFF_FRONT (last)((last)->cur), base, len);
2217 BUFF_FRONT (last)((last)->cur) += len;
2218 accum += len;
2219}
2220
2221void
2222lit_accum::read_begin (cpp_reader *pfile)
2223{
2224 /* We never accumulate more than 4 chars to read. */
2225 if (BUFF_ROOM (last)(size_t) ((last)->limit - (last)->cur) < 4)
2226
2227 last = _cpp_append_extend_buff (pfile, last, 4);
2228 rpos = BUFF_FRONT (last)((last)->cur);
2229}
2230
2231/* Returns true if a macro has been defined.
2232 This might not work if compile with -save-temps,
2233 or preprocess separately from compilation. */
2234
2235static bool
2236is_macro(cpp_reader *pfile, const uchar *base)
2237{
2238 const uchar *cur = base;
2239 if (! ISIDST (*cur)(_sch_istable[(*cur) & 0xff] & (unsigned short)(_sch_isidst
))
)
2240 return false;
2241 unsigned int hash = HT_HASHSTEP (0, *cur)((0) * 67 + ((*cur) - 113));;
2242 ++cur;
2243 while (ISIDNUM (*cur)(_sch_istable[(*cur) & 0xff] & (unsigned short)(_sch_isidnum
))
)
2244 {
2245 hash = HT_HASHSTEP (hash, *cur)((hash) * 67 + ((*cur) - 113));;
2246 ++cur;
2247 }
2248 hash = HT_HASHFINISH (hash, cur - base)((hash) + (cur - base));
2249
2250 cpp_hashnode *result = CPP_HASHNODE (ht_lookup_with_hash (pfile->hash_table,((cpp_hashnode *) (ht_lookup_with_hash (pfile->hash_table,
base, cur - base, hash, HT_NO_INSERT)))
2251 base, cur - base, hash, HT_NO_INSERT))((cpp_hashnode *) (ht_lookup_with_hash (pfile->hash_table,
base, cur - base, hash, HT_NO_INSERT)))
;
2252
2253 return result && cpp_macro_p (result);
2254}
2255
2256/* Returns true if a literal suffix does not have the expected form
2257 and is defined as a macro. */
2258
2259static bool
2260is_macro_not_literal_suffix(cpp_reader *pfile, const uchar *base)
2261{
2262 /* User-defined literals outside of namespace std must start with a single
2263 underscore, so assume anything of that form really is a UDL suffix.
2264 We don't need to worry about UDLs defined inside namespace std because
2265 their names are reserved, so cannot be used as macro names in valid
2266 programs. */
2267 if (base[0] == '_' && base[1] != '_')
2268 return false;
2269 return is_macro (pfile, base);
2270}
2271
2272/* Lexes a raw string. The stored string contains the spelling,
2273 including double quotes, delimiter string, '(' and ')', any leading
2274 'L', 'u', 'U' or 'u8' and 'R' modifier. The created token contains
2275 the type of the literal, or CPP_OTHER if it was not properly
2276 terminated.
2277
2278 BASE is the start of the token. Updates pfile->buffer->cur to just
2279 after the lexed string.
2280
2281 The spelling is NUL-terminated, but it is not guaranteed that this
2282 is the first NUL since embedded NULs are preserved. */
2283
2284static void
2285lex_raw_string (cpp_reader *pfile, cpp_token *token, const uchar *base)
2286{
2287 const uchar *pos = base;
2288 const bool warn_bidi_p = pfile->warn_bidi_p ();
2289
2290 /* 'tis a pity this information isn't passed down from the lexer's
2291 initial categorization of the token. */
2292 enum cpp_ttype type = CPP_STRING;
2293
2294 if (*pos == 'L')
2295 {
2296 type = CPP_WSTRING;
2297 pos++;
2298 }
2299 else if (*pos == 'U')
2300 {
2301 type = CPP_STRING32;
2302 pos++;
2303 }
2304 else if (*pos == 'u')
2305 {
2306 if (pos[1] == '8')
2307 {
2308 type = CPP_UTF8STRING;
2309 pos++;
2310 }
2311 else
2312 type = CPP_STRING16;
2313 pos++;
2314 }
2315
2316 gcc_checking_assert (pos[0] == 'R' && pos[1] == '"')((void)(!(pos[0] == 'R' && pos[1] == '"') ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 2316, __FUNCTION__), 0 : 0))
;
2317 pos += 2;
2318
2319 _cpp_line_note *note = &pfile->buffer->notes[pfile->buffer->cur_note];
2320
2321 /* Skip notes before the ". */
2322 while (note->pos < pos)
2323 ++note;
2324
2325 lit_accum accum;
2326
2327 uchar prefix[17];
2328 unsigned prefix_len = 0;
2329 enum Phase
2330 {
2331 PHASE_PREFIX = -2,
2332 PHASE_NONE = -1,
2333 PHASE_SUFFIX = 0
2334 } phase = PHASE_PREFIX;
2335
2336 for (;;)
2337 {
2338 gcc_checking_assert (note->pos >= pos)((void)(!(note->pos >= pos) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 2338, __FUNCTION__), 0 : 0))
;
2339
2340 /* Undo any escaped newlines and trigraphs. */
2341 if (!accum.reading_p () && note->pos == pos)
2342 switch (note->type)
2343 {
2344 case '\\':
2345 case ' ':
2346 /* Restore backslash followed by newline. */
2347 accum.append (pfile, base, pos - base);
2348 base = pos;
2349 accum.read_begin (pfile);
2350 accum.append (pfile, UC(const uchar *)"\\", 1);
2351
2352 after_backslash:
2353 if (note->type == ' ')
2354 /* GNU backslash whitespace newline extension. FIXME
2355 could be any sequence of non-vertical space. When we
2356 can properly restore any such sequence, we should
2357 mark this note as handled so _cpp_process_line_notes
2358 doesn't warn. */
2359 accum.append (pfile, UC(const uchar *)" ", 1);
2360
2361 accum.append (pfile, UC(const uchar *)"\n", 1);
2362 note++;
2363 break;
2364
2365 case '\n':
2366 /* This can happen for ??/<NEWLINE> when trigraphs are not
2367 being interpretted. */
2368 gcc_checking_assert (!CPP_OPTION (pfile, trigraphs))((void)(!(!((pfile)->opts.trigraphs)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 2368, __FUNCTION__), 0 : 0))
;
2369 note->type = 0;
2370 note++;
2371 break;
2372
2373 default:
2374 gcc_checking_assert (_cpp_trigraph_map[note->type])((void)(!(_cpp_trigraph_map[note->type]) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 2374, __FUNCTION__), 0 : 0))
;
2375
2376 /* Don't warn about this trigraph in
2377 _cpp_process_line_notes, since trigraphs show up as
2378 trigraphs in raw strings. */
2379 uchar type = note->type;
2380 note->type = 0;
2381
2382 if (CPP_OPTION (pfile, trigraphs)((pfile)->opts.trigraphs))
2383 {
2384 accum.append (pfile, base, pos - base);
2385 base = pos;
2386 accum.read_begin (pfile);
2387 accum.append (pfile, UC(const uchar *)"??", 2);
2388 accum.append (pfile, &type, 1);
2389
2390 /* ??/ followed by newline gets two line notes, one for
2391 the trigraph and one for the backslash/newline. */
2392 if (type == '/' && note[1].pos == pos)
2393 {
2394 note++;
2395 gcc_assert (note->type == '\\' || note->type == ' ')((void)(!(note->type == '\\' || note->type == ' ') ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 2395, __FUNCTION__), 0 : 0))
;
2396 goto after_backslash;
2397 }
2398 /* Skip the replacement character. */
2399 base = ++pos;
2400 }
2401
2402 note++;
2403 break;
2404 }
2405
2406 /* Now get a char to process. Either from an expanded note, or
2407 from the line buffer. */
2408 bool read_note = accum.reading_p ();
2409 char c = read_note ? accum.read_char () : *pos++;
2410
2411 if (phase == PHASE_PREFIX)
2412 {
2413 if (c == '(')
2414 {
2415 /* Done. */
2416 phase = PHASE_NONE;
2417 prefix[prefix_len++] = '"';
2418 }
2419 else if (prefix_len < 16
2420 /* Prefix chars are any of the basic character set,
2421 [lex.charset] except for '
2422 ()\\\t\v\f\n'. Optimized for a contiguous
2423 alphabet. */
2424 /* Unlike a switch, this collapses down to one or
2425 two shift and bitmask operations on an ASCII
2426 system, with an outlier or two. */
2427 && (('Z' - 'A' == 25
2428 ? ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
2429 : ISIDST (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isidst
))
)
2430 || (c >= '0' && c <= '9')
2431 || c == '_' || c == '{' || c == '}'
2432 || c == '[' || c == ']' || c == '#'
2433 || c == '<' || c == '>' || c == '%'
2434 || c == ':' || c == ';' || c == '.' || c == '?'
2435 || c == '*' || c == '+' || c == '-' || c == '/'
2436 || c == '^' || c == '&' || c == '|' || c == '~'
2437 || c == '!' || c == '=' || c == ','
2438 || c == '"' || c == '\''))
2439 prefix[prefix_len++] = c;
2440 else
2441 {
2442 /* Something is wrong. */
2443 int col = CPP_BUF_COLUMN (pfile->buffer, pos)((pos) - (pfile->buffer)->line_base) + read_note;
2444 if (prefix_len == 16)
2445 cpp_error_with_line (pfile, CPP_DL_ERROR, token->src_loc,
2446 col, "raw string delimiter longer "
2447 "than 16 characters");
2448 else if (c == '\n')
2449 cpp_error_with_line (pfile, CPP_DL_ERROR, token->src_loc,
2450 col, "invalid new-line in raw "
2451 "string delimiter");
2452 else
2453 cpp_error_with_line (pfile, CPP_DL_ERROR, token->src_loc,
2454 col, "invalid character '%c' in "
2455 "raw string delimiter", c);
2456 type = CPP_OTHER;
2457 phase = PHASE_NONE;
2458 /* Continue until we get a close quote, that's probably
2459 the best failure mode. */
2460 prefix_len = 0;
2461 }
2462 if (c != '\n')
2463 continue;
2464 }
2465
2466 if (phase != PHASE_NONE)
2467 {
2468 if (prefix[phase] != c)
2469 phase = PHASE_NONE;
2470 else if (unsigned (phase + 1) == prefix_len)
2471 break;
2472 else
2473 {
2474 phase = Phase (phase + 1);
2475 continue;
2476 }
2477 }
2478
2479 if (!prefix_len && c == '"')
2480 /* Failure mode lexing. */
2481 goto out;
2482 else if (prefix_len && c == ')')
2483 phase = PHASE_SUFFIX;
2484 else if (!read_note && c == '\n')
2485 {
2486 pos--;
2487 pfile->buffer->cur = pos;
2488 if (pfile->state.in_directive
2489 || (pfile->state.parsing_args
2490 && pfile->buffer->next_line >= pfile->buffer->rlimit))
2491 {
2492 cpp_error_with_line (pfile, CPP_DL_ERROR, token->src_loc, 0,
2493 "unterminated raw string");
2494 type = CPP_OTHER;
2495 goto out;
2496 }
2497
2498 accum.append (pfile, base, pos - base + 1);
2499 _cpp_process_line_notes (pfile, false);
2500
2501 if (pfile->buffer->next_line < pfile->buffer->rlimit)
2502 CPP_INCREMENT_LINE (pfile, 0)do { const class line_maps *line_table = pfile->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (pfile->line_table,
line + 1, 0); } while (0)
;
2503 pfile->buffer->need_line = true;
2504
2505 if (!_cpp_get_fresh_line (pfile))
2506 {
2507 /* We ran out of file and failed to get a line. */
2508 location_t src_loc = token->src_loc;
2509 token->type = CPP_EOF;
2510 /* Tell the compiler the line number of the EOF token. */
2511 token->src_loc = pfile->line_table->highest_line;
2512 token->flags = BOL(1 << 6);
2513 if (accum.first)
2514 _cpp_release_buff (pfile, accum.first);
2515 cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
2516 "unterminated raw string");
2517 /* Now pop the buffer that _cpp_get_fresh_line did not. */
2518 _cpp_pop_buffer (pfile);
2519 return;
2520 }
2521
2522 pos = base = pfile->buffer->cur;
2523 note = &pfile->buffer->notes[pfile->buffer->cur_note];
2524 }
2525 else if (__builtin_expect ((unsigned char) c == bidi::utf8_start, 0)
2526 && warn_bidi_p)
2527 {
2528 location_t loc;
2529 bidi::kind kind = get_bidi_utf8 (pfile, pos - 1, &loc);
2530 maybe_warn_bidi_on_char (pfile, kind, /*ucn_p=*/false, loc);
2531 }
2532 }
2533
2534 if (warn_bidi_p)
2535 maybe_warn_bidi_on_close (pfile, pos);
2536
2537 if (CPP_OPTION (pfile, user_literals)((pfile)->opts.user_literals))
2538 {
2539 /* If a string format macro, say from inttypes.h, is placed touching
2540 a string literal it could be parsed as a C++11 user-defined string
2541 literal thus breaking the program. */
2542 if (is_macro_not_literal_suffix (pfile, pos))
2543 {
2544 /* Raise a warning, but do not consume subsequent tokens. */
2545 if (CPP_OPTION (pfile, warn_literal_suffix)((pfile)->opts.warn_literal_suffix) && !pfile->state.skipping)
2546 cpp_warning_with_line (pfile, CPP_W_LITERAL_SUFFIX,
2547 token->src_loc, 0,
2548 "invalid suffix on literal; C++11 requires "
2549 "a space between literal and string macro");
2550 }
2551 /* Grab user defined literal suffix. */
2552 else if (ISIDST (*pos)(_sch_istable[(*pos) & 0xff] & (unsigned short)(_sch_isidst
))
)
2553 {
2554 type = cpp_userdef_string_add_type (type);
2555 ++pos;
2556
2557 while (ISIDNUM (*pos)(_sch_istable[(*pos) & 0xff] & (unsigned short)(_sch_isidnum
))
)
2558 ++pos;
2559 }
2560 }
2561
2562 out:
2563 pfile->buffer->cur = pos;
2564 if (!accum.accum)
2565 create_literal (pfile, token, base, pos - base, type);
2566 else
2567 {
2568 size_t extra_len = pos - base;
2569 uchar *dest = _cpp_unaligned_alloc (pfile, accum.accum + extra_len + 1);
2570
2571 token->type = type;
2572 token->val.str.len = accum.accum + extra_len;
2573 token->val.str.text = dest;
2574 for (_cpp_buff *buf = accum.first; buf; buf = buf->next)
2575 {
2576 size_t len = BUFF_FRONT (buf)((buf)->cur) - buf->base;
2577 memcpy (dest, buf->base, len);
2578 dest += len;
2579 }
2580 _cpp_release_buff (pfile, accum.first);
2581 memcpy (dest, base, extra_len);
2582 dest[extra_len] = '\0';
2583 }
2584}
2585
2586/* Lexes a string, character constant, or angle-bracketed header file
2587 name. The stored string contains the spelling, including opening
2588 quote and any leading 'L', 'u', 'U' or 'u8' and optional
2589 'R' modifier. It returns the type of the literal, or CPP_OTHER
2590 if it was not properly terminated, or CPP_LESS for an unterminated
2591 header name which must be relexed as normal tokens.
2592
2593 The spelling is NUL-terminated, but it is not guaranteed that this
2594 is the first NUL since embedded NULs are preserved. */
2595static void
2596lex_string (cpp_reader *pfile, cpp_token *token, const uchar *base)
2597{
2598 bool saw_NUL = false;
2599 const uchar *cur;
2600 cppchar_t terminator;
2601 enum cpp_ttype type;
2602
2603 cur = base;
2604 terminator = *cur++;
2605 if (terminator == 'L' || terminator == 'U')
2606 terminator = *cur++;
2607 else if (terminator == 'u')
2608 {
2609 terminator = *cur++;
2610 if (terminator == '8')
2611 terminator = *cur++;
2612 }
2613 if (terminator == 'R')
2614 {
2615 lex_raw_string (pfile, token, base);
2616 return;
2617 }
2618 if (terminator == '"')
2619 type = (*base == 'L' ? CPP_WSTRING :
2620 *base == 'U' ? CPP_STRING32 :
2621 *base == 'u' ? (base[1] == '8' ? CPP_UTF8STRING : CPP_STRING16)
2622 : CPP_STRING);
2623 else if (terminator == '\'')
2624 type = (*base == 'L' ? CPP_WCHAR :
2625 *base == 'U' ? CPP_CHAR32 :
2626 *base == 'u' ? (base[1] == '8' ? CPP_UTF8CHAR : CPP_CHAR16)
2627 : CPP_CHAR);
2628 else
2629 terminator = '>', type = CPP_HEADER_NAME;
2630
2631 const bool warn_bidi_p = pfile->warn_bidi_p ();
2632 for (;;)
2633 {
2634 cppchar_t c = *cur++;
2635
2636 /* In #include-style directives, terminators are not escapable. */
2637 if (c == '\\' && !pfile->state.angled_headers && *cur != '\n')
2638 {
2639 if ((cur[0] == 'u' || cur[0] == 'U') && warn_bidi_p)
2640 {
2641 location_t loc;
2642 bidi::kind kind = get_bidi_ucn (pfile, cur + 1, cur[0] == 'U',
2643 &loc);
2644 maybe_warn_bidi_on_char (pfile, kind, /*ucn_p=*/true, loc);
2645 }
2646 cur++;
2647 }
2648 else if (c == terminator)
2649 {
2650 if (warn_bidi_p)
2651 maybe_warn_bidi_on_close (pfile, cur - 1);
2652 break;
2653 }
2654 else if (c == '\n')
2655 {
2656 cur--;
2657 /* Unmatched quotes always yield undefined behavior, but
2658 greedy lexing means that what appears to be an unterminated
2659 header name may actually be a legitimate sequence of tokens. */
2660 if (terminator == '>')
2661 {
2662 token->type = CPP_LESS;
2663 return;
2664 }
2665 type = CPP_OTHER;
2666 break;
2667 }
2668 else if (c == '\0')
2669 saw_NUL = true;
2670 else if (__builtin_expect (c == bidi::utf8_start, 0) && warn_bidi_p)
2671 {
2672 location_t loc;
2673 bidi::kind kind = get_bidi_utf8 (pfile, cur - 1, &loc);
2674 maybe_warn_bidi_on_char (pfile, kind, /*ucn_p=*/false, loc);
2675 }
2676 }
2677
2678 if (saw_NUL && !pfile->state.skipping)
2679 cpp_error (pfile, CPP_DL_WARNING,
2680 "null character(s) preserved in literal");
2681
2682 if (type == CPP_OTHER && CPP_OPTION (pfile, lang)((pfile)->opts.lang) != CLK_ASM)
2683 cpp_error (pfile, CPP_DL_PEDWARN, "missing terminating %c character",
2684 (int) terminator);
2685
2686 if (CPP_OPTION (pfile, user_literals)((pfile)->opts.user_literals))
2687 {
2688 /* If a string format macro, say from inttypes.h, is placed touching
2689 a string literal it could be parsed as a C++11 user-defined string
2690 literal thus breaking the program. */
2691 if (is_macro_not_literal_suffix (pfile, cur))
2692 {
2693 /* Raise a warning, but do not consume subsequent tokens. */
2694 if (CPP_OPTION (pfile, warn_literal_suffix)((pfile)->opts.warn_literal_suffix) && !pfile->state.skipping)
2695 cpp_warning_with_line (pfile, CPP_W_LITERAL_SUFFIX,
2696 token->src_loc, 0,
2697 "invalid suffix on literal; C++11 requires "
2698 "a space between literal and string macro");
2699 }
2700 /* Grab user defined literal suffix. */
2701 else if (ISIDST (*cur)(_sch_istable[(*cur) & 0xff] & (unsigned short)(_sch_isidst
))
)
2702 {
2703 type = cpp_userdef_char_add_type (type);
2704 type = cpp_userdef_string_add_type (type);
2705 ++cur;
2706
2707 while (ISIDNUM (*cur)(_sch_istable[(*cur) & 0xff] & (unsigned short)(_sch_isidnum
))
)
2708 ++cur;
2709 }
2710 }
2711 else if (CPP_OPTION (pfile, cpp_warn_cxx11_compat)((pfile)->opts.cpp_warn_cxx11_compat)
2712 && is_macro (pfile, cur)
2713 && !pfile->state.skipping)
2714 cpp_warning_with_line (pfile, CPP_W_CXX11_COMPAT,
2715 token->src_loc, 0, "C++11 requires a space "
2716 "between string literal and macro");
2717
2718 pfile->buffer->cur = cur;
2719 create_literal (pfile, token, base, cur - base, type);
2720}
2721
2722/* Return the comment table. The client may not make any assumption
2723 about the ordering of the table. */
2724cpp_comment_table *
2725cpp_get_comments (cpp_reader *pfile)
2726{
2727 return &pfile->comments;
2728}
2729
2730/* Append a comment to the end of the comment table. */
2731static void
2732store_comment (cpp_reader *pfile, cpp_token *token)
2733{
2734 int len;
2735
2736 if (pfile->comments.allocated == 0)
2737 {
2738 pfile->comments.allocated = 256;
2739 pfile->comments.entries = (cpp_comment *) xmalloc
2740 (pfile->comments.allocated * sizeof (cpp_comment));
2741 }
2742
2743 if (pfile->comments.count == pfile->comments.allocated)
2744 {
2745 pfile->comments.allocated *= 2;
2746 pfile->comments.entries = (cpp_comment *) xrealloc
2747 (pfile->comments.entries,
2748 pfile->comments.allocated * sizeof (cpp_comment));
2749 }
2750
2751 len = token->val.str.len;
2752
2753 /* Copy comment. Note, token may not be NULL terminated. */
2754 pfile->comments.entries[pfile->comments.count].comment =
2755 (char *) xmalloc (sizeof (char) * (len + 1));
2756 memcpy (pfile->comments.entries[pfile->comments.count].comment,
2757 token->val.str.text, len);
2758 pfile->comments.entries[pfile->comments.count].comment[len] = '\0';
2759
2760 /* Set source location. */
2761 pfile->comments.entries[pfile->comments.count].sloc = token->src_loc;
2762
2763 /* Increment the count of entries in the comment table. */
2764 pfile->comments.count++;
2765}
2766
2767/* The stored comment includes the comment start and any terminator. */
2768static void
2769save_comment (cpp_reader *pfile, cpp_token *token, const unsigned char *from,
2770 cppchar_t type)
2771{
2772 unsigned char *buffer;
2773 unsigned int len, clen, i;
2774
2775 len = pfile->buffer->cur - from + 1; /* + 1 for the initial '/'. */
2776
2777 /* C++ comments probably (not definitely) have moved past a new
2778 line, which we don't want to save in the comment. */
2779 if (is_vspace (pfile->buffer->cur[-1])(_sch_istable[(pfile->buffer->cur[-1]) & 0xff] &
(unsigned short)(_sch_isvsp))
)
2780 len--;
2781
2782 /* If we are currently in a directive or in argument parsing, then
2783 we need to store all C++ comments as C comments internally, and
2784 so we need to allocate a little extra space in that case.
2785
2786 Note that the only time we encounter a directive here is
2787 when we are saving comments in a "#define". */
2788 clen = ((pfile->state.in_directive || pfile->state.parsing_args)
2789 && type == '/') ? len + 2 : len;
2790
2791 buffer = _cpp_unaligned_alloc (pfile, clen);
2792
2793 token->type = CPP_COMMENT;
2794 token->val.str.len = clen;
2795 token->val.str.text = buffer;
2796
2797 buffer[0] = '/';
2798 memcpy (buffer + 1, from, len - 1);
2799
2800 /* Finish conversion to a C comment, if necessary. */
2801 if ((pfile->state.in_directive || pfile->state.parsing_args) && type == '/')
2802 {
2803 buffer[1] = '*';
2804 buffer[clen - 2] = '*';
2805 buffer[clen - 1] = '/';
2806 /* As there can be in a C++ comments illegal sequences for C comments
2807 we need to filter them out. */
2808 for (i = 2; i < (clen - 2); i++)
2809 if (buffer[i] == '/' && (buffer[i - 1] == '*' || buffer[i + 1] == '*'))
2810 buffer[i] = '|';
2811 }
2812
2813 /* Finally store this comment for use by clients of libcpp. */
2814 store_comment (pfile, token);
2815}
2816
2817/* Returns true if comment at COMMENT_START is a recognized FALLTHROUGH
2818 comment. */
2819
2820static bool
2821fallthrough_comment_p (cpp_reader *pfile, const unsigned char *comment_start)
2822{
2823 const unsigned char *from = comment_start + 1;
2824
2825 switch (CPP_OPTION (pfile, cpp_warn_implicit_fallthrough)((pfile)->opts.cpp_warn_implicit_fallthrough))
2826 {
2827 /* For both -Wimplicit-fallthrough=0 and -Wimplicit-fallthrough=5 we
2828 don't recognize any comments. The latter only checks attributes,
2829 the former doesn't warn. */
2830 case 0:
2831 default:
2832 return false;
2833 /* -Wimplicit-fallthrough=1 considers any comment, no matter what
2834 content it has. */
2835 case 1:
2836 return true;
2837 case 2:
2838 /* -Wimplicit-fallthrough=2 looks for (case insensitive)
2839 .*falls?[ \t-]*thr(u|ough).* regex. */
2840 for (; (size_t) (pfile->buffer->cur - from) >= sizeof "fallthru" - 1;
2841 from++)
2842 {
2843 /* Is there anything like strpbrk with upper boundary, or
2844 memchr looking for 2 characters rather than just one? */
2845 if (from[0] != 'f' && from[0] != 'F')
2846 continue;
2847 if (from[1] != 'a' && from[1] != 'A')
2848 continue;
2849 if (from[2] != 'l' && from[2] != 'L')
2850 continue;
2851 if (from[3] != 'l' && from[3] != 'L')
2852 continue;
2853 from += sizeof "fall" - 1;
2854 if (from[0] == 's' || from[0] == 'S')
2855 from++;
2856 while (*from == ' ' || *from == '\t' || *from == '-')
2857 from++;
2858 if (from[0] != 't' && from[0] != 'T')
2859 continue;
2860 if (from[1] != 'h' && from[1] != 'H')
2861 continue;
2862 if (from[2] != 'r' && from[2] != 'R')
2863 continue;
2864 if (from[3] == 'u' || from[3] == 'U')
2865 return true;
2866 if (from[3] != 'o' && from[3] != 'O')
2867 continue;
2868 if (from[4] != 'u' && from[4] != 'U')
2869 continue;
2870 if (from[5] != 'g' && from[5] != 'G')
2871 continue;
2872 if (from[6] != 'h' && from[6] != 'H')
2873 continue;
2874 return true;
2875 }
2876 return false;
2877 case 3:
2878 case 4:
2879 break;
2880 }
2881
2882 /* Whole comment contents:
2883 -fallthrough
2884 @fallthrough@
2885 */
2886 if (*from == '-' || *from == '@')
2887 {
2888 size_t len = sizeof "fallthrough" - 1;
2889 if ((size_t) (pfile->buffer->cur - from - 1) < len)
2890 return false;
2891 if (memcmp (from + 1, "fallthrough", len))
2892 return false;
2893 if (*from == '@')
2894 {
2895 if (from[len + 1] != '@')
2896 return false;
2897 len++;
2898 }
2899 from += 1 + len;
2900 }
2901 /* Whole comment contents (regex):
2902 lint -fallthrough[ \t]*
2903 */
2904 else if (*from == 'l')
2905 {
2906 size_t len = sizeof "int -fallthrough" - 1;
2907 if ((size_t) (pfile->buffer->cur - from - 1) < len)
2908 return false;
2909 if (memcmp (from + 1, "int -fallthrough", len))
2910 return false;
2911 from += 1 + len;
2912 while (*from == ' ' || *from == '\t')
2913 from++;
2914 }
2915 /* Whole comment contents (regex):
2916 [ \t]*FALLTHR(U|OUGH)[ \t]*
2917 */
2918 else if (CPP_OPTION (pfile, cpp_warn_implicit_fallthrough)((pfile)->opts.cpp_warn_implicit_fallthrough) == 4)
2919 {
2920 while (*from == ' ' || *from == '\t')
2921 from++;
2922 if ((size_t) (pfile->buffer->cur - from) < sizeof "FALLTHRU" - 1)
2923 return false;
2924 if (memcmp (from, "FALLTHR", sizeof "FALLTHR" - 1))
2925 return false;
2926 from += sizeof "FALLTHR" - 1;
2927 if (*from == 'U')
2928 from++;
2929 else if ((size_t) (pfile->buffer->cur - from) < sizeof "OUGH" - 1)
2930 return false;
2931 else if (memcmp (from, "OUGH", sizeof "OUGH" - 1))
2932 return false;
2933 else
2934 from += sizeof "OUGH" - 1;
2935 while (*from == ' ' || *from == '\t')
2936 from++;
2937 }
2938 /* Whole comment contents (regex):
2939 [ \t.!]*(ELSE,? |INTENTIONAL(LY)? )?FALL(S | |-)?THR(OUGH|U)[ \t.!]*(-[^\n\r]*)?
2940 [ \t.!]*(Else,? |Intentional(ly)? )?Fall((s | |-)[Tt]|t)hr(ough|u)[ \t.!]*(-[^\n\r]*)?
2941 [ \t.!]*([Ee]lse,? |[Ii]ntentional(ly)? )?fall(s | |-)?thr(ough|u)[ \t.!]*(-[^\n\r]*)?
2942 */
2943 else
2944 {
2945 while (*from == ' ' || *from == '\t' || *from == '.' || *from == '!')
2946 from++;
2947 unsigned char f = *from;
2948 bool all_upper = false;
2949 if (f == 'E' || f == 'e')
2950 {
2951 if ((size_t) (pfile->buffer->cur - from)
2952 < sizeof "else fallthru" - 1)
2953 return false;
2954 if (f == 'E' && memcmp (from + 1, "LSE", sizeof "LSE" - 1) == 0)
2955 all_upper = true;
2956 else if (memcmp (from + 1, "lse", sizeof "lse" - 1))
2957 return false;
2958 from += sizeof "else" - 1;
2959 if (*from == ',')
2960 from++;
2961 if (*from != ' ')
2962 return false;
2963 from++;
2964 if (all_upper && *from == 'f')
2965 return false;
2966 if (f == 'e' && *from == 'F')
2967 return false;
2968 f = *from;
2969 }
2970 else if (f == 'I' || f == 'i')
2971 {
2972 if ((size_t) (pfile->buffer->cur - from)
2973 < sizeof "intentional fallthru" - 1)
2974 return false;
2975 if (f == 'I' && memcmp (from + 1, "NTENTIONAL",
2976 sizeof "NTENTIONAL" - 1) == 0)
2977 all_upper = true;
2978 else if (memcmp (from + 1, "ntentional",
2979 sizeof "ntentional" - 1))
2980 return false;
2981 from += sizeof "intentional" - 1;
2982 if (*from == ' ')
2983 {
2984 from++;
2985 if (all_upper && *from == 'f')
2986 return false;
2987 }
2988 else if (all_upper)
2989 {
2990 if (memcmp (from, "LY F", sizeof "LY F" - 1))
2991 return false;
2992 from += sizeof "LY " - 1;
2993 }
2994 else
2995 {
2996 if (memcmp (from, "ly ", sizeof "ly " - 1))
2997 return false;
2998 from += sizeof "ly " - 1;
2999 }
3000 if (f == 'i' && *from == 'F')
3001 return false;
3002 f = *from;
3003 }
3004 if (f != 'F' && f != 'f')
3005 return false;
3006 if ((size_t) (pfile->buffer->cur - from) < sizeof "fallthru" - 1)
3007 return false;
3008 if (f == 'F' && memcmp (from + 1, "ALL", sizeof "ALL" - 1) == 0)
3009 all_upper = true;
3010 else if (all_upper)
3011 return false;
3012 else if (memcmp (from + 1, "all", sizeof "all" - 1))
3013 return false;
3014 from += sizeof "fall" - 1;
3015 if (*from == (all_upper ? 'S' : 's') && from[1] == ' ')
3016 from += 2;
3017 else if (*from == ' ' || *from == '-')
3018 from++;
3019 else if (*from != (all_upper ? 'T' : 't'))
3020 return false;
3021 if ((f == 'f' || *from != 'T') && (all_upper || *from != 't'))
3022 return false;
3023 if ((size_t) (pfile->buffer->cur - from) < sizeof "thru" - 1)
3024 return false;
3025 if (memcmp (from + 1, all_upper ? "HRU" : "hru", sizeof "hru" - 1))
3026 {
3027 if ((size_t) (pfile->buffer->cur - from) < sizeof "through" - 1)
3028 return false;
3029 if (memcmp (from + 1, all_upper ? "HROUGH" : "hrough",
3030 sizeof "hrough" - 1))
3031 return false;
3032 from += sizeof "through" - 1;
3033 }
3034 else
3035 from += sizeof "thru" - 1;
3036 while (*from == ' ' || *from == '\t' || *from == '.' || *from == '!')
3037 from++;
3038 if (*from == '-')
3039 {
3040 from++;
3041 if (*comment_start == '*')
3042 {
3043 do
3044 {
3045 while (*from && *from != '*'
3046 && *from != '\n' && *from != '\r')
3047 from++;
3048 if (*from != '*' || from[1] == '/')
3049 break;
3050 from++;
3051 }
3052 while (1);
3053 }
3054 else
3055 while (*from && *from != '\n' && *from != '\r')
3056 from++;
3057 }
3058 }
3059 /* C block comment. */
3060 if (*comment_start == '*')
3061 {
3062 if (*from != '*' || from[1] != '/')
3063 return false;
3064 }
3065 /* C++ line comment. */
3066 else if (*from != '\n')
3067 return false;
3068
3069 return true;
3070}
3071
3072/* Allocate COUNT tokens for RUN. */
3073void
3074_cpp_init_tokenrun (tokenrun *run, unsigned int count)
3075{
3076 run->base = XNEWVEC (cpp_token, count)((cpp_token *) xmalloc (sizeof (cpp_token) * (count)));
3077 run->limit = run->base + count;
3078 run->next = NULL__null;
3079}
3080
3081/* Returns the next tokenrun, or creates one if there is none. */
3082static tokenrun *
3083next_tokenrun (tokenrun *run)
3084{
3085 if (run->next == NULL__null)
3086 {
3087 run->next = XNEW (tokenrun)((tokenrun *) xmalloc (sizeof (tokenrun)));
3088 run->next->prev = run;
3089 _cpp_init_tokenrun (run->next, 250);
3090 }
3091
3092 return run->next;
3093}
3094
3095/* Return the number of not yet processed token in a given
3096 context. */
3097int
3098_cpp_remaining_tokens_num_in_context (cpp_context *context)
3099{
3100 if (context->tokens_kind == TOKENS_KIND_DIRECT)
3101 return (LAST (context)((context)->u.iso.last).token - FIRST (context)((context)->u.iso.first).token);
3102 else if (context->tokens_kind == TOKENS_KIND_INDIRECT
3103 || context->tokens_kind == TOKENS_KIND_EXTENDED)
3104 return (LAST (context)((context)->u.iso.last).ptoken - FIRST (context)((context)->u.iso.first).ptoken);
3105 else
3106 abort ()fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3106, __FUNCTION__)
;
3107}
3108
3109/* Returns the token present at index INDEX in a given context. If
3110 INDEX is zero, the next token to be processed is returned. */
3111static const cpp_token*
3112_cpp_token_from_context_at (cpp_context *context, int index)
3113{
3114 if (context->tokens_kind == TOKENS_KIND_DIRECT)
3115 return &(FIRST (context)((context)->u.iso.first).token[index]);
3116 else if (context->tokens_kind == TOKENS_KIND_INDIRECT
3117 || context->tokens_kind == TOKENS_KIND_EXTENDED)
3118 return FIRST (context)((context)->u.iso.first).ptoken[index];
3119 else
3120 abort ()fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3120, __FUNCTION__)
;
3121}
3122
3123/* Look ahead in the input stream. */
3124const cpp_token *
3125cpp_peek_token (cpp_reader *pfile, int index)
3126{
3127 cpp_context *context = pfile->context;
3128 const cpp_token *peektok;
3129 int count;
3130
3131 /* First, scan through any pending cpp_context objects. */
3132 while (context->prev)
3133 {
3134 ptrdiff_t sz = _cpp_remaining_tokens_num_in_context (context);
3135
3136 if (index < (int) sz)
3137 return _cpp_token_from_context_at (context, index);
3138 index -= (int) sz;
3139 context = context->prev;
3140 }
3141
3142 /* We will have to read some new tokens after all (and do so
3143 without invalidating preceding tokens). */
3144 count = index;
3145 pfile->keep_tokens++;
3146
3147 /* For peeked tokens temporarily disable line_change reporting,
3148 until the tokens are parsed for real. */
3149 void (*line_change) (cpp_reader *, const cpp_token *, int)
3150 = pfile->cb.line_change;
3151 pfile->cb.line_change = NULL__null;
3152
3153 do
3154 {
3155 peektok = _cpp_lex_token (pfile);
3156 if (peektok->type == CPP_EOF)
3157 {
3158 index--;
3159 break;
3160 }
3161 else if (peektok->type == CPP_PRAGMA)
3162 {
3163 /* Don't peek past a pragma. */
3164 if (peektok == &pfile->directive_result)
3165 /* Save the pragma in the buffer. */
3166 *pfile->cur_token++ = *peektok;
3167 index--;
3168 break;
3169 }
3170 }
3171 while (index--);
3172
3173 _cpp_backup_tokens_direct (pfile, count - index);
3174 pfile->keep_tokens--;
3175 pfile->cb.line_change = line_change;
3176
3177 return peektok;
3178}
3179
3180/* Allocate a single token that is invalidated at the same time as the
3181 rest of the tokens on the line. Has its line and col set to the
3182 same as the last lexed token, so that diagnostics appear in the
3183 right place. */
3184cpp_token *
3185_cpp_temp_token (cpp_reader *pfile)
3186{
3187 cpp_token *old, *result;
3188 ptrdiff_t sz = pfile->cur_run->limit - pfile->cur_token;
3189 ptrdiff_t la = (ptrdiff_t) pfile->lookaheads;
3190
3191 old = pfile->cur_token - 1;
3192 /* Any pre-existing lookaheads must not be clobbered. */
3193 if (la)
3194 {
3195 if (sz <= la)
3196 {
3197 tokenrun *next = next_tokenrun (pfile->cur_run);
3198
3199 if (sz < la)
3200 memmove (next->base + 1, next->base,
3201 (la - sz) * sizeof (cpp_token));
3202
3203 next->base[0] = pfile->cur_run->limit[-1];
3204 }
3205
3206 if (sz > 1)
3207 memmove (pfile->cur_token + 1, pfile->cur_token,
3208 MIN (la, sz - 1)((la) < (sz - 1) ? (la) : (sz - 1)) * sizeof (cpp_token));
3209 }
3210
3211 if (!sz && pfile->cur_token == pfile->cur_run->limit)
3212 {
3213 pfile->cur_run = next_tokenrun (pfile->cur_run);
3214 pfile->cur_token = pfile->cur_run->base;
3215 }
3216
3217 result = pfile->cur_token++;
3218 result->src_loc = old->src_loc;
3219 return result;
3220}
3221
3222/* We're at the beginning of a logical line (so not in
3223 directives-mode) and RESULT is a CPP_NAME with NODE_MODULE set. See
3224 if we should enter deferred_pragma mode to tokenize the rest of the
3225 line as a module control-line. */
3226
3227static void
3228cpp_maybe_module_directive (cpp_reader *pfile, cpp_token *result)
3229{
3230 unsigned backup = 0; /* Tokens we peeked. */
3231 cpp_hashnode *node = result->val.node.node;
3232 cpp_token *peek = result;
3233 cpp_token *keyword = peek;
3234 cpp_hashnode *(&n_modules)[spec_nodes::M_HWM][2] = pfile->spec_nodes.n_modules;
3235 int header_count = 0;
3236
3237 /* Make sure the incoming state is as we expect it. This way we
3238 can restore it using constants. */
3239 gcc_checking_assert (!pfile->state.in_deferred_pragma((void)(!(!pfile->state.in_deferred_pragma && !pfile
->state.skipping && !pfile->state.parsing_args &&
!pfile->state.angled_headers && (pfile->state.
save_comments == !((pfile)->opts.discard_comments))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3244, __FUNCTION__), 0 : 0))
3240 && !pfile->state.skipping((void)(!(!pfile->state.in_deferred_pragma && !pfile
->state.skipping && !pfile->state.parsing_args &&
!pfile->state.angled_headers && (pfile->state.
save_comments == !((pfile)->opts.discard_comments))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3244, __FUNCTION__), 0 : 0))
3241 && !pfile->state.parsing_args((void)(!(!pfile->state.in_deferred_pragma && !pfile
->state.skipping && !pfile->state.parsing_args &&
!pfile->state.angled_headers && (pfile->state.
save_comments == !((pfile)->opts.discard_comments))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3244, __FUNCTION__), 0 : 0))
3242 && !pfile->state.angled_headers((void)(!(!pfile->state.in_deferred_pragma && !pfile
->state.skipping && !pfile->state.parsing_args &&
!pfile->state.angled_headers && (pfile->state.
save_comments == !((pfile)->opts.discard_comments))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3244, __FUNCTION__), 0 : 0))
3243 && (pfile->state.save_comments((void)(!(!pfile->state.in_deferred_pragma && !pfile
->state.skipping && !pfile->state.parsing_args &&
!pfile->state.angled_headers && (pfile->state.
save_comments == !((pfile)->opts.discard_comments))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3244, __FUNCTION__), 0 : 0))
3244 == !CPP_OPTION (pfile, discard_comments)))((void)(!(!pfile->state.in_deferred_pragma && !pfile
->state.skipping && !pfile->state.parsing_args &&
!pfile->state.angled_headers && (pfile->state.
save_comments == !((pfile)->opts.discard_comments))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3244, __FUNCTION__), 0 : 0))
;
3245
3246 /* Enter directives mode sufficiently for peeking. We don't have
3247 to actually set in_directive. */
3248 pfile->state.in_deferred_pragma = true;
3249
3250 /* These two fields are needed to process tokenization in deferred
3251 pragma mode. They are not used outside deferred pragma mode or
3252 directives mode. */
3253 pfile->state.pragma_allow_expansion = true;
3254 pfile->directive_line = result->src_loc;
3255
3256 /* Saving comments is incompatible with directives mode. */
3257 pfile->state.save_comments = 0;
3258
3259 if (node == n_modules[spec_nodes::M_EXPORT][0])
3260 {
3261 peek = _cpp_lex_direct (pfile);
3262 keyword = peek;
3263 backup++;
3264 if (keyword->type != CPP_NAME)
3265 goto not_module;
3266 node = keyword->val.node.node;
3267 if (!(node->flags & NODE_MODULE(1 << 8)))
3268 goto not_module;
3269 }
3270
3271 if (node == n_modules[spec_nodes::M__IMPORT][0])
3272 /* __import */
3273 header_count = backup + 2 + 16;
3274 else if (node == n_modules[spec_nodes::M_IMPORT][0])
3275 /* import */
3276 header_count = backup + 2 + (CPP_OPTION (pfile, preprocessed)((pfile)->opts.preprocessed) ? 16 : 0);
3277 else if (node == n_modules[spec_nodes::M_MODULE][0])
3278 ; /* module */
3279 else
3280 goto not_module;
3281
3282 /* We've seen [export] {module|import|__import}. Check the next token. */
3283 if (header_count)
3284 /* After '{,__}import' a header name may appear. */
3285 pfile->state.angled_headers = true;
3286 peek = _cpp_lex_direct (pfile);
3287 backup++;
3288
3289 /* ... import followed by identifier, ':', '<' or
3290 header-name preprocessing tokens, or module
3291 followed by cpp-identifier, ':' or ';' preprocessing
3292 tokens. C++ keywords are not yet relevant. */
3293 if (peek->type == CPP_NAME
3294 || peek->type == CPP_COLON
3295 || (header_count
3296 ? (peek->type == CPP_LESS
3297 || (peek->type == CPP_STRING && peek->val.str.text[0] != 'R')
3298 || peek->type == CPP_HEADER_NAME)
3299 : peek->type == CPP_SEMICOLON))
3300 {
3301 pfile->state.pragma_allow_expansion = !CPP_OPTION (pfile, preprocessed)((pfile)->opts.preprocessed);
3302 if (!pfile->state.pragma_allow_expansion)
3303 pfile->state.prevent_expansion++;
3304
3305 if (!header_count && linemap_included_from
3306 (LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table)))
3307 cpp_error_with_line (pfile, CPP_DL_ERROR, keyword->src_loc, 0,
3308 "module control-line cannot be in included file");
3309
3310 /* The first one or two tokens cannot be macro names. */
3311 for (int ix = backup; ix--;)
3312 {
3313 cpp_token *tok = ix ? keyword : result;
3314 cpp_hashnode *node = tok->val.node.node;
3315
3316 /* Don't attempt to expand the token. */
3317 tok->flags |= NO_EXPAND(1 << 10);
3318 if (_cpp_defined_macro_p (node)
3319 && _cpp_maybe_notify_macro_use (pfile, node, tok->src_loc)
3320 && !cpp_fun_like_macro_p (node))
3321 cpp_error_with_line (pfile, CPP_DL_ERROR, tok->src_loc, 0,
3322 "module control-line \"%s\" cannot be"
3323 " an object-like macro",
3324 NODE_NAME (node)(((&(node)->ident))->str));
3325 }
3326
3327 /* Map to underbar variants. */
3328 keyword->val.node.node = n_modules[header_count
3329 ? spec_nodes::M_IMPORT
3330 : spec_nodes::M_MODULE][1];
3331 if (backup != 1)
3332 result->val.node.node = n_modules[spec_nodes::M_EXPORT][1];
3333
3334 /* Maybe tell the tokenizer we expect a header-name down the
3335 road. */
3336 pfile->state.directive_file_token = header_count;
3337 }
3338 else
3339 {
3340 not_module:
3341 /* Drop out of directive mode. */
3342 /* We aaserted save_comments had this value upon entry. */
3343 pfile->state.save_comments
3344 = !CPP_OPTION (pfile, discard_comments)((pfile)->opts.discard_comments);
3345 pfile->state.in_deferred_pragma = false;
3346 /* Do not let this remain on. */
3347 pfile->state.angled_headers = false;
3348 }
3349
3350 /* In either case we want to backup the peeked tokens. */
3351 if (backup)
3352 {
3353 /* If we saw EOL, we should drop it, because this isn't a module
3354 control-line after all. */
3355 bool eol = peek->type == CPP_PRAGMA_EOL;
3356 if (!eol || backup > 1)
3357 {
3358 /* Put put the peeked tokens back */
3359 _cpp_backup_tokens_direct (pfile, backup);
3360 /* But if the last one was an EOL, forget it. */
3361 if (eol)
3362 pfile->lookaheads--;
3363 }
3364 }
3365}
3366
3367/* Lex a token into RESULT (external interface). Takes care of issues
3368 like directive handling, token lookahead, multiple include
3369 optimization and skipping. */
3370const cpp_token *
3371_cpp_lex_token (cpp_reader *pfile)
3372{
3373 cpp_token *result;
3374
3375 for (;;)
3376 {
3377 if (pfile->cur_token == pfile->cur_run->limit)
3378 {
3379 pfile->cur_run = next_tokenrun (pfile->cur_run);
3380 pfile->cur_token = pfile->cur_run->base;
3381 }
3382 /* We assume that the current token is somewhere in the current
3383 run. */
3384 if (pfile->cur_token < pfile->cur_run->base
3385 || pfile->cur_token >= pfile->cur_run->limit)
3386 abort ()fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3386, __FUNCTION__)
;
3387
3388 if (pfile->lookaheads)
3389 {
3390 pfile->lookaheads--;
3391 result = pfile->cur_token++;
3392 }
3393 else
3394 result = _cpp_lex_direct (pfile);
3395
3396 if (result->flags & BOL(1 << 6))
3397 {
3398 /* Is this a directive. If _cpp_handle_directive returns
3399 false, it is an assembler #. */
3400 if (result->type == CPP_HASH
3401 /* 6.10.3 p 11: Directives in a list of macro arguments
3402 gives undefined behavior. This implementation
3403 handles the directive as normal. */
3404 && pfile->state.parsing_args != 1)
3405 {
3406 if (_cpp_handle_directive (pfile, result->flags & PREV_WHITE(1 << 0)))
3407 {
3408 if (pfile->directive_result.type == CPP_PADDING)
3409 continue;
3410 result = &pfile->directive_result;
3411 }
3412 }
3413 else if (pfile->state.in_deferred_pragma)
3414 result = &pfile->directive_result;
3415 else if (result->type == CPP_NAME
3416 && (result->val.node.node->flags & NODE_MODULE(1 << 8))
3417 && !pfile->state.skipping
3418 /* Unlike regular directives, we do not deal with
3419 tokenizing module directives as macro arguments.
3420 That's not permitted. */
3421 && !pfile->state.parsing_args)
3422 {
3423 /* P1857. Before macro expansion, At start of logical
3424 line ... */
3425 /* We don't have to consider lookaheads at this point. */
3426 gcc_checking_assert (!pfile->lookaheads)((void)(!(!pfile->lookaheads) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3426, __FUNCTION__), 0 : 0))
;
3427
3428 cpp_maybe_module_directive (pfile, result);
3429 }
3430
3431 if (pfile->cb.line_change && !pfile->state.skipping)
3432 pfile->cb.line_change (pfile, result, pfile->state.parsing_args);
3433 }
3434
3435 /* We don't skip tokens in directives. */
3436 if (pfile->state.in_directive || pfile->state.in_deferred_pragma)
3437 break;
3438
3439 /* Outside a directive, invalidate controlling macros. At file
3440 EOF, _cpp_lex_direct takes care of popping the buffer, so we never
3441 get here and MI optimization works. */
3442 pfile->mi_valid = false;
3443
3444 if (!pfile->state.skipping || result->type == CPP_EOF)
3445 break;
3446 }
3447
3448 return result;
3449}
3450
3451/* Returns true if a fresh line has been loaded. */
3452bool
3453_cpp_get_fresh_line (cpp_reader *pfile)
3454{
3455 /* We can't get a new line until we leave the current directive. */
3456 if (pfile->state.in_directive)
3457 return false;
3458
3459 for (;;)
3460 {
3461 cpp_buffer *buffer = pfile->buffer;
3462
3463 if (!buffer->need_line)
3464 return true;
3465
3466 if (buffer->next_line < buffer->rlimit)
3467 {
3468 _cpp_clean_line (pfile);
3469 return true;
3470 }
3471
3472 /* First, get out of parsing arguments state. */
3473 if (pfile->state.parsing_args)
3474 return false;
3475
3476 /* End of buffer. Non-empty files should end in a newline. */
3477 if (buffer->buf != buffer->rlimit
3478 && buffer->next_line > buffer->rlimit
3479 && !buffer->from_stage3)
3480 {
3481 /* Clip to buffer size. */
3482 buffer->next_line = buffer->rlimit;
3483 }
3484
3485 if (buffer->prev && !buffer->return_at_eof)
3486 _cpp_pop_buffer (pfile);
3487 else
3488 {
3489 /* End of translation. Do not pop the buffer yet. Increment
3490 line number so that the EOF token is on a line of its own
3491 (_cpp_lex_direct doesn't increment in that case, because
3492 it's hard for it to distinguish this special case). */
3493 CPP_INCREMENT_LINE (pfile, 0)do { const class line_maps *line_table = pfile->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (pfile->line_table,
line + 1, 0); } while (0)
;
3494 return false;
3495 }
3496 }
3497}
3498
3499#define IF_NEXT_IS(CHAR, THEN_TYPE, ELSE_TYPE)do { result->type = ELSE_TYPE; if (*buffer->cur == CHAR
) buffer->cur++, result->type = THEN_TYPE; } while (0)
\
3500 do \
3501 { \
3502 result->type = ELSE_TYPE; \
3503 if (*buffer->cur == CHAR) \
3504 buffer->cur++, result->type = THEN_TYPE; \
3505 } \
3506 while (0)
3507
3508/* Lex a token into pfile->cur_token, which is also incremented, to
3509 get diagnostics pointing to the correct location.
3510
3511 Does not handle issues such as token lookahead, multiple-include
3512 optimization, directives, skipping etc. This function is only
3513 suitable for use by _cpp_lex_token, and in special cases like
3514 lex_expansion_token which doesn't care for any of these issues.
3515
3516 When meeting a newline, returns CPP_EOF if parsing a directive,
3517 otherwise returns to the start of the token buffer if permissible.
3518 Returns the location of the lexed token. */
3519cpp_token *
3520_cpp_lex_direct (cpp_reader *pfile)
3521{
3522 cppchar_t c;
3523 cpp_buffer *buffer;
3524 const unsigned char *comment_start;
3525 bool fallthrough_comment = false;
3526 cpp_token *result = pfile->cur_token++;
3527
3528 fresh_line:
3529 result->flags = 0;
3530 buffer = pfile->buffer;
3531 if (buffer->need_line)
1
Assuming field 'need_line' is false
2
Taking false branch
3532 {
3533 gcc_assert (!pfile->state.in_deferred_pragma)((void)(!(!pfile->state.in_deferred_pragma) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 3533, __FUNCTION__), 0 : 0))
;
3534 if (!_cpp_get_fresh_line (pfile))
3535 {
3536 result->type = CPP_EOF;
3537 /* Not a real EOF in a directive or arg parsing -- we refuse
3538 to advance to the next file now, and will once we're out
3539 of those modes. */
3540 if (!pfile->state.in_directive && !pfile->state.parsing_args)
3541 {
3542 /* Tell the compiler the line number of the EOF token. */
3543 result->src_loc = pfile->line_table->highest_line;
3544 result->flags = BOL(1 << 6);
3545 /* Now pop the buffer that _cpp_get_fresh_line did not. */
3546 _cpp_pop_buffer (pfile);
3547 }
3548 return result;
3549 }
3550 if (buffer != pfile->buffer)
3551 fallthrough_comment = false;
3552 if (!pfile->keep_tokens)
3553 {
3554 pfile->cur_run = &pfile->base_run;
3555 result = pfile->base_run.base;
3556 pfile->cur_token = result + 1;
3557 }
3558 result->flags = BOL(1 << 6);
3559 if (pfile->state.parsing_args == 2)
3560 result->flags |= PREV_WHITE(1 << 0);
3561 }
3562 buffer = pfile->buffer;
3563 update_tokens_line:
3564 result->src_loc = pfile->line_table->highest_line;
3565
3566 skipped_white:
3567 if (buffer->cur >= buffer->notes[buffer->cur_note].pos
3
Assuming field 'cur' is < field 'pos'
3568 && !pfile->overlaid_buffer)
3569 {
3570 _cpp_process_line_notes (pfile, false);
3571 result->src_loc = pfile->line_table->highest_line;
3572 }
3573 c = *buffer->cur++;
3574
3575 if (pfile->forced_token_location)
4
Assuming field 'forced_token_location' is 0
5
Taking false branch
3576 result->src_loc = pfile->forced_token_location;
3577 else
3578 result->src_loc = linemap_position_for_column (pfile->line_table,
3579 CPP_BUF_COLUMN (buffer, buffer->cur)((buffer->cur) - (buffer)->line_base));
3580
3581 switch (c)
6
Control jumps to the 'default' case at line 3960
3582 {
3583 case ' ': case '\t': case '\f': case '\v': case '\0':
3584 result->flags |= PREV_WHITE(1 << 0);
3585 skip_whitespace (pfile, c);
3586 goto skipped_white;
3587
3588 case '\n':
3589 /* Increment the line, unless this is the last line ... */
3590 if (buffer->cur < buffer->rlimit
3591 /* ... or this is a #include, (where _cpp_stack_file needs to
3592 unwind by one line) ... */
3593 || (pfile->state.in_directive > 1
3594 /* ... except traditional-cpp increments this elsewhere. */
3595 && !CPP_OPTION (pfile, traditional)((pfile)->opts.traditional)))
3596 CPP_INCREMENT_LINE (pfile, 0)do { const class line_maps *line_table = pfile->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (pfile->line_table,
line + 1, 0); } while (0)
;
3597 buffer->need_line = true;
3598 if (pfile->state.in_deferred_pragma)
3599 {
3600 /* Produce the PRAGMA_EOL on this line. File reading
3601 ensures there is always a \n at end of the buffer, thus
3602 in a deferred pragma we always see CPP_PRAGMA_EOL before
3603 any CPP_EOF. */
3604 result->type = CPP_PRAGMA_EOL;
3605 result->flags &= ~PREV_WHITE(1 << 0);
3606 pfile->state.in_deferred_pragma = false;
3607 if (!pfile->state.pragma_allow_expansion)
3608 pfile->state.prevent_expansion--;
3609 return result;
3610 }
3611 goto fresh_line;
3612
3613 case '0': case '1': case '2': case '3': case '4':
3614 case '5': case '6': case '7': case '8': case '9':
3615 {
3616 struct normalize_state nst = INITIAL_NORMALIZE_STATE{ 0, 0, normalized_KC };
3617 result->type = CPP_NUMBER;
3618 lex_number (pfile, &result->val.str, &nst);
3619 warn_about_normalization (pfile, result, &nst);
3620 break;
3621 }
3622
3623 case 'L':
3624 case 'u':
3625 case 'U':
3626 case 'R':
3627 /* 'L', 'u', 'U', 'u8' or 'R' may introduce wide characters,
3628 wide strings or raw strings. */
3629 if (c == 'L' || CPP_OPTION (pfile, rliterals)((pfile)->opts.rliterals)
3630 || (c != 'R' && CPP_OPTION (pfile, uliterals)((pfile)->opts.uliterals)))
3631 {
3632 if ((*buffer->cur == '\'' && c != 'R')
3633 || *buffer->cur == '"'
3634 || (*buffer->cur == 'R'
3635 && c != 'R'
3636 && buffer->cur[1] == '"'
3637 && CPP_OPTION (pfile, rliterals)((pfile)->opts.rliterals))
3638 || (*buffer->cur == '8'
3639 && c == 'u'
3640 && ((buffer->cur[1] == '"' || (buffer->cur[1] == '\''
3641 && CPP_OPTION (pfile, utf8_char_literals)((pfile)->opts.utf8_char_literals)))
3642 || (buffer->cur[1] == 'R' && buffer->cur[2] == '"'
3643 && CPP_OPTION (pfile, rliterals)((pfile)->opts.rliterals)))))
3644 {
3645 lex_string (pfile, result, buffer->cur - 1);
3646 break;
3647 }
3648 }
3649 /* Fall through. */
3650
3651 case '_':
3652 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
3653 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
3654 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
3655 case 's': case 't': case 'v': case 'w': case 'x':
3656 case 'y': case 'z':
3657 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
3658 case 'G': case 'H': case 'I': case 'J': case 'K':
3659 case 'M': case 'N': case 'O': case 'P': case 'Q':
3660 case 'S': case 'T': case 'V': case 'W': case 'X':
3661 case 'Y': case 'Z':
3662 result->type = CPP_NAME;
3663 {
3664 struct normalize_state nst = INITIAL_NORMALIZE_STATE{ 0, 0, normalized_KC };
3665 result->val.node.node = lex_identifier (pfile, buffer->cur - 1, false,
3666 &nst,
3667 &result->val.node.spelling);
3668 warn_about_normalization (pfile, result, &nst);
3669 }
3670
3671 /* Convert named operators to their proper types. */
3672 if (result->val.node.node->flags & NODE_OPERATOR(1 << 0))
3673 {
3674 result->flags |= NAMED_OP(1 << 4);
3675 result->type = (enum cpp_ttype) result->val.node.node->directive_index;
3676 }
3677
3678 /* Signal FALLTHROUGH comment followed by another token. */
3679 if (fallthrough_comment)
3680 result->flags |= PREV_FALLTHROUGH(1 << 5);
3681 break;
3682
3683 case '\'':
3684 case '"':
3685 lex_string (pfile, result, buffer->cur - 1);
3686 break;
3687
3688 case '/':
3689 /* A potential block or line comment. */
3690 comment_start = buffer->cur;
3691 c = *buffer->cur;
3692
3693 if (c == '*')
3694 {
3695 if (_cpp_skip_block_comment (pfile))
3696 cpp_error (pfile, CPP_DL_ERROR, "unterminated comment");
3697 }
3698 else if (c == '/' && ! CPP_OPTION (pfile, traditional)((pfile)->opts.traditional))
3699 {
3700 /* Don't warn for system headers. */
3701 if (_cpp_in_system_header (pfile))
3702 ;
3703 /* Warn about comments if pedantically GNUC89, and not
3704 in system headers. */
3705 else if (CPP_OPTION (pfile, lang)((pfile)->opts.lang) == CLK_GNUC89
3706 && CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic)
3707 && ! buffer->warned_cplusplus_comments)
3708 {
3709 if (cpp_error (pfile, CPP_DL_PEDWARN,
3710 "C++ style comments are not allowed in ISO C90"))
3711 cpp_error (pfile, CPP_DL_NOTE,
3712 "(this will be reported only once per input file)");
3713 buffer->warned_cplusplus_comments = 1;
3714 }
3715 /* Or if specifically desired via -Wc90-c99-compat. */
3716 else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat)((pfile)->opts.cpp_warn_c90_c99_compat) > 0
3717 && ! CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus)
3718 && ! buffer->warned_cplusplus_comments)
3719 {
3720 if (cpp_error (pfile, CPP_DL_WARNING,
3721 "C++ style comments are incompatible with C90"))
3722 cpp_error (pfile, CPP_DL_NOTE,
3723 "(this will be reported only once per input file)");
3724 buffer->warned_cplusplus_comments = 1;
3725 }
3726 /* In C89/C94, C++ style comments are forbidden. */
3727 else if ((CPP_OPTION (pfile, lang)((pfile)->opts.lang) == CLK_STDC89
3728 || CPP_OPTION (pfile, lang)((pfile)->opts.lang) == CLK_STDC94))
3729 {
3730 /* But don't be confused about valid code such as
3731 - // immediately followed by *,
3732 - // in a preprocessing directive,
3733 - // in an #if 0 block. */
3734 if (buffer->cur[1] == '*'
3735 || pfile->state.in_directive
3736 || pfile->state.skipping)
3737 {
3738 result->type = CPP_DIV;
3739 break;
3740 }
3741 else if (! buffer->warned_cplusplus_comments)
3742 {
3743 if (cpp_error (pfile, CPP_DL_ERROR,
3744 "C++ style comments are not allowed in "
3745 "ISO C90"))
3746 cpp_error (pfile, CPP_DL_NOTE,
3747 "(this will be reported only once per input "
3748 "file)");
3749 buffer->warned_cplusplus_comments = 1;
3750 }
3751 }
3752 if (skip_line_comment (pfile) && CPP_OPTION (pfile, warn_comments)((pfile)->opts.warn_comments))
3753 cpp_warning (pfile, CPP_W_COMMENTS, "multi-line comment");
3754 }
3755 else if (c == '=')
3756 {
3757 buffer->cur++;
3758 result->type = CPP_DIV_EQ;
3759 break;
3760 }
3761 else
3762 {
3763 result->type = CPP_DIV;
3764 break;
3765 }
3766
3767 if (fallthrough_comment_p (pfile, comment_start))
3768 fallthrough_comment = true;
3769
3770 if (pfile->cb.comment)
3771 {
3772 size_t len = pfile->buffer->cur - comment_start;
3773 pfile->cb.comment (pfile, result->src_loc, comment_start - 1,
3774 len + 1);
3775 }
3776
3777 if (!pfile->state.save_comments)
3778 {
3779 result->flags |= PREV_WHITE(1 << 0);
3780 goto update_tokens_line;
3781 }
3782
3783 if (fallthrough_comment)
3784 result->flags |= PREV_FALLTHROUGH(1 << 5);
3785
3786 /* Save the comment as a token in its own right. */
3787 save_comment (pfile, result, comment_start, c);
3788 break;
3789
3790 case '<':
3791 if (pfile->state.angled_headers)
3792 {
3793 lex_string (pfile, result, buffer->cur - 1);
3794 if (result->type != CPP_LESS)
3795 break;
3796 }
3797
3798 result->type = CPP_LESS;
3799 if (*buffer->cur == '=')
3800 {
3801 buffer->cur++, result->type = CPP_LESS_EQ;
3802 if (*buffer->cur == '>'
3803 && CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus)
3804 && CPP_OPTION (pfile, lang)((pfile)->opts.lang) >= CLK_GNUCXX20)
3805 buffer->cur++, result->type = CPP_SPACESHIP;
3806 }
3807 else if (*buffer->cur == '<')
3808 {
3809 buffer->cur++;
3810 IF_NEXT_IS ('=', CPP_LSHIFT_EQ, CPP_LSHIFT)do { result->type = CPP_LSHIFT; if (*buffer->cur == '='
) buffer->cur++, result->type = CPP_LSHIFT_EQ; } while (
0)
;
3811 }
3812 else if (CPP_OPTION (pfile, digraphs)((pfile)->opts.digraphs))
3813 {
3814 if (*buffer->cur == ':')
3815 {
3816 /* C++11 [2.5/3 lex.pptoken], "Otherwise, if the next
3817 three characters are <:: and the subsequent character
3818 is neither : nor >, the < is treated as a preprocessor
3819 token by itself". */
3820 if (CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus)
3821 && CPP_OPTION (pfile, lang)((pfile)->opts.lang) != CLK_CXX98
3822 && CPP_OPTION (pfile, lang)((pfile)->opts.lang) != CLK_GNUCXX
3823 && buffer->cur[1] == ':'
3824 && buffer->cur[2] != ':' && buffer->cur[2] != '>')
3825 break;
3826
3827 buffer->cur++;
3828 result->flags |= DIGRAPH(1 << 1);
3829 result->type = CPP_OPEN_SQUARE;
3830 }
3831 else if (*buffer->cur == '%')
3832 {
3833 buffer->cur++;
3834 result->flags |= DIGRAPH(1 << 1);
3835 result->type = CPP_OPEN_BRACE;
3836 }
3837 }
3838 break;
3839
3840 case '>':
3841 result->type = CPP_GREATER;
3842 if (*buffer->cur == '=')
3843 buffer->cur++, result->type = CPP_GREATER_EQ;
3844 else if (*buffer->cur == '>')
3845 {
3846 buffer->cur++;
3847 IF_NEXT_IS ('=', CPP_RSHIFT_EQ, CPP_RSHIFT)do { result->type = CPP_RSHIFT; if (*buffer->cur == '='
) buffer->cur++, result->type = CPP_RSHIFT_EQ; } while (
0)
;
3848 }
3849 break;
3850
3851 case '%':
3852 result->type = CPP_MOD;
3853 if (*buffer->cur == '=')
3854 buffer->cur++, result->type = CPP_MOD_EQ;
3855 else if (CPP_OPTION (pfile, digraphs)((pfile)->opts.digraphs))
3856 {
3857 if (*buffer->cur == ':')
3858 {
3859 buffer->cur++;
3860 result->flags |= DIGRAPH(1 << 1);
3861 result->type = CPP_HASH;
3862 if (*buffer->cur == '%' && buffer->cur[1] == ':')
3863 buffer->cur += 2, result->type = CPP_PASTE, result->val.token_no = 0;
3864 }
3865 else if (*buffer->cur == '>')
3866 {
3867 buffer->cur++;
3868 result->flags |= DIGRAPH(1 << 1);
3869 result->type = CPP_CLOSE_BRACE;
3870 }
3871 }
3872 break;
3873
3874 case '.':
3875 result->type = CPP_DOT;
3876 if (ISDIGIT (*buffer->cur)(_sch_istable[(*buffer->cur) & 0xff] & (unsigned short
)(_sch_isdigit))
)
3877 {
3878 struct normalize_state nst = INITIAL_NORMALIZE_STATE{ 0, 0, normalized_KC };
3879 result->type = CPP_NUMBER;
3880 lex_number (pfile, &result->val.str, &nst);
3881 warn_about_normalization (pfile, result, &nst);
3882 }
3883 else if (*buffer->cur == '.' && buffer->cur[1] == '.')
3884 buffer->cur += 2, result->type = CPP_ELLIPSIS;
3885 else if (*buffer->cur == '*' && CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus))
3886 buffer->cur++, result->type = CPP_DOT_STAR;
3887 break;
3888
3889 case '+':
3890 result->type = CPP_PLUS;
3891 if (*buffer->cur == '+')
3892 buffer->cur++, result->type = CPP_PLUS_PLUS;
3893 else if (*buffer->cur == '=')
3894 buffer->cur++, result->type = CPP_PLUS_EQ;
3895 break;
3896
3897 case '-':
3898 result->type = CPP_MINUS;
3899 if (*buffer->cur == '>')
3900 {
3901 buffer->cur++;
3902 result->type = CPP_DEREF;
3903 if (*buffer->cur == '*' && CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus))
3904 buffer->cur++, result->type = CPP_DEREF_STAR;
3905 }
3906 else if (*buffer->cur == '-')
3907 buffer->cur++, result->type = CPP_MINUS_MINUS;
3908 else if (*buffer->cur == '=')
3909 buffer->cur++, result->type = CPP_MINUS_EQ;
3910 break;
3911
3912 case '&':
3913 result->type = CPP_AND;
3914 if (*buffer->cur == '&')
3915 buffer->cur++, result->type = CPP_AND_AND;
3916 else if (*buffer->cur == '=')
3917 buffer->cur++, result->type = CPP_AND_EQ;
3918 break;
3919
3920 case '|':
3921 result->type = CPP_OR;
3922 if (*buffer->cur == '|')
3923 buffer->cur++, result->type = CPP_OR_OR;
3924 else if (*buffer->cur == '=')
3925 buffer->cur++, result->type = CPP_OR_EQ;
3926 break;
3927
3928 case ':':
3929 result->type = CPP_COLON;
3930 if (*buffer->cur == ':' && CPP_OPTION (pfile, scope)((pfile)->opts.scope))
3931 buffer->cur++, result->type = CPP_SCOPE;
3932 else if (*buffer->cur == '>' && CPP_OPTION (pfile, digraphs)((pfile)->opts.digraphs))
3933 {
3934 buffer->cur++;
3935 result->flags |= DIGRAPH(1 << 1);
3936 result->type = CPP_CLOSE_SQUARE;
3937 }
3938 break;
3939
3940 case '*': IF_NEXT_IS ('=', CPP_MULT_EQ, CPP_MULT)do { result->type = CPP_MULT; if (*buffer->cur == '=') buffer
->cur++, result->type = CPP_MULT_EQ; } while (0)
; break;
3941 case '=': IF_NEXT_IS ('=', CPP_EQ_EQ, CPP_EQ)do { result->type = CPP_EQ; if (*buffer->cur == '=') buffer
->cur++, result->type = CPP_EQ_EQ; } while (0)
; break;
3942 case '!': IF_NEXT_IS ('=', CPP_NOT_EQ, CPP_NOT)do { result->type = CPP_NOT; if (*buffer->cur == '=') buffer
->cur++, result->type = CPP_NOT_EQ; } while (0)
; break;
3943 case '^': IF_NEXT_IS ('=', CPP_XOR_EQ, CPP_XOR)do { result->type = CPP_XOR; if (*buffer->cur == '=') buffer
->cur++, result->type = CPP_XOR_EQ; } while (0)
; break;
3944 case '#': IF_NEXT_IS ('#', CPP_PASTE, CPP_HASH)do { result->type = CPP_HASH; if (*buffer->cur == '#') buffer
->cur++, result->type = CPP_PASTE; } while (0)
; result->val.token_no = 0; break;
3945
3946 case '?': result->type = CPP_QUERY; break;
3947 case '~': result->type = CPP_COMPL; break;
3948 case ',': result->type = CPP_COMMA; break;
3949 case '(': result->type = CPP_OPEN_PAREN; break;
3950 case ')': result->type = CPP_CLOSE_PAREN; break;
3951 case '[': result->type = CPP_OPEN_SQUARE; break;
3952 case ']': result->type = CPP_CLOSE_SQUARE; break;
3953 case '{': result->type = CPP_OPEN_BRACE; break;
3954 case '}': result->type = CPP_CLOSE_BRACE; break;
3955 case ';': result->type = CPP_SEMICOLON; break;
3956
3957 /* @ is a punctuator in Objective-C. */
3958 case '@': result->type = CPP_ATSIGN; break;
3959
3960 default:
3961 {
3962 const uchar *base = --buffer->cur;
3963
3964 /* Check for an extended identifier ($ or UCN or UTF-8). */
3965 struct normalize_state nst = INITIAL_NORMALIZE_STATE{ 0, 0, normalized_KC };
3966 if (forms_identifier_p (pfile, true, &nst))
7
Calling 'forms_identifier_p'
3967 {
3968 result->type = CPP_NAME;
3969 result->val.node.node = lex_identifier (pfile, base, true, &nst,
3970 &result->val.node.spelling);
3971 warn_about_normalization (pfile, result, &nst);
3972 break;
3973 }
3974
3975 /* Otherwise this will form a CPP_OTHER token. Parse valid UTF-8 as a
3976 single token. */
3977 buffer->cur++;
3978 if (c >= utf8_signifier)
3979 {
3980 const uchar *pstr = base;
3981 cppchar_t s;
3982 if (_cpp_valid_utf8 (pfile, &pstr, buffer->rlimit, 0, NULL__null, &s))
3983 buffer->cur = pstr;
3984 }
3985 create_literal (pfile, result, base, buffer->cur - base, CPP_OTHER);
3986 break;
3987 }
3988
3989 }
3990
3991 /* Potentially convert the location of the token to a range. */
3992 if (result->src_loc >= RESERVED_LOCATION_COUNT
3993 && result->type != CPP_EOF)
3994 {
3995 /* Ensure that any line notes are processed, so that we have the
3996 correct physical line/column for the end-point of the token even
3997 when a logical line is split via one or more backslashes. */
3998 if (buffer->cur >= buffer->notes[buffer->cur_note].pos
3999 && !pfile->overlaid_buffer)
4000 _cpp_process_line_notes (pfile, false);
4001
4002 source_range tok_range;
4003 tok_range.m_start = result->src_loc;
4004 tok_range.m_finish
4005 = linemap_position_for_column (pfile->line_table,
4006 CPP_BUF_COLUMN (buffer, buffer->cur)((buffer->cur) - (buffer)->line_base));
4007
4008 result->src_loc = COMBINE_LOCATION_DATA (pfile->line_table,
4009 result->src_loc,
4010 tok_range, NULL__null);
4011 }
4012
4013 return result;
4014}
4015
4016/* An upper bound on the number of bytes needed to spell TOKEN.
4017 Does not include preceding whitespace. */
4018unsigned int
4019cpp_token_len (const cpp_token *token)
4020{
4021 unsigned int len;
4022
4023 switch (TOKEN_SPELL (token)(token_spellings[(token)->type].category))
4024 {
4025 default: len = 6; break;
4026 case SPELL_LITERAL: len = token->val.str.len; break;
4027 case SPELL_IDENT: len = NODE_LEN (token->val.node.node)(((&(token->val.node.node)->ident))->len) * 10; break;
4028 }
4029
4030 return len;
4031}
4032
4033/* Parse UTF-8 out of NAMEP and place a \U escape in BUFFER.
4034 Return the number of bytes read out of NAME. (There are always
4035 10 bytes written to BUFFER.) */
4036
4037static size_t
4038utf8_to_ucn (unsigned char *buffer, const unsigned char *name)
4039{
4040 int j;
4041 int ucn_len = 0;
4042 int ucn_len_c;
4043 unsigned t;
4044 unsigned long utf32;
4045
4046 /* Compute the length of the UTF-8 sequence. */
4047 for (t = *name; t & 0x80; t <<= 1)
4048 ucn_len++;
4049
4050 utf32 = *name & (0x7F >> ucn_len);
4051 for (ucn_len_c = 1; ucn_len_c < ucn_len; ucn_len_c++)
4052 {
4053 utf32 = (utf32 << 6) | (*++name & 0x3F);
4054
4055 /* Ill-formed UTF-8. */
4056 if ((*name & ~0x3F) != 0x80)
4057 abort ()fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 4057, __FUNCTION__)
;
4058 }
4059
4060 *buffer++ = '\\';
4061 *buffer++ = 'U';
4062 for (j = 7; j >= 0; j--)
4063 *buffer++ = "0123456789abcdef"[(utf32 >> (4 * j)) & 0xF];
4064 return ucn_len;
4065}
4066
4067/* Given a token TYPE corresponding to a digraph, return a pointer to
4068 the spelling of the digraph. */
4069static const unsigned char *
4070cpp_digraph2name (enum cpp_ttype type)
4071{
4072 return digraph_spellings[(int) type - (int) CPP_FIRST_DIGRAPH];
4073}
4074
4075/* Write the spelling of an identifier IDENT, using UCNs, to BUFFER.
4076 The buffer must already contain the enough space to hold the
4077 token's spelling. Returns a pointer to the character after the
4078 last character written. */
4079unsigned char *
4080_cpp_spell_ident_ucns (unsigned char *buffer, cpp_hashnode *ident)
4081{
4082 size_t i;
4083 const unsigned char *name = NODE_NAME (ident)(((&(ident)->ident))->str);
4084
4085 for (i = 0; i < NODE_LEN (ident)(((&(ident)->ident))->len); i++)
4086 if (name[i] & ~0x7F)
4087 {
4088 i += utf8_to_ucn (buffer, name + i) - 1;
4089 buffer += 10;
4090 }
4091 else
4092 *buffer++ = name[i];
4093
4094 return buffer;
4095}
4096
4097/* Write the spelling of a token TOKEN to BUFFER. The buffer must
4098 already contain the enough space to hold the token's spelling.
4099 Returns a pointer to the character after the last character written.
4100 FORSTRING is true if this is to be the spelling after translation
4101 phase 1 (with the original spelling of extended identifiers), false
4102 if extended identifiers should always be written using UCNs (there is
4103 no option for always writing them in the internal UTF-8 form).
4104 FIXME: Would be nice if we didn't need the PFILE argument. */
4105unsigned char *
4106cpp_spell_token (cpp_reader *pfile, const cpp_token *token,
4107 unsigned char *buffer, bool forstring)
4108{
4109 switch (TOKEN_SPELL (token)(token_spellings[(token)->type].category))
4110 {
4111 case SPELL_OPERATOR:
4112 {
4113 const unsigned char *spelling;
4114 unsigned char c;
4115
4116 if (token->flags & DIGRAPH(1 << 1))
4117 spelling = cpp_digraph2name (token->type);
4118 else if (token->flags & NAMED_OP(1 << 4))
4119 goto spell_ident;
4120 else
4121 spelling = TOKEN_NAME (token)(token_spellings[(token)->type].name);
4122
4123 while ((c = *spelling++) != '\0')
4124 *buffer++ = c;
4125 }
4126 break;
4127
4128 spell_ident:
4129 case SPELL_IDENT:
4130 if (forstring)
4131 {
4132 memcpy (buffer, NODE_NAME (token->val.node.spelling)(((&(token->val.node.spelling)->ident))->str),
4133 NODE_LEN (token->val.node.spelling)(((&(token->val.node.spelling)->ident))->len));
4134 buffer += NODE_LEN (token->val.node.spelling)(((&(token->val.node.spelling)->ident))->len);
4135 }
4136 else
4137 buffer = _cpp_spell_ident_ucns (buffer, token->val.node.node);
4138 break;
4139
4140 case SPELL_LITERAL:
4141 memcpy (buffer, token->val.str.text, token->val.str.len);
4142 buffer += token->val.str.len;
4143 break;
4144
4145 case SPELL_NONE:
4146 cpp_error (pfile, CPP_DL_ICE,
4147 "unspellable token %s", TOKEN_NAME (token)(token_spellings[(token)->type].name));
4148 break;
4149 }
4150
4151 return buffer;
4152}
4153
4154/* Returns TOKEN spelt as a null-terminated string. The string is
4155 freed when the reader is destroyed. Useful for diagnostics. */
4156unsigned char *
4157cpp_token_as_text (cpp_reader *pfile, const cpp_token *token)
4158{
4159 unsigned int len = cpp_token_len (token) + 1;
4160 unsigned char *start = _cpp_unaligned_alloc (pfile, len), *end;
4161
4162 end = cpp_spell_token (pfile, token, start, false);
4163 end[0] = '\0';
4164
4165 return start;
4166}
4167
4168/* Returns a pointer to a string which spells the token defined by
4169 TYPE and FLAGS. Used by C front ends, which really should move to
4170 using cpp_token_as_text. */
4171const char *
4172cpp_type2name (enum cpp_ttype type, unsigned char flags)
4173{
4174 if (flags & DIGRAPH(1 << 1))
4175 return (const char *) cpp_digraph2name (type);
4176 else if (flags & NAMED_OP(1 << 4))
4177 return cpp_named_operator2name (type);
4178
4179 return (const char *) token_spellings[type].name;
4180}
4181
4182/* Writes the spelling of token to FP, without any preceding space.
4183 Separated from cpp_spell_token for efficiency - to avoid stdio
4184 double-buffering. */
4185void
4186cpp_output_token (const cpp_token *token, FILE *fp)
4187{
4188 switch (TOKEN_SPELL (token)(token_spellings[(token)->type].category))
4189 {
4190 case SPELL_OPERATOR:
4191 {
4192 const unsigned char *spelling;
4193 int c;
4194
4195 if (token->flags & DIGRAPH(1 << 1))
4196 spelling = cpp_digraph2name (token->type);
4197 else if (token->flags & NAMED_OP(1 << 4))
4198 goto spell_ident;
4199 else
4200 spelling = TOKEN_NAME (token)(token_spellings[(token)->type].name);
4201
4202 c = *spelling;
4203 do
4204 putc (c, fp)putc_unlocked (c, fp);
4205 while ((c = *++spelling) != '\0');
4206 }
4207 break;
4208
4209 spell_ident:
4210 case SPELL_IDENT:
4211 {
4212 size_t i;
4213 const unsigned char * name = NODE_NAME (token->val.node.node)(((&(token->val.node.node)->ident))->str);
4214
4215 for (i = 0; i < NODE_LEN (token->val.node.node)(((&(token->val.node.node)->ident))->len); i++)
4216 if (name[i] & ~0x7F)
4217 {
4218 unsigned char buffer[10];
4219 i += utf8_to_ucn (buffer, name + i) - 1;
4220 fwrite (buffer, 1, 10, fp)fwrite_unlocked (buffer, 1, 10, fp);
4221 }
4222 else
4223 fputc (NODE_NAME (token->val.node.node)[i], fp)fputc_unlocked ((((&(token->val.node.node)->ident))
->str)[i], fp)
;
4224 }
4225 break;
4226
4227 case SPELL_LITERAL:
4228 if (token->type == CPP_HEADER_NAME)
4229 fputc ('"', fp)fputc_unlocked ('"', fp);
4230 fwrite (token->val.str.text, 1, token->val.str.len, fp)fwrite_unlocked (token->val.str.text, 1, token->val.str
.len, fp)
;
4231 if (token->type == CPP_HEADER_NAME)
4232 fputc ('"', fp)fputc_unlocked ('"', fp);
4233 break;
4234
4235 case SPELL_NONE:
4236 /* An error, most probably. */
4237 break;
4238 }
4239}
4240
4241/* Compare two tokens. */
4242int
4243_cpp_equiv_tokens (const cpp_token *a, const cpp_token *b)
4244{
4245 if (a->type == b->type && a->flags == b->flags)
4246 switch (TOKEN_SPELL (a)(token_spellings[(a)->type].category))
4247 {
4248 default: /* Keep compiler happy. */
4249 case SPELL_OPERATOR:
4250 /* token_no is used to track where multiple consecutive ##
4251 tokens were originally located. */
4252 return (a->type != CPP_PASTE || a->val.token_no == b->val.token_no);
4253 case SPELL_NONE:
4254 return (a->type != CPP_MACRO_ARG
4255 || (a->val.macro_arg.arg_no == b->val.macro_arg.arg_no
4256 && a->val.macro_arg.spelling == b->val.macro_arg.spelling));
4257 case SPELL_IDENT:
4258 return (a->val.node.node == b->val.node.node
4259 && a->val.node.spelling == b->val.node.spelling);
4260 case SPELL_LITERAL:
4261 return (a->val.str.len == b->val.str.len
4262 && !memcmp (a->val.str.text, b->val.str.text,
4263 a->val.str.len));
4264 }
4265
4266 return 0;
4267}
4268
4269/* Returns nonzero if a space should be inserted to avoid an
4270 accidental token paste for output. For simplicity, it is
4271 conservative, and occasionally advises a space where one is not
4272 needed, e.g. "." and ".2". */
4273int
4274cpp_avoid_paste (cpp_reader *pfile, const cpp_token *token1,
4275 const cpp_token *token2)
4276{
4277 enum cpp_ttype a = token1->type, b = token2->type;
4278 cppchar_t c;
4279
4280 if (token1->flags & NAMED_OP(1 << 4))
4281 a = CPP_NAME;
4282 if (token2->flags & NAMED_OP(1 << 4))
4283 b = CPP_NAME;
4284
4285 c = EOF(-1);
4286 if (token2->flags & DIGRAPH(1 << 1))
4287 c = digraph_spellings[(int) b - (int) CPP_FIRST_DIGRAPH][0];
4288 else if (token_spellings[b].category == SPELL_OPERATOR)
4289 c = token_spellings[b].name[0];
4290
4291 /* Quickly get everything that can paste with an '='. */
4292 if ((int) a <= (int) CPP_LAST_EQ && c == '=')
4293 return 1;
4294
4295 switch (a)
4296 {
4297 case CPP_GREATER: return c == '>';
4298 case CPP_LESS: return c == '<' || c == '%' || c == ':';
4299 case CPP_PLUS: return c == '+';
4300 case CPP_MINUS: return c == '-' || c == '>';
4301 case CPP_DIV: return c == '/' || c == '*'; /* Comments. */
4302 case CPP_MOD: return c == ':' || c == '>';
4303 case CPP_AND: return c == '&';
4304 case CPP_OR: return c == '|';
4305 case CPP_COLON: return c == ':' || c == '>';
4306 case CPP_DEREF: return c == '*';
4307 case CPP_DOT: return c == '.' || c == '%' || b == CPP_NUMBER;
4308 case CPP_HASH: return c == '#' || c == '%'; /* Digraph form. */
4309 case CPP_PRAGMA:
4310 case CPP_NAME: return ((b == CPP_NUMBER
4311 && name_p (pfile, &token2->val.str))
4312 || b == CPP_NAME
4313 || b == CPP_CHAR || b == CPP_STRING); /* L */
4314 case CPP_NUMBER: return (b == CPP_NUMBER || b == CPP_NAME
4315 || b == CPP_CHAR
4316 || c == '.' || c == '+' || c == '-');
4317 /* UCNs */
4318 case CPP_OTHER: return ((token1->val.str.text[0] == '\\'
4319 && b == CPP_NAME)
4320 || (CPP_OPTION (pfile, objc)((pfile)->opts.objc)
4321 && token1->val.str.text[0] == '@'
4322 && (b == CPP_NAME || b == CPP_STRING)));
4323 case CPP_LESS_EQ: return c == '>';
4324 case CPP_STRING:
4325 case CPP_WSTRING:
4326 case CPP_UTF8STRING:
4327 case CPP_STRING16:
4328 case CPP_STRING32: return (CPP_OPTION (pfile, user_literals)((pfile)->opts.user_literals)
4329 && (b == CPP_NAME
4330 || (TOKEN_SPELL (token2)(token_spellings[(token2)->type].category) == SPELL_LITERAL
4331 && ISIDST (token2->val.str.text[0])(_sch_istable[(token2->val.str.text[0]) & 0xff] & (
unsigned short)(_sch_isidst))
)));
4332
4333 default: break;
4334 }
4335
4336 return 0;
4337}
4338
4339/* Output all the remaining tokens on the current line, and a newline
4340 character, to FP. Leading whitespace is removed. If there are
4341 macros, special token padding is not performed. */
4342void
4343cpp_output_line (cpp_reader *pfile, FILE *fp)
4344{
4345 const cpp_token *token;
4346
4347 token = cpp_get_token (pfile);
4348 while (token->type != CPP_EOF)
4349 {
4350 cpp_output_token (token, fp);
4351 token = cpp_get_token (pfile);
4352 if (token->flags & PREV_WHITE(1 << 0))
4353 putc (' ', fp)putc_unlocked (' ', fp);
4354 }
4355
4356 putc ('\n', fp)putc_unlocked ('\n', fp);
4357}
4358
4359/* Return a string representation of all the remaining tokens on the
4360 current line. The result is allocated using xmalloc and must be
4361 freed by the caller. */
4362unsigned char *
4363cpp_output_line_to_string (cpp_reader *pfile, const unsigned char *dir_name)
4364{
4365 const cpp_token *token;
4366 unsigned int out = dir_name ? ustrlen (dir_name) : 0;
4367 unsigned int alloced = 120 + out;
4368 unsigned char *result = (unsigned char *) xmalloc (alloced);
4369
4370 /* If DIR_NAME is empty, there are no initial contents. */
4371 if (dir_name)
4372 {
4373 sprintf ((char *) result, "#%s ", dir_name);
4374 out += 2;
4375 }
4376
4377 token = cpp_get_token (pfile);
4378 while (token->type != CPP_EOF)
4379 {
4380 unsigned char *last;
4381 /* Include room for a possible space and the terminating nul. */
4382 unsigned int len = cpp_token_len (token) + 2;
4383
4384 if (out + len > alloced)
4385 {
4386 alloced *= 2;
4387 if (out + len > alloced)
4388 alloced = out + len;
4389 result = (unsigned char *) xrealloc (result, alloced);
4390 }
4391
4392 last = cpp_spell_token (pfile, token, &result[out], 0);
4393 out = last - result;
4394
4395 token = cpp_get_token (pfile);
4396 if (token->flags & PREV_WHITE(1 << 0))
4397 result[out++] = ' ';
4398 }
4399
4400 result[out] = '\0';
4401 return result;
4402}
4403
4404/* Memory buffers. Changing these three constants can have a dramatic
4405 effect on performance. The values here are reasonable defaults,
4406 but might be tuned. If you adjust them, be sure to test across a
4407 range of uses of cpplib, including heavy nested function-like macro
4408 expansion. Also check the change in peak memory usage (NJAMD is a
4409 good tool for this). */
4410#define MIN_BUFF_SIZE8000 8000
4411#define BUFF_SIZE_UPPER_BOUND(MIN_SIZE)(8000 + (MIN_SIZE) * 3 / 2) (MIN_BUFF_SIZE8000 + (MIN_SIZE) * 3 / 2)
4412#define EXTENDED_BUFF_SIZE(BUFF, MIN_EXTRA)(MIN_EXTRA + ((BUFF)->limit - (BUFF)->cur) * 2) \
4413 (MIN_EXTRA + ((BUFF)->limit - (BUFF)->cur) * 2)
4414
4415#if MIN_BUFF_SIZE8000 > BUFF_SIZE_UPPER_BOUND (0)(8000 + (0) * 3 / 2)
4416 #error BUFF_SIZE_UPPER_BOUND must be at least as large as MIN_BUFF_SIZE8000!
4417#endif
4418
4419/* Create a new allocation buffer. Place the control block at the end
4420 of the buffer, so that buffer overflows will cause immediate chaos. */
4421static _cpp_buff *
4422new_buff (size_t len)
4423{
4424 _cpp_buff *result;
4425 unsigned char *base;
4426
4427 if (len < MIN_BUFF_SIZE8000)
4428 len = MIN_BUFF_SIZE8000;
4429 len = CPP_ALIGN (len)(((len) + ((__builtin_offsetof(struct dummy, u)) - 1)) & ~
((__builtin_offsetof(struct dummy, u)) - 1))
;
4430
4431#ifdef ENABLE_VALGRIND_ANNOTATIONS
4432 /* Valgrind warns about uses of interior pointers, so put _cpp_buff
4433 struct first. */
4434 size_t slen = CPP_ALIGN2 (sizeof (_cpp_buff), 2 * DEFAULT_ALIGNMENT)(((sizeof (_cpp_buff)) + ((2 * __builtin_offsetof(struct dummy
, u)) - 1)) & ~((2 * __builtin_offsetof(struct dummy, u))
- 1))
;
4435 base = XNEWVEC (unsigned char, len + slen)((unsigned char *) xmalloc (sizeof (unsigned char) * (len + slen
)))
;
4436 result = (_cpp_buff *) base;
4437 base += slen;
4438#else
4439 base = XNEWVEC (unsigned char, len + sizeof (_cpp_buff))((unsigned char *) xmalloc (sizeof (unsigned char) * (len + sizeof
(_cpp_buff))))
;
4440 result = (_cpp_buff *) (base + len);
4441#endif
4442 result->base = base;
4443 result->cur = base;
4444 result->limit = base + len;
4445 result->next = NULL__null;
4446 return result;
4447}
4448
4449/* Place a chain of unwanted allocation buffers on the free list. */
4450void
4451_cpp_release_buff (cpp_reader *pfile, _cpp_buff *buff)
4452{
4453 _cpp_buff *end = buff;
4454
4455 while (end->next)
4456 end = end->next;
4457 end->next = pfile->free_buffs;
4458 pfile->free_buffs = buff;
4459}
4460
4461/* Return a free buffer of size at least MIN_SIZE. */
4462_cpp_buff *
4463_cpp_get_buff (cpp_reader *pfile, size_t min_size)
4464{
4465 _cpp_buff *result, **p;
4466
4467 for (p = &pfile->free_buffs;; p = &(*p)->next)
4468 {
4469 size_t size;
4470
4471 if (*p == NULL__null)
4472 return new_buff (min_size);
4473 result = *p;
4474 size = result->limit - result->base;
4475 /* Return a buffer that's big enough, but don't waste one that's
4476 way too big. */
4477 if (size >= min_size && size <= BUFF_SIZE_UPPER_BOUND (min_size)(8000 + (min_size) * 3 / 2))
4478 break;
4479 }
4480
4481 *p = result->next;
4482 result->next = NULL__null;
4483 result->cur = result->base;
4484 return result;
4485}
4486
4487/* Creates a new buffer with enough space to hold the uncommitted
4488 remaining bytes of BUFF, and at least MIN_EXTRA more bytes. Copies
4489 the excess bytes to the new buffer. Chains the new buffer after
4490 BUFF, and returns the new buffer. */
4491_cpp_buff *
4492_cpp_append_extend_buff (cpp_reader *pfile, _cpp_buff *buff, size_t min_extra)
4493{
4494 size_t size = EXTENDED_BUFF_SIZE (buff, min_extra)(min_extra + ((buff)->limit - (buff)->cur) * 2);
4495 _cpp_buff *new_buff = _cpp_get_buff (pfile, size);
4496
4497 buff->next = new_buff;
4498 memcpy (new_buff->base, buff->cur, BUFF_ROOM (buff)(size_t) ((buff)->limit - (buff)->cur));
4499 return new_buff;
4500}
4501
4502/* Creates a new buffer with enough space to hold the uncommitted
4503 remaining bytes of the buffer pointed to by BUFF, and at least
4504 MIN_EXTRA more bytes. Copies the excess bytes to the new buffer.
4505 Chains the new buffer before the buffer pointed to by BUFF, and
4506 updates the pointer to point to the new buffer. */
4507void
4508_cpp_extend_buff (cpp_reader *pfile, _cpp_buff **pbuff, size_t min_extra)
4509{
4510 _cpp_buff *new_buff, *old_buff = *pbuff;
4511 size_t size = EXTENDED_BUFF_SIZE (old_buff, min_extra)(min_extra + ((old_buff)->limit - (old_buff)->cur) * 2);
4512
4513 new_buff = _cpp_get_buff (pfile, size);
4514 memcpy (new_buff->base, old_buff->cur, BUFF_ROOM (old_buff)(size_t) ((old_buff)->limit - (old_buff)->cur));
4515 new_buff->next = old_buff;
4516 *pbuff = new_buff;
4517}
4518
4519/* Free a chain of buffers starting at BUFF. */
4520void
4521_cpp_free_buff (_cpp_buff *buff)
4522{
4523 _cpp_buff *next;
4524
4525 for (; buff; buff = next)
4526 {
4527 next = buff->next;
4528#ifdef ENABLE_VALGRIND_ANNOTATIONS
4529 free (buff);
4530#else
4531 free (buff->base);
4532#endif
4533 }
4534}
4535
4536/* Allocate permanent, unaligned storage of length LEN. */
4537unsigned char *
4538_cpp_unaligned_alloc (cpp_reader *pfile, size_t len)
4539{
4540 _cpp_buff *buff = pfile->u_buff;
4541 unsigned char *result = buff->cur;
4542
4543 if (len > (size_t) (buff->limit - result))
4544 {
4545 buff = _cpp_get_buff (pfile, len);
4546 buff->next = pfile->u_buff;
4547 pfile->u_buff = buff;
4548 result = buff->cur;
4549 }
4550
4551 buff->cur = result + len;
4552 return result;
4553}
4554
4555/* Allocate permanent, unaligned storage of length LEN from a_buff.
4556 That buffer is used for growing allocations when saving macro
4557 replacement lists in a #define, and when parsing an answer to an
4558 assertion in #assert, #unassert or #if (and therefore possibly
4559 whilst expanding macros). It therefore must not be used by any
4560 code that they might call: specifically the lexer and the guts of
4561 the macro expander.
4562
4563 All existing other uses clearly fit this restriction: storing
4564 registered pragmas during initialization. */
4565unsigned char *
4566_cpp_aligned_alloc (cpp_reader *pfile, size_t len)
4567{
4568 _cpp_buff *buff = pfile->a_buff;
4569 unsigned char *result = buff->cur;
4570
4571 if (len > (size_t) (buff->limit - result))
4572 {
4573 buff = _cpp_get_buff (pfile, len);
4574 buff->next = pfile->a_buff;
4575 pfile->a_buff = buff;
4576 result = buff->cur;
4577 }
4578
4579 buff->cur = result + len;
4580 return result;
4581}
4582
4583/* Commit or allocate storage from a buffer. */
4584
4585void *
4586_cpp_commit_buff (cpp_reader *pfile, size_t size)
4587{
4588 void *ptr = BUFF_FRONT (pfile->a_buff)((pfile->a_buff)->cur);
4589
4590 if (pfile->hash_table->alloc_subobject)
4591 {
4592 void *copy = pfile->hash_table->alloc_subobject (size);
4593 memcpy (copy, ptr, size);
4594 ptr = copy;
4595 }
4596 else
4597 BUFF_FRONT (pfile->a_buff)((pfile->a_buff)->cur) += size;
4598
4599 return ptr;
4600}
4601
4602/* Say which field of TOK is in use. */
4603
4604enum cpp_token_fld_kind
4605cpp_token_val_index (const cpp_token *tok)
4606{
4607 switch (TOKEN_SPELL (tok)(token_spellings[(tok)->type].category))
4608 {
4609 case SPELL_IDENT:
4610 return CPP_TOKEN_FLD_NODE;
4611 case SPELL_LITERAL:
4612 return CPP_TOKEN_FLD_STR;
4613 case SPELL_OPERATOR:
4614 /* Operands which were originally spelled as ident keep around
4615 the node for the exact spelling. */
4616 if (tok->flags & NAMED_OP(1 << 4))
4617 return CPP_TOKEN_FLD_NODE;
4618 else if (tok->type == CPP_PASTE)
4619 return CPP_TOKEN_FLD_TOKEN_NO;
4620 else
4621 return CPP_TOKEN_FLD_NONE;
4622 case SPELL_NONE:
4623 if (tok->type == CPP_MACRO_ARG)
4624 return CPP_TOKEN_FLD_ARG_NO;
4625 else if (tok->type == CPP_PADDING)
4626 return CPP_TOKEN_FLD_SOURCE;
4627 else if (tok->type == CPP_PRAGMA)
4628 return CPP_TOKEN_FLD_PRAGMA;
4629 /* fall through */
4630 default:
4631 return CPP_TOKEN_FLD_NONE;
4632 }
4633}
4634
4635/* All tokens lexed in R after calling this function will be forced to
4636 have their location_t to be P, until
4637 cpp_stop_forcing_token_locations is called for R. */
4638
4639void
4640cpp_force_token_locations (cpp_reader *r, location_t loc)
4641{
4642 r->forced_token_location = loc;
4643}
4644
4645/* Go back to assigning locations naturally for lexed tokens. */
4646
4647void
4648cpp_stop_forcing_token_locations (cpp_reader *r)
4649{
4650 r->forced_token_location = 0;
4651}
4652
4653/* We're looking at \, if it's escaping EOL, look past it. If at
4654 LIMIT, don't advance. */
4655
4656static const unsigned char *
4657do_peek_backslash (const unsigned char *peek, const unsigned char *limit)
4658{
4659 const unsigned char *probe = peek;
4660
4661 if (__builtin_expect (peek[1] == '\n', true))
4662 {
4663 eol:
4664 probe += 2;
4665 if (__builtin_expect (probe < limit, true))
4666 {
4667 peek = probe;
4668 if (*peek == '\\')
4669 /* The user might be perverse. */
4670 return do_peek_backslash (peek, limit);
4671 }
4672 }
4673 else if (__builtin_expect (peek[1] == '\r', false))
4674 {
4675 if (probe[2] == '\n')
4676 probe++;
4677 goto eol;
4678 }
4679
4680 return peek;
4681}
4682
4683static const unsigned char *
4684do_peek_next (const unsigned char *peek, const unsigned char *limit)
4685{
4686 if (__builtin_expect (*peek == '\\', false))
4687 peek = do_peek_backslash (peek, limit);
4688 return peek;
4689}
4690
4691static const unsigned char *
4692do_peek_prev (const unsigned char *peek, const unsigned char *bound)
4693{
4694 if (peek == bound)
4695 return NULL__null;
4696
4697 unsigned char c = *--peek;
4698 if (__builtin_expect (c == '\n', false)
4699 || __builtin_expect (c == 'r', false))
4700 {
4701 if (peek == bound)
4702 return peek;
4703 int ix = -1;
4704 if (c == '\n' && peek[ix] == '\r')
4705 {
4706 if (peek + ix == bound)
4707 return peek;
4708 ix--;
4709 }
4710
4711 if (peek[ix] == '\\')
4712 return do_peek_prev (peek + ix, bound);
4713
4714 return peek;
4715 }
4716 else
4717 return peek;
4718}
4719
4720/* If PEEK[-1] is identifier MATCH, scan past it and trailing white
4721 space. Otherwise return NULL. */
4722
4723static const unsigned char *
4724do_peek_ident (const char *match, const unsigned char *peek,
4725 const unsigned char *limit)
4726{
4727 for (; *++match; peek++)
4728 if (*peek != *match)
4729 {
4730 peek = do_peek_next (peek, limit);
4731 if (*peek != *match)
4732 return NULL__null;
4733 }
4734
4735 /* Must now not be looking at an identifier char. */
4736 peek = do_peek_next (peek, limit);
4737 if (ISIDNUM (*peek)(_sch_istable[(*peek) & 0xff] & (unsigned short)(_sch_isidnum
))
)
4738 return NULL__null;
4739
4740 /* Skip control-line whitespace. */
4741 ws:
4742 while (*peek == ' ' || *peek == '\t')
4743 peek++;
4744 if (__builtin_expect (*peek == '\\', false))
4745 {
4746 peek = do_peek_backslash (peek, limit);
4747 if (*peek != '\\')
4748 goto ws;
4749 }
4750
4751 return peek;
4752}
4753
4754/* Are we looking at a module control line starting as PEEK - 1? */
4755
4756static bool
4757do_peek_module (cpp_reader *pfile, unsigned char c,
4758 const unsigned char *peek, const unsigned char *limit)
4759{
4760 bool import = false;
4761
4762 if (__builtin_expect (c == 'e', false))
4763 {
4764 if (!((peek[0] == 'x' || peek[0] == '\\')
4765 && (peek = do_peek_ident ("export", peek, limit))))
4766 return false;
4767
4768 /* export, peek for import or module. No need to peek __import
4769 here. */
4770 if (peek[0] == 'i')
4771 {
4772 if (!((peek[1] == 'm' || peek[1] == '\\')
4773 && (peek = do_peek_ident ("import", peek + 1, limit))))
4774 return false;
4775 import = true;
4776 }
4777 else if (peek[0] == 'm')
4778 {
4779 if (!((peek[1] == 'o' || peek[1] == '\\')
4780 && (peek = do_peek_ident ("module", peek + 1, limit))))
4781 return false;
4782 }
4783 else
4784 return false;
4785 }
4786 else if (__builtin_expect (c == 'i', false))
4787 {
4788 if (!((peek[0] == 'm' || peek[0] == '\\')
4789 && (peek = do_peek_ident ("import", peek, limit))))
4790 return false;
4791 import = true;
4792 }
4793 else if (__builtin_expect (c == '_', false))
4794 {
4795 /* Needed for translated includes. */
4796 if (!((peek[0] == '_' || peek[0] == '\\')
4797 && (peek = do_peek_ident ("__import", peek, limit))))
4798 return false;
4799 import = true;
4800 }
4801 else if (__builtin_expect (c == 'm', false))
4802 {
4803 if (!((peek[0] == 'o' || peek[0] == '\\')
4804 && (peek = do_peek_ident ("module", peek, limit))))
4805 return false;
4806 }
4807 else
4808 return false;
4809
4810 /* Peek the next character to see if it's good enough. We'll be at
4811 the first non-whitespace char, including skipping an escaped
4812 newline. */
4813 /* ... import followed by identifier, ':', '<' or header-name
4814 preprocessing tokens, or module followed by identifier, ':' or
4815 ';' preprocessing tokens. */
4816 unsigned char p = *peek++;
4817
4818 /* A character literal is ... single quotes, ... optionally preceded
4819 by u8, u, U, or L */
4820 /* A string-literal is a ... double quotes, optionally prefixed by
4821 R, u8, u8R, u, uR, U, UR, L, or LR */
4822 if (p == 'u')
4823 {
4824 peek = do_peek_next (peek, limit);
4825 if (*peek == '8')
4826 {
4827 peek++;
4828 goto peek_u8;
4829 }
4830 goto peek_u;
4831 }
4832 else if (p == 'U' || p == 'L')
4833 {
4834 peek_u8:
4835 peek = do_peek_next (peek, limit);
4836 peek_u:
4837 if (*peek == '\"' || *peek == '\'')
4838 return false;
4839
4840 if (*peek == 'R')
4841 goto peek_R;
4842 /* Identifier. Ok. */
4843 }
4844 else if (p == 'R')
4845 {
4846 peek_R:
4847 if (CPP_OPTION (pfile, rliterals)((pfile)->opts.rliterals))
4848 {
4849 peek = do_peek_next (peek, limit);
4850 if (*peek == '\"')
4851 return false;
4852 }
4853 /* Identifier. Ok. */
4854 }
4855 else if ('Z' - 'A' == 25
4856 ? ((p >= 'A' && p <= 'Z') || (p >= 'a' && p <= 'z') || p == '_')
4857 : ISIDST (p)(_sch_istable[(p) & 0xff] & (unsigned short)(_sch_isidst
))
)
4858 {
4859 /* Identifier. Ok. */
4860 }
4861 else if (p == '<')
4862 {
4863 /* Maybe angle header, ok for import. Reject
4864 '<=', '<<' digraph:'<:'. */
4865 if (!import)
4866 return false;
4867 peek = do_peek_next (peek, limit);
4868 if (*peek == '=' || *peek == '<'
4869 || (*peek == ':' && CPP_OPTION (pfile, digraphs)((pfile)->opts.digraphs)))
4870 return false;
4871 }
4872 else if (p == ';')
4873 {
4874 /* SEMICOLON, ok for module. */
4875 if (import)
4876 return false;
4877 }
4878 else if (p == '"')
4879 {
4880 /* STRING, ok for import. */
4881 if (!import)
4882 return false;
4883 }
4884 else if (p == ':')
4885 {
4886 /* Maybe COLON, ok. Reject '::', digraph:':>'. */
4887 peek = do_peek_next (peek, limit);
4888 if (*peek == ':' || (*peek == '>' && CPP_OPTION (pfile, digraphs)((pfile)->opts.digraphs)))
4889 return false;
4890 }
4891 else
4892 /* FIXME: Detect a unicode character, excluding those not
4893 permitted as the initial character. [lex.name]/1. I presume
4894 we need to check the \[uU] spellings, and directly using
4895 Unicode in say UTF8 form? Or perhaps we do the phase-1
4896 conversion of UTF8 to universal-character-names? */
4897 return false;
4898
4899 return true;
4900}
4901
4902/* Directives-only scanning. Somewhat more relaxed than correct
4903 parsing -- some ill-formed programs will not be rejected. */
4904
4905void
4906cpp_directive_only_process (cpp_reader *pfile,
4907 void *data,
4908 void (*cb) (cpp_reader *, CPP_DO_task, void *, ...))
4909{
4910 bool module_p = CPP_OPTION (pfile, module_directives)((pfile)->opts.module_directives);
4911
4912 do
4913 {
4914 restart:
4915 /* Buffer initialization, but no line cleaning. */
4916 cpp_buffer *buffer = pfile->buffer;
4917 buffer->cur_note = buffer->notes_used = 0;
4918 buffer->cur = buffer->line_base = buffer->next_line;
4919 buffer->need_line = false;
4920 /* Files always end in a newline or carriage return. We rely on this for
4921 character peeking safety. */
4922 gcc_assert (buffer->rlimit[0] == '\n' || buffer->rlimit[0] == '\r')((void)(!(buffer->rlimit[0] == '\n' || buffer->rlimit[0
] == '\r') ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 4922, __FUNCTION__), 0 : 0))
;
4923
4924 const unsigned char *base = buffer->cur;
4925 unsigned line_count = 0;
4926 const unsigned char *line_start = base;
4927
4928 bool bol = true;
4929 bool raw = false;
4930
4931 const unsigned char *lwm = base;
4932 for (const unsigned char *pos = base, *limit = buffer->rlimit;
4933 pos < limit;)
4934 {
4935 unsigned char c = *pos++;
4936 /* This matches the switch in _cpp_lex_direct. */
4937 switch (c)
4938 {
4939 case ' ': case '\t': case '\f': case '\v':
4940 /* Whitespace, do nothing. */
4941 break;
4942
4943 case '\r': /* MAC line ending, or Windows \r\n */
4944 if (*pos == '\n')
4945 pos++;
4946 /* FALLTHROUGH */
4947
4948 case '\n':
4949 bol = true;
4950
4951 next_line:
4952 CPP_INCREMENT_LINE (pfile, 0)do { const class line_maps *line_table = pfile->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (pfile->line_table,
line + 1, 0); } while (0)
;
4953 line_count++;
4954 line_start = pos;
4955 break;
4956
4957 case '\\':
4958 /* <backslash><newline> is removed, and doesn't undo any
4959 preceeding escape or whatnot. */
4960 if (*pos == '\n')
4961 {
4962 pos++;
4963 goto next_line;
4964 }
4965 else if (*pos == '\r')
4966 {
4967 if (pos[1] == '\n')
4968 pos++;
4969 pos++;
4970 goto next_line;
4971 }
4972 goto dflt;
4973
4974 case '#':
4975 if (bol)
4976 {
4977 /* Line directive. */
4978 if (pos - 1 > base && !pfile->state.skipping)
4979 cb (pfile, CPP_DO_print, data,
4980 line_count, base, pos - 1 - base);
4981
4982 /* Prep things for directive handling. */
4983 buffer->next_line = pos;
4984 buffer->need_line = true;
4985 bool ok = _cpp_get_fresh_line (pfile);
4986 gcc_checking_assert (ok)((void)(!(ok) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 4986, __FUNCTION__), 0 : 0))
;
4987
4988 /* Ensure proper column numbering for generated
4989 error messages. */
4990 buffer->line_base -= pos - line_start;
4991
4992 _cpp_handle_directive (pfile, line_start + 1 != pos);
4993
4994 /* Sanitize the line settings. Duplicate #include's can
4995 mess things up. */
4996 // FIXME: Necessary?
4997 pfile->line_table->highest_location
4998 = pfile->line_table->highest_line;
4999
5000 if (!pfile->state.skipping
5001 && pfile->buffer->next_line < pfile->buffer->rlimit)
5002 cb (pfile, CPP_DO_location, data,
5003 pfile->line_table->highest_line);
5004
5005 goto restart;
5006 }
5007 goto dflt;
5008
5009 case '/':
5010 {
5011 const unsigned char *peek = do_peek_next (pos, limit);
5012 if (!(*peek == '/' || *peek == '*'))
5013 goto dflt;
5014
5015 /* Line or block comment */
5016 bool is_block = *peek == '*';
5017 bool star = false;
5018 bool esc = false;
5019 location_t sloc
5020 = linemap_position_for_column (pfile->line_table,
5021 pos - line_start);
5022
5023 while (pos < limit)
5024 {
5025 char c = *pos++;
5026 switch (c)
5027 {
5028 case '\\':
5029 esc = true;
5030 break;
5031
5032 case '\r':
5033 if (*pos == '\n')
5034 pos++;
5035 /* FALLTHROUGH */
5036
5037 case '\n':
5038 {
5039 CPP_INCREMENT_LINE (pfile, 0)do { const class line_maps *line_table = pfile->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (pfile->line_table,
line + 1, 0); } while (0)
;
5040 line_count++;
5041 line_start = pos;
5042 if (!esc && !is_block)
5043 {
5044 bol = true;
5045 goto done_comment;
5046 }
5047 }
5048 if (!esc)
5049 star = false;
5050 esc = false;
5051 break;
5052
5053 case '*':
5054 if (pos > peek)
5055 star = is_block;
5056 esc = false;
5057 break;
5058
5059 case '/':
5060 if (star)
5061 goto done_comment;
5062 /* FALLTHROUGH */
5063
5064 default:
5065 star = false;
5066 esc = false;
5067 break;
5068 }
5069 }
5070 if (pos < limit || is_block)
5071 cpp_error_with_line (pfile, CPP_DL_ERROR, sloc, 0,
5072 "unterminated comment");
5073 done_comment:
5074 lwm = pos;
5075 break;
5076 }
5077
5078 case '\'':
5079 if (!CPP_OPTION (pfile, digit_separators)((pfile)->opts.digit_separators))
5080 goto delimited_string;
5081
5082 /* Possibly a number punctuator. */
5083 if (!ISIDNUM (*do_peek_next (pos, limit))(_sch_istable[(*do_peek_next (pos, limit)) & 0xff] & (
unsigned short)(_sch_isidnum))
)
5084 goto delimited_string;
5085
5086 goto quote_peek;
5087
5088 case '\"':
5089 if (!CPP_OPTION (pfile, rliterals)((pfile)->opts.rliterals))
5090 goto delimited_string;
5091
5092 quote_peek:
5093 {
5094 /* For ' see if it's a number punctuator
5095 \.?<digit>(<digit>|<identifier-nondigit>
5096 |'<digit>|'<nondigit>|[eEpP]<sign>|\.)* */
5097 /* For " see if it's a raw string
5098 {U,L,u,u8}R. This includes CPP_NUMBER detection,
5099 because that could be 0e+R. */
5100 const unsigned char *peek = pos - 1;
5101 bool quote_first = c == '"';
5102 bool quote_eight = false;
5103 bool maybe_number_start = false;
5104 bool want_number = false;
5105
5106 while ((peek = do_peek_prev (peek, lwm)))
5107 {
5108 unsigned char p = *peek;
5109 if (quote_first)
5110 {
5111 if (!raw)
5112 {
5113 if (p != 'R')
5114 break;
5115 raw = true;
5116 continue;
5117 }
5118
5119 quote_first = false;
5120 if (p == 'L' || p == 'U' || p == 'u')
5121 ;
5122 else if (p == '8')
5123 quote_eight = true;
5124 else
5125 goto second_raw;
5126 }
5127 else if (quote_eight)
5128 {
5129 if (p != 'u')
5130 {
5131 raw = false;
5132 break;
5133 }
5134 quote_eight = false;
5135 }
5136 else if (c == '"')
5137 {
5138 second_raw:;
5139 if (!want_number && ISIDNUM (p)(_sch_istable[(p) & 0xff] & (unsigned short)(_sch_isidnum
))
)
5140 {
5141 raw = false;
5142 break;
5143 }
5144 }
5145
5146 if (ISDIGIT (p)(_sch_istable[(p) & 0xff] & (unsigned short)(_sch_isdigit
))
)
5147 maybe_number_start = true;
5148 else if (p == '.')
5149 want_number = true;
5150 else if (ISIDNUM (p)(_sch_istable[(p) & 0xff] & (unsigned short)(_sch_isidnum
))
)
5151 maybe_number_start = false;
5152 else if (p == '+' || p == '-')
5153 {
5154 if (const unsigned char *peek_prev
5155 = do_peek_prev (peek, lwm))
5156 {
5157 p = *peek_prev;
5158 if (p == 'e' || p == 'E'
5159 || p == 'p' || p == 'P')
5160 {
5161 want_number = true;
5162 maybe_number_start = false;
5163 }
5164 else
5165 break;
5166 }
5167 else
5168 break;
5169 }
5170 else if (p == '\'' || p == '\"')
5171 {
5172 /* If this is lwm, this must be the end of a
5173 previous string. So this is a trailing
5174 literal type, (a) if those are allowed,
5175 and (b) maybe_start is false. Otherwise
5176 this must be a CPP_NUMBER because we've
5177 met another ', and we'd have checked that
5178 in its own right. */
5179 if (peek == lwm && CPP_OPTION (pfile, uliterals)((pfile)->opts.uliterals))
5180 {
5181 if (!maybe_number_start && !want_number)
5182 /* Must be a literal type. */
5183 raw = false;
5184 }
5185 else if (p == '\''
5186 && CPP_OPTION (pfile, digit_separators)((pfile)->opts.digit_separators))
5187 maybe_number_start = true;
5188 break;
5189 }
5190 else if (c == '\'')
5191 break;
5192 else if (!quote_first && !quote_eight)
5193 break;
5194 }
5195
5196 if (maybe_number_start)
5197 {
5198 if (c == '\'')
5199 /* A CPP NUMBER. */
5200 goto dflt;
5201 raw = false;
5202 }
5203
5204 goto delimited_string;
5205 }
5206
5207 delimited_string:
5208 {
5209 /* (Possibly raw) string or char literal. */
5210 unsigned char end = c;
5211 int delim_len = -1;
5212 const unsigned char *delim = NULL__null;
5213 location_t sloc = linemap_position_for_column (pfile->line_table,
5214 pos - line_start);
5215 int esc = 0;
5216
5217 if (raw)
5218 {
5219 /* There can be no line breaks in the delimiter. */
5220 delim = pos;
5221 for (delim_len = 0; (c = *pos++) != '('; delim_len++)
5222 {
5223 if (delim_len == 16)
5224 {
5225 cpp_error_with_line (pfile, CPP_DL_ERROR,
5226 sloc, 0,
5227 "raw string delimiter"
5228 " longer than %d"
5229 " characters",
5230 delim_len);
5231 raw = false;
5232 pos = delim;
5233 break;
5234 }
5235 if (strchr (") \\\t\v\f\n", c))
5236 {
5237 cpp_error_with_line (pfile, CPP_DL_ERROR,
5238 sloc, 0,
5239 "invalid character '%c'"
5240 " in raw string"
5241 " delimiter", c);
5242 raw = false;
5243 pos = delim;
5244 break;
5245 }
5246 if (pos >= limit)
5247 goto bad_string;
5248 }
5249 }
5250
5251 while (pos < limit)
5252 {
5253 char c = *pos++;
5254 switch (c)
5255 {
5256 case '\\':
5257 if (!raw)
5258 esc++;
5259 break;
5260
5261 case '\r':
5262 if (*pos == '\n')
5263 pos++;
5264 /* FALLTHROUGH */
5265
5266 case '\n':
5267 {
5268 CPP_INCREMENT_LINE (pfile, 0)do { const class line_maps *line_table = pfile->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (pfile->line_table,
line + 1, 0); } while (0)
;
5269 line_count++;
5270 line_start = pos;
5271 }
5272 if (esc)
5273 esc--;
5274 break;
5275
5276 case ')':
5277 if (raw
5278 && pos + delim_len + 1 < limit
5279 && pos[delim_len] == end
5280 && !memcmp (delim, pos, delim_len))
5281 {
5282 pos += delim_len + 1;
5283 raw = false;
5284 goto done_string;
5285 }
5286 break;
5287
5288 default:
5289 if (!raw && !(esc & 1) && c == end)
5290 goto done_string;
5291 esc = 0;
5292 break;
5293 }
5294 }
5295 bad_string:
5296 cpp_error_with_line (pfile, CPP_DL_ERROR, sloc, 0,
5297 "unterminated literal");
5298
5299 done_string:
5300 raw = false;
5301 lwm = pos - 1;
5302 }
5303 goto dflt;
5304
5305 case '_':
5306 case 'e':
5307 case 'i':
5308 case 'm':
5309 if (bol && module_p && !pfile->state.skipping
5310 && do_peek_module (pfile, c, pos, limit))
5311 {
5312 /* We've seen the start of a module control line.
5313 Start up the tokenizer. */
5314 pos--; /* Backup over the first character. */
5315
5316 /* Backup over whitespace to start of line. */
5317 while (pos > line_start
5318 && (pos[-1] == ' ' || pos[-1] == '\t'))
5319 pos--;
5320
5321 if (pos > base)
5322 cb (pfile, CPP_DO_print, data, line_count, base, pos - base);
5323
5324 /* Prep things for directive handling. */
5325 buffer->next_line = pos;
5326 buffer->need_line = true;
5327
5328 /* Now get tokens until the PRAGMA_EOL. */
5329 do
5330 {
5331 location_t spelling;
5332 const cpp_token *tok
5333 = cpp_get_token_with_location (pfile, &spelling);
5334
5335 gcc_assert (pfile->state.in_deferred_pragma((void)(!(pfile->state.in_deferred_pragma || tok->type ==
CPP_PRAGMA_EOL) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 5336, __FUNCTION__), 0 : 0))
5336 || tok->type == CPP_PRAGMA_EOL)((void)(!(pfile->state.in_deferred_pragma || tok->type ==
CPP_PRAGMA_EOL) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/lex.c"
, 5336, __FUNCTION__), 0 : 0))
;
5337 cb (pfile, CPP_DO_token, data, tok, spelling);
5338 }
5339 while (pfile->state.in_deferred_pragma);
5340
5341 if (pfile->buffer->next_line < pfile->buffer->rlimit)
5342 cb (pfile, CPP_DO_location, data,
5343 pfile->line_table->highest_line);
5344
5345 pfile->mi_valid = false;
5346 goto restart;
5347 }
5348 goto dflt;
5349
5350 default:
5351 dflt:
5352 bol = false;
5353 pfile->mi_valid = false;
5354 break;
5355 }
5356 }
5357
5358 if (buffer->rlimit > base && !pfile->state.skipping)
5359 {
5360 const unsigned char *limit = buffer->rlimit;
5361 /* If the file was not newline terminated, add rlimit, which is
5362 guaranteed to point to a newline, to the end of our range. */
5363 if (limit[-1] != '\n')
5364 {
5365 limit++;
5366 CPP_INCREMENT_LINE (pfile, 0)do { const class line_maps *line_table = pfile->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (pfile->line_table,
line + 1, 0); } while (0)
;
5367 line_count++;
5368 }
5369 cb (pfile, CPP_DO_print, data, line_count, base, limit - base);
5370 }
5371
5372 _cpp_pop_buffer (pfile);
5373 }
5374 while (pfile->buffer);
5375}

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/internal.h

1/* Part of CPP library.
2 Copyright (C) 1997-2021 Free Software Foundation, Inc.
3
4This program is free software; you can redistribute it and/or modify it
5under the terms of the GNU General Public License as published by the
6Free Software Foundation; either version 3, or (at your option) any
7later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12GNU General Public License for more details.
13
14You should have received a copy of the GNU General Public License
15along with this program; see the file COPYING3. If not see
16<http://www.gnu.org/licenses/>. */
17
18/* This header defines all the internal data structures and functions
19 that need to be visible across files. It should not be used outside
20 cpplib. */
21
22#ifndef LIBCPP_INTERNAL_H
23#define LIBCPP_INTERNAL_H
24
25#include "symtab.h"
26#include "cpplib.h"
27
28#if HAVE_ICONV1
29#include <iconv.h>
30#else
31#define HAVE_ICONV1 0
32typedef int iconv_t; /* dummy */
33#endif
34
35#ifdef __cplusplus201402L
36extern "C" {
37#endif
38
39struct directive; /* Deliberately incomplete. */
40struct pending_option;
41struct op;
42struct _cpp_strbuf;
43
44typedef bool (*convert_f) (iconv_t, const unsigned char *, size_t,
45 struct _cpp_strbuf *);
46struct cset_converter
47{
48 convert_f func;
49 iconv_t cd;
50 int width;
51 const char* from;
52 const char* to;
53};
54
55#define BITS_PER_CPPCHAR_T(8 * sizeof (cppchar_t)) (CHAR_BIT8 * sizeof (cppchar_t))
56
57/* Test if a sign is valid within a preprocessing number. */
58#define VALID_SIGN(c, prevc)(((c) == '+' || (c) == '-') && ((prevc) == 'e' || (prevc
) == 'E' || (((prevc) == 'p' || (prevc) == 'P') && ((
pfile)->opts.extended_numbers))))
\
59 (((c) == '+' || (c) == '-') && \
60 ((prevc) == 'e' || (prevc) == 'E' \
61 || (((prevc) == 'p' || (prevc) == 'P') \
62 && CPP_OPTION (pfile, extended_numbers)((pfile)->opts.extended_numbers))))
63
64#define DIGIT_SEP(c)((c) == '\'' && ((pfile)->opts.digit_separators)) ((c) == '\'' && CPP_OPTION (pfile, digit_separators)((pfile)->opts.digit_separators))
65
66#define CPP_OPTION(PFILE, OPTION)((PFILE)->opts.OPTION) ((PFILE)->opts.OPTION)
67#define CPP_BUFFER(PFILE)((PFILE)->buffer) ((PFILE)->buffer)
68#define CPP_BUF_COLUMN(BUF, CUR)((CUR) - (BUF)->line_base) ((CUR) - (BUF)->line_base)
69#define CPP_BUF_COL(BUF)(((BUF)->cur) - (BUF)->line_base) CPP_BUF_COLUMN(BUF, (BUF)->cur)(((BUF)->cur) - (BUF)->line_base)
70
71#define CPP_INCREMENT_LINE(PFILE, COLS_HINT)do { const class line_maps *line_table = PFILE->line_table
; const struct line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP
(line_table); linenum_type line = SOURCE_LINE (map, line_table
->highest_line); linemap_line_start (PFILE->line_table,
line + 1, COLS_HINT); } while (0)
do { \
72 const class line_maps *line_table = PFILE->line_table; \
73 const struct line_map_ordinary *map = \
74 LINEMAPS_LAST_ORDINARY_MAP (line_table); \
75 linenum_type line = SOURCE_LINE (map, line_table->highest_line); \
76 linemap_line_start (PFILE->line_table, line + 1, COLS_HINT); \
77 } while (0)
78
79/* Host alignment handling. */
80struct dummy
81{
82 char c;
83 union
84 {
85 double d;
86 int *p;
87 } u;
88};
89
90#define DEFAULT_ALIGNMENT__builtin_offsetof(struct dummy, u) offsetof (struct dummy, u)__builtin_offsetof(struct dummy, u)
91#define CPP_ALIGN2(size, align)(((size) + ((align) - 1)) & ~((align) - 1)) (((size) + ((align) - 1)) & ~((align) - 1))
92#define CPP_ALIGN(size)(((size) + ((__builtin_offsetof(struct dummy, u)) - 1)) &
~((__builtin_offsetof(struct dummy, u)) - 1))
CPP_ALIGN2 (size, DEFAULT_ALIGNMENT)(((size) + ((__builtin_offsetof(struct dummy, u)) - 1)) &
~((__builtin_offsetof(struct dummy, u)) - 1))
93
94#define _cpp_mark_macro_used(NODE)(cpp_user_macro_p (NODE) ? (NODE)->value.macro->used = 1
: 0)
\
95 (cpp_user_macro_p (NODE) ? (NODE)->value.macro->used = 1 : 0)
96
97/* A generic memory buffer, and operations on it. */
98typedef struct _cpp_buff _cpp_buff;
99struct _cpp_buff
100{
101 struct _cpp_buff *next;
102 unsigned char *base, *cur, *limit;
103};
104
105extern _cpp_buff *_cpp_get_buff (cpp_reader *, size_t);
106extern void _cpp_release_buff (cpp_reader *, _cpp_buff *);
107extern void _cpp_extend_buff (cpp_reader *, _cpp_buff **, size_t);
108extern _cpp_buff *_cpp_append_extend_buff (cpp_reader *, _cpp_buff *, size_t);
109extern void _cpp_free_buff (_cpp_buff *);
110extern unsigned char *_cpp_aligned_alloc (cpp_reader *, size_t);
111extern unsigned char *_cpp_unaligned_alloc (cpp_reader *, size_t);
112
113#define BUFF_ROOM(BUFF)(size_t) ((BUFF)->limit - (BUFF)->cur) (size_t) ((BUFF)->limit - (BUFF)->cur)
114#define BUFF_FRONT(BUFF)((BUFF)->cur) ((BUFF)->cur)
115#define BUFF_LIMIT(BUFF)((BUFF)->limit) ((BUFF)->limit)
116
117/* #include types. */
118enum include_type
119 {
120 /* Directive-based including mechanisms. */
121 IT_INCLUDE, /* #include */
122 IT_INCLUDE_NEXT, /* #include_next */
123 IT_IMPORT, /* #import */
124
125 /* Non-directive including mechanisms. */
126 IT_CMDLINE, /* -include */
127 IT_DEFAULT, /* forced header */
128 IT_MAIN, /* main, start on line 1 */
129 IT_PRE_MAIN, /* main, but there will be a preamble before line
130 1 */
131
132 IT_DIRECTIVE_HWM = IT_IMPORT + 1, /* Directives below this. */
133 IT_HEADER_HWM = IT_DEFAULT + 1 /* Header files below this. */
134 };
135
136union utoken
137{
138 const cpp_token *token;
139 const cpp_token **ptoken;
140};
141
142/* A "run" of tokens; part of a chain of runs. */
143typedef struct tokenrun tokenrun;
144struct tokenrun
145{
146 tokenrun *next, *prev;
147 cpp_token *base, *limit;
148};
149
150/* Accessor macros for struct cpp_context. */
151#define FIRST(c)((c)->u.iso.first) ((c)->u.iso.first)
152#define LAST(c)((c)->u.iso.last) ((c)->u.iso.last)
153#define CUR(c)((c)->u.trad.cur) ((c)->u.trad.cur)
154#define RLIMIT(c)((c)->u.trad.rlimit) ((c)->u.trad.rlimit)
155
156/* This describes some additional data that is added to the macro
157 token context of type cpp_context, when -ftrack-macro-expansion is
158 on. */
159typedef struct
160{
161 /* The node of the macro we are referring to. */
162 cpp_hashnode *macro_node;
163 /* This buffer contains an array of virtual locations. The virtual
164 location at index 0 is the virtual location of the token at index
165 0 in the current instance of cpp_context; similarly for all the
166 other virtual locations. */
167 location_t *virt_locs;
168 /* This is a pointer to the current virtual location. This is used
169 to iterate over the virtual locations while we iterate over the
170 tokens they belong to. */
171 location_t *cur_virt_loc;
172} macro_context;
173
174/* The kind of tokens carried by a cpp_context. */
175enum context_tokens_kind {
176 /* This is the value of cpp_context::tokens_kind if u.iso.first
177 contains an instance of cpp_token **. */
178 TOKENS_KIND_INDIRECT,
179 /* This is the value of cpp_context::tokens_kind if u.iso.first
180 contains an instance of cpp_token *. */
181 TOKENS_KIND_DIRECT,
182 /* This is the value of cpp_context::tokens_kind when the token
183 context contains tokens resulting from macro expansion. In that
184 case struct cpp_context::macro points to an instance of struct
185 macro_context. This is used only when the
186 -ftrack-macro-expansion flag is on. */
187 TOKENS_KIND_EXTENDED
188};
189
190typedef struct cpp_context cpp_context;
191struct cpp_context
192{
193 /* Doubly-linked list. */
194 cpp_context *next, *prev;
195
196 union
197 {
198 /* For ISO macro expansion. Contexts other than the base context
199 are contiguous tokens. e.g. macro expansions, expanded
200 argument tokens. */
201 struct
202 {
203 union utoken first;
204 union utoken last;
205 } iso;
206
207 /* For traditional macro expansion. */
208 struct
209 {
210 const unsigned char *cur;
211 const unsigned char *rlimit;
212 } trad;
213 } u;
214
215 /* If non-NULL, a buffer used for storage related to this context.
216 When the context is popped, the buffer is released. */
217 _cpp_buff *buff;
218
219 /* If tokens_kind is TOKEN_KIND_EXTENDED, then (as we thus are in a
220 macro context) this is a pointer to an instance of macro_context.
221 Otherwise if tokens_kind is *not* TOKEN_KIND_EXTENDED, then, if
222 we are in a macro context, this is a pointer to an instance of
223 cpp_hashnode, representing the name of the macro this context is
224 for. If we are not in a macro context, then this is just NULL.
225 Note that when tokens_kind is TOKEN_KIND_EXTENDED, the memory
226 used by the instance of macro_context pointed to by this member
227 is de-allocated upon de-allocation of the instance of struct
228 cpp_context. */
229 union
230 {
231 macro_context *mc;
232 cpp_hashnode *macro;
233 } c;
234
235 /* This determines the type of tokens held by this context. */
236 enum context_tokens_kind tokens_kind;
237};
238
239struct lexer_state
240{
241 /* 1 if we're handling a directive. 2 if it's an include-like
242 directive. */
243 unsigned char in_directive;
244
245 /* Nonzero if in a directive that will handle padding tokens itself.
246 #include needs this to avoid problems with computed include and
247 spacing between tokens. */
248 unsigned char directive_wants_padding;
249
250 /* True if we are skipping a failed conditional group. */
251 unsigned char skipping;
252
253 /* Nonzero if in a directive that takes angle-bracketed headers. */
254 unsigned char angled_headers;
255
256 /* Nonzero if in a #if or #elif directive. */
257 unsigned char in_expression;
258
259 /* Nonzero to save comments. Turned off if discard_comments, and in
260 all directives apart from #define. */
261 unsigned char save_comments;
262
263 /* Nonzero if lexing __VA_ARGS__ and __VA_OPT__ are valid. */
264 unsigned char va_args_ok;
265
266 /* Nonzero if lexing poisoned identifiers is valid. */
267 unsigned char poisoned_ok;
268
269 /* Nonzero to prevent macro expansion. */
270 unsigned char prevent_expansion;
271
272 /* Nonzero when parsing arguments to a function-like macro. */
273 unsigned char parsing_args;
274
275 /* Nonzero if prevent_expansion is true only because output is
276 being discarded. */
277 unsigned char discarding_output;
278
279 /* Nonzero to skip evaluating part of an expression. */
280 unsigned int skip_eval;
281
282 /* Nonzero when tokenizing a deferred pragma. */
283 unsigned char in_deferred_pragma;
284
285 /* Count to token that is a header-name. */
286 unsigned char directive_file_token;
287
288 /* Nonzero if the deferred pragma being handled allows macro expansion. */
289 unsigned char pragma_allow_expansion;
290};
291
292/* Special nodes - identifiers with predefined significance. */
293struct spec_nodes
294{
295 cpp_hashnode *n_defined; /* defined operator */
296 cpp_hashnode *n_true; /* C++ keyword true */
297 cpp_hashnode *n_false; /* C++ keyword false */
298 cpp_hashnode *n__VA_ARGS__; /* C99 vararg macros */
299 cpp_hashnode *n__VA_OPT__; /* C++ vararg macros */
300
301 enum {M_EXPORT, M_MODULE, M_IMPORT, M__IMPORT, M_HWM};
302
303 /* C++20 modules, only set when module_directives is in effect.
304 incoming variants [0], outgoing ones [1] */
305 cpp_hashnode *n_modules[M_HWM][2];
306};
307
308typedef struct _cpp_line_note _cpp_line_note;
309struct _cpp_line_note
310{
311 /* Location in the clean line the note refers to. */
312 const unsigned char *pos;
313
314 /* Type of note. The 9 'from' trigraph characters represent those
315 trigraphs, '\\' an escaped newline, ' ' an escaped newline with
316 intervening space, 0 represents a note that has already been handled,
317 and anything else is invalid. */
318 unsigned int type;
319};
320
321/* Represents the contents of a file cpplib has read in. */
322struct cpp_buffer
323{
324 const unsigned char *cur; /* Current location. */
325 const unsigned char *line_base; /* Start of current physical line. */
326 const unsigned char *next_line; /* Start of to-be-cleaned logical line. */
327
328 const unsigned char *buf; /* Entire character buffer. */
329 const unsigned char *rlimit; /* Writable byte at end of file. */
330 const unsigned char *to_free; /* Pointer that should be freed when
331 popping the buffer. */
332
333 _cpp_line_note *notes; /* Array of notes. */
334 unsigned int cur_note; /* Next note to process. */
335 unsigned int notes_used; /* Number of notes. */
336 unsigned int notes_cap; /* Size of allocated array. */
337
338 struct cpp_buffer *prev;
339
340 /* Pointer into the file table; non-NULL if this is a file buffer.
341 Used for include_next and to record control macros. */
342 struct _cpp_file *file;
343
344 /* Saved value of __TIMESTAMP__ macro - date and time of last modification
345 of the assotiated file. */
346 const unsigned char *timestamp;
347
348 /* Value of if_stack at start of this file.
349 Used to prohibit unmatched #endif (etc) in an include file. */
350 struct if_stack *if_stack;
351
352 /* True if we need to get the next clean line. */
353 bool need_line : 1;
354
355 /* True if we have already warned about C++ comments in this file.
356 The warning happens only for C89 extended mode with -pedantic on,
357 or for -Wtraditional, and only once per file (otherwise it would
358 be far too noisy). */
359 bool warned_cplusplus_comments : 1;
360
361 /* True if we don't process trigraphs and escaped newlines. True
362 for preprocessed input, command line directives, and _Pragma
363 buffers. */
364 bool from_stage3 : 1;
365
366 /* At EOF, a buffer is automatically popped. If RETURN_AT_EOF is
367 true, a CPP_EOF token is then returned. Otherwise, the next
368 token from the enclosing buffer is returned. */
369 bool return_at_eof : 1;
370
371 /* One for a system header, two for a C system header file that therefore
372 needs to be extern "C" protected in C++, and zero otherwise. */
373 unsigned char sysp;
374
375 /* The directory of the this buffer's file. Its NAME member is not
376 allocated, so we don't need to worry about freeing it. */
377 struct cpp_dir dir;
378
379 /* Descriptor for converting from the input character set to the
380 source character set. */
381 struct cset_converter input_cset_desc;
382};
383
384/* The list of saved macros by push_macro pragma. */
385struct def_pragma_macro {
386 /* Chain element to previous saved macro. */
387 struct def_pragma_macro *next;
388 /* Name of the macro. */
389 char *name;
390 /* The stored macro content. */
391 unsigned char *definition;
392
393 /* Definition line number. */
394 location_t line;
395 /* If macro defined in system header. */
396 unsigned int syshdr : 1;
397 /* Nonzero if it has been expanded or had its existence tested. */
398 unsigned int used : 1;
399
400 /* Mark if we save an undefined macro. */
401 unsigned int is_undef : 1;
402 /* Nonzero if it was a builtin macro. */
403 unsigned int is_builtin : 1;
404};
405
406/* A cpp_reader encapsulates the "state" of a pre-processor run.
407 Applying cpp_get_token repeatedly yields a stream of pre-processor
408 tokens. Usually, there is only one cpp_reader object active. */
409struct cpp_reader
410{
411 /* Top of buffer stack. */
412 cpp_buffer *buffer;
413
414 /* Overlaid buffer (can be different after processing #include). */
415 cpp_buffer *overlaid_buffer;
416
417 /* Lexer state. */
418 struct lexer_state state;
419
420 /* Source line tracking. */
421 class line_maps *line_table;
422
423 /* The line of the '#' of the current directive. */
424 location_t directive_line;
425
426 /* Memory buffers. */
427 _cpp_buff *a_buff; /* Aligned permanent storage. */
428 _cpp_buff *u_buff; /* Unaligned permanent storage. */
429 _cpp_buff *free_buffs; /* Free buffer chain. */
430
431 /* Context stack. */
432 struct cpp_context base_context;
433 struct cpp_context *context;
434
435 /* If in_directive, the directive if known. */
436 const struct directive *directive;
437
438 /* Token generated while handling a directive, if any. */
439 cpp_token directive_result;
440
441 /* When expanding a macro at top-level, this is the location of the
442 macro invocation. */
443 location_t invocation_location;
444
445 /* This is the node representing the macro being expanded at
446 top-level. The value of this data member is valid iff
447 cpp_in_macro_expansion_p() returns TRUE. */
448 cpp_hashnode *top_most_macro_node;
449
450 /* Nonzero if we are about to expand a macro. Note that if we are
451 really expanding a macro, the function macro_of_context returns
452 the macro being expanded and this flag is set to false. Client
453 code should use the function cpp_in_macro_expansion_p to know if we
454 are either about to expand a macro, or are actually expanding
455 one. */
456 bool about_to_expand_macro_p;
457
458 /* Search paths for include files. */
459 struct cpp_dir *quote_include; /* "" */
460 struct cpp_dir *bracket_include; /* <> */
461 struct cpp_dir no_search_path; /* No path. */
462
463 /* Chain of all hashed _cpp_file instances. */
464 struct _cpp_file *all_files;
465
466 struct _cpp_file *main_file;
467
468 /* File and directory hash table. */
469 struct htab *file_hash;
470 struct htab *dir_hash;
471 struct file_hash_entry_pool *file_hash_entries;
472
473 /* Negative path lookup hash table. */
474 struct htab *nonexistent_file_hash;
475 struct obstack nonexistent_file_ob;
476
477 /* Nonzero means don't look for #include "foo" the source-file
478 directory. */
479 bool quote_ignores_source_dir;
480
481 /* Nonzero if any file has contained #pragma once or #import has
482 been used. */
483 bool seen_once_only;
484
485 /* Multiple include optimization. */
486 const cpp_hashnode *mi_cmacro;
487 const cpp_hashnode *mi_ind_cmacro;
488 bool mi_valid;
489
490 /* Lexing. */
491 cpp_token *cur_token;
492 tokenrun base_run, *cur_run;
493 unsigned int lookaheads;
494
495 /* Nonzero prevents the lexer from re-using the token runs. */
496 unsigned int keep_tokens;
497
498 /* Buffer to hold macro definition string. */
499 unsigned char *macro_buffer;
500 unsigned int macro_buffer_len;
501
502 /* Descriptor for converting from the source character set to the
503 execution character set. */
504 struct cset_converter narrow_cset_desc;
505
506 /* Descriptor for converting from the source character set to the
507 UTF-8 execution character set. */
508 struct cset_converter utf8_cset_desc;
509
510 /* Descriptor for converting from the source character set to the
511 UTF-16 execution character set. */
512 struct cset_converter char16_cset_desc;
513
514 /* Descriptor for converting from the source character set to the
515 UTF-32 execution character set. */
516 struct cset_converter char32_cset_desc;
517
518 /* Descriptor for converting from the source character set to the
519 wide execution character set. */
520 struct cset_converter wide_cset_desc;
521
522 /* Date and time text. Calculated together if either is requested. */
523 const unsigned char *date;
524 const unsigned char *time;
525
526 /* Time stamp, set idempotently lazily. */
527 time_t time_stamp;
528 int time_stamp_kind; /* Or errno. */
529
530 /* A token forcing paste avoidance, and one demarking macro arguments. */
531 cpp_token avoid_paste;
532 cpp_token endarg;
533
534 /* Opaque handle to the dependencies of mkdeps.c. */
535 class mkdeps *deps;
536
537 /* Obstack holding all macro hash nodes. This never shrinks.
538 See identifiers.c */
539 struct obstack hash_ob;
540
541 /* Obstack holding buffer and conditional structures. This is a
542 real stack. See directives.c. */
543 struct obstack buffer_ob;
544
545 /* Pragma table - dynamic, because a library user can add to the
546 list of recognized pragmas. */
547 struct pragma_entry *pragmas;
548
549 /* Call backs to cpplib client. */
550 struct cpp_callbacks cb;
551
552 /* Identifier hash table. */
553 struct ht *hash_table;
554
555 /* Expression parser stack. */
556 struct op *op_stack, *op_limit;
557
558 /* User visible options. */
559 struct cpp_options opts;
560
561 /* Special nodes - identifiers with predefined significance to the
562 preprocessor. */
563 struct spec_nodes spec_nodes;
564
565 /* Whether cpplib owns the hashtable. */
566 bool our_hashtable;
567
568 /* Traditional preprocessing output buffer (a logical line). */
569 struct
570 {
571 unsigned char *base;
572 unsigned char *limit;
573 unsigned char *cur;
574 location_t first_line;
575 } out;
576
577 /* Used for buffer overlays by traditional.c. */
578 const unsigned char *saved_cur, *saved_rlimit, *saved_line_base;
579
580 /* A saved list of the defined macros, for dependency checking
581 of precompiled headers. */
582 struct cpp_savedstate *savedstate;
583
584 /* Next value of __COUNTER__ macro. */
585 unsigned int counter;
586
587 /* Table of comments, when state.save_comments is true. */
588 cpp_comment_table comments;
589
590 /* List of saved macros by push_macro. */
591 struct def_pragma_macro *pushed_macros;
592
593 /* If non-zero, the lexer will use this location for the next token
594 instead of getting a location from the linemap. */
595 location_t forced_token_location;
596
597 /* Location identifying the main source file -- intended to be line
598 zero of said file. */
599 location_t main_loc;
600
601 /* Returns true iff we should warn about UTF-8 bidirectional control
602 characters. */
603 bool warn_bidi_p () const
604 {
605 return CPP_OPTION (this, cpp_warn_bidirectional)((this)->opts.cpp_warn_bidirectional) != bidirectional_none;
9
Assuming field 'cpp_warn_bidirectional' is not equal to bidirectional_none
10
Returning the value 1, which participates in a condition later
606 }
607};
608
609/* Character classes. Based on the more primitive macros in safe-ctype.h.
610 If the definition of `numchar' looks odd to you, please look up the
611 definition of a pp-number in the C standard [section 6.4.8 of C99].
612
613 In the unlikely event that characters other than \r and \n enter
614 the set is_vspace, the macro handle_newline() in lex.c must be
615 updated. */
616#define _dollar_ok(x)((x) == '$' && ((pfile)->opts.dollars_in_ident)) ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident)((pfile)->opts.dollars_in_ident))
617
618#define is_idchar(x)((_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isidnum
)) || ((x) == '$' && ((pfile)->opts.dollars_in_ident
)))
(ISIDNUM(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isidnum
))
|| _dollar_ok(x)((x) == '$' && ((pfile)->opts.dollars_in_ident)))
619#define is_numchar(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isidnum
))
ISIDNUM(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isidnum
))
620#define is_idstart(x)((_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isidst
)) || ((x) == '$' && ((pfile)->opts.dollars_in_ident
)))
(ISIDST(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isidst
))
|| _dollar_ok(x)((x) == '$' && ((pfile)->opts.dollars_in_ident)))
621#define is_numstart(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isdigit
))
ISDIGIT(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isdigit
))
622#define is_hspace(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isblank
))
ISBLANK(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isblank
))
623#define is_vspace(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isvsp
))
IS_VSPACE(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isvsp
))
624#define is_nvspace(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isnvsp
))
IS_NVSPACE(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_isnvsp
))
625#define is_space(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_iscppsp
))
IS_SPACE_OR_NUL(x)(_sch_istable[(x) & 0xff] & (unsigned short)(_sch_iscppsp
))
626
627#define SEEN_EOL()(pfile->cur_token[-1].type == CPP_EOF) (pfile->cur_token[-1].type == CPP_EOF)
628
629/* This table is constant if it can be initialized at compile time,
630 which is the case if cpp was compiled with GCC >=2.7, or another
631 compiler that supports C99. */
632#if HAVE_DESIGNATED_INITIALIZERS0
633extern const unsigned char _cpp_trigraph_map[UCHAR_MAX(127*2 +1) + 1];
634#else
635extern unsigned char _cpp_trigraph_map[UCHAR_MAX(127*2 +1) + 1];
636#endif
637
638#if !defined (HAVE_UCHAR) && !defined (IN_GCC)
639typedef unsigned char uchar;
640#endif
641
642#define UC(const uchar *) (const uchar *) /* Intended use: UC"string" */
643
644/* Accessors. */
645
646inline int
647_cpp_in_system_header (cpp_reader *pfile)
648{
649 return pfile->buffer ? pfile->buffer->sysp : 0;
650}
651#define CPP_PEDANTIC(PF)((PF)->opts.cpp_pedantic) CPP_OPTION (PF, cpp_pedantic)((PF)->opts.cpp_pedantic)
652#define CPP_WTRADITIONAL(PF)((PF)->opts.cpp_warn_traditional) CPP_OPTION (PF, cpp_warn_traditional)((PF)->opts.cpp_warn_traditional)
653
654/* Return true if we're in the main file (unless it's considered to be
655 an include file in its own right. */
656inline int
657_cpp_in_main_source_file (cpp_reader *pfile)
658{
659 return (!CPP_OPTION (pfile, main_search)((pfile)->opts.main_search)
660 && pfile->buffer->file == pfile->main_file);
661}
662
663/* True if NODE is a macro for the purposes of ifdef, defined etc. */
664inline bool _cpp_defined_macro_p (cpp_hashnode *node)
665{
666 /* Do not treat conditional macros as being defined. This is due to
667 the powerpc port using conditional macros for 'vector', 'bool',
668 and 'pixel' to act as conditional keywords. This messes up tests
669 like #ifndef bool. */
670 return cpp_macro_p (node) && !(node->flags & NODE_CONDITIONAL(1 << 6));
671}
672
673/* In macro.c */
674extern bool _cpp_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node,
675 location_t);
676inline bool _cpp_maybe_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node,
677 location_t loc)
678{
679 if (!(node->flags & NODE_USED(1 << 5)))
680 return _cpp_notify_macro_use (pfile, node, loc);
681 return true;
682}
683extern cpp_macro *_cpp_new_macro (cpp_reader *, cpp_macro_kind, void *);
684extern void _cpp_free_definition (cpp_hashnode *);
685extern bool _cpp_create_definition (cpp_reader *, cpp_hashnode *);
686extern void _cpp_pop_context (cpp_reader *);
687extern void _cpp_push_text_context (cpp_reader *, cpp_hashnode *,
688 const unsigned char *, size_t);
689extern bool _cpp_save_parameter (cpp_reader *, unsigned, cpp_hashnode *,
690 cpp_hashnode *);
691extern void _cpp_unsave_parameters (cpp_reader *, unsigned);
692extern bool _cpp_arguments_ok (cpp_reader *, cpp_macro *, const cpp_hashnode *,
693 unsigned int);
694extern const unsigned char *_cpp_builtin_macro_text (cpp_reader *,
695 cpp_hashnode *,
696 location_t = 0);
697extern int _cpp_warn_if_unused_macro (cpp_reader *, cpp_hashnode *, void *);
698extern void _cpp_push_token_context (cpp_reader *, cpp_hashnode *,
699 const cpp_token *, unsigned int);
700extern void _cpp_backup_tokens_direct (cpp_reader *, unsigned int);
701
702/* In identifiers.c */
703extern void _cpp_init_hashtable (cpp_reader *, cpp_hash_table *);
704extern void _cpp_destroy_hashtable (cpp_reader *);
705
706/* In files.c */
707enum _cpp_find_file_kind
708 { _cpp_FFK_NORMAL, _cpp_FFK_FAKE, _cpp_FFK_PRE_INCLUDE, _cpp_FFK_HAS_INCLUDE };
709extern _cpp_file *_cpp_find_file (cpp_reader *, const char *, cpp_dir *,
710 int angle, _cpp_find_file_kind, location_t);
711extern bool _cpp_find_failed (_cpp_file *);
712extern void _cpp_mark_file_once_only (cpp_reader *, struct _cpp_file *);
713extern const char *_cpp_find_header_unit (cpp_reader *, const char *file,
714 bool angle_p, location_t);
715extern void _cpp_fake_include (cpp_reader *, const char *);
716extern bool _cpp_stack_file (cpp_reader *, _cpp_file*, include_type, location_t);
717extern bool _cpp_stack_include (cpp_reader *, const char *, int,
718 enum include_type, location_t);
719extern int _cpp_compare_file_date (cpp_reader *, const char *, int);
720extern void _cpp_report_missing_guards (cpp_reader *);
721extern void _cpp_init_files (cpp_reader *);
722extern void _cpp_cleanup_files (cpp_reader *);
723extern void _cpp_pop_file_buffer (cpp_reader *, struct _cpp_file *,
724 const unsigned char *);
725extern bool _cpp_save_file_entries (cpp_reader *pfile, FILE *f);
726extern bool _cpp_read_file_entries (cpp_reader *, FILE *);
727extern const char *_cpp_get_file_name (_cpp_file *);
728extern struct stat *_cpp_get_file_stat (_cpp_file *);
729extern bool _cpp_has_header (cpp_reader *, const char *, int,
730 enum include_type);
731
732/* In expr.c */
733extern bool _cpp_parse_expr (cpp_reader *, bool);
734extern struct op *_cpp_expand_op_stack (cpp_reader *);
735
736/* In lex.c */
737extern void _cpp_process_line_notes (cpp_reader *, int);
738extern void _cpp_clean_line (cpp_reader *);
739extern bool _cpp_get_fresh_line (cpp_reader *);
740extern bool _cpp_skip_block_comment (cpp_reader *);
741extern cpp_token *_cpp_temp_token (cpp_reader *);
742extern const cpp_token *_cpp_lex_token (cpp_reader *);
743extern cpp_token *_cpp_lex_direct (cpp_reader *);
744extern unsigned char *_cpp_spell_ident_ucns (unsigned char *, cpp_hashnode *);
745extern int _cpp_equiv_tokens (const cpp_token *, const cpp_token *);
746extern void _cpp_init_tokenrun (tokenrun *, unsigned int);
747extern cpp_hashnode *_cpp_lex_identifier (cpp_reader *, const char *);
748extern int _cpp_remaining_tokens_num_in_context (cpp_context *);
749extern void _cpp_init_lexer (void);
750static inline void *_cpp_reserve_room (cpp_reader *pfile, size_t have,
751 size_t extra)
752{
753 if (BUFF_ROOM (pfile->a_buff)(size_t) ((pfile->a_buff)->limit - (pfile->a_buff)->
cur)
< (have + extra))
754 _cpp_extend_buff (pfile, &pfile->a_buff, extra);
755 return BUFF_FRONT (pfile->a_buff)((pfile->a_buff)->cur);
756}
757extern void *_cpp_commit_buff (cpp_reader *pfile, size_t size);
758
759/* In init.c. */
760extern void _cpp_maybe_push_include_file (cpp_reader *);
761extern const char *cpp_named_operator2name (enum cpp_ttype type);
762extern void _cpp_restore_special_builtin (cpp_reader *pfile,
763 struct def_pragma_macro *);
764
765/* In directives.c */
766extern int _cpp_test_assertion (cpp_reader *, unsigned int *);
767extern int _cpp_handle_directive (cpp_reader *, bool);
768extern void _cpp_define_builtin (cpp_reader *, const char *);
769extern char ** _cpp_save_pragma_names (cpp_reader *);
770extern void _cpp_restore_pragma_names (cpp_reader *, char **);
771extern int _cpp_do__Pragma (cpp_reader *, location_t);
772extern void _cpp_init_directives (cpp_reader *);
773extern void _cpp_init_internal_pragmas (cpp_reader *);
774extern void _cpp_do_file_change (cpp_reader *, enum lc_reason, const char *,
775 linenum_type, unsigned int);
776extern void _cpp_pop_buffer (cpp_reader *);
777extern char *_cpp_bracket_include (cpp_reader *);
778
779/* In errors.c */
780extern location_t cpp_diagnostic_get_current_location (cpp_reader *);
781
782/* In traditional.c. */
783extern bool _cpp_scan_out_logical_line (cpp_reader *, cpp_macro *, bool);
784extern bool _cpp_read_logical_line_trad (cpp_reader *);
785extern void _cpp_overlay_buffer (cpp_reader *pfile, const unsigned char *,
786 size_t);
787extern void _cpp_remove_overlay (cpp_reader *);
788extern cpp_macro *_cpp_create_trad_definition (cpp_reader *);
789extern bool _cpp_expansions_different_trad (const cpp_macro *,
790 const cpp_macro *);
791extern unsigned char *_cpp_copy_replacement_text (const cpp_macro *,
792 unsigned char *);
793extern size_t _cpp_replacement_text_len (const cpp_macro *);
794
795/* In charset.c. */
796
797/* The normalization state at this point in the sequence.
798 It starts initialized to all zeros, and at the end
799 'level' is the normalization level of the sequence. */
800
801struct normalize_state
802{
803 /* The previous starter character. */
804 cppchar_t previous;