1 /* CPP Library - lexical analysis.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994-95.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
6 Broken out to separate file, Zack Weinberg, Mar 2000
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
37 enum spell_type category
;
38 const unsigned char *name
;
41 static const unsigned char *const digraph_spellings
[] =
42 { U
"%:", U
"%:%:", U
"<:", U
":>", U
"<%", U
"%>" };
44 #define OP(e, s) { SPELL_OPERATOR, U s },
45 #define TK(e, s) { SPELL_ ## s, U #e },
46 static const struct token_spelling token_spellings
[N_TTYPES
] = { TTYPE_TABLE
};
50 #define TOKEN_SPELL(token) (token_spellings[(token)->type].category)
51 #define TOKEN_NAME(token) (token_spellings[(token)->type].name)
53 static void add_line_note (cpp_buffer
*, const uchar
*, unsigned int);
54 static int skip_line_comment (cpp_reader
*);
55 static void skip_whitespace (cpp_reader
*, cppchar_t
);
56 static void lex_string (cpp_reader
*, cpp_token
*, const uchar
*);
57 static void save_comment (cpp_reader
*, cpp_token
*, const uchar
*, cppchar_t
);
58 static void create_literal (cpp_reader
*, cpp_token
*, const uchar
*,
59 unsigned int, enum cpp_ttype
);
60 static bool warn_in_comment (cpp_reader
*, _cpp_line_note
*);
61 static int name_p (cpp_reader
*, const cpp_string
*);
62 static tokenrun
*next_tokenrun (tokenrun
*);
64 static _cpp_buff
*new_buff (size_t);
69 Compares, the token TOKEN to the NUL-terminated string STRING.
70 TOKEN must be a CPP_NAME. Returns 1 for equal, 0 for unequal. */
72 cpp_ideq (const cpp_token
*token
, const char *string
)
74 if (token
->type
!= CPP_NAME
)
77 return !ustrcmp (NODE_NAME (token
->val
.node
), (const uchar
*) string
);
80 /* Record a note TYPE at byte POS into the current cleaned logical
83 add_line_note (cpp_buffer
*buffer
, const uchar
*pos
, unsigned int type
)
85 if (buffer
->notes_used
== buffer
->notes_cap
)
87 buffer
->notes_cap
= buffer
->notes_cap
* 2 + 200;
88 buffer
->notes
= XRESIZEVEC (_cpp_line_note
, buffer
->notes
,
92 buffer
->notes
[buffer
->notes_used
].pos
= pos
;
93 buffer
->notes
[buffer
->notes_used
].type
= type
;
97 /* Returns with a logical line that contains no escaped newlines or
98 trigraphs. This is a time-critical inner loop. */
100 _cpp_clean_line (cpp_reader
*pfile
)
106 buffer
= pfile
->buffer
;
107 buffer
->cur_note
= buffer
->notes_used
= 0;
108 buffer
->cur
= buffer
->line_base
= buffer
->next_line
;
109 buffer
->need_line
= false;
110 s
= buffer
->next_line
- 1;
112 if (!buffer
->from_stage3
)
114 /* Short circuit for the common case of an un-escaped line with
115 no trigraphs. The primary win here is by not writing any
116 data back to memory until we have to. */
120 if (c
== '\n' || c
== '\r')
124 if (s
== buffer
->rlimit
)
127 /* DOS line ending? */
128 if (c
== '\r' && s
[1] == '\n')
131 if (s
== buffer
->rlimit
)
134 /* check for escaped newline */
136 while (p
!= buffer
->next_line
&& is_nvspace (p
[-1]))
138 if (p
== buffer
->next_line
|| p
[-1] != '\\')
141 /* Have an escaped newline; process it and proceed to
143 add_line_note (buffer
, p
- 1, p
!= d
? ' ' : '\\');
145 buffer
->next_line
= p
- 1;
148 if (c
== '?' && s
[1] == '?' && _cpp_trigraph_map
[s
[2]])
150 /* Have a trigraph. We may or may not have to convert
151 it. Add a line note regardless, for -Wtrigraphs. */
152 add_line_note (buffer
, s
, s
[2]);
153 if (CPP_OPTION (pfile
, trigraphs
))
155 /* We do, and that means we have to switch to the
158 *d
= _cpp_trigraph_map
[s
[2]];
171 if (c
== '\n' || c
== '\r')
173 /* Handle DOS line endings. */
174 if (c
== '\r' && s
!= buffer
->rlimit
&& s
[1] == '\n')
176 if (s
== buffer
->rlimit
)
181 while (p
!= buffer
->next_line
&& is_nvspace (p
[-1]))
183 if (p
== buffer
->next_line
|| p
[-1] != '\\')
186 add_line_note (buffer
, p
- 1, p
!= d
? ' ': '\\');
188 buffer
->next_line
= p
- 1;
190 else if (c
== '?' && s
[1] == '?' && _cpp_trigraph_map
[s
[2]])
192 /* Add a note regardless, for the benefit of -Wtrigraphs. */
193 add_line_note (buffer
, d
, s
[2]);
194 if (CPP_OPTION (pfile
, trigraphs
))
196 *d
= _cpp_trigraph_map
[s
[2]];
206 while (*s
!= '\n' && *s
!= '\r');
209 /* Handle DOS line endings. */
210 if (*s
== '\r' && s
!= buffer
->rlimit
&& s
[1] == '\n')
216 /* A sentinel note that should never be processed. */
217 add_line_note (buffer
, d
+ 1, '\n');
218 buffer
->next_line
= s
+ 1;
221 /* Return true if the trigraph indicated by NOTE should be warned
222 about in a comment. */
224 warn_in_comment (cpp_reader
*pfile
, _cpp_line_note
*note
)
228 /* Within comments we don't warn about trigraphs, unless the
229 trigraph forms an escaped newline, as that may change
231 if (note
->type
!= '/')
234 /* If -trigraphs, then this was an escaped newline iff the next note
236 if (CPP_OPTION (pfile
, trigraphs
))
237 return note
[1].pos
== note
->pos
;
239 /* Otherwise, see if this forms an escaped newline. */
241 while (is_nvspace (*p
))
244 /* There might have been escaped newlines between the trigraph and the
245 newline we found. Hence the position test. */
246 return (*p
== '\n' && p
< note
[1].pos
);
249 /* Process the notes created by add_line_note as far as the current
252 _cpp_process_line_notes (cpp_reader
*pfile
, int in_comment
)
254 cpp_buffer
*buffer
= pfile
->buffer
;
258 _cpp_line_note
*note
= &buffer
->notes
[buffer
->cur_note
];
261 if (note
->pos
> buffer
->cur
)
265 col
= CPP_BUF_COLUMN (buffer
, note
->pos
+ 1);
267 if (note
->type
== '\\' || note
->type
== ' ')
269 if (note
->type
== ' ' && !in_comment
)
270 cpp_error_with_line (pfile
, CPP_DL_WARNING
, pfile
->line_table
->highest_line
, col
,
271 "backslash and newline separated by space");
273 if (buffer
->next_line
> buffer
->rlimit
)
275 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, pfile
->line_table
->highest_line
, col
,
276 "backslash-newline at end of file");
277 /* Prevent "no newline at end of file" warning. */
278 buffer
->next_line
= buffer
->rlimit
;
281 buffer
->line_base
= note
->pos
;
282 CPP_INCREMENT_LINE (pfile
, 0);
284 else if (_cpp_trigraph_map
[note
->type
])
286 if (CPP_OPTION (pfile
, warn_trigraphs
)
287 && (!in_comment
|| warn_in_comment (pfile
, note
)))
289 if (CPP_OPTION (pfile
, trigraphs
))
290 cpp_error_with_line (pfile
, CPP_DL_WARNING
, pfile
->line_table
->highest_line
, col
,
291 "trigraph ??%c converted to %c",
293 (int) _cpp_trigraph_map
[note
->type
]);
297 (pfile
, CPP_DL_WARNING
, pfile
->line_table
->highest_line
, col
,
298 "trigraph ??%c ignored, use -trigraphs to enable",
308 /* Skip a C-style block comment. We find the end of the comment by
309 seeing if an asterisk is before every '/' we encounter. Returns
310 nonzero if comment terminated by EOF, zero otherwise.
312 Buffer->cur points to the initial asterisk of the comment. */
314 _cpp_skip_block_comment (cpp_reader
*pfile
)
316 cpp_buffer
*buffer
= pfile
->buffer
;
317 const uchar
*cur
= buffer
->cur
;
326 /* People like decorating comments with '*', so check for '/'
327 instead for efficiency. */
335 /* Warn about potential nested comments, but not if the '/'
336 comes immediately before the true comment delimiter.
337 Don't bother to get it right across escaped newlines. */
338 if (CPP_OPTION (pfile
, warn_comments
)
339 && cur
[0] == '*' && cur
[1] != '/')
342 cpp_error_with_line (pfile
, CPP_DL_WARNING
,
343 pfile
->line_table
->highest_line
, CPP_BUF_COL (buffer
),
344 "\"/*\" within comment");
350 buffer
->cur
= cur
- 1;
351 _cpp_process_line_notes (pfile
, true);
352 if (buffer
->next_line
>= buffer
->rlimit
)
354 _cpp_clean_line (pfile
);
356 cols
= buffer
->next_line
- buffer
->line_base
;
357 CPP_INCREMENT_LINE (pfile
, cols
);
364 _cpp_process_line_notes (pfile
, true);
368 /* Skip a C++ line comment, leaving buffer->cur pointing to the
369 terminating newline. Handles escaped newlines. Returns nonzero
370 if a multiline comment. */
372 skip_line_comment (cpp_reader
*pfile
)
374 cpp_buffer
*buffer
= pfile
->buffer
;
375 unsigned int orig_line
= pfile
->line_table
->highest_line
;
377 while (*buffer
->cur
!= '\n')
380 _cpp_process_line_notes (pfile
, true);
381 return orig_line
!= pfile
->line_table
->highest_line
;
384 /* Skips whitespace, saving the next non-whitespace character. */
386 skip_whitespace (cpp_reader
*pfile
, cppchar_t c
)
388 cpp_buffer
*buffer
= pfile
->buffer
;
389 bool saw_NUL
= false;
393 /* Horizontal space always OK. */
394 if (c
== ' ' || c
== '\t')
396 /* Just \f \v or \0 left. */
399 else if (pfile
->state
.in_directive
&& CPP_PEDANTIC (pfile
))
400 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, pfile
->line_table
->highest_line
,
401 CPP_BUF_COL (buffer
),
402 "%s in preprocessing directive",
403 c
== '\f' ? "form feed" : "vertical tab");
407 /* We only want non-vertical space, i.e. ' ' \t \f \v \0. */
408 while (is_nvspace (c
));
411 cpp_error (pfile
, CPP_DL_WARNING
, "null character(s) ignored");
416 /* See if the characters of a number token are valid in a name (no
419 name_p (cpp_reader
*pfile
, const cpp_string
*string
)
423 for (i
= 0; i
< string
->len
; i
++)
424 if (!is_idchar (string
->text
[i
]))
430 /* After parsing an identifier or other sequence, produce a warning about
431 sequences not in NFC/NFKC. */
433 warn_about_normalization (cpp_reader
*pfile
,
434 const cpp_token
*token
,
435 const struct normalize_state
*s
)
437 if (CPP_OPTION (pfile
, warn_normalize
) < NORMALIZE_STATE_RESULT (s
)
438 && !pfile
->state
.skipping
)
440 /* Make sure that the token is printed using UCNs, even
441 if we'd otherwise happily print UTF-8. */
442 unsigned char *buf
= XNEWVEC (unsigned char, cpp_token_len (token
));
445 sz
= cpp_spell_token (pfile
, token
, buf
, false) - buf
;
446 if (NORMALIZE_STATE_RESULT (s
) == normalized_C
)
447 cpp_error_with_line (pfile
, CPP_DL_WARNING
, token
->src_loc
, 0,
448 "`%.*s' is not in NFKC", (int) sz
, buf
);
450 cpp_error_with_line (pfile
, CPP_DL_WARNING
, token
->src_loc
, 0,
451 "`%.*s' is not in NFC", (int) sz
, buf
);
455 /* Returns TRUE if the sequence starting at buffer->cur is invalid in
456 an identifier. FIRST is TRUE if this starts an identifier. */
458 forms_identifier_p (cpp_reader
*pfile
, int first
,
459 struct normalize_state
*state
)
461 cpp_buffer
*buffer
= pfile
->buffer
;
463 if (*buffer
->cur
== '$')
465 if (!CPP_OPTION (pfile
, dollars_in_ident
))
469 if (CPP_OPTION (pfile
, warn_dollars
) && !pfile
->state
.skipping
)
471 CPP_OPTION (pfile
, warn_dollars
) = 0;
472 cpp_error (pfile
, CPP_DL_PEDWARN
, "'$' in identifier or number");
478 /* Is this a syntactically valid UCN? */
479 if (CPP_OPTION (pfile
, extended_identifiers
)
480 && *buffer
->cur
== '\\'
481 && (buffer
->cur
[1] == 'u' || buffer
->cur
[1] == 'U'))
484 if (_cpp_valid_ucn (pfile
, &buffer
->cur
, buffer
->rlimit
, 1 + !first
,
493 /* Lex an identifier starting at BUFFER->CUR - 1. */
494 static cpp_hashnode
*
495 lex_identifier (cpp_reader
*pfile
, const uchar
*base
, bool starts_ucn
,
496 struct normalize_state
*nst
)
498 cpp_hashnode
*result
;
501 unsigned int hash
= HT_HASHSTEP (0, *base
);
503 cur
= pfile
->buffer
->cur
;
505 while (ISIDNUM (*cur
))
507 hash
= HT_HASHSTEP (hash
, *cur
);
510 pfile
->buffer
->cur
= cur
;
511 if (starts_ucn
|| forms_identifier_p (pfile
, false, nst
))
513 /* Slower version for identifiers containing UCNs (or $). */
515 while (ISIDNUM (*pfile
->buffer
->cur
))
517 pfile
->buffer
->cur
++;
518 NORMALIZE_STATE_UPDATE_IDNUM (nst
);
520 } while (forms_identifier_p (pfile
, false, nst
));
521 result
= _cpp_interpret_identifier (pfile
, base
,
522 pfile
->buffer
->cur
- base
);
527 hash
= HT_HASHFINISH (hash
, len
);
529 result
= (cpp_hashnode
*)
530 ht_lookup_with_hash (pfile
->hash_table
, base
, len
, hash
, HT_ALLOC
);
533 /* Rarely, identifiers require diagnostics when lexed. */
534 if (__builtin_expect ((result
->flags
& NODE_DIAGNOSTIC
)
535 && !pfile
->state
.skipping
, 0))
537 /* It is allowed to poison the same identifier twice. */
538 if ((result
->flags
& NODE_POISONED
) && !pfile
->state
.poisoned_ok
)
539 cpp_error (pfile
, CPP_DL_ERROR
, "attempt to use poisoned \"%s\"",
542 /* Constraint 6.10.3.5: __VA_ARGS__ should only appear in the
543 replacement list of a variadic macro. */
544 if (result
== pfile
->spec_nodes
.n__VA_ARGS__
545 && !pfile
->state
.va_args_ok
)
546 cpp_error (pfile
, CPP_DL_PEDWARN
,
547 "__VA_ARGS__ can only appear in the expansion"
548 " of a C99 variadic macro");
554 /* Lex a number to NUMBER starting at BUFFER->CUR - 1. */
556 lex_number (cpp_reader
*pfile
, cpp_string
*number
,
557 struct normalize_state
*nst
)
563 base
= pfile
->buffer
->cur
- 1;
566 cur
= pfile
->buffer
->cur
;
568 /* N.B. ISIDNUM does not include $. */
569 while (ISIDNUM (*cur
) || *cur
== '.' || VALID_SIGN (*cur
, cur
[-1]))
572 NORMALIZE_STATE_UPDATE_IDNUM (nst
);
575 pfile
->buffer
->cur
= cur
;
577 while (forms_identifier_p (pfile
, false, nst
));
579 number
->len
= cur
- base
;
580 dest
= _cpp_unaligned_alloc (pfile
, number
->len
+ 1);
581 memcpy (dest
, base
, number
->len
);
582 dest
[number
->len
] = '\0';
586 /* Create a token of type TYPE with a literal spelling. */
588 create_literal (cpp_reader
*pfile
, cpp_token
*token
, const uchar
*base
,
589 unsigned int len
, enum cpp_ttype type
)
591 uchar
*dest
= _cpp_unaligned_alloc (pfile
, len
+ 1);
593 memcpy (dest
, base
, len
);
596 token
->val
.str
.len
= len
;
597 token
->val
.str
.text
= dest
;
600 /* Lexes a string, character constant, or angle-bracketed header file
601 name. The stored string contains the spelling, including opening
602 quote and leading any leading 'L'. It returns the type of the
603 literal, or CPP_OTHER if it was not properly terminated.
605 The spelling is NUL-terminated, but it is not guaranteed that this
606 is the first NUL since embedded NULs are preserved. */
608 lex_string (cpp_reader
*pfile
, cpp_token
*token
, const uchar
*base
)
610 bool saw_NUL
= false;
612 cppchar_t terminator
;
617 if (terminator
== 'L')
619 if (terminator
== '\"')
620 type
= *base
== 'L' ? CPP_WSTRING
: CPP_STRING
;
621 else if (terminator
== '\'')
622 type
= *base
== 'L' ? CPP_WCHAR
: CPP_CHAR
;
624 terminator
= '>', type
= CPP_HEADER_NAME
;
628 cppchar_t c
= *cur
++;
630 /* In #include-style directives, terminators are not escapable. */
631 if (c
== '\\' && !pfile
->state
.angled_headers
&& *cur
!= '\n')
633 else if (c
== terminator
)
645 if (saw_NUL
&& !pfile
->state
.skipping
)
646 cpp_error (pfile
, CPP_DL_WARNING
,
647 "null character(s) preserved in literal");
649 if (type
== CPP_OTHER
&& CPP_OPTION (pfile
, lang
) != CLK_ASM
)
650 cpp_error (pfile
, CPP_DL_PEDWARN
, "missing terminating %c character",
653 pfile
->buffer
->cur
= cur
;
654 create_literal (pfile
, token
, base
, cur
- base
, type
);
657 /* The stored comment includes the comment start and any terminator. */
659 save_comment (cpp_reader
*pfile
, cpp_token
*token
, const unsigned char *from
,
662 unsigned char *buffer
;
663 unsigned int len
, clen
;
665 len
= pfile
->buffer
->cur
- from
+ 1; /* + 1 for the initial '/'. */
667 /* C++ comments probably (not definitely) have moved past a new
668 line, which we don't want to save in the comment. */
669 if (is_vspace (pfile
->buffer
->cur
[-1]))
672 /* If we are currently in a directive, then we need to store all
673 C++ comments as C comments internally, and so we need to
674 allocate a little extra space in that case.
676 Note that the only time we encounter a directive here is
677 when we are saving comments in a "#define". */
678 clen
= (pfile
->state
.in_directive
&& type
== '/') ? len
+ 2 : len
;
680 buffer
= _cpp_unaligned_alloc (pfile
, clen
);
682 token
->type
= CPP_COMMENT
;
683 token
->val
.str
.len
= clen
;
684 token
->val
.str
.text
= buffer
;
687 memcpy (buffer
+ 1, from
, len
- 1);
689 /* Finish conversion to a C comment, if necessary. */
690 if (pfile
->state
.in_directive
&& type
== '/')
693 buffer
[clen
- 2] = '*';
694 buffer
[clen
- 1] = '/';
698 /* Allocate COUNT tokens for RUN. */
700 _cpp_init_tokenrun (tokenrun
*run
, unsigned int count
)
702 run
->base
= XNEWVEC (cpp_token
, count
);
703 run
->limit
= run
->base
+ count
;
707 /* Returns the next tokenrun, or creates one if there is none. */
709 next_tokenrun (tokenrun
*run
)
711 if (run
->next
== NULL
)
713 run
->next
= XNEW (tokenrun
);
714 run
->next
->prev
= run
;
715 _cpp_init_tokenrun (run
->next
, 250);
721 /* Allocate a single token that is invalidated at the same time as the
722 rest of the tokens on the line. Has its line and col set to the
723 same as the last lexed token, so that diagnostics appear in the
726 _cpp_temp_token (cpp_reader
*pfile
)
728 cpp_token
*old
, *result
;
730 old
= pfile
->cur_token
- 1;
731 if (pfile
->cur_token
== pfile
->cur_run
->limit
)
733 pfile
->cur_run
= next_tokenrun (pfile
->cur_run
);
734 pfile
->cur_token
= pfile
->cur_run
->base
;
737 result
= pfile
->cur_token
++;
738 result
->src_loc
= old
->src_loc
;
742 /* Lex a token into RESULT (external interface). Takes care of issues
743 like directive handling, token lookahead, multiple include
744 optimization and skipping. */
746 _cpp_lex_token (cpp_reader
*pfile
)
752 if (pfile
->cur_token
== pfile
->cur_run
->limit
)
754 pfile
->cur_run
= next_tokenrun (pfile
->cur_run
);
755 pfile
->cur_token
= pfile
->cur_run
->base
;
758 if (pfile
->lookaheads
)
761 result
= pfile
->cur_token
++;
764 result
= _cpp_lex_direct (pfile
);
766 if (result
->flags
& BOL
)
768 /* Is this a directive. If _cpp_handle_directive returns
769 false, it is an assembler #. */
770 if (result
->type
== CPP_HASH
771 /* 6.10.3 p 11: Directives in a list of macro arguments
772 gives undefined behavior. This implementation
773 handles the directive as normal. */
774 && pfile
->state
.parsing_args
!= 1)
776 if (_cpp_handle_directive (pfile
, result
->flags
& PREV_WHITE
))
778 if (pfile
->directive_result
.type
== CPP_PADDING
)
780 result
= &pfile
->directive_result
;
783 else if (pfile
->state
.in_deferred_pragma
)
784 result
= &pfile
->directive_result
;
786 if (pfile
->cb
.line_change
&& !pfile
->state
.skipping
)
787 pfile
->cb
.line_change (pfile
, result
, pfile
->state
.parsing_args
);
790 /* We don't skip tokens in directives. */
791 if (pfile
->state
.in_directive
|| pfile
->state
.in_deferred_pragma
)
794 /* Outside a directive, invalidate controlling macros. At file
795 EOF, _cpp_lex_direct takes care of popping the buffer, so we never
796 get here and MI optimization works. */
797 pfile
->mi_valid
= false;
799 if (!pfile
->state
.skipping
|| result
->type
== CPP_EOF
)
806 /* Returns true if a fresh line has been loaded. */
808 _cpp_get_fresh_line (cpp_reader
*pfile
)
812 /* We can't get a new line until we leave the current directive. */
813 if (pfile
->state
.in_directive
)
818 cpp_buffer
*buffer
= pfile
->buffer
;
820 if (!buffer
->need_line
)
823 if (buffer
->next_line
< buffer
->rlimit
)
825 _cpp_clean_line (pfile
);
829 /* First, get out of parsing arguments state. */
830 if (pfile
->state
.parsing_args
)
833 /* End of buffer. Non-empty files should end in a newline. */
834 if (buffer
->buf
!= buffer
->rlimit
835 && buffer
->next_line
> buffer
->rlimit
836 && !buffer
->from_stage3
)
838 /* Only warn once. */
839 buffer
->next_line
= buffer
->rlimit
;
840 cpp_error_with_line (pfile
, CPP_DL_PEDWARN
, pfile
->line_table
->highest_line
,
841 CPP_BUF_COLUMN (buffer
, buffer
->cur
),
842 "no newline at end of file");
845 return_at_eof
= buffer
->return_at_eof
;
846 _cpp_pop_buffer (pfile
);
847 if (pfile
->buffer
== NULL
|| return_at_eof
)
852 #define IF_NEXT_IS(CHAR, THEN_TYPE, ELSE_TYPE) \
855 result->type = ELSE_TYPE; \
856 if (*buffer->cur == CHAR) \
857 buffer->cur++, result->type = THEN_TYPE; \
861 /* Lex a token into pfile->cur_token, which is also incremented, to
862 get diagnostics pointing to the correct location.
864 Does not handle issues such as token lookahead, multiple-include
865 optimization, directives, skipping etc. This function is only
866 suitable for use by _cpp_lex_token, and in special cases like
867 lex_expansion_token which doesn't care for any of these issues.
869 When meeting a newline, returns CPP_EOF if parsing a directive,
870 otherwise returns to the start of the token buffer if permissible.
871 Returns the location of the lexed token. */
873 _cpp_lex_direct (cpp_reader
*pfile
)
877 const unsigned char *comment_start
;
878 cpp_token
*result
= pfile
->cur_token
++;
882 buffer
= pfile
->buffer
;
883 if (buffer
->need_line
)
885 if (pfile
->state
.in_deferred_pragma
)
887 result
->type
= CPP_PRAGMA_EOL
;
888 pfile
->state
.in_deferred_pragma
= false;
889 if (!pfile
->state
.pragma_allow_expansion
)
890 pfile
->state
.prevent_expansion
--;
893 if (!_cpp_get_fresh_line (pfile
))
895 result
->type
= CPP_EOF
;
896 if (!pfile
->state
.in_directive
)
898 /* Tell the compiler the line number of the EOF token. */
899 result
->src_loc
= pfile
->line_table
->highest_line
;
904 if (!pfile
->keep_tokens
)
906 pfile
->cur_run
= &pfile
->base_run
;
907 result
= pfile
->base_run
.base
;
908 pfile
->cur_token
= result
+ 1;
911 if (pfile
->state
.parsing_args
== 2)
912 result
->flags
|= PREV_WHITE
;
914 buffer
= pfile
->buffer
;
916 result
->src_loc
= pfile
->line_table
->highest_line
;
919 if (buffer
->cur
>= buffer
->notes
[buffer
->cur_note
].pos
920 && !pfile
->overlaid_buffer
)
922 _cpp_process_line_notes (pfile
, false);
923 result
->src_loc
= pfile
->line_table
->highest_line
;
927 LINEMAP_POSITION_FOR_COLUMN (result
->src_loc
, pfile
->line_table
,
928 CPP_BUF_COLUMN (buffer
, buffer
->cur
));
932 case ' ': case '\t': case '\f': case '\v': case '\0':
933 result
->flags
|= PREV_WHITE
;
934 skip_whitespace (pfile
, c
);
938 if (buffer
->cur
< buffer
->rlimit
)
939 CPP_INCREMENT_LINE (pfile
, 0);
940 buffer
->need_line
= true;
943 case '0': case '1': case '2': case '3': case '4':
944 case '5': case '6': case '7': case '8': case '9':
946 struct normalize_state nst
= INITIAL_NORMALIZE_STATE
;
947 result
->type
= CPP_NUMBER
;
948 lex_number (pfile
, &result
->val
.str
, &nst
);
949 warn_about_normalization (pfile
, result
, &nst
);
954 /* 'L' may introduce wide characters or strings. */
955 if (*buffer
->cur
== '\'' || *buffer
->cur
== '"')
957 lex_string (pfile
, result
, buffer
->cur
- 1);
963 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
964 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
965 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
966 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
968 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
969 case 'G': case 'H': case 'I': case 'J': case 'K':
970 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
971 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
973 result
->type
= CPP_NAME
;
975 struct normalize_state nst
= INITIAL_NORMALIZE_STATE
;
976 result
->val
.node
= lex_identifier (pfile
, buffer
->cur
- 1, false,
978 warn_about_normalization (pfile
, result
, &nst
);
981 /* Convert named operators to their proper types. */
982 if (result
->val
.node
->flags
& NODE_OPERATOR
)
984 result
->flags
|= NAMED_OP
;
985 result
->type
= (enum cpp_ttype
) result
->val
.node
->directive_index
;
991 lex_string (pfile
, result
, buffer
->cur
- 1);
995 /* A potential block or line comment. */
996 comment_start
= buffer
->cur
;
1001 if (_cpp_skip_block_comment (pfile
))
1002 cpp_error (pfile
, CPP_DL_ERROR
, "unterminated comment");
1004 else if (c
== '/' && (CPP_OPTION (pfile
, cplusplus_comments
)
1005 || cpp_in_system_header (pfile
)))
1007 /* Warn about comments only if pedantically GNUC89, and not
1008 in system headers. */
1009 if (CPP_OPTION (pfile
, lang
) == CLK_GNUC89
&& CPP_PEDANTIC (pfile
)
1010 && ! buffer
->warned_cplusplus_comments
)
1012 cpp_error (pfile
, CPP_DL_PEDWARN
,
1013 "C++ style comments are not allowed in ISO C90");
1014 cpp_error (pfile
, CPP_DL_PEDWARN
,
1015 "(this will be reported only once per input file)");
1016 buffer
->warned_cplusplus_comments
= 1;
1019 if (skip_line_comment (pfile
) && CPP_OPTION (pfile
, warn_comments
))
1020 cpp_error (pfile
, CPP_DL_WARNING
, "multi-line comment");
1025 result
->type
= CPP_DIV_EQ
;
1030 result
->type
= CPP_DIV
;
1034 if (!pfile
->state
.save_comments
)
1036 result
->flags
|= PREV_WHITE
;
1037 goto update_tokens_line
;
1040 /* Save the comment as a token in its own right. */
1041 save_comment (pfile
, result
, comment_start
, c
);
1045 if (pfile
->state
.angled_headers
)
1047 lex_string (pfile
, result
, buffer
->cur
- 1);
1051 result
->type
= CPP_LESS
;
1052 if (*buffer
->cur
== '=')
1053 buffer
->cur
++, result
->type
= CPP_LESS_EQ
;
1054 else if (*buffer
->cur
== '<')
1057 IF_NEXT_IS ('=', CPP_LSHIFT_EQ
, CPP_LSHIFT
);
1059 else if (CPP_OPTION (pfile
, digraphs
))
1061 if (*buffer
->cur
== ':')
1064 result
->flags
|= DIGRAPH
;
1065 result
->type
= CPP_OPEN_SQUARE
;
1067 else if (*buffer
->cur
== '%')
1070 result
->flags
|= DIGRAPH
;
1071 result
->type
= CPP_OPEN_BRACE
;
1077 result
->type
= CPP_GREATER
;
1078 if (*buffer
->cur
== '=')
1079 buffer
->cur
++, result
->type
= CPP_GREATER_EQ
;
1080 else if (*buffer
->cur
== '>')
1083 IF_NEXT_IS ('=', CPP_RSHIFT_EQ
, CPP_RSHIFT
);
1088 result
->type
= CPP_MOD
;
1089 if (*buffer
->cur
== '=')
1090 buffer
->cur
++, result
->type
= CPP_MOD_EQ
;
1091 else if (CPP_OPTION (pfile
, digraphs
))
1093 if (*buffer
->cur
== ':')
1096 result
->flags
|= DIGRAPH
;
1097 result
->type
= CPP_HASH
;
1098 if (*buffer
->cur
== '%' && buffer
->cur
[1] == ':')
1099 buffer
->cur
+= 2, result
->type
= CPP_PASTE
;
1101 else if (*buffer
->cur
== '>')
1104 result
->flags
|= DIGRAPH
;
1105 result
->type
= CPP_CLOSE_BRACE
;
1111 result
->type
= CPP_DOT
;
1112 if (ISDIGIT (*buffer
->cur
))
1114 struct normalize_state nst
= INITIAL_NORMALIZE_STATE
;
1115 result
->type
= CPP_NUMBER
;
1116 lex_number (pfile
, &result
->val
.str
, &nst
);
1117 warn_about_normalization (pfile
, result
, &nst
);
1119 else if (*buffer
->cur
== '.' && buffer
->cur
[1] == '.')
1120 buffer
->cur
+= 2, result
->type
= CPP_ELLIPSIS
;
1121 else if (*buffer
->cur
== '*' && CPP_OPTION (pfile
, cplusplus
))
1122 buffer
->cur
++, result
->type
= CPP_DOT_STAR
;
1126 result
->type
= CPP_PLUS
;
1127 if (*buffer
->cur
== '+')
1128 buffer
->cur
++, result
->type
= CPP_PLUS_PLUS
;
1129 else if (*buffer
->cur
== '=')
1130 buffer
->cur
++, result
->type
= CPP_PLUS_EQ
;
1134 result
->type
= CPP_MINUS
;
1135 if (*buffer
->cur
== '>')
1138 result
->type
= CPP_DEREF
;
1139 if (*buffer
->cur
== '*' && CPP_OPTION (pfile
, cplusplus
))
1140 buffer
->cur
++, result
->type
= CPP_DEREF_STAR
;
1142 else if (*buffer
->cur
== '-')
1143 buffer
->cur
++, result
->type
= CPP_MINUS_MINUS
;
1144 else if (*buffer
->cur
== '=')
1145 buffer
->cur
++, result
->type
= CPP_MINUS_EQ
;
1149 result
->type
= CPP_AND
;
1150 if (*buffer
->cur
== '&')
1151 buffer
->cur
++, result
->type
= CPP_AND_AND
;
1152 else if (*buffer
->cur
== '=')
1153 buffer
->cur
++, result
->type
= CPP_AND_EQ
;
1157 result
->type
= CPP_OR
;
1158 if (*buffer
->cur
== '|')
1159 buffer
->cur
++, result
->type
= CPP_OR_OR
;
1160 else if (*buffer
->cur
== '=')
1161 buffer
->cur
++, result
->type
= CPP_OR_EQ
;
1165 result
->type
= CPP_COLON
;
1166 if (*buffer
->cur
== ':' && CPP_OPTION (pfile
, cplusplus
))
1167 buffer
->cur
++, result
->type
= CPP_SCOPE
;
1168 else if (*buffer
->cur
== '>' && CPP_OPTION (pfile
, digraphs
))
1171 result
->flags
|= DIGRAPH
;
1172 result
->type
= CPP_CLOSE_SQUARE
;
1176 case '*': IF_NEXT_IS ('=', CPP_MULT_EQ
, CPP_MULT
); break;
1177 case '=': IF_NEXT_IS ('=', CPP_EQ_EQ
, CPP_EQ
); break;
1178 case '!': IF_NEXT_IS ('=', CPP_NOT_EQ
, CPP_NOT
); break;
1179 case '^': IF_NEXT_IS ('=', CPP_XOR_EQ
, CPP_XOR
); break;
1180 case '#': IF_NEXT_IS ('#', CPP_PASTE
, CPP_HASH
); break;
1182 case '?': result
->type
= CPP_QUERY
; break;
1183 case '~': result
->type
= CPP_COMPL
; break;
1184 case ',': result
->type
= CPP_COMMA
; break;
1185 case '(': result
->type
= CPP_OPEN_PAREN
; break;
1186 case ')': result
->type
= CPP_CLOSE_PAREN
; break;
1187 case '[': result
->type
= CPP_OPEN_SQUARE
; break;
1188 case ']': result
->type
= CPP_CLOSE_SQUARE
; break;
1189 case '{': result
->type
= CPP_OPEN_BRACE
; break;
1190 case '}': result
->type
= CPP_CLOSE_BRACE
; break;
1191 case ';': result
->type
= CPP_SEMICOLON
; break;
1193 /* @ is a punctuator in Objective-C. */
1194 case '@': result
->type
= CPP_ATSIGN
; break;
1199 const uchar
*base
= --buffer
->cur
;
1200 struct normalize_state nst
= INITIAL_NORMALIZE_STATE
;
1202 if (forms_identifier_p (pfile
, true, &nst
))
1204 result
->type
= CPP_NAME
;
1205 result
->val
.node
= lex_identifier (pfile
, base
, true, &nst
);
1206 warn_about_normalization (pfile
, result
, &nst
);
1213 create_literal (pfile
, result
, buffer
->cur
- 1, 1, CPP_OTHER
);
1220 /* An upper bound on the number of bytes needed to spell TOKEN.
1221 Does not include preceding whitespace. */
1223 cpp_token_len (const cpp_token
*token
)
1227 switch (TOKEN_SPELL (token
))
1229 default: len
= 4; break;
1230 case SPELL_LITERAL
: len
= token
->val
.str
.len
; break;
1231 case SPELL_IDENT
: len
= NODE_LEN (token
->val
.node
) * 10; break;
1237 /* Parse UTF-8 out of NAMEP and place a \U escape in BUFFER.
1238 Return the number of bytes read out of NAME. (There are always
1239 10 bytes written to BUFFER.) */
1242 utf8_to_ucn (unsigned char *buffer
, const unsigned char *name
)
1248 unsigned long utf32
;
1250 /* Compute the length of the UTF-8 sequence. */
1251 for (t
= *name
; t
& 0x80; t
<<= 1)
1254 utf32
= *name
& (0x7F >> ucn_len
);
1255 for (ucn_len_c
= 1; ucn_len_c
< ucn_len
; ucn_len_c
++)
1257 utf32
= (utf32
<< 6) | (*++name
& 0x3F);
1259 /* Ill-formed UTF-8. */
1260 if ((*name
& ~0x3F) != 0x80)
1266 for (j
= 7; j
>= 0; j
--)
1267 *buffer
++ = "0123456789abcdef"[(utf32
>> (4 * j
)) & 0xF];
1272 /* Write the spelling of a token TOKEN to BUFFER. The buffer must
1273 already contain the enough space to hold the token's spelling.
1274 Returns a pointer to the character after the last character written.
1275 FORSTRING is true if this is to be the spelling after translation
1276 phase 1 (this is different for UCNs).
1277 FIXME: Would be nice if we didn't need the PFILE argument. */
1279 cpp_spell_token (cpp_reader
*pfile
, const cpp_token
*token
,
1280 unsigned char *buffer
, bool forstring
)
1282 switch (TOKEN_SPELL (token
))
1284 case SPELL_OPERATOR
:
1286 const unsigned char *spelling
;
1289 if (token
->flags
& DIGRAPH
)
1291 = digraph_spellings
[(int) token
->type
- (int) CPP_FIRST_DIGRAPH
];
1292 else if (token
->flags
& NAMED_OP
)
1295 spelling
= TOKEN_NAME (token
);
1297 while ((c
= *spelling
++) != '\0')
1306 memcpy (buffer
, NODE_NAME (token
->val
.node
),
1307 NODE_LEN (token
->val
.node
));
1308 buffer
+= NODE_LEN (token
->val
.node
);
1313 const unsigned char * name
= NODE_NAME (token
->val
.node
);
1315 for (i
= 0; i
< NODE_LEN (token
->val
.node
); i
++)
1316 if (name
[i
] & ~0x7F)
1318 i
+= utf8_to_ucn (buffer
, name
+ i
) - 1;
1322 *buffer
++ = NODE_NAME (token
->val
.node
)[i
];
1327 memcpy (buffer
, token
->val
.str
.text
, token
->val
.str
.len
);
1328 buffer
+= token
->val
.str
.len
;
1332 cpp_error (pfile
, CPP_DL_ICE
,
1333 "unspellable token %s", TOKEN_NAME (token
));
1340 /* Returns TOKEN spelt as a null-terminated string. The string is
1341 freed when the reader is destroyed. Useful for diagnostics. */
1343 cpp_token_as_text (cpp_reader
*pfile
, const cpp_token
*token
)
1345 unsigned int len
= cpp_token_len (token
) + 1;
1346 unsigned char *start
= _cpp_unaligned_alloc (pfile
, len
), *end
;
1348 end
= cpp_spell_token (pfile
, token
, start
, false);
1354 /* Used by C front ends, which really should move to using
1355 cpp_token_as_text. */
1357 cpp_type2name (enum cpp_ttype type
)
1359 return (const char *) token_spellings
[type
].name
;
1362 /* Writes the spelling of token to FP, without any preceding space.
1363 Separated from cpp_spell_token for efficiency - to avoid stdio
1364 double-buffering. */
1366 cpp_output_token (const cpp_token
*token
, FILE *fp
)
1368 switch (TOKEN_SPELL (token
))
1370 case SPELL_OPERATOR
:
1372 const unsigned char *spelling
;
1375 if (token
->flags
& DIGRAPH
)
1377 = digraph_spellings
[(int) token
->type
- (int) CPP_FIRST_DIGRAPH
];
1378 else if (token
->flags
& NAMED_OP
)
1381 spelling
= TOKEN_NAME (token
);
1386 while ((c
= *++spelling
) != '\0');
1394 const unsigned char * name
= NODE_NAME (token
->val
.node
);
1396 for (i
= 0; i
< NODE_LEN (token
->val
.node
); i
++)
1397 if (name
[i
] & ~0x7F)
1399 unsigned char buffer
[10];
1400 i
+= utf8_to_ucn (buffer
, name
+ i
) - 1;
1401 fwrite (buffer
, 1, 10, fp
);
1404 fputc (NODE_NAME (token
->val
.node
)[i
], fp
);
1409 fwrite (token
->val
.str
.text
, 1, token
->val
.str
.len
, fp
);
1413 /* An error, most probably. */
1418 /* Compare two tokens. */
1420 _cpp_equiv_tokens (const cpp_token
*a
, const cpp_token
*b
)
1422 if (a
->type
== b
->type
&& a
->flags
== b
->flags
)
1423 switch (TOKEN_SPELL (a
))
1425 default: /* Keep compiler happy. */
1426 case SPELL_OPERATOR
:
1429 return (a
->type
!= CPP_MACRO_ARG
|| a
->val
.arg_no
== b
->val
.arg_no
);
1431 return a
->val
.node
== b
->val
.node
;
1433 return (a
->val
.str
.len
== b
->val
.str
.len
1434 && !memcmp (a
->val
.str
.text
, b
->val
.str
.text
,
1441 /* Returns nonzero if a space should be inserted to avoid an
1442 accidental token paste for output. For simplicity, it is
1443 conservative, and occasionally advises a space where one is not
1444 needed, e.g. "." and ".2". */
1446 cpp_avoid_paste (cpp_reader
*pfile
, const cpp_token
*token1
,
1447 const cpp_token
*token2
)
1449 enum cpp_ttype a
= token1
->type
, b
= token2
->type
;
1452 if (token1
->flags
& NAMED_OP
)
1454 if (token2
->flags
& NAMED_OP
)
1458 if (token2
->flags
& DIGRAPH
)
1459 c
= digraph_spellings
[(int) b
- (int) CPP_FIRST_DIGRAPH
][0];
1460 else if (token_spellings
[b
].category
== SPELL_OPERATOR
)
1461 c
= token_spellings
[b
].name
[0];
1463 /* Quickly get everything that can paste with an '='. */
1464 if ((int) a
<= (int) CPP_LAST_EQ
&& c
== '=')
1469 case CPP_GREATER
: return c
== '>';
1470 case CPP_LESS
: return c
== '<' || c
== '%' || c
== ':';
1471 case CPP_PLUS
: return c
== '+';
1472 case CPP_MINUS
: return c
== '-' || c
== '>';
1473 case CPP_DIV
: return c
== '/' || c
== '*'; /* Comments. */
1474 case CPP_MOD
: return c
== ':' || c
== '>';
1475 case CPP_AND
: return c
== '&';
1476 case CPP_OR
: return c
== '|';
1477 case CPP_COLON
: return c
== ':' || c
== '>';
1478 case CPP_DEREF
: return c
== '*';
1479 case CPP_DOT
: return c
== '.' || c
== '%' || b
== CPP_NUMBER
;
1480 case CPP_HASH
: return c
== '#' || c
== '%'; /* Digraph form. */
1481 case CPP_NAME
: return ((b
== CPP_NUMBER
1482 && name_p (pfile
, &token2
->val
.str
))
1484 || b
== CPP_CHAR
|| b
== CPP_STRING
); /* L */
1485 case CPP_NUMBER
: return (b
== CPP_NUMBER
|| b
== CPP_NAME
1486 || c
== '.' || c
== '+' || c
== '-');
1488 case CPP_OTHER
: return ((token1
->val
.str
.text
[0] == '\\'
1490 || (CPP_OPTION (pfile
, objc
)
1491 && token1
->val
.str
.text
[0] == '@'
1492 && (b
== CPP_NAME
|| b
== CPP_STRING
)));
1499 /* Output all the remaining tokens on the current line, and a newline
1500 character, to FP. Leading whitespace is removed. If there are
1501 macros, special token padding is not performed. */
1503 cpp_output_line (cpp_reader
*pfile
, FILE *fp
)
1505 const cpp_token
*token
;
1507 token
= cpp_get_token (pfile
);
1508 while (token
->type
!= CPP_EOF
)
1510 cpp_output_token (token
, fp
);
1511 token
= cpp_get_token (pfile
);
1512 if (token
->flags
& PREV_WHITE
)
1519 /* Memory buffers. Changing these three constants can have a dramatic
1520 effect on performance. The values here are reasonable defaults,
1521 but might be tuned. If you adjust them, be sure to test across a
1522 range of uses of cpplib, including heavy nested function-like macro
1523 expansion. Also check the change in peak memory usage (NJAMD is a
1524 good tool for this). */
1525 #define MIN_BUFF_SIZE 8000
1526 #define BUFF_SIZE_UPPER_BOUND(MIN_SIZE) (MIN_BUFF_SIZE + (MIN_SIZE) * 3 / 2)
1527 #define EXTENDED_BUFF_SIZE(BUFF, MIN_EXTRA) \
1528 (MIN_EXTRA + ((BUFF)->limit - (BUFF)->cur) * 2)
1530 #if MIN_BUFF_SIZE > BUFF_SIZE_UPPER_BOUND (0)
1531 #error BUFF_SIZE_UPPER_BOUND must be at least as large as MIN_BUFF_SIZE!
1534 /* Create a new allocation buffer. Place the control block at the end
1535 of the buffer, so that buffer overflows will cause immediate chaos. */
1537 new_buff (size_t len
)
1540 unsigned char *base
;
1542 if (len
< MIN_BUFF_SIZE
)
1543 len
= MIN_BUFF_SIZE
;
1544 len
= CPP_ALIGN (len
);
1546 base
= XNEWVEC (unsigned char, len
+ sizeof (_cpp_buff
));
1547 result
= (_cpp_buff
*) (base
+ len
);
1548 result
->base
= base
;
1550 result
->limit
= base
+ len
;
1551 result
->next
= NULL
;
1555 /* Place a chain of unwanted allocation buffers on the free list. */
1557 _cpp_release_buff (cpp_reader
*pfile
, _cpp_buff
*buff
)
1559 _cpp_buff
*end
= buff
;
1563 end
->next
= pfile
->free_buffs
;
1564 pfile
->free_buffs
= buff
;
1567 /* Return a free buffer of size at least MIN_SIZE. */
1569 _cpp_get_buff (cpp_reader
*pfile
, size_t min_size
)
1571 _cpp_buff
*result
, **p
;
1573 for (p
= &pfile
->free_buffs
;; p
= &(*p
)->next
)
1578 return new_buff (min_size
);
1580 size
= result
->limit
- result
->base
;
1581 /* Return a buffer that's big enough, but don't waste one that's
1583 if (size
>= min_size
&& size
<= BUFF_SIZE_UPPER_BOUND (min_size
))
1588 result
->next
= NULL
;
1589 result
->cur
= result
->base
;
1593 /* Creates a new buffer with enough space to hold the uncommitted
1594 remaining bytes of BUFF, and at least MIN_EXTRA more bytes. Copies
1595 the excess bytes to the new buffer. Chains the new buffer after
1596 BUFF, and returns the new buffer. */
1598 _cpp_append_extend_buff (cpp_reader
*pfile
, _cpp_buff
*buff
, size_t min_extra
)
1600 size_t size
= EXTENDED_BUFF_SIZE (buff
, min_extra
);
1601 _cpp_buff
*new_buff
= _cpp_get_buff (pfile
, size
);
1603 buff
->next
= new_buff
;
1604 memcpy (new_buff
->base
, buff
->cur
, BUFF_ROOM (buff
));
1608 /* Creates a new buffer with enough space to hold the uncommitted
1609 remaining bytes of the buffer pointed to by BUFF, and at least
1610 MIN_EXTRA more bytes. Copies the excess bytes to the new buffer.
1611 Chains the new buffer before the buffer pointed to by BUFF, and
1612 updates the pointer to point to the new buffer. */
1614 _cpp_extend_buff (cpp_reader
*pfile
, _cpp_buff
**pbuff
, size_t min_extra
)
1616 _cpp_buff
*new_buff
, *old_buff
= *pbuff
;
1617 size_t size
= EXTENDED_BUFF_SIZE (old_buff
, min_extra
);
1619 new_buff
= _cpp_get_buff (pfile
, size
);
1620 memcpy (new_buff
->base
, old_buff
->cur
, BUFF_ROOM (old_buff
));
1621 new_buff
->next
= old_buff
;
1625 /* Free a chain of buffers starting at BUFF. */
1627 _cpp_free_buff (_cpp_buff
*buff
)
1631 for (; buff
; buff
= next
)
1638 /* Allocate permanent, unaligned storage of length LEN. */
1640 _cpp_unaligned_alloc (cpp_reader
*pfile
, size_t len
)
1642 _cpp_buff
*buff
= pfile
->u_buff
;
1643 unsigned char *result
= buff
->cur
;
1645 if (len
> (size_t) (buff
->limit
- result
))
1647 buff
= _cpp_get_buff (pfile
, len
);
1648 buff
->next
= pfile
->u_buff
;
1649 pfile
->u_buff
= buff
;
1653 buff
->cur
= result
+ len
;
1657 /* Allocate permanent, unaligned storage of length LEN from a_buff.
1658 That buffer is used for growing allocations when saving macro
1659 replacement lists in a #define, and when parsing an answer to an
1660 assertion in #assert, #unassert or #if (and therefore possibly
1661 whilst expanding macros). It therefore must not be used by any
1662 code that they might call: specifically the lexer and the guts of
1665 All existing other uses clearly fit this restriction: storing
1666 registered pragmas during initialization. */
1668 _cpp_aligned_alloc (cpp_reader
*pfile
, size_t len
)
1670 _cpp_buff
*buff
= pfile
->a_buff
;
1671 unsigned char *result
= buff
->cur
;
1673 if (len
> (size_t) (buff
->limit
- result
))
1675 buff
= _cpp_get_buff (pfile
, len
);
1676 buff
->next
= pfile
->a_buff
;
1677 pfile
->a_buff
= buff
;
1681 buff
->cur
= result
+ len
;
1685 /* Say which field of TOK is in use. */
1687 enum cpp_token_fld_kind
1688 cpp_token_val_index (cpp_token
*tok
)
1690 switch (TOKEN_SPELL (tok
))
1693 return CPP_TOKEN_FLD_NODE
;
1695 return CPP_TOKEN_FLD_STR
;
1697 if (tok
->type
== CPP_MACRO_ARG
)
1698 return CPP_TOKEN_FLD_ARG_NO
;
1699 else if (tok
->type
== CPP_PADDING
)
1700 return CPP_TOKEN_FLD_SOURCE
;
1701 else if (tok
->type
== CPP_PRAGMA
)
1702 return CPP_TOKEN_FLD_PRAGMA
;
1703 /* else fall through */
1705 return CPP_TOKEN_FLD_NONE
;