1 /* CPP Library - lexical analysis.
2 Copyright (C) 2000 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994-95.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
6 Broken out to separate file, Zack Weinberg, Mar 2000
7 Single-pass line tokenization by Neil Booth, April 2000
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 2, or (at your option) any
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.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 o Check line numbers assigned to all errors.
28 o Replace strncmp with memcmp almost everywhere.
29 o lex_line's use of cur_token, flags and list->token_used is a bit opaque.
30 o Distinguish integers, floats, and 'other' pp-numbers.
31 o Store ints and char constants as binary values.
32 o New command-line assertion syntax.
33 o Work towards functions in cpperror.c taking a message level parameter.
34 If we do this, merge the common code of do_warning and do_error.
35 o Comment all functions, and describe macro expansion algorithm.
36 o Move as much out of header files as possible.
37 o Remove single quote pairs `', and some '', from diagnostics.
38 o Correct pastability test for CPP_NAME and CPP_NUMBER.
49 static const cpp_token placemarker_token = {0, 0, CPP_PLACEMARKER, 0 UNION_INIT_ZERO};
50 static const cpp_token eof_token = {0, 0, CPP_EOF, 0 UNION_INIT_ZERO};
52 /* Flags for cpp_context. */
53 #define CONTEXT_PASTEL (1 << 0) /* An argument context on LHS of ##. */
54 #define CONTEXT_PASTER (1 << 1) /* An argument context on RHS of ##. */
55 #define CONTEXT_RAW (1 << 2) /* If argument tokens already expanded. */
56 #define CONTEXT_ARG (1 << 3) /* If an argument context. */
58 typedef struct cpp_context cpp_context;
63 const cpp_toklist *list; /* Used for macro contexts only. */
64 const cpp_token **arg; /* Used for arg contexts only. */
67 /* Pushed token to be returned by next call to get_raw_token. */
68 const cpp_token *pushed_token;
70 struct macro_args *args; /* The arguments for a function-like
71 macro. NULL otherwise. */
72 unsigned short posn; /* Current posn, index into u. */
73 unsigned short count; /* No. of tokens in u. */
78 typedef struct macro_args macro_args;
82 const cpp_token **tokens;
83 unsigned int capacity;
88 static const cpp_token *get_raw_token PARAMS ((cpp_reader *));
89 static const cpp_token *parse_arg PARAMS ((cpp_reader *, int, unsigned int,
90 macro_args *, unsigned int *));
91 static int parse_args PARAMS ((cpp_reader *, cpp_hashnode *, macro_args *));
92 static void save_token PARAMS ((macro_args *, const cpp_token *));
93 static int pop_context PARAMS ((cpp_reader *));
94 static int push_macro_context PARAMS ((cpp_reader *, const cpp_token *));
95 static void push_arg_context PARAMS ((cpp_reader *, const cpp_token *));
96 static void free_macro_args PARAMS ((macro_args *));
98 #define auto_expand_name_space(list) \
99 _cpp_expand_name_space ((list), 1 + (list)->name_cap / 2)
100 static void dump_param_spelling PARAMS ((FILE *, const cpp_toklist *,
102 static void output_line_command PARAMS ((cpp_reader *, cpp_printer *,
105 static void process_directive PARAMS ((cpp_reader *, const cpp_token *));
106 static unsigned char *trigraph_replace PARAMS ((cpp_reader *, unsigned char *,
108 static const unsigned char *backslash_start PARAMS ((cpp_reader *,
109 const unsigned char *));
110 static int skip_block_comment PARAMS ((cpp_reader *));
111 static int skip_line_comment PARAMS ((cpp_reader *));
112 static void adjust_column PARAMS ((cpp_reader *, const U_CHAR *));
113 static void skip_whitespace PARAMS ((cpp_reader *, int));
114 static const U_CHAR *parse_name PARAMS ((cpp_reader *, cpp_token *,
115 const U_CHAR *, const U_CHAR *));
116 static void parse_number PARAMS ((cpp_reader *, cpp_toklist *, cpp_string *));
117 static void parse_string PARAMS ((cpp_reader *, cpp_toklist *, cpp_token *,
119 static int trigraph_ok PARAMS ((cpp_reader *, const unsigned char *));
120 static void save_comment PARAMS ((cpp_toklist *, cpp_token *,
121 const unsigned char *,
122 unsigned int, unsigned int));
123 static void lex_line PARAMS ((cpp_reader *, cpp_toklist *));
124 static int lex_next PARAMS ((cpp_reader *, int));
125 static int is_macro_disabled PARAMS ((cpp_reader *, const cpp_toklist *,
128 static cpp_token *stringify_arg PARAMS ((cpp_reader *, const cpp_token *));
129 static void expand_context_stack PARAMS ((cpp_reader *));
130 static unsigned char * spell_token PARAMS ((cpp_reader *, const cpp_token *,
132 static void output_token PARAMS ((cpp_reader *, FILE *, const cpp_token *,
133 const cpp_token *, int));
134 typedef unsigned int (* speller) PARAMS ((unsigned char *, cpp_toklist *,
136 static cpp_token *make_string_token PARAMS ((cpp_token *, const U_CHAR *,
138 static cpp_token *alloc_number_token PARAMS ((cpp_reader *, int number));
139 static const cpp_token *special_symbol PARAMS ((cpp_reader *, cpp_hashnode *,
141 static cpp_token *duplicate_token PARAMS ((cpp_reader *, const cpp_token *));
142 static const cpp_token *maybe_paste_with_next PARAMS ((cpp_reader *,
144 static enum cpp_ttype can_paste PARAMS ((cpp_reader *, const cpp_token *,
145 const cpp_token *, int *));
146 static unsigned int prevent_macro_expansion PARAMS ((cpp_reader *));
147 static void restore_macro_expansion PARAMS ((cpp_reader *, unsigned int));
148 static cpp_token *get_temp_token PARAMS ((cpp_reader *));
149 static void release_temp_tokens PARAMS ((cpp_reader *));
150 static U_CHAR * quote_string PARAMS ((U_CHAR *, const U_CHAR *, unsigned int));
151 static void process_directive PARAMS ((cpp_reader *, const cpp_token *));
153 #define INIT_TOKEN_STR(list, token) \
154 do {(token)->val.str.len = 0; \
155 (token)->val.str.text = (list)->namebuf + (list)->name_used; \
158 #define VALID_SIGN(c, prevc) \
159 (((c) == '+' || (c) == '-') && \
160 ((prevc) == 'e' || (prevc) == 'E' \
161 || (((prevc) == 'p' || (prevc) == 'P') && !CPP_OPTION (pfile, c89))))
163 /* Handle LF, CR, CR-LF and LF-CR style newlines. Assumes next
164 character, if any, is in buffer. */
166 #define handle_newline(cur, limit, c) \
168 if ((cur) < (limit) && *(cur) == '\r' + '\n' - c) \
170 pfile->buffer->lineno++; \
171 pfile->buffer->line_base = (cur); \
172 pfile->col_adjust = 0; \
175 #define IMMED_TOKEN() (!(cur_token->flags & PREV_WHITE))
176 #define PREV_TOKEN_TYPE (cur_token[-1].type)
178 #define PUSH_TOKEN(ttype) cur_token++->type = (ttype)
179 #define REVISE_TOKEN(ttype) cur_token[-1].type = (ttype)
180 #define BACKUP_TOKEN(ttype) (--cur_token)->type = (ttype)
181 #define BACKUP_DIGRAPH(ttype) do { \
182 BACKUP_TOKEN(ttype); cur_token->flags |= DIGRAPH;} while (0)
184 /* An upper bound on the number of bytes needed to spell a token,
185 including preceding whitespace. */
186 static inline size_t TOKEN_LEN PARAMS ((const cpp_token *));
189 const cpp_token *token;
193 switch (TOKEN_SPELL (token))
195 default: len = 0; break;
196 case SPELL_STRING: len = token->val.str.len; break;
197 case SPELL_IDENT: len = token->val.node->length; break;
202 #define IS_ARG_CONTEXT(c) ((c)->flags & CONTEXT_ARG)
203 #define CURRENT_CONTEXT(pfile) ((pfile)->contexts + (pfile)->cur_context)
204 #define ON_REST_ARG(c) \
205 (((c)->flags & VAR_ARGS) \
206 && (c)->u.list->tokens[(c)->posn].val.aux \
207 == (unsigned int) ((c)->u.list->paramc - 1))
209 #define ASSIGN_FLAGS_AND_POS(d, s) \
210 do {(d)->flags = (s)->flags & (PREV_WHITE | BOL | PASTE_LEFT); \
211 if ((d)->flags & BOL) {(d)->col = (s)->col; (d)->line = (s)->line;} \
214 /* f is flags, just consisting of PREV_WHITE | BOL. */
215 #define MODIFY_FLAGS_AND_POS(d, s, f) \
216 do {(d)->flags &= ~(PREV_WHITE | BOL); (d)->flags |= (f); \
217 if ((f) & BOL) {(d)->col = (s)->col; (d)->line = (s)->line;} \
220 #define OP(e, s) { SPELL_OPERATOR, U s },
221 #define TK(e, s) { s, U STRINGX (e) },
223 const struct token_spelling
224 _cpp_token_spellings [N_TTYPES] = {TTYPE_TABLE };
229 /* The following table is used by trigraph_ok/trigraph_replace. If we
230 have designated initializers, it can be constant data; otherwise,
231 it is set up at runtime by _cpp_init_input_buffer. */
233 #if (GCC_VERSION >= 2007)
234 #define init_trigraph_map() /* nothing */
235 #define TRIGRAPH_MAP \
236 __extension__ static const U_CHAR trigraph_map[UCHAR_MAX + 1] = {
238 #define s(p, v) [p] = v,
240 #define TRIGRAPH_MAP static U_CHAR trigraph_map[UCHAR_MAX + 1] = { 0 }; \
241 static void init_trigraph_map PARAMS ((void)) { \
242 unsigned char *x = trigraph_map;
244 #define s(p, v) x[p] = v;
248 s('=', '#') s(')', ']') s('!', '|')
249 s('(', '[') s('\'', '^') s('>', '}')
250 s('/', '\\') s('<', '{') s('-', '~')
257 /* Notify the compiler proper that the current line number has jumped,
258 or the current file name has changed. */
261 output_line_command (pfile, print, line)
266 cpp_buffer *ip = CPP_BUFFER (pfile);
271 /* End the previous line of text. */
272 if (pfile->need_newline)
274 putc ('\n', print->outf);
277 pfile->need_newline = 0;
279 if (CPP_OPTION (pfile, no_line_commands))
282 /* If the current file has not changed, we can output a few newlines
283 instead if we want to increase the line number by a small amount.
284 We cannot do this if print->lineno is zero, because that means we
285 haven't output any line commands yet. (The very first line
286 command output is a `same_file' command.)
288 'nominal_fname' values are unique, so they can be compared by
289 comparing pointers. */
290 if (ip->nominal_fname == print->last_fname && print->lineno > 0
291 && line >= print->lineno && line < print->lineno + 8)
293 while (line > print->lineno)
295 putc ('\n', print->outf);
301 fprintf (print->outf, "# %u \"%s\"%s\n", line, ip->nominal_fname,
302 cpp_syshdr_flags (pfile, ip));
304 print->last_fname = ip->nominal_fname;
305 print->lineno = line;
308 /* Like fprintf, but writes to a printer object. You should be sure
309 always to generate a complete line when you use this function. */
311 cpp_printf VPARAMS ((cpp_reader *pfile, cpp_printer *print,
312 const char *fmt, ...))
315 #ifndef ANSI_PROTOTYPES
323 #ifndef ANSI_PROTOTYPES
324 pfile = va_arg (ap, cpp_reader *);
325 print = va_arg (ap, cpp_printer *);
326 fmt = va_arg (ap, const char *);
329 /* End the previous line of text. */
330 if (pfile->need_newline)
331 putc ('\n', print->outf);
332 pfile->need_newline = 0;
334 vfprintf (print->outf, fmt, ap);
338 /* Scan until CPP_BUFFER (PFILE) is exhausted, discarding output. */
341 cpp_scan_buffer_nooutput (pfile)
344 cpp_buffer *stop = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
345 const cpp_token *token;
347 /* In no-output mode, we can ignore everything but directives. */
350 token = _cpp_get_token (pfile);
352 if (token->type == CPP_EOF)
354 cpp_pop_buffer (pfile);
355 if (CPP_BUFFER (pfile) == stop)
359 if (token->type == CPP_HASH && token->flags & BOL
360 && pfile->token_list.directive)
362 process_directive (pfile, token);
366 _cpp_skip_rest_of_line (pfile);
370 /* Scan until CPP_BUFFER (pfile) is exhausted, writing output to PRINT. */
372 cpp_scan_buffer (pfile, print)
376 cpp_buffer *stop = CPP_PREV_BUFFER (CPP_BUFFER (pfile));
377 const cpp_token *token, *prev = 0;
381 token = _cpp_get_token (pfile);
382 if (token->type == CPP_EOF)
384 cpp_pop_buffer (pfile);
386 if (CPP_BUFFER (pfile) == stop)
393 if (token->flags & BOL)
395 if (token->type == CPP_HASH && pfile->token_list.directive)
397 process_directive (pfile, token);
401 output_line_command (pfile, print, pfile->token_list.line);
405 if (token->type != CPP_PLACEMARKER)
407 output_token (pfile, print->outf, token, prev, 1);
408 pfile->need_newline = 1;
415 /* Helper routine used by parse_include, which can't see spell_token.
416 Reinterpret the current line as an h-char-sequence (< ... >); we are
417 looking at the first token after the <. */
419 _cpp_glue_header_name (pfile)
429 buf = xmalloc (avail);
433 t = _cpp_get_token (pfile);
434 if (t->type == CPP_GREATER || t->type == CPP_EOF)
437 if (len + TOKEN_LEN (t) > avail)
439 avail = len + TOKEN_LEN (t) + 40;
440 buf = xrealloc (buf, avail);
443 if (t->flags & PREV_WHITE)
446 p = spell_token (pfile, t, buf + len);
447 len = (size_t) (p - buf); /* p known >= buf */
450 if (t->type == CPP_EOF)
451 cpp_error (pfile, "missing terminating > character");
453 buf = xrealloc (buf, len);
455 hdr = get_temp_token (pfile);
456 hdr->type = CPP_HEADER_NAME;
458 hdr->val.str.text = buf;
459 hdr->val.str.len = len;
463 /* Token-buffer helper functions. */
465 /* Expand a token list's string space. It is *vital* that
466 list->tokens_used is correct, to get pointer fix-up right. */
468 _cpp_expand_name_space (list, len)
472 const U_CHAR *old_namebuf;
474 old_namebuf = list->namebuf;
475 list->name_cap += len;
476 list->namebuf = (unsigned char *) xrealloc (list->namebuf, list->name_cap);
478 /* Fix up token text pointers. */
479 if (list->namebuf != old_namebuf)
483 for (i = 0; i < list->tokens_used; i++)
484 if (TOKEN_SPELL (&list->tokens[i]) == SPELL_STRING)
485 list->tokens[i].val.str.text += (list->namebuf - old_namebuf);
489 /* If there is not enough room for LEN more characters, expand the
490 list by just enough to have room for LEN characters. */
492 _cpp_reserve_name_space (list, len)
496 unsigned int room = list->name_cap - list->name_used;
499 _cpp_expand_name_space (list, len - room);
502 /* Expand the number of tokens in a list. */
504 _cpp_expand_token_space (list, count)
510 list->tokens_cap += count;
511 n = list->tokens_cap;
512 if (list->flags & LIST_OFFSET)
514 list->tokens = (cpp_token *)
515 xrealloc (list->tokens, n * sizeof (cpp_token));
516 if (list->flags & LIST_OFFSET)
517 list->tokens++; /* Skip the dummy. */
520 /* Initialize a token list. If flags is DUMMY_TOKEN, we allocate
521 an extra token in front of the token list, as this allows the lexer
522 to always peek at the previous token without worrying about
523 underflowing the list, and some initial space. Otherwise, no
524 token- or name-space is allocated, and there is no dummy token. */
526 _cpp_init_toklist (list, flags)
530 if (flags == NO_DUMMY_TOKEN)
532 list->tokens_cap = 0;
540 /* Initialize token space. Put a dummy token before the start
541 that will fail matches. */
542 list->tokens_cap = 256; /* 4K's worth. */
543 list->tokens = (cpp_token *)
544 xmalloc ((list->tokens_cap + 1) * sizeof (cpp_token));
545 list->tokens[0].type = CPP_EOF;
548 /* Initialize name space. */
549 list->name_cap = 1024;
550 list->namebuf = (unsigned char *) xmalloc (list->name_cap);
551 list->flags = LIST_OFFSET;
554 _cpp_clear_toklist (list);
557 /* Clear a token list. */
559 _cpp_clear_toklist (list)
562 list->tokens_used = 0;
566 list->params_len = 0;
567 list->flags &= LIST_OFFSET; /* clear all but that one */
570 /* Free a token list. Does not free the list itself, which may be
571 embedded in a larger structure. */
573 _cpp_free_toklist (list)
574 const cpp_toklist *list;
576 if (list->flags & LIST_OFFSET)
577 free (list->tokens - 1); /* Backup over dummy token. */
580 free (list->namebuf);
583 /* Compare two tokens. */
585 _cpp_equiv_tokens (a, b)
586 const cpp_token *a, *b;
588 if (a->type == b->type && a->flags == b->flags)
589 switch (TOKEN_SPELL (a))
591 default: /* Keep compiler happy. */
596 return a->val.aux == b->val.aux; /* arg_no or character. */
598 return a->val.node == b->val.node;
600 return (a->val.str.len == b->val.str.len
601 && !memcmp (a->val.str.text, b->val.str.text,
608 /* Compare two token lists. */
610 _cpp_equiv_toklists (a, b)
611 const cpp_toklist *a, *b;
615 if (a->tokens_used != b->tokens_used
616 || a->flags != b->flags
617 || a->paramc != b->paramc)
620 for (i = 0; i < a->tokens_used; i++)
621 if (! _cpp_equiv_tokens (&a->tokens[i], &b->tokens[i]))
628 Compares, the token TOKEN to the NUL-terminated string STRING.
629 TOKEN must be a CPP_NAME. Returns 1 for equal, 0 for unequal. */
632 cpp_ideq (token, string)
633 const cpp_token *token;
636 if (token->type != CPP_NAME)
639 return !ustrcmp (token->val.node->name, (const U_CHAR *)string);
644 The original lexer in cpplib was made up of two passes: a first pass
645 that replaced trigraphs and deleted esacped newlines, and a second
646 pass that tokenized the result of the first pass. Tokenisation was
647 performed by peeking at the next character in the input stream. For
648 example, if the input stream contained "!=", the handler for the !
649 character would peek at the next character, and if it were a '='
650 would skip over it, and return a "!=" token, otherwise it would
651 return just the "!" token.
653 To implement a single-pass lexer, this peeking ahead is unworkable.
654 An arbitrary number of escaped newlines, and trigraphs (in particular
655 ??/ which translates to the escape \), could separate the '!' and '='
656 in the input stream, yet the next token is still a "!=".
658 Suppose instead that we lex by one logical line at a time, producing
659 a token list or stack for each logical line, and when seeing the '!'
660 push a CPP_NOT token on the list. Then if the '!' is part of a
661 longer token ("!=") we know we must see the remainder of the token by
662 the time we reach the end of the logical line. Thus we can have the
663 '=' handler look at the previous token (at the end of the list / top
664 of the stack) and see if it is a "!" token, and if so, instead of
665 pushing a "=" token revise the existing token to be a "!=" token.
667 This works in the presence of escaped newlines, because the '\' would
668 have been pushed on the top of the stack as a CPP_BACKSLASH. The
669 newline ('\n' or '\r') handler looks at the token at the top of the
670 stack to see if it is a CPP_BACKSLASH, and if so discards both.
671 Hence the '=' handler would never see any intervening tokens.
673 To make trigraphs work in this context, as in precedence trigraphs
674 are highest and converted before anything else, the '?' handler does
675 lookahead to see if it is a trigraph, and if so skips the trigraph
676 and pushes the token it represents onto the top of the stack. This
677 also works in the particular case of a CPP_BACKSLASH trigraph.
679 To the preprocessor, whitespace is only significant to the point of
680 knowing whether whitespace precedes a particular token. For example,
681 the '=' handler needs to know whether there was whitespace between it
682 and a "!" token on the top of the stack, to make the token conversion
683 decision correctly. So each token has a PREV_WHITE flag to
684 indicate this - the standard permits consecutive whitespace to be
685 regarded as a single space. The compiler front ends are not
686 interested in whitespace at all; they just require a token stream.
687 Another place where whitespace is significant to the preprocessor is
688 a #define statment - if there is whitespace between the macro name
689 and an initial "(" token the macro is "object-like", otherwise it is
690 a function-like macro that takes arguments.
692 However, all is not rosy. Parsing of identifiers, numbers, comments
693 and strings becomes trickier because of the possibility of raw
694 trigraphs and escaped newlines in the input stream.
696 The trigraphs are three consecutive characters beginning with two
697 question marks. A question mark is not valid as part of a number or
698 identifier, so parsing of a number or identifier terminates normally
699 upon reaching it, returning to the mainloop which handles the
700 trigraph just like it would in any other position. Similarly for the
701 backslash of a backslash-newline combination. So we just need the
702 escaped-newline dropper in the mainloop to check if the token on the
703 top of the stack after dropping the escaped newline is a number or
704 identifier, and if so to continue the processing it as if nothing had
707 For strings, we replace trigraphs whenever we reach a quote or
708 newline, because there might be a backslash trigraph escaping them.
709 We need to be careful that we start trigraph replacing from where we
710 left off previously, because it is possible for a first scan to leave
711 "fake" trigraphs that a second scan would pick up as real (e.g. the
712 sequence "????/\n=" would find a fake ??= trigraph after removing the
715 For line comments, on reaching a newline we scan the previous
716 character(s) to see if it escaped, and continue if it is. Block
717 comments ignore everything and just focus on finding the comment
718 termination mark. The only difficult thing, and it is surprisingly
719 tricky, is checking if an asterisk precedes the final slash since
720 they could be separated by escaped newlines. If the preprocessor is
721 invoked with the output comments option, we don't bother removing
722 escaped newlines and replacing trigraphs for output.
724 Finally, numbers can begin with a period, which is pushed initially
725 as a CPP_DOT token in its own right. The digit handler checks if the
726 previous token was a CPP_DOT not separated by whitespace, and if so
727 pops it off the stack and pushes a period into the number's buffer
728 before calling the number parser.
732 static const unsigned char *digraph_spellings [] = {U"%:", U"%:%:", U"<:",
733 U":>", U"<%", U"%>"};
735 /* Call when a trigraph is encountered. It warns if necessary, and
736 returns true if the trigraph should be honoured. END is the third
737 character of a trigraph in the input stream. */
739 trigraph_ok (pfile, end)
741 const unsigned char *end;
743 int accept = CPP_OPTION (pfile, trigraphs);
745 if (CPP_OPTION (pfile, warn_trigraphs))
747 unsigned int col = end - 1 - pfile->buffer->line_base;
749 cpp_warning_with_line (pfile, pfile->buffer->lineno, col,
750 "trigraph ??%c converted to %c",
751 (int) *end, (int) trigraph_map[*end]);
753 cpp_warning_with_line (pfile, pfile->buffer->lineno, col,
754 "trigraph ??%c ignored", (int) *end);
759 /* Scan a string for trigraphs, warning or replacing them inline as
760 appropriate. When parsing a string, we must call this routine
761 before processing a newline character (if trigraphs are enabled),
762 since the newline might be escaped by a preceding backslash
763 trigraph sequence. Returns a pointer to the end of the name after
766 static unsigned char *
767 trigraph_replace (pfile, src, limit)
770 unsigned char *limit;
774 /* Starting with src[1], find two consecutive '?'. The case of no
775 trigraphs is streamlined. */
777 for (src++; src + 1 < limit; src += 2)
782 /* Make src point to the 1st (NOT 2nd) of two consecutive '?'s. */
785 else if (src + 2 == limit || src[1] != '?')
788 /* Check if it really is a trigraph. */
789 if (trigraph_map[src[2]] == 0)
797 /* Now we have a trigraph, we need to scan the remaining buffer, and
798 copy-shifting its contents left if replacement is enabled. */
799 for (; src + 2 < limit; dest++, src++)
800 if ((*dest = *src) == '?' && src[1] == '?' && trigraph_map[src[2]])
804 if (trigraph_ok (pfile, pfile->buffer->cur - (limit - src)))
805 *dest = trigraph_map[*src];
808 /* Copy remaining (at most 2) characters. */
814 /* If CUR is a backslash or the end of a trigraphed backslash, return
815 a pointer to its beginning, otherwise NULL. We don't read beyond
816 the buffer start, because there is the start of the comment in the
818 static const unsigned char *
819 backslash_start (pfile, cur)
821 const unsigned char *cur;
825 if (cur[0] == '/' && cur[-1] == '?' && cur[-2] == '?'
826 && trigraph_ok (pfile, cur))
831 /* Skip a C-style block comment. This is probably the trickiest
832 handler. We find the end of the comment by seeing if an asterisk
833 is before every '/' we encounter. The nasty complication is that a
834 previous asterisk may be separated by one or more escaped newlines.
835 Returns non-zero if comment terminated by EOF, zero otherwise. */
837 skip_block_comment (pfile)
840 cpp_buffer *buffer = pfile->buffer;
841 const unsigned char *char_after_star = 0;
842 const unsigned char *cur = buffer->cur;
844 for (; cur < buffer->rlimit; )
846 unsigned char c = *cur++;
848 /* People like decorating comments with '*', so check for
849 '/' instead for efficiency. */
852 /* Don't view / then * then / as finishing the comment. */
853 if ((cur[-2] == '*' && cur - 1 > buffer->cur)
854 || cur - 1 == char_after_star)
860 /* Warn about potential nested comments, but not when
861 the final character inside the comment is a '/'.
862 Don't bother to get it right across escaped newlines. */
863 if (CPP_OPTION (pfile, warn_comments) && cur + 1 < buffer->rlimit
864 && cur[0] == '*' && cur[1] != '/')
867 cpp_warning (pfile, "'/*' within comment");
870 else if (is_vspace (c))
872 const unsigned char* bslash = backslash_start (pfile, cur - 2);
874 handle_newline (cur, buffer->rlimit, c);
875 /* Work correctly if there is an asterisk before an
876 arbirtrarily long sequence of escaped newlines. */
877 if (bslash && (bslash[-1] == '*' || bslash == char_after_star))
878 char_after_star = cur;
883 adjust_column (pfile, cur - 1);
890 /* Skip a C++ line comment. Handles escaped newlines. Returns
891 non-zero if a multiline comment. */
893 skip_line_comment (pfile)
896 cpp_buffer *buffer = pfile->buffer;
897 register const unsigned char *cur = buffer->cur;
900 for (; cur < buffer->rlimit; )
902 unsigned char c = *cur++;
906 /* Check for a (trigaph?) backslash escaping the newline. */
907 if (!backslash_start (pfile, cur - 2))
910 handle_newline (cur, buffer->rlimit, c);
916 buffer->cur = cur - 1; /* Leave newline for caller. */
920 /* TAB points to a \t character. Update col_adjust so we track the
923 adjust_column (pfile, tab)
927 /* Zero-based column. */
928 unsigned int col = CPP_BUF_COLUMN (pfile->buffer, tab);
930 /* Round it up to multiple of the tabstop, but subtract 1 since the
931 tab itself occupies a character position. */
932 pfile->col_adjust += (CPP_OPTION (pfile, tabstop)
933 - col % CPP_OPTION (pfile, tabstop)) - 1;
936 /* Skips whitespace, stopping at next non-whitespace character.
937 Adjusts pfile->col_adjust to account for tabs. This enables tokens
938 to be assigned the correct column. */
940 skip_whitespace (pfile, in_directive)
944 cpp_buffer *buffer = pfile->buffer;
945 unsigned short warned = 0;
947 /* We only want non-vertical space, i.e. ' ' \t \f \v \0. */
948 while (buffer->cur < buffer->rlimit)
950 unsigned char c = *buffer->cur;
956 /* Horizontal space always OK. */
960 adjust_column (pfile, buffer->cur - 1);
961 /* Must be \f \v or \0. */
965 cpp_warning_with_line (pfile, CPP_BUF_LINE (buffer),
966 CPP_BUF_COL (buffer),
967 "embedded null character ignored");
970 else if (in_directive && CPP_PEDANTIC (pfile))
971 cpp_pedwarn_with_line (pfile, CPP_BUF_LINE (buffer),
972 CPP_BUF_COL (buffer),
973 "%s in preprocessing directive",
974 c == '\f' ? "form feed" : "vertical tab");
978 /* Parse (append) an identifier. Calculates the hash value of the
979 token while parsing, for performance. The algorithm *must* match
981 static const U_CHAR *
982 parse_name (pfile, tok, cur, rlimit)
985 const U_CHAR *cur, *rlimit;
995 if (! is_idchar (*cur))
997 /* $ is not a identifier character in the standard, but is
998 commonly accepted as an extension. Don't warn about it in
999 skipped conditional blocks. */
1000 if (*cur == '$' && CPP_PEDANTIC (pfile) && ! pfile->skipping)
1002 CPP_BUFFER (pfile)->cur = cur;
1003 cpp_pedwarn (pfile, "'$' character in identifier");
1006 r = HASHSTEP (r, cur);
1011 if (tok->type == CPP_NAME && tok->val.node == 0)
1012 tok->val.node = _cpp_lookup_with_hash (pfile, name, len, r);
1015 unsigned int oldlen;
1018 if (tok->type == CPP_NAME)
1019 oldlen = tok->val.node->length;
1023 newname = alloca (oldlen + len);
1025 if (tok->type == CPP_NAME)
1026 memcpy (newname, tok->val.node->name, oldlen);
1028 newname[0] = tok->val.aux;
1029 memcpy (newname + oldlen, name, len);
1030 tok->val.node = cpp_lookup (pfile, newname, len + oldlen);
1031 tok->type = CPP_NAME;
1037 /* Parse (append) a number. */
1039 parse_number (pfile, list, name)
1044 const unsigned char *name_limit;
1045 unsigned char *namebuf;
1046 cpp_buffer *buffer = pfile->buffer;
1047 register const unsigned char *cur = buffer->cur;
1050 name_limit = list->namebuf + list->name_cap;
1051 namebuf = list->namebuf + list->name_used;
1053 for (; cur < buffer->rlimit && namebuf < name_limit; )
1055 unsigned char c = *namebuf = *cur; /* Copy a single char. */
1057 /* Perhaps we should accept '$' here if we accept it for
1058 identifiers. We know namebuf[-1] is safe, because for c to
1059 be a sign we must have pushed at least one character. */
1060 if (!is_numchar (c) && c != '.' && ! VALID_SIGN (c, namebuf[-1]))
1067 /* Run out of name space? */
1068 if (cur < buffer->rlimit)
1070 list->name_used = namebuf - list->namebuf;
1071 auto_expand_name_space (list);
1077 name->len = namebuf - name->text;
1078 list->name_used = namebuf - list->namebuf;
1081 /* Places a string terminated by an unescaped TERMINATOR into a
1082 cpp_string, which should be expandable and thus at the top of the
1083 list's stack. Handles embedded trigraphs, if necessary, and
1086 Can be used for character constants (terminator = '\''), string
1087 constants ('"') and angled headers ('>'). Multi-line strings are
1088 allowed, except for within directives. */
1091 parse_string (pfile, list, token, terminator)
1095 unsigned int terminator;
1097 cpp_buffer *buffer = pfile->buffer;
1098 cpp_string *name = &token->val.str;
1099 register const unsigned char *cur = buffer->cur;
1100 const unsigned char *name_limit;
1101 unsigned char *namebuf;
1102 unsigned int null_count = 0;
1103 unsigned int trigraphed = list->name_used;
1106 name_limit = list->namebuf + list->name_cap;
1107 namebuf = list->namebuf + list->name_used;
1109 for (; cur < buffer->rlimit && namebuf < name_limit; )
1111 unsigned int c = *namebuf++ = *cur++; /* Copy a single char. */
1115 else if (c == terminator || is_vspace (c))
1117 /* Needed for trigraph_replace and multiline string warning. */
1120 /* Scan for trigraphs before checking if backslash-escaped. */
1121 if ((CPP_OPTION (pfile, trigraphs)
1122 || CPP_OPTION (pfile, warn_trigraphs))
1123 && namebuf - (list->namebuf + trigraphed) >= 3)
1125 namebuf = trigraph_replace (pfile, list->namebuf + trigraphed,
1127 /* The test above guarantees trigraphed will be positive. */
1128 trigraphed = namebuf - list->namebuf - 2;
1131 namebuf--; /* Drop the newline / terminator from the name. */
1134 /* Drop a backslash newline, and continue. */
1135 if (namebuf[-1] == '\\')
1137 handle_newline (cur, buffer->rlimit, c);
1144 /* In assembly language, silently terminate strings of
1145 either variety at end of line. This is a kludge
1146 around not knowing where comments are. */
1147 if (CPP_OPTION (pfile, lang_asm))
1150 /* Character constants and header names may not extend
1151 over multiple lines. In Standard C, neither may
1152 strings. We accept multiline strings as an
1153 extension. (Even in directives - otherwise, glibc's
1154 longlong.h breaks.) */
1155 if (terminator != '"')
1158 cur++; /* Move forwards again. */
1160 if (pfile->multiline_string_line == 0)
1162 pfile->multiline_string_line = token->line;
1163 pfile->multiline_string_column = token->col;
1164 if (CPP_PEDANTIC (pfile))
1165 cpp_pedwarn (pfile, "multi-line string constant");
1169 handle_newline (cur, buffer->rlimit, c);
1173 unsigned char *temp;
1175 /* An odd number of consecutive backslashes represents
1176 an escaped terminator. */
1178 while (temp >= name->text && *temp == '\\')
1181 if ((namebuf - temp) & 1)
1188 /* Run out of name space? */
1189 if (cur < buffer->rlimit)
1191 list->name_used = namebuf - list->namebuf;
1192 auto_expand_name_space (list);
1196 /* We may not have trigraph-replaced the input for this code path,
1197 but as the input is in error by being unterminated we don't
1198 bother. Prevent warnings about no newlines at EOF. */
1199 if (is_vspace (cur[-1]))
1203 cpp_error (pfile, "missing terminating %c character", (int) terminator);
1205 if (terminator == '\"' && pfile->multiline_string_line != list->line
1206 && pfile->multiline_string_line != 0)
1208 cpp_error_with_line (pfile, pfile->multiline_string_line,
1209 pfile->multiline_string_column,
1210 "possible start of unterminated string literal");
1211 pfile->multiline_string_line = 0;
1216 name->len = namebuf - name->text;
1217 list->name_used = namebuf - list->namebuf;
1220 cpp_warning (pfile, (null_count > 1 ? "null characters preserved"
1221 : "null character preserved"));
1224 /* The character TYPE helps us distinguish comment types: '*' = C
1225 style, '/' = C++ style. For code simplicity, the stored comment
1226 includes the comment start and any terminator. */
1228 #define COMMENT_START_LEN 2
1230 save_comment (list, token, from, len, type)
1233 const unsigned char *from;
1237 unsigned char *buffer;
1239 len += COMMENT_START_LEN;
1241 if (list->name_used + len > list->name_cap)
1242 _cpp_expand_name_space (list, len);
1244 INIT_TOKEN_STR (list, token);
1245 token->type = CPP_COMMENT;
1246 token->val.str.len = len;
1248 buffer = list->namebuf + list->name_used;
1249 list->name_used += len;
1251 /* Copy the comment. */
1262 memcpy (buffer, from, len - COMMENT_START_LEN);
1266 * The tokenizer's main loop. Returns a token list, representing a
1267 * logical line in the input file. On EOF after some tokens have
1268 * been processed, we return immediately. Then in next call, or if
1269 * EOF occurred at the beginning of a logical line, a single CPP_EOF
1270 * token is placed in the list.
1272 * Implementation relies almost entirely on lookback, rather than
1273 * looking forwards. This means that tokenization requires just
1274 * a single pass of the file, even in the presence of trigraphs and
1275 * escaped newlines, providing significant performance benefits.
1276 * Trigraph overhead is negligible if they are disabled, and low
1277 * even when enabled.
1280 #define KNOWN_DIRECTIVE() (list->directive != 0)
1281 #define MIGHT_BE_DIRECTIVE() \
1282 (cur_token == &list->tokens[first_token + 1] && cur_token[-1].type == CPP_HASH)
1285 lex_line (pfile, list)
1289 cpp_token *cur_token, *token_limit, *first;
1290 cpp_buffer *buffer = pfile->buffer;
1291 const unsigned char *cur = buffer->cur;
1292 unsigned char flags = 0;
1293 unsigned int first_token = list->tokens_used;
1295 if (!(list->flags & LIST_OFFSET))
1299 list->file = buffer->nominal_fname;
1300 list->line = CPP_BUF_LINE (buffer);
1301 pfile->col_adjust = 0;
1302 pfile->in_lex_line = 1;
1303 if (cur == buffer->buf)
1304 list->flags |= BEG_OF_FILE;
1307 token_limit = list->tokens + list->tokens_cap;
1308 cur_token = list->tokens + list->tokens_used;
1310 for (; cur < buffer->rlimit && cur_token < token_limit;)
1314 /* Optimize non-vertical whitespace skipping; most tokens are
1315 probably separated by whitespace. (' ' '\t' '\v' '\f' '\0'). */
1320 skip_whitespace (pfile, (list->tokens[first_token].type == CPP_HASH
1321 && cur_token > &list->tokens[first_token]));
1325 if (cur == buffer->rlimit)
1331 /* Initialize current token. CPP_EOF will not be fixed up by
1332 expand_name_space. */
1333 list->tokens_used = cur_token - list->tokens + 1;
1334 cur_token->type = CPP_EOF;
1335 cur_token->col = CPP_BUF_COLUMN (buffer, cur);
1336 cur_token->line = CPP_BUF_LINE (buffer);
1337 cur_token->flags = flags;
1342 case '0': case '1': case '2': case '3': case '4':
1343 case '5': case '6': case '7': case '8': case '9':
1347 cur--; /* Backup character. */
1348 prev_dot = PREV_TOKEN_TYPE == CPP_DOT && IMMED_TOKEN ();
1351 INIT_TOKEN_STR (list, cur_token);
1352 /* Prepend an immediately previous CPP_DOT token. */
1355 if (list->name_cap == list->name_used)
1356 auto_expand_name_space (list);
1358 cur_token->val.str.len = 1;
1359 list->namebuf[list->name_used++] = '.';
1363 cur_token->type = CPP_NUMBER; /* Before parse_number. */
1365 parse_number (pfile, list, &cur_token->val.str);
1368 /* Check for # 123 form of #line. */
1369 if (MIGHT_BE_DIRECTIVE ())
1370 list->directive = _cpp_check_linemarker (pfile, cur_token,
1371 !(cur_token[-1].flags
1378 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
1379 case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
1380 case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
1381 case 's': case 't': case 'u': case 'v': case 'w': case 'x':
1383 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
1384 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
1385 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
1386 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
1388 cur--; /* Backup character. */
1390 /* In Objective C, '@' may begin certain keywords. */
1391 if (CPP_OPTION (pfile, objc) && cur_token[-1].type == CPP_OTHER
1392 && cur_token[-1].val.aux == '@' && IMMED_TOKEN ())
1396 cur_token->val.node = 0;
1397 cur_token->type = CPP_NAME; /* Identifier, macro etc. */
1401 cur = parse_name (pfile, cur_token, cur, buffer->rlimit);
1403 if (MIGHT_BE_DIRECTIVE ())
1404 list->directive = _cpp_check_directive (pfile, cur_token,
1405 !(list->tokens[0].flags
1407 /* Convert named operators to their proper types. */
1408 if (cur_token->val.node->type == T_OPERATOR)
1410 cur_token->flags |= NAMED_OP;
1411 cur_token->type = cur_token->val.node->value.code;
1418 cur_token->type = CPP_CHAR;
1419 if (cur_token[-1].type == CPP_NAME && IMMED_TOKEN ()
1420 && cur_token[-1].val.node == pfile->spec_nodes->n_L)
1421 BACKUP_TOKEN (CPP_WCHAR);
1422 goto do_parse_string;
1425 cur_token->type = CPP_STRING;
1426 if (cur_token[-1].type == CPP_NAME && IMMED_TOKEN ()
1427 && cur_token[-1].val.node == pfile->spec_nodes->n_L)
1428 BACKUP_TOKEN (CPP_WSTRING);
1429 else if (CPP_OPTION (pfile, objc)
1430 && cur_token[-1].type == CPP_OTHER && IMMED_TOKEN ()
1431 && cur_token[-1].val.aux == '@')
1432 BACKUP_TOKEN (CPP_OSTRING);
1435 /* Here c is one of ' " or >. */
1436 INIT_TOKEN_STR (list, cur_token);
1438 parse_string (pfile, list, cur_token, c);
1444 cur_token->type = CPP_DIV;
1447 if (PREV_TOKEN_TYPE == CPP_DIV)
1449 /* We silently allow C++ comments in system headers,
1450 irrespective of conformance mode, because lots of
1451 broken systems do that and trying to clean it up
1452 in fixincludes is a nightmare. */
1453 if (CPP_IN_SYSTEM_HEADER (pfile))
1454 goto do_line_comment;
1455 else if (CPP_OPTION (pfile, cplusplus_comments))
1457 if (CPP_OPTION (pfile, c89) && CPP_PEDANTIC (pfile)
1458 && ! buffer->warned_cplusplus_comments)
1462 "C++ style comments are not allowed in ISO C89");
1464 "(this will be reported only once per input file)");
1465 buffer->warned_cplusplus_comments = 1;
1469 #if 0 /* Leave until new lexer in place. */
1472 "comment start split across lines");
1474 if (skip_line_comment (pfile))
1475 cpp_warning (pfile, "multi-line comment");
1477 /* Back-up to first '-' or '/'. */
1479 if (!CPP_OPTION (pfile, discard_comments)
1480 && (!KNOWN_DIRECTIVE()
1481 || (list->directive->flags & COMMENTS)))
1482 save_comment (list, cur_token++, cur,
1483 buffer->cur - cur, c);
1496 cur_token->type = CPP_MULT;
1499 if (PREV_TOKEN_TYPE == CPP_DIV)
1502 #if 0 /* Leave until new lexer in place. */
1505 "comment start '/*' split across lines");
1507 if (skip_block_comment (pfile))
1508 cpp_error_with_line (pfile, list->line, cur_token[-1].col,
1509 "unterminated comment");
1510 #if 0 /* Leave until new lexer in place. */
1511 else if (buffer->cur[-2] != '*')
1513 "comment end '*/' split across lines");
1515 /* Back up to opening '/'. */
1517 if (!CPP_OPTION (pfile, discard_comments)
1518 && (!KNOWN_DIRECTIVE()
1519 || (list->directive->flags & COMMENTS)))
1520 save_comment (list, cur_token++, cur,
1521 buffer->cur - cur, c);
1528 else if (CPP_OPTION (pfile, cplusplus))
1530 /* In C++, there are .* and ->* operators. */
1531 if (PREV_TOKEN_TYPE == CPP_DEREF)
1532 BACKUP_TOKEN (CPP_DEREF_STAR);
1533 else if (PREV_TOKEN_TYPE == CPP_DOT)
1534 BACKUP_TOKEN (CPP_DOT_STAR);
1542 handle_newline (cur, buffer->rlimit, c);
1543 if (PREV_TOKEN_TYPE == CPP_BACKSLASH)
1547 /* Remove the escaped newline. Then continue to process
1548 any interrupted name or number. */
1550 /* Backslash-newline may not be immediately followed by
1551 EOF (C99 5.1.1.2). */
1552 if (cur >= buffer->rlimit)
1554 cpp_pedwarn (pfile, "backslash-newline at end of file");
1560 if (cur_token->type == CPP_NAME)
1562 else if (cur_token->type == CPP_NUMBER)
1563 goto continue_number;
1566 /* Remember whitespace setting. */
1567 flags = cur_token->flags;
1574 "backslash and newline separated by space");
1577 else if (MIGHT_BE_DIRECTIVE ())
1579 /* "Null directive." C99 6.10.7: A preprocessing
1580 directive of the form # <new-line> has no effect.
1582 But it is still a directive, and therefore disappears
1585 if (cur_token->flags & PREV_WHITE
1586 && CPP_WTRADITIONAL (pfile))
1587 cpp_warning (pfile, "K+R C ignores #\\n with the # indented");
1590 /* Skip vertical space until we have at least one token to
1592 if (cur_token != &list->tokens[first_token])
1594 list->line = CPP_BUF_LINE (buffer);
1598 if (IMMED_TOKEN () && PREV_TOKEN_TYPE == CPP_MINUS)
1599 REVISE_TOKEN (CPP_MINUS_MINUS);
1601 PUSH_TOKEN (CPP_MINUS);
1606 /* The digraph flag checking ensures that ## and %:%:
1607 are interpreted as CPP_PASTE, but #%: and %:# are not. */
1608 if (PREV_TOKEN_TYPE == CPP_HASH && IMMED_TOKEN ()
1609 && ((cur_token->flags ^ cur_token[-1].flags) & DIGRAPH) == 0)
1610 REVISE_TOKEN (CPP_PASTE);
1612 PUSH_TOKEN (CPP_HASH);
1616 cur_token->type = CPP_COLON;
1619 if (PREV_TOKEN_TYPE == CPP_COLON
1620 && CPP_OPTION (pfile, cplusplus))
1621 BACKUP_TOKEN (CPP_SCOPE);
1622 else if (CPP_OPTION (pfile, digraphs))
1624 /* Digraph: "<:" is a '[' */
1625 if (PREV_TOKEN_TYPE == CPP_LESS)
1626 BACKUP_DIGRAPH (CPP_OPEN_SQUARE);
1627 /* Digraph: "%:" is a '#' */
1628 else if (PREV_TOKEN_TYPE == CPP_MOD)
1630 (--cur_token)->flags |= DIGRAPH;
1639 if (IMMED_TOKEN () && PREV_TOKEN_TYPE == CPP_AND)
1640 REVISE_TOKEN (CPP_AND_AND);
1642 PUSH_TOKEN (CPP_AND);
1647 if (IMMED_TOKEN () && PREV_TOKEN_TYPE == CPP_OR)
1648 REVISE_TOKEN (CPP_OR_OR);
1650 PUSH_TOKEN (CPP_OR);
1654 if (IMMED_TOKEN () && PREV_TOKEN_TYPE == CPP_PLUS)
1655 REVISE_TOKEN (CPP_PLUS_PLUS);
1657 PUSH_TOKEN (CPP_PLUS);
1661 /* This relies on equidistance of "?=" and "?" tokens. */
1662 if (IMMED_TOKEN () && PREV_TOKEN_TYPE <= CPP_LAST_EQ)
1663 REVISE_TOKEN (PREV_TOKEN_TYPE + (CPP_EQ_EQ - CPP_EQ));
1665 PUSH_TOKEN (CPP_EQ);
1669 cur_token->type = CPP_GREATER;
1672 if (PREV_TOKEN_TYPE == CPP_GREATER)
1673 BACKUP_TOKEN (CPP_RSHIFT);
1674 else if (PREV_TOKEN_TYPE == CPP_MINUS)
1675 BACKUP_TOKEN (CPP_DEREF);
1676 else if (CPP_OPTION (pfile, digraphs))
1678 /* Digraph: ":>" is a ']' */
1679 if (PREV_TOKEN_TYPE == CPP_COLON)
1680 BACKUP_DIGRAPH (CPP_CLOSE_SQUARE);
1681 /* Digraph: "%>" is a '}' */
1682 else if (PREV_TOKEN_TYPE == CPP_MOD)
1683 BACKUP_DIGRAPH (CPP_CLOSE_BRACE);
1690 if (IMMED_TOKEN () && PREV_TOKEN_TYPE == CPP_LESS)
1692 REVISE_TOKEN (CPP_LSHIFT);
1695 /* Is this the beginning of a header name? */
1696 if (KNOWN_DIRECTIVE () && (list->directive->flags & INCL))
1698 c = '>'; /* Terminator. */
1699 cur_token->type = CPP_HEADER_NAME;
1700 goto do_parse_string;
1702 PUSH_TOKEN (CPP_LESS);
1706 /* Digraph: "<%" is a '{' */
1707 cur_token->type = CPP_MOD;
1708 if (IMMED_TOKEN () && PREV_TOKEN_TYPE == CPP_LESS
1709 && CPP_OPTION (pfile, digraphs))
1710 BACKUP_DIGRAPH (CPP_OPEN_BRACE);
1715 if (cur + 1 < buffer->rlimit && *cur == '?'
1716 && trigraph_map[cur[1]] && trigraph_ok (pfile, cur + 1))
1718 /* Handle trigraph. */
1722 case '(': goto make_open_square;
1723 case ')': goto make_close_square;
1724 case '<': goto make_open_brace;
1725 case '>': goto make_close_brace;
1726 case '=': goto make_hash;
1727 case '!': goto make_or;
1728 case '-': goto make_complement;
1729 case '/': goto make_backslash;
1730 case '\'': goto make_xor;
1733 if (IMMED_TOKEN () && CPP_OPTION (pfile, cplusplus))
1735 /* GNU C++ defines <? and >? operators. */
1736 if (PREV_TOKEN_TYPE == CPP_LESS)
1738 REVISE_TOKEN (CPP_MIN);
1741 else if (PREV_TOKEN_TYPE == CPP_GREATER)
1743 REVISE_TOKEN (CPP_MAX);
1747 PUSH_TOKEN (CPP_QUERY);
1751 if (PREV_TOKEN_TYPE == CPP_DOT && cur_token[-2].type == CPP_DOT
1753 && !(cur_token[-1].flags & PREV_WHITE))
1756 PUSH_TOKEN (CPP_ELLIPSIS);
1759 PUSH_TOKEN (CPP_DOT);
1763 case '~': PUSH_TOKEN (CPP_COMPL); break;
1765 case '^': PUSH_TOKEN (CPP_XOR); break;
1767 case '{': PUSH_TOKEN (CPP_OPEN_BRACE); break;
1769 case '}': PUSH_TOKEN (CPP_CLOSE_BRACE); break;
1771 case '[': PUSH_TOKEN (CPP_OPEN_SQUARE); break;
1773 case ']': PUSH_TOKEN (CPP_CLOSE_SQUARE); break;
1775 case '\\': PUSH_TOKEN (CPP_BACKSLASH); break;
1776 case '!': PUSH_TOKEN (CPP_NOT); break;
1777 case ',': PUSH_TOKEN (CPP_COMMA); break;
1778 case ';': PUSH_TOKEN (CPP_SEMICOLON); break;
1779 case '(': PUSH_TOKEN (CPP_OPEN_PAREN); break;
1780 case ')': PUSH_TOKEN (CPP_CLOSE_PAREN); break;
1783 if (CPP_OPTION (pfile, dollars_in_ident))
1787 cur_token->val.aux = c;
1788 PUSH_TOKEN (CPP_OTHER);
1793 /* Run out of token space? */
1794 if (cur_token == token_limit)
1796 list->tokens_used = cur_token - list->tokens;
1797 _cpp_expand_token_space (list, 256);
1801 cur_token->flags = flags;
1802 if (cur_token == &list->tokens[first_token] && pfile->done_initializing)
1804 if (cur > buffer->buf && !is_vspace (cur[-1]))
1805 cpp_pedwarn_with_line (pfile, CPP_BUF_LINE (buffer),
1806 CPP_BUF_COLUMN (buffer, cur),
1807 "no newline at end of file");
1808 cur_token++->type = CPP_EOF;
1812 /* All tokens are allocated, so the memory location is fixed. */
1813 first = &list->tokens[first_token];
1815 /* Don't complain about the null directive, nor directives in
1816 assembly source: we don't know where the comments are, and # may
1817 introduce assembler pseudo-ops. Don't complain about invalid
1818 directives in skipped conditional groups (6.10 p4). */
1819 if (first->type == CPP_HASH && list->directive == 0 && !pfile->skipping
1820 && cur_token > first + 1 && !CPP_OPTION (pfile, lang_asm))
1822 if (first[1].type == CPP_NAME)
1823 cpp_error (pfile, "invalid preprocessing directive #%s",
1824 first[1].val.node->name);
1826 cpp_error (pfile, "invalid preprocessing directive");
1828 /* Discard this line to prevent further errors from cc1. */
1829 _cpp_clear_toklist (list);
1833 /* Put EOF at end of known directives. This covers "directives do
1834 not extend beyond the end of the line (description 6.10 part 2)". */
1835 if (KNOWN_DIRECTIVE () || !pfile->done_initializing)
1837 pfile->first_directive_token = first;
1838 cur_token++->type = CPP_EOF;
1841 first->flags |= BOL;
1842 if (first_token != 0)
1843 /* 6.10.3.10: Within the sequence of preprocessing tokens making
1844 up the invocation of a function-like macro, new line is
1845 considered a normal white-space character. */
1846 first->flags |= PREV_WHITE;
1849 list->tokens_used = cur_token - list->tokens;
1850 pfile->in_lex_line = 0;
1853 /* Write the spelling of a token TOKEN, with any appropriate
1854 whitespace before it, to FP. PREV is the previous token, which
1855 is used to determine if we need to shove in an extra space in order
1856 to avoid accidental token paste. If WHITE is 0, do not insert any
1857 leading whitespace. */
1859 output_token (pfile, fp, token, prev, white)
1862 const cpp_token *token, *prev;
1869 if (token->col && (token->flags & BOL))
1871 /* Supply enough whitespace to put this token in its original
1872 column. Don't bother trying to reconstruct tabs; we can't
1873 get it right in general, and nothing ought to care. (Yes,
1874 some things do care; the fault lies with them.) */
1875 unsigned int spaces = token->col - 1;
1880 else if (token->flags & PREV_WHITE)
1883 /* Check for and prevent accidental token pasting.
1884 In addition to the cases handled by can_paste, consider
1886 a + ++b - if there is not a space between the + and ++, it
1887 will be misparsed as a++ + b. But + ## ++ doesn't produce
1890 && (can_paste (pfile, prev, token, &dummy) != CPP_EOF
1891 || (prev->type == CPP_PLUS && token->type == CPP_PLUS_PLUS)
1892 || (prev->type == CPP_MINUS && token->type == CPP_MINUS_MINUS)))
1896 switch (TOKEN_SPELL (token))
1898 case SPELL_OPERATOR:
1900 const unsigned char *spelling;
1902 if (token->flags & DIGRAPH)
1903 spelling = digraph_spellings[token->type - CPP_FIRST_DIGRAPH];
1904 else if (token->flags & NAMED_OP)
1907 spelling = TOKEN_NAME (token);
1909 ufputs (spelling, fp);
1915 ufputs (token->val.node->name, fp);
1920 int left, right, tag;
1921 switch (token->type)
1923 case CPP_STRING: left = '"'; right = '"'; tag = '\0'; break;
1924 case CPP_WSTRING: left = '"'; right = '"'; tag = 'L'; break;
1925 case CPP_OSTRING: left = '"'; right = '"'; tag = '@'; break;
1926 case CPP_CHAR: left = '\''; right = '\''; tag = '\0'; break;
1927 case CPP_WCHAR: left = '\''; right = '\''; tag = 'L'; break;
1928 case CPP_HEADER_NAME: left = '<'; right = '>'; tag = '\0'; break;
1929 default: left = '\0'; right = '\0'; tag = '\0'; break;
1931 if (tag) putc (tag, fp);
1932 if (left) putc (left, fp);
1933 fwrite (token->val.str.text, 1, token->val.str.len, fp);
1934 if (right) putc (right, fp);
1939 putc (token->val.aux, fp);
1943 /* Placemarker or EOF - no output. (Macro args are handled
1949 /* Dump the original user's spelling of argument index ARG_NO to the
1950 macro whose expansion is LIST. */
1952 dump_param_spelling (fp, list, arg_no)
1954 const cpp_toklist *list;
1955 unsigned int arg_no;
1957 const U_CHAR *param = list->namebuf;
1960 param += ustrlen (param) + 1;
1964 /* Output all the tokens of LIST, starting at TOKEN, to FP. */
1966 cpp_output_list (pfile, fp, list, token)
1969 const cpp_toklist *list;
1970 const cpp_token *token;
1972 const cpp_token *limit = list->tokens + list->tokens_used;
1973 const cpp_token *prev = 0;
1976 while (token < limit)
1978 /* XXX Find some way we can write macro args from inside
1979 output_token/spell_token. */
1980 if (token->type == CPP_MACRO_ARG)
1982 if (white && token->flags & PREV_WHITE)
1984 if (token->flags & STRINGIFY_ARG)
1986 dump_param_spelling (fp, list, token->val.aux);
1989 output_token (pfile, fp, token, prev, white);
1990 if (token->flags & PASTE_LEFT)
1999 /* Write the spelling of a token TOKEN to BUFFER. The buffer must
2000 already contain the enough space to hold the token's spelling.
2001 Returns a pointer to the character after the last character
2004 static unsigned char *
2005 spell_token (pfile, token, buffer)
2006 cpp_reader *pfile; /* Would be nice to be rid of this... */
2007 const cpp_token *token;
2008 unsigned char *buffer;
2010 switch (TOKEN_SPELL (token))
2012 case SPELL_OPERATOR:
2014 const unsigned char *spelling;
2017 if (token->flags & DIGRAPH)
2018 spelling = digraph_spellings[token->type - CPP_FIRST_DIGRAPH];
2019 else if (token->flags & NAMED_OP)
2022 spelling = TOKEN_NAME (token);
2024 while ((c = *spelling++) != '\0')
2031 memcpy (buffer, token->val.node->name, token->val.node->length);
2032 buffer += token->val.node->length;
2037 int left, right, tag;
2038 switch (token->type)
2040 case CPP_STRING: left = '"'; right = '"'; tag = '\0'; break;
2041 case CPP_WSTRING: left = '"'; right = '"'; tag = 'L'; break;
2042 case CPP_OSTRING: left = '"'; right = '"'; tag = '@'; break;
2043 case CPP_CHAR: left = '\''; right = '\''; tag = '\0'; break;
2044 case CPP_WCHAR: left = '\''; right = '\''; tag = 'L'; break;
2045 case CPP_HEADER_NAME: left = '<'; right = '>'; tag = '\0'; break;
2046 default: left = '\0'; right = '\0'; tag = '\0'; break;
2048 if (tag) *buffer++ = tag;
2049 if (left) *buffer++ = left;
2050 memcpy (buffer, token->val.str.text, token->val.str.len);
2051 buffer += token->val.str.len;
2052 if (right) *buffer++ = right;
2057 *buffer++ = token->val.aux;
2061 cpp_ice (pfile, "Unspellable token %s", TOKEN_NAME (token));
2068 /* Macro expansion algorithm.
2070 Macro expansion is implemented by a single-pass algorithm; there are
2071 no rescan passes involved. cpp_get_token expands just enough to be
2072 able to return a token to the caller, a consequence is that when it
2073 returns the preprocessor can be in a state of mid-expansion. The
2074 algorithm does not work by fully expanding a macro invocation into
2075 some kind of token list, and then returning them one by one.
2077 Our expansion state is recorded in a context stack. We start out with
2078 a single context on the stack, let's call it base context. This
2079 consists of the token list returned by lex_line that forms the next
2080 logical line in the source file.
2082 The current level in the context stack is stored in the cur_context
2083 member of the cpp_reader structure. The context it references keeps,
2084 amongst other things, a count of how many tokens form that context and
2085 our position within those tokens.
2087 Fundamentally, calling cpp_get_token will return the next token from
2088 the current context. If we're at the end of the current context, that
2089 context is popped from the stack first, unless it is the base context,
2090 in which case the next logical line is lexed from the source file.
2092 However, before returning the token, if it is a CPP_NAME token
2093 _cpp_get_token checks to see if it is a macro and if it is enabled.
2094 Each time it encounters a macro name, it calls push_macro_context.
2095 This function checks that the macro should be expanded (with
2096 is_macro_enabled), and if so pushes a new macro context on the stack
2097 which becomes the current context. It then loops back to read the
2098 first token of the macro context.
2100 A macro context basically consists of the token list representing the
2101 macro's replacement list, which was saved in the hash table by
2102 save_macro_expansion when its #define statement was parsed. If the
2103 macro is function-like, it also contains the tokens that form the
2104 arguments to the macro. I say more about macro arguments below, but
2105 for now just saying that each argument is a set of pointers to tokens
2108 When taking tokens from a macro context, we may get a CPP_MACRO_ARG
2109 token. This represents an argument passed to the macro, with the
2110 argument number stored in the token's AUX field. The argument should
2111 be substituted, this is achieved by pushing an "argument context". An
2112 argument context is just refers to the tokens forming the argument,
2113 which are obtained directly from the macro context. The STRINGIFY
2114 flag on a CPP_MACRO_ARG token indicates that the argument should be
2117 Here's a few simple rules the context stack obeys:-
2119 1) The lex_line token list is always context zero.
2121 2) Context 1, if it exists, must be a macro context.
2123 3) An argument context can only appear above a macro context.
2125 4) A macro context can appear above the base context, another macro
2126 context, or an argument context.
2128 5) These imply that the minimal level of an argument context is 2.
2130 The only tricky thing left is ensuring that macros are enabled and
2131 disabled correctly. The algorithm controls macro expansion by the
2132 level of the context a token is taken from in the context stack. If a
2133 token is taken from a level equal to no_expand_level (a member of
2134 struct cpp_reader), no expansion is performed.
2136 When popping a context off the stack, if no_expand_level equals the
2137 level of the popped context, it is reduced by one to match the new
2138 context level, so that expansion is still disabled. It does not
2139 increase if a context is pushed, though. It starts out life as
2140 UINT_MAX, which has the effect that initially macro expansion is
2141 enabled. I explain how this mechanism works below.
2143 The standard requires:-
2145 1) Arguments to be fully expanded before substitution.
2147 2) Stringified arguments to not be expanded, nor the tokens
2148 immediately surrounding a ## operator.
2150 3) Continual rescanning until there are no more macros left to
2153 4) Once a macro has been expanded in stage 1) or 3), it cannot be
2154 expanded again during later rescans. This prevents infinite
2157 The first thing to observe is that stage 3) is mostly redundant.
2158 Since a macro is disabled once it has been expanded, how can a rescan
2159 find an unexpanded macro name? There are only two cases where this is
2162 a) If the macro name results from a token paste operation.
2164 b) If the macro in question is a function-like macro that hasn't
2165 already been expanded because previously there was not the required
2166 '(' token immediately following it. This is only possible when an
2167 argument is substituted, and after substitution the last token of
2168 the argument can bind with a parenthesis appearing in the tokens
2169 following the substitution. Note that if the '(' appears within the
2170 argument, the ')' must too, as expanding macro arguments cannot
2171 "suck in" tokens outside the argument.
2173 So we tackle this as follows. When parsing the macro invocation for
2174 arguments, we record the tokens forming each argument as a list of
2175 pointers to those tokens. We do not expand any tokens that are "raw",
2176 i.e. directly from the macro invocation, but other tokens that come
2177 from (nested) argument substitution are fully expanded.
2179 This is achieved by setting the no_expand_level to that of the macro
2180 invocation. A CPP_MACRO_ARG token never appears in the list of tokens
2181 forming an argument, because parse_args (indirectly) calls
2182 get_raw_token which automatically pushes argument contexts and traces
2183 into them. Since these contexts are at a higher level than the
2184 no_expand_level, they get fully macro expanded.
2186 "Raw" and non-raw tokens are separated in arguments by null pointers,
2187 with the policy that the initial state of an argument is raw. If the
2188 first token is not raw, it should be preceded by a null pointer. When
2189 tracing through the tokens of an argument context, each time
2190 get_raw_token encounters a null pointer, it toggles the flag
2193 This flag, when set, indicates to is_macro_disabled that we are
2194 reading raw tokens which should be macro-expanded. Similarly, if
2195 clear, is_macro_disabled suppresses re-expansion.
2197 It's probably time for an example.
2201 #define xstr(y) str(y hash)
2203 xstr(hash) // "# hash"
2205 In the invocation of str, parse_args turns off macro expansion and so
2206 parses the argument as <hash>. This is the only token (pointer)
2207 passed as the argument to str. Since <hash> is raw there is no need
2208 for an initial null pointer. stringify_arg is called from
2209 get_raw_token when tracing through the expansion of str, since the
2210 argument has the STRINGIFY flag set. stringify_arg turns off
2211 macro_expansion by setting the no_expand_level to that of the argument
2212 context. Thus it gets the token <hash> and stringifies it to "hash"
2215 Similary xstr is passed <hash>. However, when parse_args is parsing
2216 the invocation of str() in xstr's expansion, get_raw_token encounters
2217 a CPP_MACRO_ARG token for y. Transparently to parse_args, it pushes
2218 an argument context, and enters the tokens of the argument,
2219 i.e. <hash>. This is at a higher context level than parse_args
2220 disabled, and so is_macro_disabled permits expansion of it and a macro
2221 context is pushed on top of the argument context. This contains the
2222 <#> token, and the end result is that <hash> is macro expanded.
2223 However, after popping off the argument context, the <hash> of xstr's
2224 expansion does not get macro expanded because we're back at the
2225 no_expand_level. The end result is that the argument passed to str is
2226 <NULL> <#> <NULL> <hash>. Note the nulls - policy is we start off
2227 raw, <#> is not raw, but then <hash> is.
2232 /* Free the storage allocated for macro arguments. */
2234 free_macro_args (args)
2238 free ((PTR) args->tokens);
2243 /* Determines if a macro has been already used (and is therefore
2246 is_macro_disabled (pfile, expansion, token)
2248 const cpp_toklist *expansion;
2249 const cpp_token *token;
2251 cpp_context *context = CURRENT_CONTEXT (pfile);
2253 /* Don't expand anything if this file has already been preprocessed. */
2254 if (CPP_OPTION (pfile, preprocessed))
2257 /* Arguments on either side of ## are inserted in place without
2258 macro expansion (6.10.3.3.2). Conceptually, any macro expansion
2259 occurs during a later rescan pass. The effect is that we expand
2260 iff we would as part of the macro's expansion list, so we should
2261 drop to the macro's context. */
2262 if (IS_ARG_CONTEXT (context))
2264 if (token->flags & PASTED)
2266 else if (!(context->flags & CONTEXT_RAW))
2268 else if (context->flags & (CONTEXT_PASTEL | CONTEXT_PASTER))
2272 /* Have we already used this macro? */
2273 while (context->level > 0)
2275 if (!IS_ARG_CONTEXT (context) && context->u.list == expansion)
2277 /* Raw argument tokens are judged based on the token list they
2279 if (context->flags & CONTEXT_RAW)
2280 context = pfile->contexts + context->level;
2285 /* Function-like macros may be disabled if the '(' is not in the
2286 current context. We check this without disrupting the context
2288 if (expansion->paramc >= 0)
2290 const cpp_token *next;
2291 unsigned int prev_nme;
2293 context = CURRENT_CONTEXT (pfile);
2294 /* Drop down any contexts we're at the end of: the '(' may
2295 appear in lower macro expansions, or in the rest of the file. */
2296 while (context->posn == context->count && context > pfile->contexts)
2299 /* If we matched, we are disabled, as we appear in the
2300 expansion of each macro we meet. */
2301 if (!IS_ARG_CONTEXT (context) && context->u.list == expansion)
2305 prev_nme = pfile->no_expand_level;
2306 pfile->no_expand_level = context - pfile->contexts;
2307 next = _cpp_get_token (pfile);
2308 restore_macro_expansion (pfile, prev_nme);
2309 if (next->type != CPP_OPEN_PAREN)
2311 _cpp_push_token (pfile, next);
2312 if (CPP_WTRADITIONAL (pfile))
2314 "function macro %s must be used with arguments in traditional C",
2315 token->val.node->name);
2323 /* Add a token to the set of tokens forming the arguments to the macro
2324 being parsed in parse_args. */
2326 save_token (args, token)
2328 const cpp_token *token;
2330 if (args->used == args->capacity)
2332 args->capacity += args->capacity + 100;
2333 args->tokens = (const cpp_token **)
2334 xrealloc ((PTR) args->tokens,
2335 args->capacity * sizeof (const cpp_token *));
2337 args->tokens[args->used++] = token;
2340 /* Take and save raw tokens until we finish one argument. Empty
2341 arguments are saved as a single CPP_PLACEMARKER token. */
2342 static const cpp_token *
2343 parse_arg (pfile, var_args, paren_context, args, pcount)
2346 unsigned int paren_context;
2348 unsigned int *pcount;
2350 const cpp_token *token;
2351 unsigned int paren = 0, count = 0;
2352 int raw, was_raw = 1;
2354 for (count = 0;; count++)
2356 token = _cpp_get_token (pfile);
2358 switch (token->type)
2363 case CPP_OPEN_PAREN:
2367 case CPP_CLOSE_PAREN:
2373 /* Commas are not terminators within parantheses or var_args. */
2374 if (paren || var_args)
2378 case CPP_EOF: /* Error reported by caller. */
2382 raw = pfile->cur_context <= paren_context;
2386 save_token (args, 0);
2389 save_token (args, token);
2395 /* Duplicate the placemarker. Then we can set its flags and
2396 position and safely be using more than one. */
2397 save_token (args, duplicate_token (pfile, &placemarker_token));
2405 /* This macro returns true if the argument starting at offset O of arglist
2406 A is empty - that is, it's either a single PLACEMARKER token, or a null
2407 pointer followed by a PLACEMARKER. */
2409 #define empty_argument(A, O) \
2410 ((A)->tokens[O] ? (A)->tokens[O]->type == CPP_PLACEMARKER \
2411 : (A)->tokens[(O)+1]->type == CPP_PLACEMARKER)
2413 /* Parse the arguments making up a macro invocation. Nested arguments
2414 are automatically macro expanded, but immediate macros are not
2415 expanded; this enables e.g. operator # to work correctly. Returns
2416 non-zero on error. */
2418 parse_args (pfile, hp, args)
2423 const cpp_token *token;
2424 const cpp_toklist *macro;
2425 unsigned int total = 0;
2426 unsigned int paren_context = pfile->cur_context;
2429 macro = hp->value.expansion;
2434 token = parse_arg (pfile, (argc + 1 == macro->paramc
2435 && (macro->flags & VAR_ARGS)),
2436 paren_context, args, &count);
2437 if (argc < macro->paramc)
2440 args->ends[argc] = total;
2444 while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
2446 if (token->type == CPP_EOF)
2448 cpp_error(pfile, "unterminated argument list for macro \"%s\"", hp->name);
2451 else if (argc < macro->paramc)
2453 /* A rest argument is allowed to not appear in the invocation at all.
2454 e.g. #define debug(format, args...) ...
2456 This is exactly the same as if the rest argument had received no
2457 tokens - debug("string",); This extension is deprecated. */
2459 if (argc + 1 == macro->paramc && (macro->flags & VAR_ARGS))
2461 /* Duplicate the placemarker. Then we can set its flags and
2462 position and safely be using more than one. */
2463 cpp_token *pm = duplicate_token (pfile, &placemarker_token);
2464 pm->flags = VOID_REST;
2465 save_token (args, pm);
2466 args->ends[argc] = total + 1;
2468 if (CPP_OPTION (pfile, c99) && CPP_PEDANTIC (pfile))
2469 cpp_pedwarn (pfile, "ISO C99 requires rest arguments to be used");
2475 cpp_error (pfile, "not enough arguments for macro \"%s\"", hp->name);
2479 /* An empty argument to an empty function-like macro is fine. */
2480 else if (argc > macro->paramc
2481 && !(macro->paramc == 0 && argc == 1 && empty_argument (args, 0)))
2483 cpp_error (pfile, "too many arguments for macro \"%s\"", hp->name);
2490 /* Adds backslashes before all backslashes and double quotes appearing
2491 in strings. Non-printable characters are converted to octal. */
2493 quote_string (dest, src, len)
2502 if (c == '\\' || c == '"')
2513 sprintf ((char *) dest, "\\%03o", c);
2522 /* Allocates a buffer to hold a token's TEXT, and converts TOKEN to a
2523 CPP_STRING token containing TEXT in quoted form. */
2525 make_string_token (token, text, len)
2532 buf = (U_CHAR *) xmalloc (len * 4);
2533 token->type = CPP_STRING;
2535 token->val.str.text = buf;
2536 token->val.str.len = quote_string (buf, text, len) - buf;
2540 /* Allocates and converts a temporary token to a CPP_NUMBER token,
2541 evaluating to NUMBER. */
2543 alloc_number_token (pfile, number)
2550 result = get_temp_token (pfile);
2552 sprintf (buf, "%d", number);
2554 result->type = CPP_NUMBER;
2556 result->val.str.text = (U_CHAR *) buf;
2557 result->val.str.len = strlen (buf);
2561 /* Returns a temporary token from the temporary token store of PFILE. */
2563 get_temp_token (pfile)
2566 if (pfile->temp_used == pfile->temp_alloced)
2568 if (pfile->temp_used == pfile->temp_cap)
2570 pfile->temp_cap += pfile->temp_cap + 20;
2571 pfile->temp_tokens = (cpp_token **) xrealloc
2572 (pfile->temp_tokens, pfile->temp_cap * sizeof (cpp_token *));
2574 pfile->temp_tokens[pfile->temp_alloced++] = (cpp_token *) xmalloc
2575 (sizeof (cpp_token));
2578 return pfile->temp_tokens[pfile->temp_used++];
2581 /* Release (not free) for re-use the temporary tokens of PFILE. */
2583 release_temp_tokens (pfile)
2586 while (pfile->temp_used)
2588 cpp_token *token = pfile->temp_tokens[--pfile->temp_used];
2590 if (TOKEN_SPELL (token) == SPELL_STRING)
2592 free ((char *) token->val.str.text);
2593 token->val.str.text = 0;
2598 /* Free all of PFILE's dynamically-allocated temporary tokens. */
2600 _cpp_free_temp_tokens (pfile)
2603 if (pfile->temp_tokens)
2605 /* It is possible, though unlikely (looking for '(' of a funlike
2606 macro into EOF), that we haven't released the tokens yet. */
2607 release_temp_tokens (pfile);
2608 while (pfile->temp_alloced)
2609 free (pfile->temp_tokens[--pfile->temp_alloced]);
2610 free (pfile->temp_tokens);
2615 free ((char *) pfile->date->val.str.text);
2617 free ((char *) pfile->time->val.str.text);
2622 /* Copy TOKEN into a temporary token from PFILE's store. */
2624 duplicate_token (pfile, token)
2626 const cpp_token *token;
2628 cpp_token *result = get_temp_token (pfile);
2631 if (TOKEN_SPELL (token) == SPELL_STRING)
2633 U_CHAR *buff = (U_CHAR *) xmalloc (token->val.str.len);
2634 memcpy (buff, token->val.str.text, token->val.str.len);
2635 result->val.str.text = buff;
2640 /* Determine whether two tokens can be pasted together, and if so,
2641 what the resulting token is. Returns CPP_EOF if the tokens cannot
2642 be pasted, or the appropriate type for the merged token if they
2644 static enum cpp_ttype
2645 can_paste (pfile, token1, token2, digraph)
2647 const cpp_token *token1, *token2;
2650 enum cpp_ttype a = token1->type, b = token2->type;
2651 int cxx = CPP_OPTION (pfile, cplusplus);
2653 /* Treat named operators as if they were ordinary NAMEs. */
2654 if (token1->flags & NAMED_OP)
2656 if (token2->flags & NAMED_OP)
2659 if (a <= CPP_LAST_EQ && b == CPP_EQ)
2660 return a + (CPP_EQ_EQ - CPP_EQ);
2665 if (b == a) return CPP_RSHIFT;
2666 if (b == CPP_QUERY && cxx) return CPP_MAX;
2667 if (b == CPP_GREATER_EQ) return CPP_RSHIFT_EQ;
2670 if (b == a) return CPP_LSHIFT;
2671 if (b == CPP_QUERY && cxx) return CPP_MIN;
2672 if (b == CPP_LESS_EQ) return CPP_LSHIFT_EQ;
2673 if (CPP_OPTION (pfile, digraphs))
2676 {*digraph = 1; return CPP_OPEN_SQUARE;} /* <: digraph */
2678 {*digraph = 1; return CPP_OPEN_BRACE;} /* <% digraph */
2682 case CPP_PLUS: if (b == a) return CPP_PLUS_PLUS; break;
2683 case CPP_AND: if (b == a) return CPP_AND_AND; break;
2684 case CPP_OR: if (b == a) return CPP_OR_OR; break;
2687 if (b == a) return CPP_MINUS_MINUS;
2688 if (b == CPP_GREATER) return CPP_DEREF;
2691 if (b == a && cxx) return CPP_SCOPE;
2692 if (b == CPP_GREATER && CPP_OPTION (pfile, digraphs))
2693 {*digraph = 1; return CPP_CLOSE_SQUARE;} /* :> digraph */
2697 if (CPP_OPTION (pfile, digraphs))
2699 if (b == CPP_GREATER)
2700 {*digraph = 1; return CPP_CLOSE_BRACE;} /* %> digraph */
2702 {*digraph = 1; return CPP_HASH;} /* %: digraph */
2706 if (b == CPP_MULT && cxx) return CPP_DEREF_STAR;
2709 if (b == CPP_MULT && cxx) return CPP_DOT_STAR;
2710 if (b == CPP_NUMBER) return CPP_NUMBER;
2714 if (b == a && (token1->flags & DIGRAPH) == (token2->flags & DIGRAPH))
2716 {*digraph = (token1->flags & DIGRAPH); return CPP_PASTE;}
2720 if (b == CPP_NAME) return CPP_NAME;
2722 && is_numstart(token2->val.str.text[0])) return CPP_NAME;
2724 && token1->val.node == pfile->spec_nodes->n_L) return CPP_WCHAR;
2726 && token1->val.node == pfile->spec_nodes->n_L) return CPP_WSTRING;
2730 if (b == CPP_NUMBER) return CPP_NUMBER;
2731 if (b == CPP_NAME) return CPP_NUMBER;
2732 if (b == CPP_DOT) return CPP_NUMBER;
2733 /* Numbers cannot have length zero, so this is safe. */
2734 if ((b == CPP_PLUS || b == CPP_MINUS)
2735 && VALID_SIGN ('+', token1->val.str.text[token1->val.str.len - 1]))
2740 if (CPP_OPTION (pfile, objc) && token1->val.aux == '@')
2742 if (b == CPP_NAME) return CPP_NAME;
2743 if (b == CPP_STRING) return CPP_OSTRING;
2753 /* Check if TOKEN is to be ##-pasted with the token after it. */
2754 static const cpp_token *
2755 maybe_paste_with_next (pfile, token)
2757 const cpp_token *token;
2760 const cpp_token *second;
2761 cpp_context *context = CURRENT_CONTEXT (pfile);
2763 /* Is this token on the LHS of ## ? */
2765 while ((token->flags & PASTE_LEFT)
2766 || ((context->flags & CONTEXT_PASTEL)
2767 && context->posn == context->count))
2769 /* Suppress macro expansion for next token, but don't conflict
2770 with the other method of suppression. If it is an argument,
2771 macro expansion within the argument will still occur. */
2772 pfile->paste_level = pfile->cur_context;
2773 second = _cpp_get_token (pfile);
2774 pfile->paste_level = 0;
2776 /* Ignore placemarker argument tokens (cannot be from an empty
2777 macro since macros are not expanded). */
2778 if (token->type == CPP_PLACEMARKER)
2779 pasted = duplicate_token (pfile, second);
2780 else if (second->type == CPP_PLACEMARKER)
2782 /* GCC has special extended semantics for , ## b where b is
2783 a varargs parameter: the comma disappears if b was given
2784 no actual arguments (not merely if b is an empty
2786 if (token->type == CPP_COMMA && second->flags & VOID_REST)
2787 pasted = duplicate_token (pfile, second);
2789 pasted = duplicate_token (pfile, token);
2794 enum cpp_ttype type = can_paste (pfile, token, second, &digraph);
2796 if (type == CPP_EOF)
2798 if (CPP_OPTION (pfile, warn_paste))
2800 /* Do not complain about , ## <whatever> if
2801 <whatever> came from a variable argument, because
2802 the author probably intended the ## to trigger
2803 the special extended semantics (see above). */
2804 if (token->type == CPP_COMMA
2805 && IS_ARG_CONTEXT (CURRENT_CONTEXT (pfile))
2806 && ON_REST_ARG (CURRENT_CONTEXT (pfile) - 1))
2810 "pasting would not give a valid preprocessing token");
2812 _cpp_push_token (pfile, second);
2816 if (type == CPP_NAME || type == CPP_NUMBER)
2818 /* Join spellings. */
2821 pasted = get_temp_token (pfile);
2822 buf = (U_CHAR *) alloca (TOKEN_LEN (token) + TOKEN_LEN (second));
2823 end = spell_token (pfile, token, buf);
2824 end = spell_token (pfile, second, end);
2827 if (type == CPP_NAME)
2828 pasted->val.node = cpp_lookup (pfile, buf, end - buf);
2831 pasted->val.str.text = uxstrdup (buf);
2832 pasted->val.str.len = end - buf;
2835 else if (type == CPP_WCHAR || type == CPP_WSTRING
2836 || type == CPP_OSTRING)
2837 pasted = duplicate_token (pfile, second);
2840 pasted = get_temp_token (pfile);
2841 pasted->val.integer = 0;
2844 pasted->type = type;
2845 pasted->flags = digraph ? DIGRAPH : 0;
2847 if (type == CPP_NAME && pasted->val.node->type == T_OPERATOR)
2849 pasted->type = pasted->val.node->value.code;
2850 pasted->flags |= NAMED_OP;
2854 /* The pasted token gets the whitespace flags and position of the
2855 first token, the PASTE_LEFT flag of the second token, plus the
2856 PASTED flag to indicate it is the result of a paste. However, we
2857 want to preserve the DIGRAPH flag. */
2858 pasted->flags &= ~(PREV_WHITE | BOL | PASTE_LEFT);
2859 pasted->flags |= ((token->flags & (PREV_WHITE | BOL))
2860 | (second->flags & PASTE_LEFT) | PASTED);
2861 pasted->col = token->col;
2862 pasted->line = token->line;
2864 /* See if there is another token to be pasted onto the one we just
2867 context = CURRENT_CONTEXT (pfile);
2873 /* Convert a token sequence to a single string token according to the
2874 rules of the ISO C #-operator. */
2875 #define INIT_SIZE 200
2877 stringify_arg (pfile, token)
2879 const cpp_token *token;
2882 unsigned char *main_buf;
2883 unsigned int prev_value, backslash_count = 0;
2884 unsigned int buf_used = 0, whitespace = 0, buf_cap = INIT_SIZE;
2886 push_arg_context (pfile, token);
2887 prev_value = prevent_macro_expansion (pfile);
2888 main_buf = (unsigned char *) xmalloc (buf_cap);
2890 result = get_temp_token (pfile);
2891 ASSIGN_FLAGS_AND_POS (result, token);
2893 for (; (token = _cpp_get_token (pfile))->type != CPP_EOF; )
2897 unsigned int len = TOKEN_LEN (token);
2899 if (token->type == CPP_PLACEMARKER)
2902 escape = (token->type == CPP_STRING || token->type == CPP_WSTRING
2903 || token->type == CPP_CHAR || token->type == CPP_WCHAR);
2907 if (buf_used + len > buf_cap)
2909 buf_cap = buf_used + len + INIT_SIZE;
2910 main_buf = xrealloc (main_buf, buf_cap);
2913 if (whitespace && (token->flags & PREV_WHITE))
2914 main_buf[buf_used++] = ' ';
2917 buf = (unsigned char *) xmalloc (len);
2919 buf = main_buf + buf_used;
2921 len = spell_token (pfile, token, buf) - buf;
2924 buf_used = quote_string (&main_buf[buf_used], buf, len) - main_buf;
2931 if (token->type == CPP_BACKSLASH)
2934 backslash_count = 0;
2937 /* Ignore the final \ of invalid string literals. */
2938 if (backslash_count & 1)
2940 cpp_warning (pfile, "invalid string literal, ignoring final '\\'");
2944 result->type = CPP_STRING;
2945 result->val.str.text = main_buf;
2946 result->val.str.len = buf_used;
2947 restore_macro_expansion (pfile, prev_value);
2951 /* Allocate more room on the context stack of PFILE. */
2953 expand_context_stack (pfile)
2956 pfile->context_cap += pfile->context_cap + 20;
2957 pfile->contexts = (cpp_context *)
2958 xrealloc (pfile->contexts, pfile->context_cap * sizeof (cpp_context));
2961 /* Push the context of macro NODE onto the context stack. TOKEN is
2962 the CPP_NAME token invoking the macro. */
2964 push_macro_context (pfile, token)
2966 const cpp_token *token;
2968 unsigned char orig_flags;
2970 cpp_context *context;
2971 cpp_hashnode *node = token->val.node;
2973 /* Token's flags may change when parsing args containing a nested
2974 invocation of this macro. */
2975 orig_flags = token->flags & (PREV_WHITE | BOL);
2977 if (node->value.expansion->paramc >= 0)
2979 unsigned int error, prev_nme;
2981 /* Allocate room for the argument contexts, and parse them. */
2982 args = (macro_args *) xmalloc (sizeof (macro_args));
2983 args->ends = (unsigned int *)
2984 xmalloc (node->value.expansion->paramc * sizeof (unsigned int));
2988 args->level = pfile->cur_context;
2990 prev_nme = prevent_macro_expansion (pfile);
2992 error = parse_args (pfile, node, args);
2994 restore_macro_expansion (pfile, prev_nme);
2997 free_macro_args (args);
3002 /* Now push its context. */
3003 pfile->cur_context++;
3004 if (pfile->cur_context == pfile->context_cap)
3005 expand_context_stack (pfile);
3007 context = CURRENT_CONTEXT (pfile);
3008 context->u.list = node->value.expansion;
3009 context->args = args;
3011 context->count = context->u.list->tokens_used;
3012 context->level = pfile->cur_context;
3014 context->pushed_token = 0;
3016 /* Set the flags of the first token. We know there must
3017 be one, empty macros are a single placemarker token. */
3018 MODIFY_FLAGS_AND_POS (&context->u.list->tokens[0], token, orig_flags);
3023 /* Push an argument to the current macro onto the context stack.
3024 TOKEN is the MACRO_ARG token representing the argument expansion. */
3026 push_arg_context (pfile, token)
3028 const cpp_token *token;
3030 cpp_context *context;
3033 pfile->cur_context++;
3034 if (pfile->cur_context == pfile->context_cap)
3035 expand_context_stack (pfile);
3037 context = CURRENT_CONTEXT (pfile);
3038 args = context[-1].args;
3040 context->count = token->val.aux ? args->ends[token->val.aux - 1]: 0;
3041 context->u.arg = args->tokens + context->count;
3042 context->count = args->ends[token->val.aux] - context->count;
3045 context->level = args->level;
3046 context->flags = CONTEXT_ARG | CONTEXT_RAW;
3047 context->pushed_token = 0;
3049 /* Set the flags of the first token. There is one. */
3051 const cpp_token *first = context->u.arg[0];
3053 first = context->u.arg[1];
3055 MODIFY_FLAGS_AND_POS ((cpp_token *) first, token,
3056 token->flags & (PREV_WHITE | BOL));
3059 if (token->flags & PASTE_LEFT)
3060 context->flags |= CONTEXT_PASTEL;
3061 if (pfile->paste_level)
3062 context->flags |= CONTEXT_PASTER;
3065 /* "Unget" a token. It is effectively inserted in the token queue and
3066 will be returned by the next call to get_raw_token. */
3068 _cpp_push_token (pfile, token)
3070 const cpp_token *token;
3072 cpp_context *context = CURRENT_CONTEXT (pfile);
3074 if (context->posn > 0)
3076 const cpp_token *prev;
3077 if (IS_ARG_CONTEXT (context))
3078 prev = context->u.arg[context->posn - 1];
3080 prev = &context->u.list->tokens[context->posn - 1];
3089 if (context->pushed_token)
3090 cpp_ice (pfile, "two tokens pushed in a row");
3091 if (token->type != CPP_EOF)
3092 context->pushed_token = token;
3093 /* Don't push back a directive's CPP_EOF, step back instead. */
3094 else if (pfile->cur_context == 0)
3095 pfile->contexts[0].posn--;
3098 /* Handle a preprocessing directive. TOKEN is the CPP_HASH token
3099 introducing the directive. */
3101 process_directive (pfile, token)
3103 const cpp_token *token;
3105 const struct directive *d = pfile->token_list.directive;
3108 /* Skip over the directive name. */
3109 if (token[1].type == CPP_NAME)
3110 _cpp_get_raw_token (pfile);
3111 else if (token[1].type != CPP_NUMBER)
3112 cpp_ice (pfile, "directive begins with %s?!", TOKEN_NAME (token));
3114 if (! (d->flags & EXPAND))
3115 prev_nme = prevent_macro_expansion (pfile);
3116 (void) (*d->handler) (pfile);
3117 if (! (d->flags & EXPAND))
3118 restore_macro_expansion (pfile, prev_nme);
3119 _cpp_skip_rest_of_line (pfile);
3122 /* The external interface to return the next token. All macro
3123 expansion and directive processing is handled internally, the
3124 caller only ever sees the output after preprocessing. */
3126 cpp_get_token (pfile)
3129 const cpp_token *token;
3130 /* Loop till we hit a non-directive, non-placemarker token. */
3133 token = _cpp_get_token (pfile);
3135 if (token->type == CPP_PLACEMARKER)
3138 if (token->type == CPP_HASH && token->flags & BOL
3139 && pfile->token_list.directive)
3141 process_directive (pfile, token);
3149 /* The internal interface to return the next token. There are two
3150 differences between the internal and external interfaces: the
3151 internal interface may return a PLACEMARKER token, and it does not
3152 process directives. */
3154 _cpp_get_token (pfile)
3157 const cpp_token *token, *old_token;
3160 /* Loop until we hit a non-macro token. */
3163 token = get_raw_token (pfile);
3165 /* Short circuit EOF. */
3166 if (token->type == CPP_EOF)
3169 /* If we are skipping... */
3170 if (pfile->skipping)
3172 /* we still have to process directives, */
3173 if (pfile->token_list.directive)
3176 /* but everything else is ignored. */
3177 _cpp_skip_rest_of_line (pfile);
3181 /* If there's a potential control macro and we get here, then that
3182 #ifndef didn't cover the entire file and its argument shouldn't
3183 be taken as a control macro. */
3184 pfile->potential_control_macro = 0;
3188 /* See if there's a token to paste with this one. */
3189 if (!pfile->paste_level)
3190 token = maybe_paste_with_next (pfile, token);
3192 /* If it isn't a macro, return it now. */
3193 if (token->type != CPP_NAME || token->val.node->type == T_VOID)
3196 /* Is macro expansion disabled in general, or are we in the
3197 middle of a token paste, or was this token just pasted?
3198 (Note we don't check token->flags & PASTED, because that
3199 counts tokens that were pasted at some point in the past,
3200 we're only interested in tokens that were pasted by this call
3201 to maybe_paste_with_next.) */
3202 if (pfile->no_expand_level == pfile->cur_context
3203 || pfile->paste_level
3204 || (token != old_token
3205 && pfile->no_expand_level + 1 == pfile->cur_context))
3208 node = token->val.node;
3209 if (node->type != T_MACRO)
3210 return special_symbol (pfile, node, token);
3212 if (is_macro_disabled (pfile, node->value.expansion, token))
3215 if (pfile->cur_context > CPP_STACK_MAX)
3217 cpp_error (pfile, "macros nested too deep invoking '%s'", node->name);
3221 if (push_macro_context (pfile, token))
3227 /* Returns the next raw token, i.e. without performing macro
3228 expansion. Argument contexts are automatically entered. */
3229 static const cpp_token *
3230 get_raw_token (pfile)
3233 const cpp_token *result;
3234 cpp_context *context;
3238 context = CURRENT_CONTEXT (pfile);
3239 if (context->pushed_token)
3241 result = context->pushed_token;
3242 context->pushed_token = 0;
3243 return result; /* Cannot be a CPP_MACRO_ARG */
3245 else if (context->posn == context->count)
3247 if (pop_context (pfile))
3251 else if (IS_ARG_CONTEXT (context))
3253 result = context->u.arg[context->posn++];
3256 context->flags ^= CONTEXT_RAW;
3257 result = context->u.arg[context->posn++];
3259 return result; /* Cannot be a CPP_MACRO_ARG */
3262 result = &context->u.list->tokens[context->posn++];
3264 if (result->type != CPP_MACRO_ARG)
3267 if (result->flags & STRINGIFY_ARG)
3268 return stringify_arg (pfile, result);
3270 push_arg_context (pfile, result);
3274 /* Internal interface to get the token without macro expanding. */
3276 _cpp_get_raw_token (pfile)
3279 int prev_nme = prevent_macro_expansion (pfile);
3280 const cpp_token *result = _cpp_get_token (pfile);
3281 restore_macro_expansion (pfile, prev_nme);
3285 /* A thin wrapper to lex_line. CLEAR is non-zero if the current token
3286 list should be overwritten, or zero if we need to append
3287 (typically, if we are within the arguments to a macro, or looking
3288 for the '(' to start a function-like macro invocation). */
3290 lex_next (pfile, clear)
3294 cpp_toklist *list = &pfile->token_list;
3295 const cpp_token *old_list = list->tokens;
3296 unsigned int old_used = list->tokens_used;
3300 /* Release all temporary tokens. */
3301 _cpp_clear_toklist (list);
3302 pfile->contexts[0].posn = 0;
3303 if (pfile->temp_used)
3304 release_temp_tokens (pfile);
3306 lex_line (pfile, list);
3307 pfile->contexts[0].count = list->tokens_used;
3309 if (!clear && pfile->args)
3311 /* Fix up argument token pointers. */
3312 if (old_list != list->tokens)
3316 for (i = 0; i < pfile->args->used; i++)
3318 const cpp_token *token = pfile->args->tokens[i];
3319 if (token >= old_list && token < old_list + old_used)
3320 pfile->args->tokens[i] = (const cpp_token *)
3321 ((char *) token + ((char *) list->tokens - (char *) old_list));
3325 /* 6.10.3 paragraph 11: If there are sequences of preprocessing
3326 tokens within the list of arguments that would otherwise act as
3327 preprocessing directives, the behavior is undefined.
3329 This implementation will report a hard error and treat the
3330 'sequence of preprocessing tokens' as part of the macro argument,
3333 Note if pfile->args == 0, we're OK since we're only inside a
3334 macro argument after a '('. */
3335 if (list->directive)
3337 cpp_error_with_line (pfile, list->tokens[old_used].line,
3338 list->tokens[old_used].col,
3339 "#%s may not be used inside a macro argument",
3340 list->directive->name);
3348 /* Pops a context off the context stack. If we're at the bottom, lexes
3349 the next logical line. Returns EOF if we're at the end of the
3350 argument list to the # operator, or we should not "overflow"
3351 into the rest of the file (e.g. 6.10.3.1.1). */
3356 cpp_context *context;
3358 if (pfile->cur_context == 0)
3360 /* If we are currently processing a directive, do not advance. 6.10
3361 paragraph 2: A new-line character ends the directive even if it
3362 occurs within what would otherwise be an invocation of a
3363 function-like macro. */
3364 if (pfile->token_list.directive)
3367 return lex_next (pfile, pfile->no_expand_level == UINT_MAX);
3370 /* Argument contexts, when parsing args or handling # operator
3371 return CPP_EOF at the end. */
3372 context = CURRENT_CONTEXT (pfile);
3373 if (IS_ARG_CONTEXT (context) && pfile->cur_context == pfile->no_expand_level)
3376 /* Free resources when leaving macro contexts. */
3378 free_macro_args (context->args);
3380 if (pfile->cur_context == pfile->no_expand_level)
3381 pfile->no_expand_level--;
3382 pfile->cur_context--;
3387 /* Turn off macro expansion at the current context level. */
3389 prevent_macro_expansion (pfile)
3392 unsigned int prev_value = pfile->no_expand_level;
3393 pfile->no_expand_level = pfile->cur_context;
3397 /* Restore macro expansion to its previous state. */
3399 restore_macro_expansion (pfile, prev_value)
3401 unsigned int prev_value;
3403 pfile->no_expand_level = prev_value;
3406 /* Used by cpperror.c to obtain the correct line and column to report
3409 _cpp_get_line (pfile, pcol)
3414 const cpp_token *cur_token;
3416 if (pfile->in_lex_line)
3417 index = pfile->token_list.tokens_used;
3419 index = pfile->contexts[0].posn;
3428 cur_token = &pfile->token_list.tokens[index - 1];
3430 *pcol = cur_token->col;
3431 return cur_token->line;
3434 #define DSC(str) (const U_CHAR *)str, sizeof str - 1
3435 static const char * const monthnames[] =
3437 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
3438 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
3441 /* Handle builtin macros like __FILE__. */
3442 static const cpp_token *
3443 special_symbol (pfile, node, token)
3446 const cpp_token *token;
3458 ip = CPP_BUFFER (pfile);
3463 if (node->type == T_BASE_FILE)
3464 while (CPP_PREV_BUFFER (ip) != NULL)
3465 ip = CPP_PREV_BUFFER (ip);
3467 file = ip->nominal_fname;
3469 result = make_string_token (get_temp_token (pfile), (U_CHAR *) file,
3474 case T_INCLUDE_LEVEL:
3475 /* pfile->include_depth counts the primary source as level 1,
3476 but historically __INCLUDE_DEPTH__ has called the primary
3478 result = alloc_number_token (pfile, pfile->include_depth - 1);
3482 /* If __LINE__ is embedded in a macro, it must expand to the
3483 line of the macro's invocation, not its definition.
3484 Otherwise things like assert() will not work properly. */
3485 result = alloc_number_token (pfile, _cpp_get_line (pfile, NULL));
3492 #ifdef STDC_0_IN_SYSTEM_HEADERS
3493 if (CPP_IN_SYSTEM_HEADER (pfile)
3494 && pfile->spec_nodes->n__STRICT_ANSI__->type == T_VOID)
3497 result = alloc_number_token (pfile, stdc);
3503 if (pfile->date == 0)
3505 /* Allocate __DATE__ and __TIME__ from permanent storage,
3506 and save them in pfile so we don't have to do this again.
3507 We don't generate these strings at init time because
3508 time() and localtime() are very slow on some systems. */
3509 time_t tt = time (NULL);
3510 struct tm *tb = localtime (&tt);
3512 pfile->date = make_string_token
3513 ((cpp_token *) xmalloc (sizeof (cpp_token)), DSC("Oct 11 1347"));
3514 pfile->time = make_string_token
3515 ((cpp_token *) xmalloc (sizeof (cpp_token)), DSC("12:34:56"));
3517 sprintf ((char *) pfile->date->val.str.text, "%s %2d %4d",
3518 monthnames[tb->tm_mon], tb->tm_mday, tb->tm_year + 1900);
3519 sprintf ((char *) pfile->time->val.str.text, "%02d:%02d:%02d",
3520 tb->tm_hour, tb->tm_min, tb->tm_sec);
3522 result = node->type == T_DATE ? pfile->date: pfile->time;
3526 cpp_error (pfile, "attempt to use poisoned \"%s\"", node->name);
3530 cpp_ice (pfile, "invalid special hash type");
3534 ASSIGN_FLAGS_AND_POS (result, token);
3539 /* Allocate pfile->input_buffer, and initialize trigraph_map[]
3540 if it hasn't happened already. */
3543 _cpp_init_input_buffer (pfile)
3548 init_trigraph_map ();
3549 _cpp_init_toklist (&pfile->token_list, DUMMY_TOKEN);
3550 pfile->no_expand_level = UINT_MAX;
3551 pfile->context_cap = 20;
3552 pfile->cur_context = 0;
3554 pfile->contexts = (cpp_context *)
3555 xmalloc (pfile->context_cap * sizeof (cpp_context));
3557 /* Clear the base context. */
3558 base = &pfile->contexts[0];
3559 base->u.list = &pfile->token_list;
3565 base->pushed_token = 0;
3568 /* Moves to the end of the directive line, popping contexts as
3571 _cpp_skip_rest_of_line (pfile)
3574 /* Discard all stacked contexts. */
3576 for (i = pfile->cur_context; i > 0; i--)
3577 if (pfile->contexts[i].args)
3578 free_macro_args (pfile->contexts[i].args);
3580 if (pfile->no_expand_level <= pfile->cur_context)
3581 pfile->no_expand_level = 0;
3582 pfile->cur_context = 0;
3584 /* Clear the base context, and clear the directive pointer so that
3585 get_raw_token will advance to the next line. */
3586 pfile->contexts[0].count = 0;
3587 pfile->contexts[0].posn = 0;
3588 pfile->token_list.directive = 0;
3591 /* Directive handler wrapper used by the command line option
3594 _cpp_run_directive (pfile, dir, buf, count)
3596 const struct directive *dir;
3600 if (cpp_push_buffer (pfile, (const U_CHAR *)buf, count) != NULL)
3602 unsigned int prev_lvl = 0;
3604 /* Scan the line now, else prevent_macro_expansion won't work. */
3605 lex_next (pfile, 1);
3606 if (! (dir->flags & EXPAND))
3607 prev_lvl = prevent_macro_expansion (pfile);
3609 (void) (*dir->handler) (pfile);
3611 if (! (dir->flags & EXPAND))
3612 restore_macro_expansion (pfile, prev_lvl);
3614 _cpp_skip_rest_of_line (pfile);
3615 cpp_pop_buffer (pfile);