OSDN Git Service

PR c++/45399
[pf3gnuchains/gcc-fork.git] / libcpp / lex.c
1 /* CPP Library - lexical analysis.
2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
3    Free Software Foundation, Inc.
4    Contributed by Per Bothner, 1994-95.
5    Based on CCCP program by Paul Rubin, June 1986
6    Adapted to ANSI C, Richard Stallman, Jan 1987
7    Broken out to separate file, Zack Weinberg, Mar 2000
8
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
12 later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "cpplib.h"
26 #include "internal.h"
27
28 enum spell_type
29 {
30   SPELL_OPERATOR = 0,
31   SPELL_IDENT,
32   SPELL_LITERAL,
33   SPELL_NONE
34 };
35
36 struct token_spelling
37 {
38   enum spell_type category;
39   const unsigned char *name;
40 };
41
42 static const unsigned char *const digraph_spellings[] =
43 { UC"%:", UC"%:%:", UC"<:", UC":>", UC"<%", UC"%>" };
44
45 #define OP(e, s) { SPELL_OPERATOR, UC s  },
46 #define TK(e, s) { SPELL_ ## s,    UC #e },
47 static const struct token_spelling token_spellings[N_TTYPES] = { TTYPE_TABLE };
48 #undef OP
49 #undef TK
50
51 #define TOKEN_SPELL(token) (token_spellings[(token)->type].category)
52 #define TOKEN_NAME(token) (token_spellings[(token)->type].name)
53
54 static void add_line_note (cpp_buffer *, const uchar *, unsigned int);
55 static int skip_line_comment (cpp_reader *);
56 static void skip_whitespace (cpp_reader *, cppchar_t);
57 static void lex_string (cpp_reader *, cpp_token *, const uchar *);
58 static void save_comment (cpp_reader *, cpp_token *, const uchar *, cppchar_t);
59 static void store_comment (cpp_reader *, cpp_token *);
60 static void create_literal (cpp_reader *, cpp_token *, const uchar *,
61                             unsigned int, enum cpp_ttype);
62 static bool warn_in_comment (cpp_reader *, _cpp_line_note *);
63 static int name_p (cpp_reader *, const cpp_string *);
64 static tokenrun *next_tokenrun (tokenrun *);
65
66 static _cpp_buff *new_buff (size_t);
67
68
69 /* Utility routine:
70
71    Compares, the token TOKEN to the NUL-terminated string STRING.
72    TOKEN must be a CPP_NAME.  Returns 1 for equal, 0 for unequal.  */
73 int
74 cpp_ideq (const cpp_token *token, const char *string)
75 {
76   if (token->type != CPP_NAME)
77     return 0;
78
79   return !ustrcmp (NODE_NAME (token->val.node.node), (const uchar *) string);
80 }
81
82 /* Record a note TYPE at byte POS into the current cleaned logical
83    line.  */
84 static void
85 add_line_note (cpp_buffer *buffer, const uchar *pos, unsigned int type)
86 {
87   if (buffer->notes_used == buffer->notes_cap)
88     {
89       buffer->notes_cap = buffer->notes_cap * 2 + 200;
90       buffer->notes = XRESIZEVEC (_cpp_line_note, buffer->notes,
91                                   buffer->notes_cap);
92     }
93
94   buffer->notes[buffer->notes_used].pos = pos;
95   buffer->notes[buffer->notes_used].type = type;
96   buffer->notes_used++;
97 }
98
99 \f
100 /* Fast path to find line special characters using optimized character
101    scanning algorithms.  Anything complicated falls back to the slow
102    path below.  Since this loop is very hot it's worth doing these kinds
103    of optimizations.
104
105    One of the paths through the ifdefs should provide 
106
107      const uchar *search_line_fast (const uchar *s, const uchar *end);
108
109    Between S and END, search for \n, \r, \\, ?.  Return a pointer to
110    the found character.
111
112    Note that the last character of the buffer is *always* a newline,
113    as forced by _cpp_convert_input.  This fact can be used to avoid
114    explicitly looking for the end of the buffer.  */
115
116 /* Configure gives us an ifdef test.  */
117 #ifndef WORDS_BIGENDIAN
118 #define WORDS_BIGENDIAN 0
119 #endif
120
121 /* We'd like the largest integer that fits into a register.  There's nothing
122    in <stdint.h> that gives us that.  For most hosts this is unsigned long,
123    but MS decided on an LLP64 model.  Thankfully when building with GCC we
124    can get the "real" word size.  */
125 #ifdef __GNUC__
126 typedef unsigned int word_type __attribute__((__mode__(__word__)));
127 #else
128 typedef unsigned long word_type;
129 #endif
130
131 /* The code below is only expecting sizes 4 or 8.
132    Die at compile-time if this expectation is violated.  */
133 typedef char check_word_type_size
134   [(sizeof(word_type) == 8 || sizeof(word_type) == 4) * 2 - 1];
135
136 /* Return X with the first N bytes forced to values that won't match one
137    of the interesting characters.  Note that NUL is not interesting.  */
138
139 static inline word_type
140 acc_char_mask_misalign (word_type val, unsigned int n)
141 {
142   word_type mask = -1;
143   if (WORDS_BIGENDIAN)
144     mask >>= n * 8;
145   else
146     mask <<= n * 8;
147   return val & mask;
148 }
149
150 /* Return X replicated to all byte positions within WORD_TYPE.  */
151
152 static inline word_type
153 acc_char_replicate (uchar x)
154 {
155   word_type ret;
156
157   ret = (x << 24) | (x << 16) | (x << 8) | x;
158   if (sizeof(word_type) == 8)
159     ret = (ret << 16 << 16) | ret;
160   return ret;
161 }
162
163 /* Return non-zero if some byte of VAL is (probably) C.  */
164
165 static inline word_type
166 acc_char_cmp (word_type val, word_type c)
167 {
168 #if defined(__GNUC__) && defined(__alpha__)
169   /* We can get exact results using a compare-bytes instruction.  
170      Get (val == c) via (0 >= (val ^ c)).  */
171   return __builtin_alpha_cmpbge (0, val ^ c);
172 #else
173   word_type magic = 0x7efefefeU;
174   if (sizeof(word_type) == 8)
175     magic = (magic << 16 << 16) | 0xfefefefeU;
176   magic |= 1;
177
178   val ^= c;
179   return ((val + magic) ^ ~val) & ~magic;
180 #endif
181 }
182
183 /* Given the result of acc_char_cmp is non-zero, return the index of
184    the found character.  If this was a false positive, return -1.  */
185
186 static inline int
187 acc_char_index (word_type cmp ATTRIBUTE_UNUSED,
188                 word_type val ATTRIBUTE_UNUSED)
189 {
190 #if defined(__GNUC__) && defined(__alpha__) && !WORDS_BIGENDIAN
191   /* The cmpbge instruction sets *bits* of the result corresponding to
192      matches in the bytes with no false positives.  */
193   return __builtin_ctzl (cmp);
194 #else
195   unsigned int i;
196
197   /* ??? It would be nice to force unrolling here,
198      and have all of these constants folded.  */
199   for (i = 0; i < sizeof(word_type); ++i)
200     {
201       uchar c;
202       if (WORDS_BIGENDIAN)
203         c = (val >> (sizeof(word_type) - i - 1) * 8) & 0xff;
204       else
205         c = (val >> i * 8) & 0xff;
206
207       if (c == '\n' || c == '\r' || c == '\\' || c == '?')
208         return i;
209     }
210
211   return -1;
212 #endif
213 }
214
215 /* A version of the fast scanner using bit fiddling techniques.
216  
217    For 32-bit words, one would normally perform 16 comparisons and
218    16 branches.  With this algorithm one performs 24 arithmetic
219    operations and one branch.  Whether this is faster with a 32-bit
220    word size is going to be somewhat system dependent.
221
222    For 64-bit words, we eliminate twice the number of comparisons
223    and branches without increasing the number of arithmetic operations.
224    It's almost certainly going to be a win with 64-bit word size.  */
225
226 static const uchar * search_line_acc_char (const uchar *, const uchar *)
227   ATTRIBUTE_UNUSED;
228
229 static const uchar *
230 search_line_acc_char (const uchar *s, const uchar *end ATTRIBUTE_UNUSED)
231 {
232   const word_type repl_nl = acc_char_replicate ('\n');
233   const word_type repl_cr = acc_char_replicate ('\r');
234   const word_type repl_bs = acc_char_replicate ('\\');
235   const word_type repl_qm = acc_char_replicate ('?');
236
237   unsigned int misalign;
238   const word_type *p;
239   word_type val, t;
240   
241   /* Align the buffer.  Mask out any bytes from before the beginning.  */
242   p = (word_type *)((uintptr_t)s & -sizeof(word_type));
243   val = *p;
244   misalign = (uintptr_t)s & (sizeof(word_type) - 1);
245   if (misalign)
246     val = acc_char_mask_misalign (val, misalign);
247
248   /* Main loop.  */
249   while (1)
250     {
251       t  = acc_char_cmp (val, repl_nl);
252       t |= acc_char_cmp (val, repl_cr);
253       t |= acc_char_cmp (val, repl_bs);
254       t |= acc_char_cmp (val, repl_qm);
255
256       if (__builtin_expect (t != 0, 0))
257         {
258           int i = acc_char_index (t, val);
259           if (i >= 0)
260             return (const uchar *)p + i;
261         }
262
263       val = *++p;
264     }
265 }
266
267 /* Disable on Solaris 2/x86 until the following problems can be properly
268    autoconfed:
269
270    The Solaris 8 assembler cannot assemble SSE2/SSE4.2 insns.
271    The Solaris 9 assembler cannot assemble SSE4.2 insns.
272    Before Solaris 9 Update 6, SSE insns cannot be executed.
273    The Solaris 10+ assembler tags objects with the instruction set
274    extensions used, so SSE4.2 executables cannot run on machines that
275    don't support that extension.  */
276
277 #if (GCC_VERSION >= 4005) && (defined(__i386__) || defined(__x86_64__)) && !(defined(__sun__) && defined(__svr4__))
278
279 /* Replicated character data to be shared between implementations.
280    Recall that outside of a context with vector support we can't
281    define compatible vector types, therefore these are all defined
282    in terms of raw characters.  */
283 static const char repl_chars[4][16] __attribute__((aligned(16))) = {
284   { '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n',
285     '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n' },
286   { '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r',
287     '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r' },
288   { '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\',
289     '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\' },
290   { '?', '?', '?', '?', '?', '?', '?', '?',
291     '?', '?', '?', '?', '?', '?', '?', '?' },
292 };
293
294 /* A version of the fast scanner using MMX vectorized byte compare insns.
295
296    This uses the PMOVMSKB instruction which was introduced with "MMX2",
297    which was packaged into SSE1; it is also present in the AMD MMX
298    extension.  Mark the function as using "sse" so that we emit a real
299    "emms" instruction, rather than the 3dNOW "femms" instruction.  */
300
301 static const uchar *
302 #ifndef __SSE__
303 __attribute__((__target__("sse")))
304 #endif
305 search_line_mmx (const uchar *s, const uchar *end ATTRIBUTE_UNUSED)
306 {
307   typedef char v8qi __attribute__ ((__vector_size__ (8)));
308   typedef int __m64 __attribute__ ((__vector_size__ (8), __may_alias__));
309
310   const v8qi repl_nl = *(const v8qi *)repl_chars[0];
311   const v8qi repl_cr = *(const v8qi *)repl_chars[1];
312   const v8qi repl_bs = *(const v8qi *)repl_chars[2];
313   const v8qi repl_qm = *(const v8qi *)repl_chars[3];
314
315   unsigned int misalign, found, mask;
316   const v8qi *p;
317   v8qi data, t, c;
318
319   /* Align the source pointer.  While MMX doesn't generate unaligned data
320      faults, this allows us to safely scan to the end of the buffer without
321      reading beyond the end of the last page.  */
322   misalign = (uintptr_t)s & 7;
323   p = (const v8qi *)((uintptr_t)s & -8);
324   data = *p;
325
326   /* Create a mask for the bytes that are valid within the first
327      16-byte block.  The Idea here is that the AND with the mask
328      within the loop is "free", since we need some AND or TEST
329      insn in order to set the flags for the branch anyway.  */
330   mask = -1u << misalign;
331
332   /* Main loop processing 8 bytes at a time.  */
333   goto start;
334   do
335     {
336       data = *++p;
337       mask = -1;
338
339     start:
340       t = __builtin_ia32_pcmpeqb(data, repl_nl);
341       c = __builtin_ia32_pcmpeqb(data, repl_cr);
342       t = (v8qi) __builtin_ia32_por ((__m64)t, (__m64)c);
343       c = __builtin_ia32_pcmpeqb(data, repl_bs);
344       t = (v8qi) __builtin_ia32_por ((__m64)t, (__m64)c);
345       c = __builtin_ia32_pcmpeqb(data, repl_qm);
346       t = (v8qi) __builtin_ia32_por ((__m64)t, (__m64)c);
347       found = __builtin_ia32_pmovmskb (t);
348       found &= mask;
349     }
350   while (!found);
351
352   __builtin_ia32_emms ();
353
354   /* FOUND contains 1 in bits for which we matched a relevant
355      character.  Conversion to the byte index is trivial.  */
356   found = __builtin_ctz(found);
357   return (const uchar *)p + found;
358 }
359
360 /* A version of the fast scanner using SSE2 vectorized byte compare insns.  */
361
362 static const uchar *
363 #ifndef __SSE2__
364 __attribute__((__target__("sse2")))
365 #endif
366 search_line_sse2 (const uchar *s, const uchar *end ATTRIBUTE_UNUSED)
367 {
368   typedef char v16qi __attribute__ ((__vector_size__ (16)));
369
370   const v16qi repl_nl = *(const v16qi *)repl_chars[0];
371   const v16qi repl_cr = *(const v16qi *)repl_chars[1];
372   const v16qi repl_bs = *(const v16qi *)repl_chars[2];
373   const v16qi repl_qm = *(const v16qi *)repl_chars[3];
374
375   unsigned int misalign, found, mask;
376   const v16qi *p;
377   v16qi data, t;
378
379   /* Align the source pointer.  */
380   misalign = (uintptr_t)s & 15;
381   p = (const v16qi *)((uintptr_t)s & -16);
382   data = *p;
383
384   /* Create a mask for the bytes that are valid within the first
385      16-byte block.  The Idea here is that the AND with the mask
386      within the loop is "free", since we need some AND or TEST
387      insn in order to set the flags for the branch anyway.  */
388   mask = -1u << misalign;
389
390   /* Main loop processing 16 bytes at a time.  */
391   goto start;
392   do
393     {
394       data = *++p;
395       mask = -1;
396
397     start:
398       t  = __builtin_ia32_pcmpeqb128(data, repl_nl);
399       t |= __builtin_ia32_pcmpeqb128(data, repl_cr);
400       t |= __builtin_ia32_pcmpeqb128(data, repl_bs);
401       t |= __builtin_ia32_pcmpeqb128(data, repl_qm);
402       found = __builtin_ia32_pmovmskb128 (t);
403       found &= mask;
404     }
405   while (!found);
406
407   /* FOUND contains 1 in bits for which we matched a relevant
408      character.  Conversion to the byte index is trivial.  */
409   found = __builtin_ctz(found);
410   return (const uchar *)p + found;
411 }
412
413 #ifdef HAVE_SSE4
414 /* A version of the fast scanner using SSE 4.2 vectorized string insns.  */
415
416 static const uchar *
417 #ifndef __SSE4_2__
418 __attribute__((__target__("sse4.2")))
419 #endif
420 search_line_sse42 (const uchar *s, const uchar *end)
421 {
422   typedef char v16qi __attribute__ ((__vector_size__ (16)));
423   static const v16qi search = { '\n', '\r', '?', '\\' };
424
425   uintptr_t si = (uintptr_t)s;
426   uintptr_t index;
427
428   /* Check for unaligned input.  */
429   if (si & 15)
430     {
431       if (__builtin_expect (end - s < 16, 0)
432           && __builtin_expect ((si & 0xfff) > 0xff0, 0))
433         {
434           /* There are less than 16 bytes left in the buffer, and less
435              than 16 bytes left on the page.  Reading 16 bytes at this
436              point might generate a spurious page fault.  Defer to the
437              SSE2 implementation, which already handles alignment.  */
438           return search_line_sse2 (s, end);
439         }
440
441       /* ??? The builtin doesn't understand that the PCMPESTRI read from
442          memory need not be aligned.  */
443       __asm ("%vpcmpestri $0, (%1), %2"
444              : "=c"(index) : "r"(s), "x"(search), "a"(4), "d"(16));
445       if (__builtin_expect (index < 16, 0))
446         goto found;
447
448       /* Advance the pointer to an aligned address.  We will re-scan a
449          few bytes, but we no longer need care for reading past the
450          end of a page, since we're guaranteed a match.  */
451       s = (const uchar *)((si + 16) & -16);
452     }
453
454   /* Main loop, processing 16 bytes at a time.  By doing the whole loop
455      in inline assembly, we can make proper use of the flags set.  */
456   __asm (      "sub $16, %1\n"
457         "       .balign 16\n"
458         "0:     add $16, %1\n"
459         "       %vpcmpestri $0, (%1), %2\n"
460         "       jnc 0b"
461         : "=&c"(index), "+r"(s)
462         : "x"(search), "a"(4), "d"(16));
463
464  found:
465   return s + index;
466 }
467
468 #else
469 /* Work around out-dated assemblers without sse4 support.  */
470 #define search_line_sse42 search_line_sse2
471 #endif
472
473 /* Check the CPU capabilities.  */
474
475 #include "../gcc/config/i386/cpuid.h"
476
477 typedef const uchar * (*search_line_fast_type) (const uchar *, const uchar *);
478 static search_line_fast_type search_line_fast;
479
480 static void __attribute__((constructor))
481 init_vectorized_lexer (void)
482 {
483   unsigned dummy, ecx = 0, edx = 0;
484   search_line_fast_type impl = search_line_acc_char;
485   int minimum = 0;
486
487 #if defined(__SSE4_2__)
488   minimum = 3;
489 #elif defined(__SSE2__)
490   minimum = 2;
491 #elif defined(__SSE__)
492   minimum = 1;
493 #endif
494
495   if (minimum == 3)
496     impl = search_line_sse42;
497   else if (__get_cpuid (1, &dummy, &dummy, &ecx, &edx) || minimum == 2)
498     {
499       if (minimum == 3 || (ecx & bit_SSE4_2))
500         impl = search_line_sse42;
501       else if (minimum == 2 || (edx & bit_SSE2))
502         impl = search_line_sse2;
503       else if (minimum == 1 || (edx & bit_SSE))
504         impl = search_line_mmx;
505     }
506   else if (__get_cpuid (0x80000001, &dummy, &dummy, &dummy, &edx))
507     {
508       if (minimum == 1
509           || (edx & (bit_MMXEXT | bit_CMOV)) == (bit_MMXEXT | bit_CMOV))
510         impl = search_line_mmx;
511     }
512
513   search_line_fast = impl;
514 }
515
516 #elif (GCC_VERSION >= 4005) && defined(__ALTIVEC__)
517
518 /* A vection of the fast scanner using AltiVec vectorized byte compares.  */
519 /* ??? Unfortunately, attribute(target("altivec")) is not yet supported,
520    so we can't compile this function without -maltivec on the command line
521    (or implied by some other switch).  */
522
523 static const uchar *
524 search_line_fast (const uchar *s, const uchar *end ATTRIBUTE_UNUSED)
525 {
526   typedef __attribute__((altivec(vector))) unsigned char vc;
527
528   const vc repl_nl = {
529     '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n', 
530     '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'
531   };
532   const vc repl_cr = {
533     '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r', 
534     '\r', '\r', '\r', '\r', '\r', '\r', '\r', '\r'
535   };
536   const vc repl_bs = {
537     '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\', 
538     '\\', '\\', '\\', '\\', '\\', '\\', '\\', '\\'
539   };
540   const vc repl_qm = {
541     '?', '?', '?', '?', '?', '?', '?', '?', 
542     '?', '?', '?', '?', '?', '?', '?', '?', 
543   };
544   const vc ones = {
545     -1, -1, -1, -1, -1, -1, -1, -1,
546     -1, -1, -1, -1, -1, -1, -1, -1,
547   };
548   const vc zero = { 0 };
549
550   vc data, mask, t;
551
552   /* Altivec loads automatically mask addresses with -16.  This lets us
553      issue the first load as early as possible.  */
554   data = __builtin_vec_ld(0, (const vc *)s);
555
556   /* Discard bytes before the beginning of the buffer.  Do this by
557      beginning with all ones and shifting in zeros according to the
558      mis-alignment.  The LVSR instruction pulls the exact shift we
559      want from the address.  */
560   mask = __builtin_vec_lvsr(0, s);
561   mask = __builtin_vec_perm(zero, ones, mask);
562   data &= mask;
563
564   /* While altivec loads mask addresses, we still need to align S so
565      that the offset we compute at the end is correct.  */
566   s = (const uchar *)((uintptr_t)s & -16);
567
568   /* Main loop processing 16 bytes at a time.  */
569   goto start;
570   do
571     {
572       vc m_nl, m_cr, m_bs, m_qm;
573
574       s += 16;
575       data = __builtin_vec_ld(0, (const vc *)s);
576
577     start:
578       m_nl = (vc) __builtin_vec_cmpeq(data, repl_nl);
579       m_cr = (vc) __builtin_vec_cmpeq(data, repl_cr);
580       m_bs = (vc) __builtin_vec_cmpeq(data, repl_bs);
581       m_qm = (vc) __builtin_vec_cmpeq(data, repl_qm);
582       t = (m_nl | m_cr) | (m_bs | m_qm);
583
584       /* T now contains 0xff in bytes for which we matched one of the relevant
585          characters.  We want to exit the loop if any byte in T is non-zero.
586          Below is the expansion of vec_any_ne(t, zero).  */
587     }
588   while (!__builtin_vec_vcmpeq_p(/*__CR6_LT_REV*/3, t, zero));
589
590   {
591 #define N  (sizeof(vc) / sizeof(long))
592
593     typedef char check_count[(N == 2 || N == 4) * 2 - 1];
594     union {
595       vc v;
596       unsigned long l[N];
597     } u;
598     unsigned long l, i = 0;
599
600     u.v = t;
601
602     /* Find the first word of T that is non-zero.  */
603     switch (N)
604       {
605       case 4:
606         l = u.l[i++];
607         if (l != 0)
608           break;
609         s += sizeof(unsigned long);
610         l = u.l[i++];
611         if (l != 0)
612           break;
613         s += sizeof(unsigned long);
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     l = __builtin_clzl(l) >> 3;
626     return s + l;
627
628 #undef N
629   }
630 }
631
632 #else
633
634 /* We only have one accellerated alternative.  Use a direct call so that
635    we encourage inlining.  */
636
637 #define search_line_fast  search_line_acc_char
638
639 #endif
640
641 /* Returns with a logical line that contains no escaped newlines or
642    trigraphs.  This is a time-critical inner loop.  */
643 void
644 _cpp_clean_line (cpp_reader *pfile)
645 {
646   cpp_buffer *buffer;
647   const uchar *s;
648   uchar c, *d, *p;
649
650   buffer = pfile->buffer;
651   buffer->cur_note = buffer->notes_used = 0;
652   buffer->cur = buffer->line_base = buffer->next_line;
653   buffer->need_line = false;
654   s = buffer->next_line;
655
656   if (!buffer->from_stage3)
657     {
658       const uchar *pbackslash = NULL;
659
660       /* Fast path.  This is the common case of an un-escaped line with
661          no trigraphs.  The primary win here is by not writing any
662          data back to memory until we have to.  */
663       while (1)
664         {
665           /* Perform an optimized search for \n, \r, \\, ?.  */
666           s = search_line_fast (s, buffer->rlimit);
667
668           c = *s;
669           if (c == '\\')
670             {
671               /* Record the location of the backslash and continue.  */
672               pbackslash = s++;
673             }
674           else if (__builtin_expect (c == '?', 0))
675             {
676               if (__builtin_expect (s[1] == '?', false)
677                    && _cpp_trigraph_map[s[2]])
678                 {
679                   /* Have a trigraph.  We may or may not have to convert
680                      it.  Add a line note regardless, for -Wtrigraphs.  */
681                   add_line_note (buffer, s, s[2]);
682                   if (CPP_OPTION (pfile, trigraphs))
683                     {
684                       /* We do, and that means we have to switch to the
685                          slow path.  */
686                       d = (uchar *) s;
687                       *d = _cpp_trigraph_map[s[2]];
688                       s += 2;
689                       goto slow_path;
690                     }
691                 }
692               /* Not a trigraph.  Continue on fast-path.  */
693               s++;
694             }
695           else
696             break;
697         }
698
699       /* This must be \r or \n.  We're either done, or we'll be forced
700          to write back to the buffer and continue on the slow path.  */
701       d = (uchar *) s;
702
703       if (__builtin_expect (s == buffer->rlimit, false))
704         goto done;
705
706       /* DOS line ending? */
707       if (__builtin_expect (c == '\r', false) && s[1] == '\n')
708         {
709           s++;
710           if (s == buffer->rlimit)
711             goto done;
712         }
713
714       if (__builtin_expect (pbackslash == NULL, true))
715         goto done;
716
717       /* Check for escaped newline.  */
718       p = d;
719       while (is_nvspace (p[-1]))
720         p--;
721       if (p - 1 != pbackslash)
722         goto done;
723
724       /* Have an escaped newline; process it and proceed to
725          the slow path.  */
726       add_line_note (buffer, p - 1, p != d ? ' ' : '\\');
727       d = p - 2;
728       buffer->next_line = p - 1;
729
730     slow_path:
731       while (1)
732         {
733           c = *++s;
734           *++d = c;
735
736           if (c == '\n' || c == '\r')
737             {
738               /* Handle DOS line endings.  */
739               if (c == '\r' && s != buffer->rlimit && s[1] == '\n')
740                 s++;
741               if (s == buffer->rlimit)
742                 break;
743
744               /* Escaped?  */
745               p = d;
746               while (p != buffer->next_line && is_nvspace (p[-1]))
747                 p--;
748               if (p == buffer->next_line || p[-1] != '\\')
749                 break;
750
751               add_line_note (buffer, p - 1, p != d ? ' ': '\\');
752               d = p - 2;
753               buffer->next_line = p - 1;
754             }
755           else if (c == '?' && s[1] == '?' && _cpp_trigraph_map[s[2]])
756             {
757               /* Add a note regardless, for the benefit of -Wtrigraphs.  */
758               add_line_note (buffer, d, s[2]);
759               if (CPP_OPTION (pfile, trigraphs))
760                 {
761                   *d = _cpp_trigraph_map[s[2]];
762                   s += 2;
763                 }
764             }
765         }
766     }
767   else
768     {
769       while (*s != '\n' && *s != '\r')
770         s++;
771       d = (uchar *) s;
772
773       /* Handle DOS line endings.  */
774       if (*s == '\r' && s != buffer->rlimit && s[1] == '\n')
775         s++;
776     }
777
778  done:
779   *d = '\n';
780   /* A sentinel note that should never be processed.  */
781   add_line_note (buffer, d + 1, '\n');
782   buffer->next_line = s + 1;
783 }
784
785 /* Return true if the trigraph indicated by NOTE should be warned
786    about in a comment.  */
787 static bool
788 warn_in_comment (cpp_reader *pfile, _cpp_line_note *note)
789 {
790   const uchar *p;
791
792   /* Within comments we don't warn about trigraphs, unless the
793      trigraph forms an escaped newline, as that may change
794      behavior.  */
795   if (note->type != '/')
796     return false;
797
798   /* If -trigraphs, then this was an escaped newline iff the next note
799      is coincident.  */
800   if (CPP_OPTION (pfile, trigraphs))
801     return note[1].pos == note->pos;
802
803   /* Otherwise, see if this forms an escaped newline.  */
804   p = note->pos + 3;
805   while (is_nvspace (*p))
806     p++;
807
808   /* There might have been escaped newlines between the trigraph and the
809      newline we found.  Hence the position test.  */
810   return (*p == '\n' && p < note[1].pos);
811 }
812
813 /* Process the notes created by add_line_note as far as the current
814    location.  */
815 void
816 _cpp_process_line_notes (cpp_reader *pfile, int in_comment)
817 {
818   cpp_buffer *buffer = pfile->buffer;
819
820   for (;;)
821     {
822       _cpp_line_note *note = &buffer->notes[buffer->cur_note];
823       unsigned int col;
824
825       if (note->pos > buffer->cur)
826         break;
827
828       buffer->cur_note++;
829       col = CPP_BUF_COLUMN (buffer, note->pos + 1);
830
831       if (note->type == '\\' || note->type == ' ')
832         {
833           if (note->type == ' ' && !in_comment)
834             cpp_error_with_line (pfile, CPP_DL_WARNING, pfile->line_table->highest_line, col,
835                                  "backslash and newline separated by space");
836
837           if (buffer->next_line > buffer->rlimit)
838             {
839               cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->line_table->highest_line, col,
840                                    "backslash-newline at end of file");
841               /* Prevent "no newline at end of file" warning.  */
842               buffer->next_line = buffer->rlimit;
843             }
844
845           buffer->line_base = note->pos;
846           CPP_INCREMENT_LINE (pfile, 0);
847         }
848       else if (_cpp_trigraph_map[note->type])
849         {
850           if (CPP_OPTION (pfile, warn_trigraphs)
851               && (!in_comment || warn_in_comment (pfile, note)))
852             {
853               if (CPP_OPTION (pfile, trigraphs))
854                 cpp_warning_with_line (pfile, CPP_W_TRIGRAPHS,
855                                        pfile->line_table->highest_line, col,
856                                        "trigraph ??%c converted to %c",
857                                        note->type,
858                                        (int) _cpp_trigraph_map[note->type]);
859               else
860                 {
861                   cpp_warning_with_line 
862                     (pfile, CPP_W_TRIGRAPHS,
863                      pfile->line_table->highest_line, col,
864                      "trigraph ??%c ignored, use -trigraphs to enable",
865                      note->type);
866                 }
867             }
868         }
869       else if (note->type == 0)
870         /* Already processed in lex_raw_string.  */;
871       else
872         abort ();
873     }
874 }
875
876 /* Skip a C-style block comment.  We find the end of the comment by
877    seeing if an asterisk is before every '/' we encounter.  Returns
878    nonzero if comment terminated by EOF, zero otherwise.
879
880    Buffer->cur points to the initial asterisk of the comment.  */
881 bool
882 _cpp_skip_block_comment (cpp_reader *pfile)
883 {
884   cpp_buffer *buffer = pfile->buffer;
885   const uchar *cur = buffer->cur;
886   uchar c;
887
888   cur++;
889   if (*cur == '/')
890     cur++;
891
892   for (;;)
893     {
894       /* People like decorating comments with '*', so check for '/'
895          instead for efficiency.  */
896       c = *cur++;
897
898       if (c == '/')
899         {
900           if (cur[-2] == '*')
901             break;
902
903           /* Warn about potential nested comments, but not if the '/'
904              comes immediately before the true comment delimiter.
905              Don't bother to get it right across escaped newlines.  */
906           if (CPP_OPTION (pfile, warn_comments)
907               && cur[0] == '*' && cur[1] != '/')
908             {
909               buffer->cur = cur;
910               cpp_warning_with_line (pfile, CPP_W_COMMENTS,
911                                      pfile->line_table->highest_line,
912                                      CPP_BUF_COL (buffer),
913                                      "\"/*\" within comment");
914             }
915         }
916       else if (c == '\n')
917         {
918           unsigned int cols;
919           buffer->cur = cur - 1;
920           _cpp_process_line_notes (pfile, true);
921           if (buffer->next_line >= buffer->rlimit)
922             return true;
923           _cpp_clean_line (pfile);
924
925           cols = buffer->next_line - buffer->line_base;
926           CPP_INCREMENT_LINE (pfile, cols);
927
928           cur = buffer->cur;
929         }
930     }
931
932   buffer->cur = cur;
933   _cpp_process_line_notes (pfile, true);
934   return false;
935 }
936
937 /* Skip a C++ line comment, leaving buffer->cur pointing to the
938    terminating newline.  Handles escaped newlines.  Returns nonzero
939    if a multiline comment.  */
940 static int
941 skip_line_comment (cpp_reader *pfile)
942 {
943   cpp_buffer *buffer = pfile->buffer;
944   source_location orig_line = pfile->line_table->highest_line;
945
946   while (*buffer->cur != '\n')
947     buffer->cur++;
948
949   _cpp_process_line_notes (pfile, true);
950   return orig_line != pfile->line_table->highest_line;
951 }
952
953 /* Skips whitespace, saving the next non-whitespace character.  */
954 static void
955 skip_whitespace (cpp_reader *pfile, cppchar_t c)
956 {
957   cpp_buffer *buffer = pfile->buffer;
958   bool saw_NUL = false;
959
960   do
961     {
962       /* Horizontal space always OK.  */
963       if (c == ' ' || c == '\t')
964         ;
965       /* Just \f \v or \0 left.  */
966       else if (c == '\0')
967         saw_NUL = true;
968       else if (pfile->state.in_directive && CPP_PEDANTIC (pfile))
969         cpp_error_with_line (pfile, CPP_DL_PEDWARN, pfile->line_table->highest_line,
970                              CPP_BUF_COL (buffer),
971                              "%s in preprocessing directive",
972                              c == '\f' ? "form feed" : "vertical tab");
973
974       c = *buffer->cur++;
975     }
976   /* We only want non-vertical space, i.e. ' ' \t \f \v \0.  */
977   while (is_nvspace (c));
978
979   if (saw_NUL)
980     cpp_error (pfile, CPP_DL_WARNING, "null character(s) ignored");
981
982   buffer->cur--;
983 }
984
985 /* See if the characters of a number token are valid in a name (no
986    '.', '+' or '-').  */
987 static int
988 name_p (cpp_reader *pfile, const cpp_string *string)
989 {
990   unsigned int i;
991
992   for (i = 0; i < string->len; i++)
993     if (!is_idchar (string->text[i]))
994       return 0;
995
996   return 1;
997 }
998
999 /* After parsing an identifier or other sequence, produce a warning about
1000    sequences not in NFC/NFKC.  */
1001 static void
1002 warn_about_normalization (cpp_reader *pfile, 
1003                           const cpp_token *token,
1004                           const struct normalize_state *s)
1005 {
1006   if (CPP_OPTION (pfile, warn_normalize) < NORMALIZE_STATE_RESULT (s)
1007       && !pfile->state.skipping)
1008     {
1009       /* Make sure that the token is printed using UCNs, even
1010          if we'd otherwise happily print UTF-8.  */
1011       unsigned char *buf = XNEWVEC (unsigned char, cpp_token_len (token));
1012       size_t sz;
1013
1014       sz = cpp_spell_token (pfile, token, buf, false) - buf;
1015       if (NORMALIZE_STATE_RESULT (s) == normalized_C)
1016         cpp_warning_with_line (pfile, CPP_W_NORMALIZE, token->src_loc, 0,
1017                                "`%.*s' is not in NFKC", (int) sz, buf);
1018       else
1019         cpp_warning_with_line (pfile, CPP_W_NORMALIZE, token->src_loc, 0,
1020                                "`%.*s' is not in NFC", (int) sz, buf);
1021     }
1022 }
1023
1024 /* Returns TRUE if the sequence starting at buffer->cur is invalid in
1025    an identifier.  FIRST is TRUE if this starts an identifier.  */
1026 static bool
1027 forms_identifier_p (cpp_reader *pfile, int first,
1028                     struct normalize_state *state)
1029 {
1030   cpp_buffer *buffer = pfile->buffer;
1031
1032   if (*buffer->cur == '$')
1033     {
1034       if (!CPP_OPTION (pfile, dollars_in_ident))
1035         return false;
1036
1037       buffer->cur++;
1038       if (CPP_OPTION (pfile, warn_dollars) && !pfile->state.skipping)
1039         {
1040           CPP_OPTION (pfile, warn_dollars) = 0;
1041           cpp_error (pfile, CPP_DL_PEDWARN, "'$' in identifier or number");
1042         }
1043
1044       return true;
1045     }
1046
1047   /* Is this a syntactically valid UCN?  */
1048   if (CPP_OPTION (pfile, extended_identifiers)
1049       && *buffer->cur == '\\'
1050       && (buffer->cur[1] == 'u' || buffer->cur[1] == 'U'))
1051     {
1052       buffer->cur += 2;
1053       if (_cpp_valid_ucn (pfile, &buffer->cur, buffer->rlimit, 1 + !first,
1054                           state))
1055         return true;
1056       buffer->cur -= 2;
1057     }
1058
1059   return false;
1060 }
1061
1062 /* Helper function to get the cpp_hashnode of the identifier BASE.  */
1063 static cpp_hashnode *
1064 lex_identifier_intern (cpp_reader *pfile, const uchar *base)
1065 {
1066   cpp_hashnode *result;
1067   const uchar *cur;
1068   unsigned int len;
1069   unsigned int hash = HT_HASHSTEP (0, *base);
1070
1071   cur = base + 1;
1072   while (ISIDNUM (*cur))
1073     {
1074       hash = HT_HASHSTEP (hash, *cur);
1075       cur++;
1076     }
1077   len = cur - base;
1078   hash = HT_HASHFINISH (hash, len);
1079   result = CPP_HASHNODE (ht_lookup_with_hash (pfile->hash_table,
1080                                               base, len, hash, HT_ALLOC));
1081
1082   /* Rarely, identifiers require diagnostics when lexed.  */
1083   if (__builtin_expect ((result->flags & NODE_DIAGNOSTIC)
1084                         && !pfile->state.skipping, 0))
1085     {
1086       /* It is allowed to poison the same identifier twice.  */
1087       if ((result->flags & NODE_POISONED) && !pfile->state.poisoned_ok)
1088         cpp_error (pfile, CPP_DL_ERROR, "attempt to use poisoned \"%s\"",
1089                    NODE_NAME (result));
1090
1091       /* Constraint 6.10.3.5: __VA_ARGS__ should only appear in the
1092          replacement list of a variadic macro.  */
1093       if (result == pfile->spec_nodes.n__VA_ARGS__
1094           && !pfile->state.va_args_ok)
1095         cpp_error (pfile, CPP_DL_PEDWARN,
1096                    "__VA_ARGS__ can only appear in the expansion"
1097                    " of a C99 variadic macro");
1098
1099       /* For -Wc++-compat, warn about use of C++ named operators.  */
1100       if (result->flags & NODE_WARN_OPERATOR)
1101         cpp_warning (pfile, CPP_W_CXX_OPERATOR_NAMES,
1102                      "identifier \"%s\" is a special operator name in C++",
1103                      NODE_NAME (result));
1104     }
1105
1106   return result;
1107 }
1108
1109 /* Get the cpp_hashnode of an identifier specified by NAME in
1110    the current cpp_reader object.  If none is found, NULL is returned.  */
1111 cpp_hashnode *
1112 _cpp_lex_identifier (cpp_reader *pfile, const char *name)
1113 {
1114   cpp_hashnode *result;
1115   result = lex_identifier_intern (pfile, (uchar *) name);
1116   return result;
1117 }
1118
1119 /* Lex an identifier starting at BUFFER->CUR - 1.  */
1120 static cpp_hashnode *
1121 lex_identifier (cpp_reader *pfile, const uchar *base, bool starts_ucn,
1122                 struct normalize_state *nst)
1123 {
1124   cpp_hashnode *result;
1125   const uchar *cur;
1126   unsigned int len;
1127   unsigned int hash = HT_HASHSTEP (0, *base);
1128
1129   cur = pfile->buffer->cur;
1130   if (! starts_ucn)
1131     while (ISIDNUM (*cur))
1132       {
1133         hash = HT_HASHSTEP (hash, *cur);
1134         cur++;
1135       }
1136   pfile->buffer->cur = cur;
1137   if (starts_ucn || forms_identifier_p (pfile, false, nst))
1138     {
1139       /* Slower version for identifiers containing UCNs (or $).  */
1140       do {
1141         while (ISIDNUM (*pfile->buffer->cur))
1142           {
1143             pfile->buffer->cur++;
1144             NORMALIZE_STATE_UPDATE_IDNUM (nst);
1145           }
1146       } while (forms_identifier_p (pfile, false, nst));
1147       result = _cpp_interpret_identifier (pfile, base,
1148                                           pfile->buffer->cur - base);
1149     }
1150   else
1151     {
1152       len = cur - base;
1153       hash = HT_HASHFINISH (hash, len);
1154
1155       result = CPP_HASHNODE (ht_lookup_with_hash (pfile->hash_table,
1156                                                   base, len, hash, HT_ALLOC));
1157     }
1158
1159   /* Rarely, identifiers require diagnostics when lexed.  */
1160   if (__builtin_expect ((result->flags & NODE_DIAGNOSTIC)
1161                         && !pfile->state.skipping, 0))
1162     {
1163       /* It is allowed to poison the same identifier twice.  */
1164       if ((result->flags & NODE_POISONED) && !pfile->state.poisoned_ok)
1165         cpp_error (pfile, CPP_DL_ERROR, "attempt to use poisoned \"%s\"",
1166                    NODE_NAME (result));
1167
1168       /* Constraint 6.10.3.5: __VA_ARGS__ should only appear in the
1169          replacement list of a variadic macro.  */
1170       if (result == pfile->spec_nodes.n__VA_ARGS__
1171           && !pfile->state.va_args_ok)
1172         cpp_error (pfile, CPP_DL_PEDWARN,
1173                    "__VA_ARGS__ can only appear in the expansion"
1174                    " of a C99 variadic macro");
1175
1176       /* For -Wc++-compat, warn about use of C++ named operators.  */
1177       if (result->flags & NODE_WARN_OPERATOR)
1178         cpp_warning (pfile, CPP_W_CXX_OPERATOR_NAMES,
1179                      "identifier \"%s\" is a special operator name in C++",
1180                      NODE_NAME (result));
1181     }
1182
1183   return result;
1184 }
1185
1186 /* Lex a number to NUMBER starting at BUFFER->CUR - 1.  */
1187 static void
1188 lex_number (cpp_reader *pfile, cpp_string *number,
1189             struct normalize_state *nst)
1190 {
1191   const uchar *cur;
1192   const uchar *base;
1193   uchar *dest;
1194
1195   base = pfile->buffer->cur - 1;
1196   do
1197     {
1198       cur = pfile->buffer->cur;
1199
1200       /* N.B. ISIDNUM does not include $.  */
1201       while (ISIDNUM (*cur) || *cur == '.' || VALID_SIGN (*cur, cur[-1]))
1202         {
1203           cur++;
1204           NORMALIZE_STATE_UPDATE_IDNUM (nst);
1205         }
1206
1207       pfile->buffer->cur = cur;
1208     }
1209   while (forms_identifier_p (pfile, false, nst));
1210
1211   number->len = cur - base;
1212   dest = _cpp_unaligned_alloc (pfile, number->len + 1);
1213   memcpy (dest, base, number->len);
1214   dest[number->len] = '\0';
1215   number->text = dest;
1216 }
1217
1218 /* Create a token of type TYPE with a literal spelling.  */
1219 static void
1220 create_literal (cpp_reader *pfile, cpp_token *token, const uchar *base,
1221                 unsigned int len, enum cpp_ttype type)
1222 {
1223   uchar *dest = _cpp_unaligned_alloc (pfile, len + 1);
1224
1225   memcpy (dest, base, len);
1226   dest[len] = '\0';
1227   token->type = type;
1228   token->val.str.len = len;
1229   token->val.str.text = dest;
1230 }
1231
1232 /* Subroutine of lex_raw_string: Append LEN chars from BASE to the buffer
1233    sequence from *FIRST_BUFF_P to LAST_BUFF_P.  */
1234
1235 static void
1236 bufring_append (cpp_reader *pfile, const uchar *base, size_t len,
1237                 _cpp_buff **first_buff_p, _cpp_buff **last_buff_p)
1238 {
1239   _cpp_buff *first_buff = *first_buff_p;
1240   _cpp_buff *last_buff = *last_buff_p;
1241
1242   if (first_buff == NULL)
1243     first_buff = last_buff = _cpp_get_buff (pfile, len);
1244   else if (len > BUFF_ROOM (last_buff))
1245     {
1246       size_t room = BUFF_ROOM (last_buff);
1247       memcpy (BUFF_FRONT (last_buff), base, room);
1248       BUFF_FRONT (last_buff) += room;
1249       base += room;
1250       len -= room;
1251       last_buff = _cpp_append_extend_buff (pfile, last_buff, len);
1252     }
1253
1254   memcpy (BUFF_FRONT (last_buff), base, len);
1255   BUFF_FRONT (last_buff) += len;
1256
1257   *first_buff_p = first_buff;
1258   *last_buff_p = last_buff;
1259 }
1260
1261 /* Lexes a raw string.  The stored string contains the spelling, including
1262    double quotes, delimiter string, '(' and ')', any leading
1263    'L', 'u', 'U' or 'u8' and 'R' modifier.  It returns the type of the
1264    literal, or CPP_OTHER if it was not properly terminated.
1265
1266    The spelling is NUL-terminated, but it is not guaranteed that this
1267    is the first NUL since embedded NULs are preserved.  */
1268
1269 static void
1270 lex_raw_string (cpp_reader *pfile, cpp_token *token, const uchar *base,
1271                 const uchar *cur)
1272 {
1273   const uchar *raw_prefix;
1274   unsigned int raw_prefix_len = 0;
1275   enum cpp_ttype type;
1276   size_t total_len = 0;
1277   _cpp_buff *first_buff = NULL, *last_buff = NULL;
1278   _cpp_line_note *note = &pfile->buffer->notes[pfile->buffer->cur_note];
1279
1280   type = (*base == 'L' ? CPP_WSTRING :
1281           *base == 'U' ? CPP_STRING32 :
1282           *base == 'u' ? (base[1] == '8' ? CPP_UTF8STRING : CPP_STRING16)
1283           : CPP_STRING);
1284
1285   raw_prefix = cur + 1;
1286   while (raw_prefix_len < 16)
1287     {
1288       switch (raw_prefix[raw_prefix_len])
1289         {
1290         case ' ': case '(': case ')': case '\\': case '\t':
1291         case '\v': case '\f': case '\n': default:
1292           break;
1293         /* Basic source charset except the above chars.  */
1294         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
1295         case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1296         case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
1297         case 's': case 't': case 'u': case 'v': case 'w': case 'x':
1298         case 'y': case 'z':
1299         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
1300         case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
1301         case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
1302         case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
1303         case 'Y': case 'Z':
1304         case '0': case '1': case '2': case '3': case '4': case '5':
1305         case '6': case '7': case '8': case '9':
1306         case '_': case '{': case '}': case '#': case '[': case ']':
1307         case '<': case '>': case '%': case ':': case ';': case '.':
1308         case '?': case '*': case '+': case '-': case '/': case '^':
1309         case '&': case '|': case '~': case '!': case '=': case ',':
1310         case '"': case '\'':
1311           raw_prefix_len++;
1312           continue;
1313         }
1314       break;
1315     }
1316
1317   if (raw_prefix[raw_prefix_len] != '(')
1318     {
1319       int col = CPP_BUF_COLUMN (pfile->buffer, raw_prefix + raw_prefix_len)
1320                 + 1;
1321       if (raw_prefix_len == 16)
1322         cpp_error_with_line (pfile, CPP_DL_ERROR, token->src_loc, col,
1323                              "raw string delimiter longer than 16 characters");
1324       else
1325         cpp_error_with_line (pfile, CPP_DL_ERROR, token->src_loc, col,
1326                              "invalid character '%c' in raw string delimiter",
1327                              (int) raw_prefix[raw_prefix_len]);
1328       pfile->buffer->cur = raw_prefix - 1;
1329       create_literal (pfile, token, base, raw_prefix - 1 - base, CPP_OTHER);
1330       return;
1331     }
1332
1333   cur = raw_prefix + raw_prefix_len + 1;
1334   for (;;)
1335     {
1336 #define BUF_APPEND(STR,LEN)                                     \
1337       do {                                                      \
1338         bufring_append (pfile, (const uchar *)(STR), (LEN),     \
1339                         &first_buff, &last_buff);               \
1340         total_len += (LEN);                                     \
1341       } while (0);
1342
1343       cppchar_t c;
1344
1345       /* If we previously performed any trigraph or line splicing
1346          transformations, undo them within the body of the raw string.  */
1347       while (note->pos < cur)
1348         ++note;
1349       for (; note->pos == cur; ++note)
1350         {
1351           switch (note->type)
1352             {
1353             case '\\':
1354             case ' ':
1355               /* Restore backslash followed by newline.  */
1356               BUF_APPEND (base, cur - base);
1357               base = cur;
1358               BUF_APPEND ("\\", 1);
1359             after_backslash:
1360               if (note->type == ' ')
1361                 {
1362                   /* GNU backslash whitespace newline extension.  FIXME
1363                      could be any sequence of non-vertical space.  When we
1364                      can properly restore any such sequence, we should mark
1365                      this note as handled so _cpp_process_line_notes
1366                      doesn't warn.  */
1367                   BUF_APPEND (" ", 1);
1368                 }
1369
1370               BUF_APPEND ("\n", 1);
1371               break;
1372
1373             case 0:
1374               /* Already handled.  */
1375               break;
1376
1377             default:
1378               if (_cpp_trigraph_map[note->type])
1379                 {
1380                   /* Don't warn about this trigraph in
1381                      _cpp_process_line_notes, since trigraphs show up as
1382                      trigraphs in raw strings.  */
1383                   uchar type = note->type;
1384                   note->type = 0;
1385
1386                   if (!CPP_OPTION (pfile, trigraphs))
1387                     /* If we didn't convert the trigraph in the first
1388                        place, don't do anything now either.  */
1389                     break;
1390
1391                   BUF_APPEND (base, cur - base);
1392                   base = cur;
1393                   BUF_APPEND ("??", 2);
1394
1395                   /* ??/ followed by newline gets two line notes, one for
1396                      the trigraph and one for the backslash/newline.  */
1397                   if (type == '/' && note[1].pos == cur)
1398                     {
1399                       if (note[1].type != '\\'
1400                           && note[1].type != ' ')
1401                         abort ();
1402                       BUF_APPEND ("/", 1);
1403                       ++note;
1404                       goto after_backslash;
1405                     }
1406                   /* The ) from ??) could be part of the suffix.  */
1407                   else if (type == ')'
1408                            && strncmp ((const char *) cur+1,
1409                                        (const char *) raw_prefix,
1410                                        raw_prefix_len) == 0
1411                            && cur[raw_prefix_len+1] == '"')
1412                     {
1413                       BUF_APPEND (")", 1);
1414                       base++;
1415                       cur += raw_prefix_len + 2;
1416                       goto break_outer_loop;
1417                     }
1418                   else
1419                     {
1420                       /* Skip the replacement character.  */
1421                       base = ++cur;
1422                       BUF_APPEND (&type, 1);
1423                     }
1424                 }
1425               else
1426                 abort ();
1427               break;
1428             }
1429         }
1430       c = *cur++;
1431
1432       if (c == ')'
1433           && strncmp ((const char *) cur, (const char *) raw_prefix,
1434                       raw_prefix_len) == 0
1435           && cur[raw_prefix_len] == '"')
1436         {
1437           cur += raw_prefix_len + 1;
1438           break;
1439         }
1440       else if (c == '\n')
1441         {
1442           if (pfile->state.in_directive
1443               || pfile->state.parsing_args
1444               || pfile->state.in_deferred_pragma)
1445             {
1446               cur--;
1447               type = CPP_OTHER;
1448               cpp_error_with_line (pfile, CPP_DL_ERROR, token->src_loc, 0,
1449                                    "unterminated raw string");
1450               break;
1451             }
1452
1453           BUF_APPEND (base, cur - base);
1454
1455           if (pfile->buffer->cur < pfile->buffer->rlimit)
1456             CPP_INCREMENT_LINE (pfile, 0);
1457           pfile->buffer->need_line = true;
1458
1459           pfile->buffer->cur = cur-1;
1460           _cpp_process_line_notes (pfile, false);
1461           if (!_cpp_get_fresh_line (pfile))
1462             {
1463               source_location src_loc = token->src_loc;
1464               token->type = CPP_EOF;
1465               /* Tell the compiler the line number of the EOF token.  */
1466               token->src_loc = pfile->line_table->highest_line;
1467               token->flags = BOL;
1468               if (first_buff != NULL)
1469                 _cpp_release_buff (pfile, first_buff);
1470               cpp_error_with_line (pfile, CPP_DL_ERROR, src_loc, 0,
1471                                    "unterminated raw string");
1472               return;
1473             }
1474
1475           cur = base = pfile->buffer->cur;
1476           note = &pfile->buffer->notes[pfile->buffer->cur_note];
1477         }
1478     }
1479  break_outer_loop:
1480
1481   pfile->buffer->cur = cur;
1482   if (first_buff == NULL)
1483     create_literal (pfile, token, base, cur - base, type);
1484   else
1485     {
1486       uchar *dest = _cpp_unaligned_alloc (pfile, total_len + (cur - base) + 1);
1487
1488       token->type = type;
1489       token->val.str.len = total_len + (cur - base);
1490       token->val.str.text = dest;
1491       last_buff = first_buff;
1492       while (last_buff != NULL)
1493         {
1494           memcpy (dest, last_buff->base,
1495                   BUFF_FRONT (last_buff) - last_buff->base);
1496           dest += BUFF_FRONT (last_buff) - last_buff->base;
1497           last_buff = last_buff->next;
1498         }
1499       _cpp_release_buff (pfile, first_buff);
1500       memcpy (dest, base, cur - base);
1501       dest[cur - base] = '\0';
1502     }
1503 }
1504
1505 /* Lexes a string, character constant, or angle-bracketed header file
1506    name.  The stored string contains the spelling, including opening
1507    quote and any leading 'L', 'u', 'U' or 'u8' and optional
1508    'R' modifier.  It returns the type of the literal, or CPP_OTHER
1509    if it was not properly terminated, or CPP_LESS for an unterminated
1510    header name which must be relexed as normal tokens.
1511
1512    The spelling is NUL-terminated, but it is not guaranteed that this
1513    is the first NUL since embedded NULs are preserved.  */
1514 static void
1515 lex_string (cpp_reader *pfile, cpp_token *token, const uchar *base)
1516 {
1517   bool saw_NUL = false;
1518   const uchar *cur;
1519   cppchar_t terminator;
1520   enum cpp_ttype type;
1521
1522   cur = base;
1523   terminator = *cur++;
1524   if (terminator == 'L' || terminator == 'U')
1525     terminator = *cur++;
1526   else if (terminator == 'u')
1527     {
1528       terminator = *cur++;
1529       if (terminator == '8')
1530         terminator = *cur++;
1531     }
1532   if (terminator == 'R')
1533     {
1534       lex_raw_string (pfile, token, base, cur);
1535       return;
1536     }
1537   if (terminator == '"')
1538     type = (*base == 'L' ? CPP_WSTRING :
1539             *base == 'U' ? CPP_STRING32 :
1540             *base == 'u' ? (base[1] == '8' ? CPP_UTF8STRING : CPP_STRING16)
1541                          : CPP_STRING);
1542   else if (terminator == '\'')
1543     type = (*base == 'L' ? CPP_WCHAR :
1544             *base == 'U' ? CPP_CHAR32 :
1545             *base == 'u' ? CPP_CHAR16 : CPP_CHAR);
1546   else
1547     terminator = '>', type = CPP_HEADER_NAME;
1548
1549   for (;;)
1550     {
1551       cppchar_t c = *cur++;
1552
1553       /* In #include-style directives, terminators are not escapable.  */
1554       if (c == '\\' && !pfile->state.angled_headers && *cur != '\n')
1555         cur++;
1556       else if (c == terminator)
1557         break;
1558       else if (c == '\n')
1559         {
1560           cur--;
1561           /* Unmatched quotes always yield undefined behavior, but
1562              greedy lexing means that what appears to be an unterminated
1563              header name may actually be a legitimate sequence of tokens.  */
1564           if (terminator == '>')
1565             {
1566               token->type = CPP_LESS;
1567               return;
1568             }
1569           type = CPP_OTHER;
1570           break;
1571         }
1572       else if (c == '\0')
1573         saw_NUL = true;
1574     }
1575
1576   if (saw_NUL && !pfile->state.skipping)
1577     cpp_error (pfile, CPP_DL_WARNING,
1578                "null character(s) preserved in literal");
1579
1580   if (type == CPP_OTHER && CPP_OPTION (pfile, lang) != CLK_ASM)
1581     cpp_error (pfile, CPP_DL_PEDWARN, "missing terminating %c character",
1582                (int) terminator);
1583
1584   pfile->buffer->cur = cur;
1585   create_literal (pfile, token, base, cur - base, type);
1586 }
1587
1588 /* Return the comment table. The client may not make any assumption
1589    about the ordering of the table.  */
1590 cpp_comment_table *
1591 cpp_get_comments (cpp_reader *pfile)
1592 {
1593   return &pfile->comments;
1594 }
1595
1596 /* Append a comment to the end of the comment table. */
1597 static void 
1598 store_comment (cpp_reader *pfile, cpp_token *token) 
1599 {
1600   int len;
1601
1602   if (pfile->comments.allocated == 0)
1603     {
1604       pfile->comments.allocated = 256; 
1605       pfile->comments.entries = (cpp_comment *) xmalloc
1606         (pfile->comments.allocated * sizeof (cpp_comment));
1607     }
1608
1609   if (pfile->comments.count == pfile->comments.allocated)
1610     {
1611       pfile->comments.allocated *= 2;
1612       pfile->comments.entries = (cpp_comment *) xrealloc
1613         (pfile->comments.entries,
1614          pfile->comments.allocated * sizeof (cpp_comment));
1615     }
1616
1617   len = token->val.str.len;
1618
1619   /* Copy comment. Note, token may not be NULL terminated. */
1620   pfile->comments.entries[pfile->comments.count].comment = 
1621     (char *) xmalloc (sizeof (char) * (len + 1));
1622   memcpy (pfile->comments.entries[pfile->comments.count].comment,
1623           token->val.str.text, len);
1624   pfile->comments.entries[pfile->comments.count].comment[len] = '\0';
1625
1626   /* Set source location. */
1627   pfile->comments.entries[pfile->comments.count].sloc = token->src_loc;
1628
1629   /* Increment the count of entries in the comment table. */
1630   pfile->comments.count++;
1631 }
1632
1633 /* The stored comment includes the comment start and any terminator.  */
1634 static void
1635 save_comment (cpp_reader *pfile, cpp_token *token, const unsigned char *from,
1636               cppchar_t type)
1637 {
1638   unsigned char *buffer;
1639   unsigned int len, clen, i;
1640
1641   len = pfile->buffer->cur - from + 1; /* + 1 for the initial '/'.  */
1642
1643   /* C++ comments probably (not definitely) have moved past a new
1644      line, which we don't want to save in the comment.  */
1645   if (is_vspace (pfile->buffer->cur[-1]))
1646     len--;
1647
1648   /* If we are currently in a directive or in argument parsing, then
1649      we need to store all C++ comments as C comments internally, and
1650      so we need to allocate a little extra space in that case.
1651
1652      Note that the only time we encounter a directive here is
1653      when we are saving comments in a "#define".  */
1654   clen = ((pfile->state.in_directive || pfile->state.parsing_args)
1655           && type == '/') ? len + 2 : len;
1656
1657   buffer = _cpp_unaligned_alloc (pfile, clen);
1658
1659   token->type = CPP_COMMENT;
1660   token->val.str.len = clen;
1661   token->val.str.text = buffer;
1662
1663   buffer[0] = '/';
1664   memcpy (buffer + 1, from, len - 1);
1665
1666   /* Finish conversion to a C comment, if necessary.  */
1667   if ((pfile->state.in_directive || pfile->state.parsing_args) && type == '/')
1668     {
1669       buffer[1] = '*';
1670       buffer[clen - 2] = '*';
1671       buffer[clen - 1] = '/';
1672       /* As there can be in a C++ comments illegal sequences for C comments
1673          we need to filter them out.  */
1674       for (i = 2; i < (clen - 2); i++)
1675         if (buffer[i] == '/' && (buffer[i - 1] == '*' || buffer[i + 1] == '*'))
1676           buffer[i] = '|';
1677     }
1678
1679   /* Finally store this comment for use by clients of libcpp. */
1680   store_comment (pfile, token);
1681 }
1682
1683 /* Allocate COUNT tokens for RUN.  */
1684 void
1685 _cpp_init_tokenrun (tokenrun *run, unsigned int count)
1686 {
1687   run->base = XNEWVEC (cpp_token, count);
1688   run->limit = run->base + count;
1689   run->next = NULL;
1690 }
1691
1692 /* Returns the next tokenrun, or creates one if there is none.  */
1693 static tokenrun *
1694 next_tokenrun (tokenrun *run)
1695 {
1696   if (run->next == NULL)
1697     {
1698       run->next = XNEW (tokenrun);
1699       run->next->prev = run;
1700       _cpp_init_tokenrun (run->next, 250);
1701     }
1702
1703   return run->next;
1704 }
1705
1706 /* Look ahead in the input stream.  */
1707 const cpp_token *
1708 cpp_peek_token (cpp_reader *pfile, int index)
1709 {
1710   cpp_context *context = pfile->context;
1711   const cpp_token *peektok;
1712   int count;
1713
1714   /* First, scan through any pending cpp_context objects.  */
1715   while (context->prev)
1716     {
1717       ptrdiff_t sz = (context->direct_p
1718                       ? LAST (context).token - FIRST (context).token
1719                       : LAST (context).ptoken - FIRST (context).ptoken);
1720
1721       if (index < (int) sz)
1722         return (context->direct_p
1723                 ? FIRST (context).token + index
1724                 : *(FIRST (context).ptoken + index));
1725
1726       index -= (int) sz;
1727       context = context->prev;
1728     }
1729
1730   /* We will have to read some new tokens after all (and do so
1731      without invalidating preceding tokens).  */
1732   count = index;
1733   pfile->keep_tokens++;
1734
1735   do
1736     {
1737       peektok = _cpp_lex_token (pfile);
1738       if (peektok->type == CPP_EOF)
1739         return peektok;
1740     }
1741   while (index--);
1742
1743   _cpp_backup_tokens_direct (pfile, count + 1);
1744   pfile->keep_tokens--;
1745
1746   return peektok;
1747 }
1748
1749 /* Allocate a single token that is invalidated at the same time as the
1750    rest of the tokens on the line.  Has its line and col set to the
1751    same as the last lexed token, so that diagnostics appear in the
1752    right place.  */
1753 cpp_token *
1754 _cpp_temp_token (cpp_reader *pfile)
1755 {
1756   cpp_token *old, *result;
1757   ptrdiff_t sz = pfile->cur_run->limit - pfile->cur_token;
1758   ptrdiff_t la = (ptrdiff_t) pfile->lookaheads;
1759
1760   old = pfile->cur_token - 1;
1761   /* Any pre-existing lookaheads must not be clobbered.  */
1762   if (la)
1763     {
1764       if (sz <= la)
1765         {
1766           tokenrun *next = next_tokenrun (pfile->cur_run);
1767
1768           if (sz < la)
1769             memmove (next->base + 1, next->base,
1770                      (la - sz) * sizeof (cpp_token));
1771
1772           next->base[0] = pfile->cur_run->limit[-1];
1773         }
1774
1775       if (sz > 1)
1776         memmove (pfile->cur_token + 1, pfile->cur_token,
1777                  MIN (la, sz - 1) * sizeof (cpp_token));
1778     }
1779
1780   if (!sz && pfile->cur_token == pfile->cur_run->limit)
1781     {
1782       pfile->cur_run = next_tokenrun (pfile->cur_run);
1783       pfile->cur_token = pfile->cur_run->base;
1784     }
1785
1786   result = pfile->cur_token++;
1787   result->src_loc = old->src_loc;
1788   return result;
1789 }
1790
1791 /* Lex a token into RESULT (external interface).  Takes care of issues
1792    like directive handling, token lookahead, multiple include
1793    optimization and skipping.  */
1794 const cpp_token *
1795 _cpp_lex_token (cpp_reader *pfile)
1796 {
1797   cpp_token *result;
1798
1799   for (;;)
1800     {
1801       if (pfile->cur_token == pfile->cur_run->limit)
1802         {
1803           pfile->cur_run = next_tokenrun (pfile->cur_run);
1804           pfile->cur_token = pfile->cur_run->base;
1805         }
1806       /* We assume that the current token is somewhere in the current
1807          run.  */
1808       if (pfile->cur_token < pfile->cur_run->base
1809           || pfile->cur_token >= pfile->cur_run->limit)
1810         abort ();
1811
1812       if (pfile->lookaheads)
1813         {
1814           pfile->lookaheads--;
1815           result = pfile->cur_token++;
1816         }
1817       else
1818         result = _cpp_lex_direct (pfile);
1819
1820       if (result->flags & BOL)
1821         {
1822           /* Is this a directive.  If _cpp_handle_directive returns
1823              false, it is an assembler #.  */
1824           if (result->type == CPP_HASH
1825               /* 6.10.3 p 11: Directives in a list of macro arguments
1826                  gives undefined behavior.  This implementation
1827                  handles the directive as normal.  */
1828               && pfile->state.parsing_args != 1)
1829             {
1830               if (_cpp_handle_directive (pfile, result->flags & PREV_WHITE))
1831                 {
1832                   if (pfile->directive_result.type == CPP_PADDING)
1833                     continue;
1834                   result = &pfile->directive_result;
1835                 }
1836             }
1837           else if (pfile->state.in_deferred_pragma)
1838             result = &pfile->directive_result;
1839
1840           if (pfile->cb.line_change && !pfile->state.skipping)
1841             pfile->cb.line_change (pfile, result, pfile->state.parsing_args);
1842         }
1843
1844       /* We don't skip tokens in directives.  */
1845       if (pfile->state.in_directive || pfile->state.in_deferred_pragma)
1846         break;
1847
1848       /* Outside a directive, invalidate controlling macros.  At file
1849          EOF, _cpp_lex_direct takes care of popping the buffer, so we never
1850          get here and MI optimization works.  */
1851       pfile->mi_valid = false;
1852
1853       if (!pfile->state.skipping || result->type == CPP_EOF)
1854         break;
1855     }
1856
1857   return result;
1858 }
1859
1860 /* Returns true if a fresh line has been loaded.  */
1861 bool
1862 _cpp_get_fresh_line (cpp_reader *pfile)
1863 {
1864   int return_at_eof;
1865
1866   /* We can't get a new line until we leave the current directive.  */
1867   if (pfile->state.in_directive)
1868     return false;
1869
1870   for (;;)
1871     {
1872       cpp_buffer *buffer = pfile->buffer;
1873
1874       if (!buffer->need_line)
1875         return true;
1876
1877       if (buffer->next_line < buffer->rlimit)
1878         {
1879           _cpp_clean_line (pfile);
1880           return true;
1881         }
1882
1883       /* First, get out of parsing arguments state.  */
1884       if (pfile->state.parsing_args)
1885         return false;
1886
1887       /* End of buffer.  Non-empty files should end in a newline.  */
1888       if (buffer->buf != buffer->rlimit
1889           && buffer->next_line > buffer->rlimit
1890           && !buffer->from_stage3)
1891         {
1892           /* Clip to buffer size.  */
1893           buffer->next_line = buffer->rlimit;
1894         }
1895
1896       return_at_eof = buffer->return_at_eof;
1897       _cpp_pop_buffer (pfile);
1898       if (pfile->buffer == NULL || return_at_eof)
1899         return false;
1900     }
1901 }
1902
1903 #define IF_NEXT_IS(CHAR, THEN_TYPE, ELSE_TYPE)          \
1904   do                                                    \
1905     {                                                   \
1906       result->type = ELSE_TYPE;                         \
1907       if (*buffer->cur == CHAR)                         \
1908         buffer->cur++, result->type = THEN_TYPE;        \
1909     }                                                   \
1910   while (0)
1911
1912 /* Lex a token into pfile->cur_token, which is also incremented, to
1913    get diagnostics pointing to the correct location.
1914
1915    Does not handle issues such as token lookahead, multiple-include
1916    optimization, directives, skipping etc.  This function is only
1917    suitable for use by _cpp_lex_token, and in special cases like
1918    lex_expansion_token which doesn't care for any of these issues.
1919
1920    When meeting a newline, returns CPP_EOF if parsing a directive,
1921    otherwise returns to the start of the token buffer if permissible.
1922    Returns the location of the lexed token.  */
1923 cpp_token *
1924 _cpp_lex_direct (cpp_reader *pfile)
1925 {
1926   cppchar_t c;
1927   cpp_buffer *buffer;
1928   const unsigned char *comment_start;
1929   cpp_token *result = pfile->cur_token++;
1930
1931  fresh_line:
1932   result->flags = 0;
1933   buffer = pfile->buffer;
1934   if (buffer->need_line)
1935     {
1936       if (pfile->state.in_deferred_pragma)
1937         {
1938           result->type = CPP_PRAGMA_EOL;
1939           pfile->state.in_deferred_pragma = false;
1940           if (!pfile->state.pragma_allow_expansion)
1941             pfile->state.prevent_expansion--;
1942           return result;
1943         }
1944       if (!_cpp_get_fresh_line (pfile))
1945         {
1946           result->type = CPP_EOF;
1947           if (!pfile->state.in_directive)
1948             {
1949               /* Tell the compiler the line number of the EOF token.  */
1950               result->src_loc = pfile->line_table->highest_line;
1951               result->flags = BOL;
1952             }
1953           return result;
1954         }
1955       if (!pfile->keep_tokens)
1956         {
1957           pfile->cur_run = &pfile->base_run;
1958           result = pfile->base_run.base;
1959           pfile->cur_token = result + 1;
1960         }
1961       result->flags = BOL;
1962       if (pfile->state.parsing_args == 2)
1963         result->flags |= PREV_WHITE;
1964     }
1965   buffer = pfile->buffer;
1966  update_tokens_line:
1967   result->src_loc = pfile->line_table->highest_line;
1968
1969  skipped_white:
1970   if (buffer->cur >= buffer->notes[buffer->cur_note].pos
1971       && !pfile->overlaid_buffer)
1972     {
1973       _cpp_process_line_notes (pfile, false);
1974       result->src_loc = pfile->line_table->highest_line;
1975     }
1976   c = *buffer->cur++;
1977
1978   LINEMAP_POSITION_FOR_COLUMN (result->src_loc, pfile->line_table,
1979                                CPP_BUF_COLUMN (buffer, buffer->cur));
1980
1981   switch (c)
1982     {
1983     case ' ': case '\t': case '\f': case '\v': case '\0':
1984       result->flags |= PREV_WHITE;
1985       skip_whitespace (pfile, c);
1986       goto skipped_white;
1987
1988     case '\n':
1989       if (buffer->cur < buffer->rlimit)
1990         CPP_INCREMENT_LINE (pfile, 0);
1991       buffer->need_line = true;
1992       goto fresh_line;
1993
1994     case '0': case '1': case '2': case '3': case '4':
1995     case '5': case '6': case '7': case '8': case '9':
1996       {
1997         struct normalize_state nst = INITIAL_NORMALIZE_STATE;
1998         result->type = CPP_NUMBER;
1999         lex_number (pfile, &result->val.str, &nst);
2000         warn_about_normalization (pfile, result, &nst);
2001         break;
2002       }
2003
2004     case 'L':
2005     case 'u':
2006     case 'U':
2007     case 'R':
2008       /* 'L', 'u', 'U', 'u8' or 'R' may introduce wide characters,
2009          wide strings or raw strings.  */
2010       if (c == 'L' || CPP_OPTION (pfile, uliterals))
2011         {
2012           if ((*buffer->cur == '\'' && c != 'R')
2013               || *buffer->cur == '"'
2014               || (*buffer->cur == 'R'
2015                   && c != 'R'
2016                   && buffer->cur[1] == '"'
2017                   && CPP_OPTION (pfile, uliterals))
2018               || (*buffer->cur == '8'
2019                   && c == 'u'
2020                   && (buffer->cur[1] == '"'
2021                       || (buffer->cur[1] == 'R' && buffer->cur[2] == '"'))))
2022             {
2023               lex_string (pfile, result, buffer->cur - 1);
2024               break;
2025             }
2026         }
2027       /* Fall through.  */
2028
2029     case '_':
2030     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
2031     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
2032     case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
2033     case 's': case 't':           case 'v': case 'w': case 'x':
2034     case 'y': case 'z':
2035     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
2036     case 'G': case 'H': case 'I': case 'J': case 'K':
2037     case 'M': case 'N': case 'O': case 'P': case 'Q':
2038     case 'S': case 'T':           case 'V': case 'W': case 'X':
2039     case 'Y': case 'Z':
2040       result->type = CPP_NAME;
2041       {
2042         struct normalize_state nst = INITIAL_NORMALIZE_STATE;
2043         result->val.node.node = lex_identifier (pfile, buffer->cur - 1, false,
2044                                                 &nst);
2045         warn_about_normalization (pfile, result, &nst);
2046       }
2047
2048       /* Convert named operators to their proper types.  */
2049       if (result->val.node.node->flags & NODE_OPERATOR)
2050         {
2051           result->flags |= NAMED_OP;
2052           result->type = (enum cpp_ttype) result->val.node.node->directive_index;
2053         }
2054       break;
2055
2056     case '\'':
2057     case '"':
2058       lex_string (pfile, result, buffer->cur - 1);
2059       break;
2060
2061     case '/':
2062       /* A potential block or line comment.  */
2063       comment_start = buffer->cur;
2064       c = *buffer->cur;
2065       
2066       if (c == '*')
2067         {
2068           if (_cpp_skip_block_comment (pfile))
2069             cpp_error (pfile, CPP_DL_ERROR, "unterminated comment");
2070         }
2071       else if (c == '/' && (CPP_OPTION (pfile, cplusplus_comments)
2072                             || cpp_in_system_header (pfile)))
2073         {
2074           /* Warn about comments only if pedantically GNUC89, and not
2075              in system headers.  */
2076           if (CPP_OPTION (pfile, lang) == CLK_GNUC89 && CPP_PEDANTIC (pfile)
2077               && ! buffer->warned_cplusplus_comments)
2078             {
2079               cpp_error (pfile, CPP_DL_PEDWARN,
2080                          "C++ style comments are not allowed in ISO C90");
2081               cpp_error (pfile, CPP_DL_PEDWARN,
2082                          "(this will be reported only once per input file)");
2083               buffer->warned_cplusplus_comments = 1;
2084             }
2085
2086           if (skip_line_comment (pfile) && CPP_OPTION (pfile, warn_comments))
2087             cpp_warning (pfile, CPP_W_COMMENTS, "multi-line comment");
2088         }
2089       else if (c == '=')
2090         {
2091           buffer->cur++;
2092           result->type = CPP_DIV_EQ;
2093           break;
2094         }
2095       else
2096         {
2097           result->type = CPP_DIV;
2098           break;
2099         }
2100
2101       if (!pfile->state.save_comments)
2102         {
2103           result->flags |= PREV_WHITE;
2104           goto update_tokens_line;
2105         }
2106
2107       /* Save the comment as a token in its own right.  */
2108       save_comment (pfile, result, comment_start, c);
2109       break;
2110
2111     case '<':
2112       if (pfile->state.angled_headers)
2113         {
2114           lex_string (pfile, result, buffer->cur - 1);
2115           if (result->type != CPP_LESS)
2116             break;
2117         }
2118
2119       result->type = CPP_LESS;
2120       if (*buffer->cur == '=')
2121         buffer->cur++, result->type = CPP_LESS_EQ;
2122       else if (*buffer->cur == '<')
2123         {
2124           buffer->cur++;
2125           IF_NEXT_IS ('=', CPP_LSHIFT_EQ, CPP_LSHIFT);
2126         }
2127       else if (CPP_OPTION (pfile, digraphs))
2128         {
2129           if (*buffer->cur == ':')
2130             {
2131               buffer->cur++;
2132               result->flags |= DIGRAPH;
2133               result->type = CPP_OPEN_SQUARE;
2134             }
2135           else if (*buffer->cur == '%')
2136             {
2137               buffer->cur++;
2138               result->flags |= DIGRAPH;
2139               result->type = CPP_OPEN_BRACE;
2140             }
2141         }
2142       break;
2143
2144     case '>':
2145       result->type = CPP_GREATER;
2146       if (*buffer->cur == '=')
2147         buffer->cur++, result->type = CPP_GREATER_EQ;
2148       else if (*buffer->cur == '>')
2149         {
2150           buffer->cur++;
2151           IF_NEXT_IS ('=', CPP_RSHIFT_EQ, CPP_RSHIFT);
2152         }
2153       break;
2154
2155     case '%':
2156       result->type = CPP_MOD;
2157       if (*buffer->cur == '=')
2158         buffer->cur++, result->type = CPP_MOD_EQ;
2159       else if (CPP_OPTION (pfile, digraphs))
2160         {
2161           if (*buffer->cur == ':')
2162             {
2163               buffer->cur++;
2164               result->flags |= DIGRAPH;
2165               result->type = CPP_HASH;
2166               if (*buffer->cur == '%' && buffer->cur[1] == ':')
2167                 buffer->cur += 2, result->type = CPP_PASTE, result->val.token_no = 0;
2168             }
2169           else if (*buffer->cur == '>')
2170             {
2171               buffer->cur++;
2172               result->flags |= DIGRAPH;
2173               result->type = CPP_CLOSE_BRACE;
2174             }
2175         }
2176       break;
2177
2178     case '.':
2179       result->type = CPP_DOT;
2180       if (ISDIGIT (*buffer->cur))
2181         {
2182           struct normalize_state nst = INITIAL_NORMALIZE_STATE;
2183           result->type = CPP_NUMBER;
2184           lex_number (pfile, &result->val.str, &nst);
2185           warn_about_normalization (pfile, result, &nst);
2186         }
2187       else if (*buffer->cur == '.' && buffer->cur[1] == '.')
2188         buffer->cur += 2, result->type = CPP_ELLIPSIS;
2189       else if (*buffer->cur == '*' && CPP_OPTION (pfile, cplusplus))
2190         buffer->cur++, result->type = CPP_DOT_STAR;
2191       break;
2192
2193     case '+':
2194       result->type = CPP_PLUS;
2195       if (*buffer->cur == '+')
2196         buffer->cur++, result->type = CPP_PLUS_PLUS;
2197       else if (*buffer->cur == '=')
2198         buffer->cur++, result->type = CPP_PLUS_EQ;
2199       break;
2200
2201     case '-':
2202       result->type = CPP_MINUS;
2203       if (*buffer->cur == '>')
2204         {
2205           buffer->cur++;
2206           result->type = CPP_DEREF;
2207           if (*buffer->cur == '*' && CPP_OPTION (pfile, cplusplus))
2208             buffer->cur++, result->type = CPP_DEREF_STAR;
2209         }
2210       else if (*buffer->cur == '-')
2211         buffer->cur++, result->type = CPP_MINUS_MINUS;
2212       else if (*buffer->cur == '=')
2213         buffer->cur++, result->type = CPP_MINUS_EQ;
2214       break;
2215
2216     case '&':
2217       result->type = CPP_AND;
2218       if (*buffer->cur == '&')
2219         buffer->cur++, result->type = CPP_AND_AND;
2220       else if (*buffer->cur == '=')
2221         buffer->cur++, result->type = CPP_AND_EQ;
2222       break;
2223
2224     case '|':
2225       result->type = CPP_OR;
2226       if (*buffer->cur == '|')
2227         buffer->cur++, result->type = CPP_OR_OR;
2228       else if (*buffer->cur == '=')
2229         buffer->cur++, result->type = CPP_OR_EQ;
2230       break;
2231
2232     case ':':
2233       result->type = CPP_COLON;
2234       if (*buffer->cur == ':' && CPP_OPTION (pfile, cplusplus))
2235         buffer->cur++, result->type = CPP_SCOPE;
2236       else if (*buffer->cur == '>' && CPP_OPTION (pfile, digraphs))
2237         {
2238           buffer->cur++;
2239           result->flags |= DIGRAPH;
2240           result->type = CPP_CLOSE_SQUARE;
2241         }
2242       break;
2243
2244     case '*': IF_NEXT_IS ('=', CPP_MULT_EQ, CPP_MULT); break;
2245     case '=': IF_NEXT_IS ('=', CPP_EQ_EQ, CPP_EQ); break;
2246     case '!': IF_NEXT_IS ('=', CPP_NOT_EQ, CPP_NOT); break;
2247     case '^': IF_NEXT_IS ('=', CPP_XOR_EQ, CPP_XOR); break;
2248     case '#': IF_NEXT_IS ('#', CPP_PASTE, CPP_HASH); result->val.token_no = 0; break;
2249
2250     case '?': result->type = CPP_QUERY; break;
2251     case '~': result->type = CPP_COMPL; break;
2252     case ',': result->type = CPP_COMMA; break;
2253     case '(': result->type = CPP_OPEN_PAREN; break;
2254     case ')': result->type = CPP_CLOSE_PAREN; break;
2255     case '[': result->type = CPP_OPEN_SQUARE; break;
2256     case ']': result->type = CPP_CLOSE_SQUARE; break;
2257     case '{': result->type = CPP_OPEN_BRACE; break;
2258     case '}': result->type = CPP_CLOSE_BRACE; break;
2259     case ';': result->type = CPP_SEMICOLON; break;
2260
2261       /* @ is a punctuator in Objective-C.  */
2262     case '@': result->type = CPP_ATSIGN; break;
2263
2264     case '$':
2265     case '\\':
2266       {
2267         const uchar *base = --buffer->cur;
2268         struct normalize_state nst = INITIAL_NORMALIZE_STATE;
2269
2270         if (forms_identifier_p (pfile, true, &nst))
2271           {
2272             result->type = CPP_NAME;
2273             result->val.node.node = lex_identifier (pfile, base, true, &nst);
2274             warn_about_normalization (pfile, result, &nst);
2275             break;
2276           }
2277         buffer->cur++;
2278       }
2279
2280     default:
2281       create_literal (pfile, result, buffer->cur - 1, 1, CPP_OTHER);
2282       break;
2283     }
2284
2285   return result;
2286 }
2287
2288 /* An upper bound on the number of bytes needed to spell TOKEN.
2289    Does not include preceding whitespace.  */
2290 unsigned int
2291 cpp_token_len (const cpp_token *token)
2292 {
2293   unsigned int len;
2294
2295   switch (TOKEN_SPELL (token))
2296     {
2297     default:            len = 6;                                break;
2298     case SPELL_LITERAL: len = token->val.str.len;               break;
2299     case SPELL_IDENT:   len = NODE_LEN (token->val.node.node) * 10;     break;
2300     }
2301
2302   return len;
2303 }
2304
2305 /* Parse UTF-8 out of NAMEP and place a \U escape in BUFFER.
2306    Return the number of bytes read out of NAME.  (There are always
2307    10 bytes written to BUFFER.)  */
2308
2309 static size_t
2310 utf8_to_ucn (unsigned char *buffer, const unsigned char *name)
2311 {
2312   int j;
2313   int ucn_len = 0;
2314   int ucn_len_c;
2315   unsigned t;
2316   unsigned long utf32;
2317   
2318   /* Compute the length of the UTF-8 sequence.  */
2319   for (t = *name; t & 0x80; t <<= 1)
2320     ucn_len++;
2321   
2322   utf32 = *name & (0x7F >> ucn_len);
2323   for (ucn_len_c = 1; ucn_len_c < ucn_len; ucn_len_c++)
2324     {
2325       utf32 = (utf32 << 6) | (*++name & 0x3F);
2326       
2327       /* Ill-formed UTF-8.  */
2328       if ((*name & ~0x3F) != 0x80)
2329         abort ();
2330     }
2331   
2332   *buffer++ = '\\';
2333   *buffer++ = 'U';
2334   for (j = 7; j >= 0; j--)
2335     *buffer++ = "0123456789abcdef"[(utf32 >> (4 * j)) & 0xF];
2336   return ucn_len;
2337 }
2338
2339 /* Given a token TYPE corresponding to a digraph, return a pointer to
2340    the spelling of the digraph.  */
2341 static const unsigned char *
2342 cpp_digraph2name (enum cpp_ttype type)
2343 {
2344   return digraph_spellings[(int) type - (int) CPP_FIRST_DIGRAPH];
2345 }
2346
2347 /* Write the spelling of a token TOKEN to BUFFER.  The buffer must
2348    already contain the enough space to hold the token's spelling.
2349    Returns a pointer to the character after the last character written.
2350    FORSTRING is true if this is to be the spelling after translation
2351    phase 1 (this is different for UCNs).
2352    FIXME: Would be nice if we didn't need the PFILE argument.  */
2353 unsigned char *
2354 cpp_spell_token (cpp_reader *pfile, const cpp_token *token,
2355                  unsigned char *buffer, bool forstring)
2356 {
2357   switch (TOKEN_SPELL (token))
2358     {
2359     case SPELL_OPERATOR:
2360       {
2361         const unsigned char *spelling;
2362         unsigned char c;
2363
2364         if (token->flags & DIGRAPH)
2365           spelling = cpp_digraph2name (token->type);
2366         else if (token->flags & NAMED_OP)
2367           goto spell_ident;
2368         else
2369           spelling = TOKEN_NAME (token);
2370
2371         while ((c = *spelling++) != '\0')
2372           *buffer++ = c;
2373       }
2374       break;
2375
2376     spell_ident:
2377     case SPELL_IDENT:
2378       if (forstring)
2379         {
2380           memcpy (buffer, NODE_NAME (token->val.node.node),
2381                   NODE_LEN (token->val.node.node));
2382           buffer += NODE_LEN (token->val.node.node);
2383         }
2384       else
2385         {
2386           size_t i;
2387           const unsigned char * name = NODE_NAME (token->val.node.node);
2388           
2389           for (i = 0; i < NODE_LEN (token->val.node.node); i++)
2390             if (name[i] & ~0x7F)
2391               {
2392                 i += utf8_to_ucn (buffer, name + i) - 1;
2393                 buffer += 10;
2394               }
2395             else
2396               *buffer++ = NODE_NAME (token->val.node.node)[i];
2397         }
2398       break;
2399
2400     case SPELL_LITERAL:
2401       memcpy (buffer, token->val.str.text, token->val.str.len);
2402       buffer += token->val.str.len;
2403       break;
2404
2405     case SPELL_NONE:
2406       cpp_error (pfile, CPP_DL_ICE,
2407                  "unspellable token %s", TOKEN_NAME (token));
2408       break;
2409     }
2410
2411   return buffer;
2412 }
2413
2414 /* Returns TOKEN spelt as a null-terminated string.  The string is
2415    freed when the reader is destroyed.  Useful for diagnostics.  */
2416 unsigned char *
2417 cpp_token_as_text (cpp_reader *pfile, const cpp_token *token)
2418
2419   unsigned int len = cpp_token_len (token) + 1;
2420   unsigned char *start = _cpp_unaligned_alloc (pfile, len), *end;
2421
2422   end = cpp_spell_token (pfile, token, start, false);
2423   end[0] = '\0';
2424
2425   return start;
2426 }
2427
2428 /* Returns a pointer to a string which spells the token defined by
2429    TYPE and FLAGS.  Used by C front ends, which really should move to
2430    using cpp_token_as_text.  */
2431 const char *
2432 cpp_type2name (enum cpp_ttype type, unsigned char flags)
2433 {
2434   if (flags & DIGRAPH)
2435     return (const char *) cpp_digraph2name (type);
2436   else if (flags & NAMED_OP)
2437     return cpp_named_operator2name (type);
2438
2439   return (const char *) token_spellings[type].name;
2440 }
2441
2442 /* Writes the spelling of token to FP, without any preceding space.
2443    Separated from cpp_spell_token for efficiency - to avoid stdio
2444    double-buffering.  */
2445 void
2446 cpp_output_token (const cpp_token *token, FILE *fp)
2447 {
2448   switch (TOKEN_SPELL (token))
2449     {
2450     case SPELL_OPERATOR:
2451       {
2452         const unsigned char *spelling;
2453         int c;
2454
2455         if (token->flags & DIGRAPH)
2456           spelling = cpp_digraph2name (token->type);
2457         else if (token->flags & NAMED_OP)
2458           goto spell_ident;
2459         else
2460           spelling = TOKEN_NAME (token);
2461
2462         c = *spelling;
2463         do
2464           putc (c, fp);
2465         while ((c = *++spelling) != '\0');
2466       }
2467       break;
2468
2469     spell_ident:
2470     case SPELL_IDENT:
2471       {
2472         size_t i;
2473         const unsigned char * name = NODE_NAME (token->val.node.node);
2474         
2475         for (i = 0; i < NODE_LEN (token->val.node.node); i++)
2476           if (name[i] & ~0x7F)
2477             {
2478               unsigned char buffer[10];
2479               i += utf8_to_ucn (buffer, name + i) - 1;
2480               fwrite (buffer, 1, 10, fp);
2481             }
2482           else
2483             fputc (NODE_NAME (token->val.node.node)[i], fp);
2484       }
2485       break;
2486
2487     case SPELL_LITERAL:
2488       fwrite (token->val.str.text, 1, token->val.str.len, fp);
2489       break;
2490
2491     case SPELL_NONE:
2492       /* An error, most probably.  */
2493       break;
2494     }
2495 }
2496
2497 /* Compare two tokens.  */
2498 int
2499 _cpp_equiv_tokens (const cpp_token *a, const cpp_token *b)
2500 {
2501   if (a->type == b->type && a->flags == b->flags)
2502     switch (TOKEN_SPELL (a))
2503       {
2504       default:                  /* Keep compiler happy.  */
2505       case SPELL_OPERATOR:
2506         /* token_no is used to track where multiple consecutive ##
2507            tokens were originally located.  */
2508         return (a->type != CPP_PASTE || a->val.token_no == b->val.token_no);
2509       case SPELL_NONE:
2510         return (a->type != CPP_MACRO_ARG
2511                 || a->val.macro_arg.arg_no == b->val.macro_arg.arg_no);
2512       case SPELL_IDENT:
2513         return a->val.node.node == b->val.node.node;
2514       case SPELL_LITERAL:
2515         return (a->val.str.len == b->val.str.len
2516                 && !memcmp (a->val.str.text, b->val.str.text,
2517                             a->val.str.len));
2518       }
2519
2520   return 0;
2521 }
2522
2523 /* Returns nonzero if a space should be inserted to avoid an
2524    accidental token paste for output.  For simplicity, it is
2525    conservative, and occasionally advises a space where one is not
2526    needed, e.g. "." and ".2".  */
2527 int
2528 cpp_avoid_paste (cpp_reader *pfile, const cpp_token *token1,
2529                  const cpp_token *token2)
2530 {
2531   enum cpp_ttype a = token1->type, b = token2->type;
2532   cppchar_t c;
2533
2534   if (token1->flags & NAMED_OP)
2535     a = CPP_NAME;
2536   if (token2->flags & NAMED_OP)
2537     b = CPP_NAME;
2538
2539   c = EOF;
2540   if (token2->flags & DIGRAPH)
2541     c = digraph_spellings[(int) b - (int) CPP_FIRST_DIGRAPH][0];
2542   else if (token_spellings[b].category == SPELL_OPERATOR)
2543     c = token_spellings[b].name[0];
2544
2545   /* Quickly get everything that can paste with an '='.  */
2546   if ((int) a <= (int) CPP_LAST_EQ && c == '=')
2547     return 1;
2548
2549   switch (a)
2550     {
2551     case CPP_GREATER:   return c == '>';
2552     case CPP_LESS:      return c == '<' || c == '%' || c == ':';
2553     case CPP_PLUS:      return c == '+';
2554     case CPP_MINUS:     return c == '-' || c == '>';
2555     case CPP_DIV:       return c == '/' || c == '*'; /* Comments.  */
2556     case CPP_MOD:       return c == ':' || c == '>';
2557     case CPP_AND:       return c == '&';
2558     case CPP_OR:        return c == '|';
2559     case CPP_COLON:     return c == ':' || c == '>';
2560     case CPP_DEREF:     return c == '*';
2561     case CPP_DOT:       return c == '.' || c == '%' || b == CPP_NUMBER;
2562     case CPP_HASH:      return c == '#' || c == '%'; /* Digraph form.  */
2563     case CPP_NAME:      return ((b == CPP_NUMBER
2564                                  && name_p (pfile, &token2->val.str))
2565                                 || b == CPP_NAME
2566                                 || b == CPP_CHAR || b == CPP_STRING); /* L */
2567     case CPP_NUMBER:    return (b == CPP_NUMBER || b == CPP_NAME
2568                                 || c == '.' || c == '+' || c == '-');
2569                                       /* UCNs */
2570     case CPP_OTHER:     return ((token1->val.str.text[0] == '\\'
2571                                  && b == CPP_NAME)
2572                                 || (CPP_OPTION (pfile, objc)
2573                                     && token1->val.str.text[0] == '@'
2574                                     && (b == CPP_NAME || b == CPP_STRING)));
2575     default:            break;
2576     }
2577
2578   return 0;
2579 }
2580
2581 /* Output all the remaining tokens on the current line, and a newline
2582    character, to FP.  Leading whitespace is removed.  If there are
2583    macros, special token padding is not performed.  */
2584 void
2585 cpp_output_line (cpp_reader *pfile, FILE *fp)
2586 {
2587   const cpp_token *token;
2588
2589   token = cpp_get_token (pfile);
2590   while (token->type != CPP_EOF)
2591     {
2592       cpp_output_token (token, fp);
2593       token = cpp_get_token (pfile);
2594       if (token->flags & PREV_WHITE)
2595         putc (' ', fp);
2596     }
2597
2598   putc ('\n', fp);
2599 }
2600
2601 /* Return a string representation of all the remaining tokens on the
2602    current line.  The result is allocated using xmalloc and must be
2603    freed by the caller.  */
2604 unsigned char *
2605 cpp_output_line_to_string (cpp_reader *pfile, const unsigned char *dir_name)
2606 {
2607   const cpp_token *token;
2608   unsigned int out = dir_name ? ustrlen (dir_name) : 0;
2609   unsigned int alloced = 120 + out;
2610   unsigned char *result = (unsigned char *) xmalloc (alloced);
2611
2612   /* If DIR_NAME is empty, there are no initial contents.  */
2613   if (dir_name)
2614     {
2615       sprintf ((char *) result, "#%s ", dir_name);
2616       out += 2;
2617     }
2618
2619   token = cpp_get_token (pfile);
2620   while (token->type != CPP_EOF)
2621     {
2622       unsigned char *last;
2623       /* Include room for a possible space and the terminating nul.  */
2624       unsigned int len = cpp_token_len (token) + 2;
2625
2626       if (out + len > alloced)
2627         {
2628           alloced *= 2;
2629           if (out + len > alloced)
2630             alloced = out + len;
2631           result = (unsigned char *) xrealloc (result, alloced);
2632         }
2633
2634       last = cpp_spell_token (pfile, token, &result[out], 0);
2635       out = last - result;
2636
2637       token = cpp_get_token (pfile);
2638       if (token->flags & PREV_WHITE)
2639         result[out++] = ' ';
2640     }
2641
2642   result[out] = '\0';
2643   return result;
2644 }
2645
2646 /* Memory buffers.  Changing these three constants can have a dramatic
2647    effect on performance.  The values here are reasonable defaults,
2648    but might be tuned.  If you adjust them, be sure to test across a
2649    range of uses of cpplib, including heavy nested function-like macro
2650    expansion.  Also check the change in peak memory usage (NJAMD is a
2651    good tool for this).  */
2652 #define MIN_BUFF_SIZE 8000
2653 #define BUFF_SIZE_UPPER_BOUND(MIN_SIZE) (MIN_BUFF_SIZE + (MIN_SIZE) * 3 / 2)
2654 #define EXTENDED_BUFF_SIZE(BUFF, MIN_EXTRA) \
2655         (MIN_EXTRA + ((BUFF)->limit - (BUFF)->cur) * 2)
2656
2657 #if MIN_BUFF_SIZE > BUFF_SIZE_UPPER_BOUND (0)
2658   #error BUFF_SIZE_UPPER_BOUND must be at least as large as MIN_BUFF_SIZE!
2659 #endif
2660
2661 /* Create a new allocation buffer.  Place the control block at the end
2662    of the buffer, so that buffer overflows will cause immediate chaos.  */
2663 static _cpp_buff *
2664 new_buff (size_t len)
2665 {
2666   _cpp_buff *result;
2667   unsigned char *base;
2668
2669   if (len < MIN_BUFF_SIZE)
2670     len = MIN_BUFF_SIZE;
2671   len = CPP_ALIGN (len);
2672
2673   base = XNEWVEC (unsigned char, len + sizeof (_cpp_buff));
2674   result = (_cpp_buff *) (base + len);
2675   result->base = base;
2676   result->cur = base;
2677   result->limit = base + len;
2678   result->next = NULL;
2679   return result;
2680 }
2681
2682 /* Place a chain of unwanted allocation buffers on the free list.  */
2683 void
2684 _cpp_release_buff (cpp_reader *pfile, _cpp_buff *buff)
2685 {
2686   _cpp_buff *end = buff;
2687
2688   while (end->next)
2689     end = end->next;
2690   end->next = pfile->free_buffs;
2691   pfile->free_buffs = buff;
2692 }
2693
2694 /* Return a free buffer of size at least MIN_SIZE.  */
2695 _cpp_buff *
2696 _cpp_get_buff (cpp_reader *pfile, size_t min_size)
2697 {
2698   _cpp_buff *result, **p;
2699
2700   for (p = &pfile->free_buffs;; p = &(*p)->next)
2701     {
2702       size_t size;
2703
2704       if (*p == NULL)
2705         return new_buff (min_size);
2706       result = *p;
2707       size = result->limit - result->base;
2708       /* Return a buffer that's big enough, but don't waste one that's
2709          way too big.  */
2710       if (size >= min_size && size <= BUFF_SIZE_UPPER_BOUND (min_size))
2711         break;
2712     }
2713
2714   *p = result->next;
2715   result->next = NULL;
2716   result->cur = result->base;
2717   return result;
2718 }
2719
2720 /* Creates a new buffer with enough space to hold the uncommitted
2721    remaining bytes of BUFF, and at least MIN_EXTRA more bytes.  Copies
2722    the excess bytes to the new buffer.  Chains the new buffer after
2723    BUFF, and returns the new buffer.  */
2724 _cpp_buff *
2725 _cpp_append_extend_buff (cpp_reader *pfile, _cpp_buff *buff, size_t min_extra)
2726 {
2727   size_t size = EXTENDED_BUFF_SIZE (buff, min_extra);
2728   _cpp_buff *new_buff = _cpp_get_buff (pfile, size);
2729
2730   buff->next = new_buff;
2731   memcpy (new_buff->base, buff->cur, BUFF_ROOM (buff));
2732   return new_buff;
2733 }
2734
2735 /* Creates a new buffer with enough space to hold the uncommitted
2736    remaining bytes of the buffer pointed to by BUFF, and at least
2737    MIN_EXTRA more bytes.  Copies the excess bytes to the new buffer.
2738    Chains the new buffer before the buffer pointed to by BUFF, and
2739    updates the pointer to point to the new buffer.  */
2740 void
2741 _cpp_extend_buff (cpp_reader *pfile, _cpp_buff **pbuff, size_t min_extra)
2742 {
2743   _cpp_buff *new_buff, *old_buff = *pbuff;
2744   size_t size = EXTENDED_BUFF_SIZE (old_buff, min_extra);
2745
2746   new_buff = _cpp_get_buff (pfile, size);
2747   memcpy (new_buff->base, old_buff->cur, BUFF_ROOM (old_buff));
2748   new_buff->next = old_buff;
2749   *pbuff = new_buff;
2750 }
2751
2752 /* Free a chain of buffers starting at BUFF.  */
2753 void
2754 _cpp_free_buff (_cpp_buff *buff)
2755 {
2756   _cpp_buff *next;
2757
2758   for (; buff; buff = next)
2759     {
2760       next = buff->next;
2761       free (buff->base);
2762     }
2763 }
2764
2765 /* Allocate permanent, unaligned storage of length LEN.  */
2766 unsigned char *
2767 _cpp_unaligned_alloc (cpp_reader *pfile, size_t len)
2768 {
2769   _cpp_buff *buff = pfile->u_buff;
2770   unsigned char *result = buff->cur;
2771
2772   if (len > (size_t) (buff->limit - result))
2773     {
2774       buff = _cpp_get_buff (pfile, len);
2775       buff->next = pfile->u_buff;
2776       pfile->u_buff = buff;
2777       result = buff->cur;
2778     }
2779
2780   buff->cur = result + len;
2781   return result;
2782 }
2783
2784 /* Allocate permanent, unaligned storage of length LEN from a_buff.
2785    That buffer is used for growing allocations when saving macro
2786    replacement lists in a #define, and when parsing an answer to an
2787    assertion in #assert, #unassert or #if (and therefore possibly
2788    whilst expanding macros).  It therefore must not be used by any
2789    code that they might call: specifically the lexer and the guts of
2790    the macro expander.
2791
2792    All existing other uses clearly fit this restriction: storing
2793    registered pragmas during initialization.  */
2794 unsigned char *
2795 _cpp_aligned_alloc (cpp_reader *pfile, size_t len)
2796 {
2797   _cpp_buff *buff = pfile->a_buff;
2798   unsigned char *result = buff->cur;
2799
2800   if (len > (size_t) (buff->limit - result))
2801     {
2802       buff = _cpp_get_buff (pfile, len);
2803       buff->next = pfile->a_buff;
2804       pfile->a_buff = buff;
2805       result = buff->cur;
2806     }
2807
2808   buff->cur = result + len;
2809   return result;
2810 }
2811
2812 /* Say which field of TOK is in use.  */
2813
2814 enum cpp_token_fld_kind
2815 cpp_token_val_index (cpp_token *tok)
2816 {
2817   switch (TOKEN_SPELL (tok))
2818     {
2819     case SPELL_IDENT:
2820       return CPP_TOKEN_FLD_NODE;
2821     case SPELL_LITERAL:
2822       return CPP_TOKEN_FLD_STR;
2823     case SPELL_OPERATOR:
2824       if (tok->type == CPP_PASTE)
2825         return CPP_TOKEN_FLD_TOKEN_NO;
2826       else
2827         return CPP_TOKEN_FLD_NONE;
2828     case SPELL_NONE:
2829       if (tok->type == CPP_MACRO_ARG)
2830         return CPP_TOKEN_FLD_ARG_NO;
2831       else if (tok->type == CPP_PADDING)
2832         return CPP_TOKEN_FLD_SOURCE;
2833       else if (tok->type == CPP_PRAGMA)
2834         return CPP_TOKEN_FLD_PRAGMA;
2835       /* else fall through */
2836     default:
2837       return CPP_TOKEN_FLD_NONE;
2838     }
2839 }