Lines Matching defs:lexer
46 /* The lexer. */
48 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
114 /* The cp_lexer structure represents the C++ lexer. It is responsible
121 /* The memory allocated for the buffer. NULL if this lexer does not
124 /* If the lexer owns the buffer, this is the number of tokens in the
129 in this lexer are [buffer, last_token). */
142 /* The next lexer in a linked list of lexers. */
155 lexer's array. There is also no need for the GC to walk through
157 a lexer. */
222 #define cp_lexer_debugging_p(lexer) 0
266 /* Create a new main C++ lexer, the lexer that gets tokens from the
273 cp_lexer *lexer;
290 lexer = GGC_CNEW (cp_lexer);
294 lexer->debugging_p = false;
296 lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
319 cp_lexer_get_preprocessor_token (lexer, pos);
321 lexer->buffer = buffer;
322 lexer->buffer_length = alloc - space;
323 lexer->last_token = pos;
324 lexer->next_token = lexer->buffer_length ? buffer : (cp_token *)&eof_token;
331 gcc_assert (lexer->next_token->type != CPP_PURGED);
332 return lexer;
335 /* Create a new lexer whose token stream is primed with the tokens in
343 cp_lexer *lexer = GGC_CNEW (cp_lexer);
346 lexer->buffer = NULL;
347 lexer->buffer_length = 0;
348 lexer->next_token = first == last ? (cp_token *)&eof_token : first;
349 lexer->last_token = last;
351 lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
356 lexer->debugging_p = false;
359 gcc_assert (lexer->next_token->type != CPP_PURGED);
360 return lexer;
366 cp_lexer_destroy (cp_lexer *lexer)
368 if (lexer->buffer)
369 ggc_free (lexer->buffer);
370 VEC_free (cp_token_position, heap, lexer->saved_tokens);
371 ggc_free (lexer);
379 cp_lexer_debugging_p (cp_lexer *lexer)
381 return lexer->debugging_p;
387 cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
389 gcc_assert (!previous_p || lexer->next_token != &eof_token);
391 return lexer->next_token - previous_p;
395 cp_lexer_token_at (cp_lexer *lexer ATTRIBUTE_UNUSED, cp_token_position pos)
403 cp_lexer_saving_tokens (const cp_lexer* lexer)
405 return VEC_length (cp_token_position, lexer->saved_tokens) != 0;
412 cp_lexer_get_preprocessor_token (cp_lexer *lexer ATTRIBUTE_UNUSED ,
495 cp_lexer_peek_token (cp_lexer *lexer)
497 if (cp_lexer_debugging_p (lexer))
500 cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
503 return lexer->next_token;
509 cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
511 return cp_lexer_peek_token (lexer)->type == type;
517 cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
519 return !cp_lexer_next_token_is (lexer, type);
525 cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
527 return cp_lexer_peek_token (lexer)->keyword == keyword;
533 cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
537 token = cp_lexer_peek_token (lexer);
582 cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
589 if (cp_lexer_debugging_p (lexer))
594 token = lexer->next_token;
599 if (token == lexer->last_token)
609 if (cp_lexer_debugging_p (lexer))
618 /* Return the next token, and advance the lexer's next_token pointer
622 cp_lexer_consume_token (cp_lexer* lexer)
624 cp_token *token = lexer->next_token;
627 gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);
631 lexer->next_token++;
632 if (lexer->next_token == lexer->last_token)
634 lexer->next_token = (cp_token *)&eof_token;
639 while (lexer->next_token->type == CPP_PURGED);
644 if (cp_lexer_debugging_p (lexer))
659 cp_lexer_purge_token (cp_lexer *lexer)
661 cp_token *tok = lexer->next_token;
672 if (tok == lexer->last_token)
679 lexer->next_token = tok;
687 cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
689 cp_token *peek = lexer->next_token;
692 peek = lexer->last_token;
709 cp_lexer_save_tokens (cp_lexer* lexer)
712 if (cp_lexer_debugging_p (lexer))
716 lexer->saved_tokens, lexer->next_token);
722 cp_lexer_commit_tokens (cp_lexer* lexer)
725 if (cp_lexer_debugging_p (lexer))
728 VEC_pop (cp_token_position, lexer->saved_tokens);
735 cp_lexer_rollback_tokens (cp_lexer* lexer)
738 if (cp_lexer_debugging_p (lexer))
741 lexer->next_token = VEC_pop (cp_token_position, lexer->saved_tokens);
798 cp_lexer_start_debugging (cp_lexer* lexer)
800 lexer->debugging_p = true;
806 cp_lexer_stop_debugging (cp_lexer* lexer)
808 lexer->debugging_p = false;
1316 /* The lexer from which we are obtaining tokens. */
1317 cp_lexer *lexer;
2001 cp_token *token = cp_lexer_peek_token (parser->lexer);
2173 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2183 start = cp_lexer_token_position (parser->lexer, true);
2185 cp_lexer_consume_token (parser->lexer);
2191 cp_lexer_purge_tokens_after (parser->lexer, start);
2325 if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME)
2364 cp_token * token = cp_lexer_peek_token (parser->lexer);
2401 cp_lexer_consume_token (parser->lexer);
2411 cp_lexer_consume_token (parser->lexer);
2426 cp_token *token = cp_lexer_peek_token (parser->lexer);
2465 cp_lexer_consume_token (parser->lexer);
2478 cp_lexer_consume_token (parser->lexer);
2490 return c_dialect_objc () && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
2508 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
2523 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
2529 cp_lexer_consume_token (parser->lexer); /* Eat ';'. */
2542 cp_lexer_consume_token (parser->lexer);
2543 token = cp_lexer_peek_token (parser->lexer);
2546 cp_lexer_consume_token (parser->lexer);
2562 token = cp_lexer_consume_token (parser->lexer);
2574 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
2575 cp_lexer_consume_token (parser->lexer);
2597 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
2598 && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
2599 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
2602 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
2603 cp_lexer_consume_token (parser->lexer);
2604 token = cp_lexer_peek_token (parser->lexer);
2611 cp_lexer_consume_token (parser->lexer);
2631 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
2632 cp_lexer_consume_token (parser->lexer);
2646 cp_token *token = cp_lexer_peek_token (parser->lexer);
2679 cp_lexer_consume_token (parser->lexer);
2693 cp_token *token = cp_lexer_peek_token (parser->lexer);
2720 cp_lexer_consume_token (parser->lexer);
2733 parser->lexer->in_pragma = false;
2736 token = cp_lexer_consume_token (parser->lexer);
2740 cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
2749 parser->lexer->in_pragma = false;
2780 cp_lexer *lexer;
2785 lexer = cp_lexer_new_main ();
2793 parser->lexer = lexer;
2853 and push it onto the parser's lexer stack. This is used for delayed
2859 cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
2860 lexer->next = parser->lexer;
2861 parser->lexer = lexer;
2864 new lexer. */
2865 cp_lexer_set_source_position_from_token (lexer->next_token);
2868 /* Pop the top lexer off the parser stack. This is never used for the
2869 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
2873 cp_lexer *lexer = parser->lexer;
2874 parser->lexer = lexer->next;
2875 cp_lexer_destroy (lexer);
2878 lexer was pushed. */
2879 cp_lexer_set_source_position_from_token (parser->lexer->next_token);
2922 tok = cp_lexer_peek_token (parser->lexer);
2932 (cp_lexer_peek_nth_token (parser->lexer, 2)))
2934 cp_lexer_consume_token (parser->lexer);
2951 cp_lexer_consume_token (parser->lexer);
2960 tok = cp_lexer_peek_token (parser->lexer);
3026 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
3029 cp_lexer_destroy (parser->lexer);
3030 parser->lexer = NULL;
3107 token = cp_lexer_peek_token (parser->lexer);
3129 token = cp_lexer_consume_token (parser->lexer);
3144 next_token = cp_lexer_peek_token (parser->lexer);
3187 cp_lexer_consume_token (parser->lexer);
3196 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
3245 cp_lexer_consume_token (parser->lexer);
3248 cp_lexer_consume_token (parser->lexer);
3253 cp_lexer_consume_token (parser->lexer);
3258 cp_lexer_consume_token (parser->lexer);
3285 token = cp_lexer_consume_token (parser->lexer);
3296 cp_lexer_consume_token (parser->lexer);
3355 token = cp_lexer_peek_token (parser->lexer);
3563 token = cp_lexer_peek_token (parser->lexer);
3585 token = cp_lexer_peek_token (parser->lexer);
3641 token = cp_lexer_peek_token (parser->lexer);
3677 cp_lexer_consume_token (parser->lexer);
3720 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
3721 cp_lexer_consume_token (parser->lexer);
3729 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
3730 cp_lexer_consume_token (parser->lexer);
3736 token = cp_lexer_peek_token (parser->lexer);
3739 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
3743 cp_lexer_consume_token (parser->lexer);
3916 start = cp_lexer_token_position (parser->lexer, false);
3929 token = cp_lexer_peek_token (parser->lexer);
3969 token = cp_lexer_peek_nth_token (parser->lexer, 2);
4028 while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
4029 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4031 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
4034 token = cp_lexer_consume_token (parser->lexer);
4074 cp_lexer_consume_token (parser->lexer);
4119 token = cp_lexer_token_at (parser->lexer, start);
4132 cp_lexer_purge_tokens_after (parser->lexer, start);
4231 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
4232 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
4288 token = cp_lexer_peek_token (parser->lexer);
4305 cp_lexer_consume_token (parser->lexer);
4366 cp_lexer_consume_token (parser->lexer);
4445 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
4452 cp_lexer_consume_token (parser->lexer);
4471 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
4472 cp_lexer_consume_token (parser->lexer);
4520 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
4526 token = cp_lexer_peek_token (parser->lexer);
4687 cp_lexer_consume_token (parser->lexer);
4698 cp_lexer_consume_token (parser->lexer);
4713 cp_lexer_consume_token (parser->lexer);
4751 cp_lexer_consume_token (parser->lexer);
4986 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
4994 && cp_lexer_peek_token (parser->lexer)->type == CPP_NAME)
4999 token = cp_lexer_consume_token (parser->lexer);
5037 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
5041 cp_lexer_consume_token (parser->lexer);
5104 && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
5107 cp_lexer_consume_token (parser->lexer);
5118 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
5131 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE)
5132 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_COMPL)
5186 token = cp_lexer_peek_token (parser->lexer);
5202 cp_lexer_consume_token (parser->lexer);
5240 cp_lexer_consume_token (parser->lexer);
5259 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
5265 keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
5291 cp_lexer_consume_token (parser->lexer);
5305 token = cp_lexer_consume_token (parser->lexer);
5418 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5421 cp_lexer_consume_token (parser->lexer);
5429 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
5442 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5591 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
5654 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
5706 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
5709 cp_lexer_consume_token (parser->lexer);
5745 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5761 cp_lexer_consume_token (parser->lexer);
5778 cp_lexer_save_tokens (parser->lexer);
5785 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
5787 cp_lexer_rollback_tokens (parser->lexer);
5940 token = cp_lexer_peek_token (parser->lexer);
5963 cp_lexer_consume_token (parser->lexer);
5973 token = cp_lexer_peek_token (parser->lexer);
6050 cp_lexer_consume_token (parser->lexer);
6052 && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
6088 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
6098 if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
6154 token = cp_lexer_peek_token (parser->lexer);
6209 cp_lexer_consume_token (parser->lexer);
6245 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
6248 cp_lexer_consume_token (parser->lexer);
6353 cp_lexer_consume_token (parser->lexer);
6369 cp_token *token = cp_lexer_peek_token (parser->lexer);
6379 cp_lexer_consume_token (parser->lexer);
6386 cp_lexer_consume_token (parser->lexer);
6449 token = cp_lexer_peek_token (parser->lexer);
6509 token = cp_lexer_peek_nth_token (parser->lexer, 2);
6550 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
6587 token = cp_lexer_peek_token (parser->lexer);
6603 cp_lexer_consume_token (parser->lexer);
6609 ellipsis = cp_lexer_peek_token (parser->lexer);
6613 cp_lexer_consume_token (parser->lexer);
6633 cp_lexer_consume_token (parser->lexer);
6668 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
6675 && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
6748 cp_token *token = cp_lexer_peek_token (parser->lexer);
6841 if (cp_lexer_next_token_is_keyword (parser->lexer,
6845 cp_lexer_consume_token (parser->lexer);
7010 list and returns true. At success, lexer points to token following the 'in' keyword.
7028 token = cp_lexer_peek_token (parser->lexer);
7051 token = cp_lexer_peek_token (parser->lexer);
7057 enum cpp_ttype nt = cp_lexer_peek_nth_token (parser->lexer, 2)->type;
7107 cp_lexer_consume_token (parser->lexer);
7231 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
7238 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
7278 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
7372 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
7389 if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
7395 cp_lexer_consume_token (parser->lexer);
7461 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
7463 cp_lexer_consume_token (parser->lexer);
7467 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
7494 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
7521 token = cp_lexer_peek_token (parser->lexer);
7532 cp_lexer_consume_token (parser->lexer);
7602 token1 = *cp_lexer_peek_token (parser->lexer);
7605 token2 = *cp_lexer_peek_nth_token (parser->lexer, 2);
7627 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
7654 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
7711 token1 = cp_lexer_peek_token (parser->lexer);
7734 token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
7827 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
7833 while (cp_lexer_next_token_is_not (parser->lexer,
7843 token = cp_lexer_peek_token (parser->lexer);
7845 cp_lexer_consume_token (parser->lexer);
7872 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
7882 token = cp_lexer_peek_token (parser->lexer);
7900 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
7901 cp_lexer_consume_token (parser->lexer);
7984 token = cp_lexer_peek_token (parser->lexer);
8006 cp_lexer_purge_token (parser->lexer);
8012 cp_lexer_consume_token (parser->lexer);
8031 cp_lexer_consume_token (parser->lexer);
8057 cp_lexer_consume_token (parser->lexer);
8062 cp_lexer_consume_token (parser->lexer);
8181 switch (cp_lexer_peek_token (parser->lexer)->keyword)
8190 return cp_lexer_consume_token (parser->lexer)->u.value;
8211 switch (cp_lexer_peek_token (parser->lexer)->keyword)
8238 return cp_lexer_consume_token (parser->lexer)->u.value;
8276 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8279 cp_lexer_consume_token (parser->lexer);
8445 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
8455 cp_lexer_consume_token (parser->lexer);
8492 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
8495 cp_lexer_consume_token (parser->lexer);
8526 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
8570 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
8574 cp_lexer_consume_token (parser->lexer);
8671 token = cp_lexer_peek_token (parser->lexer);
8688 cp_lexer_consume_token (parser->lexer);
8691 token = cp_lexer_peek_token (parser->lexer);
8697 cp_lexer_consume_token (parser->lexer);
8856 cp_lexer_consume_token (parser->lexer);
8863 cp_lexer_consume_token (parser->lexer);
8876 cp_lexer_consume_token (parser->lexer);
8912 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
8915 cp_lexer_consume_token (parser->lexer);
8959 token = cp_lexer_peek_token (parser->lexer);
8964 cp_lexer_consume_token (parser->lexer);
8991 token = cp_lexer_peek_token (parser->lexer);
9011 token = cp_lexer_peek_nth_token (parser->lexer, 2);
9014 token = cp_lexer_peek_nth_token (parser->lexer, 3);
9081 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
9090 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
9093 cp_lexer_consume_token (parser->lexer);
9126 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
9127 && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
9128 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
9144 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
9149 cp_lexer_consume_token (parser->lexer);
9227 next_token = cp_lexer_peek_token (parser->lexer);
9233 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
9264 start_of_id = cp_lexer_token_position (parser->lexer, false);
9283 next_token = cp_lexer_peek_token (parser->lexer);
9284 next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2);
9295 cp_lexer_consume_token (parser->lexer);
9348 && cp_lexer_next_token_is (parser->lexer,
9372 cp_token *token = cp_lexer_token_at (parser->lexer, start_of_id);
9384 cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
9448 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
9509 start = cp_lexer_token_position (parser->lexer, true);
9512 cp_lexer_consume_token (parser->lexer);
9525 cp_lexer_purge_tokens_after (parser->lexer, start);
9625 cp_lexer_consume_token (parser->lexer);
9643 while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
9709 && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
9771 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
9788 address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
9790 cp_lexer_consume_token (parser->lexer);
9792 token = cp_lexer_peek_token (parser->lexer);
10033 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
10035 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
10036 && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
10111 token = cp_lexer_peek_token (parser->lexer);
10212 return cp_lexer_consume_token (parser->lexer)->u.value;
10267 token = cp_lexer_peek_token (parser->lexer);
10320 cp_lexer_consume_token (parser->lexer);
10355 id = cp_lexer_consume_token (parser->lexer)->u.value;
10571 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
10574 cp_lexer_consume_token (parser->lexer);
10581 else if (cp_lexer_next_token_is_keyword (parser->lexer,
10585 cp_lexer_consume_token (parser->lexer);
10788 && cp_lexer_next_token_is (parser->lexer,
10798 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
10865 cp_lexer_consume_token (parser->lexer);
10869 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
10875 if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10891 cp_lexer_consume_token (parser->lexer);
10900 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
10939 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
10942 cp_lexer_consume_token (parser->lexer);
10944 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
10975 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
10978 cp_lexer_consume_token (parser->lexer);
11078 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
11194 token = cp_lexer_peek_token (parser->lexer);
11201 cp_lexer_consume_token (parser->lexer);
11244 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
11352 && cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE))
11357 cp_lexer_consume_token (parser->lexer);
11378 && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
11379 || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
11388 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
11391 cp_lexer_consume_token (parser->lexer);
11393 if (cp_lexer_next_token_is_not (parser->lexer,
11395 && cp_lexer_next_token_is_not (parser->lexer,
11397 && cp_lexer_next_token_is_not (parser->lexer,
11403 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
11409 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
11412 cp_lexer_consume_token (parser->lexer);
11414 if (cp_lexer_next_token_is_not (parser->lexer,
11416 && cp_lexer_next_token_is_not (parser->lexer,
11420 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
11426 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
11429 cp_lexer_consume_token (parser->lexer);
11431 if (cp_lexer_next_token_is_not (parser->lexer,
11586 token = cp_lexer_peek_token (parser->lexer);
11810 token = cp_lexer_peek_token (parser->lexer);
11897 token = cp_lexer_peek_token (parser->lexer);
11906 cp_lexer_consume_token (parser->lexer);
11965 *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
12033 token = cp_lexer_peek_token (parser->lexer);
12089 cp_lexer_consume_token (parser->lexer);
12162 cp_lexer_consume_token (parser->lexer);
12197 cp_lexer_consume_token (parser->lexer);
12199 token = cp_lexer_peek_token (parser->lexer);
12445 token = cp_lexer_peek_token (parser->lexer);
12453 cp_lexer_consume_token (parser->lexer);
12534 token = cp_lexer_peek_token (parser->lexer);
12561 cp_lexer_purge_token (parser->lexer);
12565 cp_lexer_consume_token (parser->lexer);
12681 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
12754 token = cp_lexer_peek_token (parser->lexer);
12759 cp_lexer_consume_token (parser->lexer);
12775 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
12779 cp_lexer_consume_token (parser->lexer);
12793 token = cp_lexer_peek_token (parser->lexer);
12798 cp_lexer_consume_token (parser->lexer);
12808 cp_lexer_consume_token (parser->lexer);
12873 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
12874 || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
12876 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
12877 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
12880 else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
12885 token = cp_lexer_peek_nth_token (parser->lexer, 2);
12891 cp_lexer_consume_token (parser->lexer);
12991 token = cp_lexer_peek_token (parser->lexer);
13024 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
13044 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
13048 cp_lexer_consume_token (parser->lexer);
13061 first_token = cp_lexer_peek_token (parser->lexer);
13067 token = cp_lexer_peek_token (parser->lexer);
13132 token = cp_lexer_consume_token (parser->lexer);
13253 token = cp_lexer_peek_token (parser->lexer);
13264 cp_lexer_consume_token (parser->lexer);
13311 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
13323 cp_lexer_consume_token (parser->lexer);
13327 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
13333 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
13334 cp_lexer_consume_token (parser->lexer);
13380 && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
13381 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
13387 identifier = cp_lexer_consume_token (parser->lexer)->u.value;
13389 cp_lexer_consume_token (parser->lexer);
13406 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
13410 token = cp_lexer_peek_nth_token (parser->lexer, 2);
13418 cp_lexer_consume_token (parser->lexer);
13458 token = cp_lexer_peek_token (parser->lexer);
13485 identifier_token = cp_lexer_peek_token (parser->lexer);
13515 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
13561 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
13640 cp_lexer_consume_token (parser->lexer);
13677 token = cp_lexer_peek_token (parser->lexer);
13925 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
14114 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
14175 token = cp_lexer_peek_token (parser->lexer);
14190 cp_lexer_consume_token (parser->lexer);
14263 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
14267 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
14268 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
14277 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
14286 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
14317 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
14330 cp_token *token = cp_lexer_peek_token (parser->lexer);
14398 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
14404 token = cp_lexer_peek_token (parser->lexer);
14409 && cp_lexer_peek_nth_token (parser->lexer, 2)->type
14418 if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
14424 cp_lexer_consume_token (parser->lexer);
14475 if (cp_lexer_next_token_is (parser->lexer,
14477 cp_lexer_consume_token (parser->lexer);
14502 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
14533 (cp_lexer_peek_token (parser->lexer)))
14550 token = cp_lexer_peek_token (parser->lexer);
14553 cp_lexer_consume_token (parser->lexer);
14576 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
14577 cp_lexer_consume_token (parser->lexer);
14579 else if (cp_lexer_next_token_is_not (parser->lexer,
14621 token = cp_lexer_consume_token (parser->lexer);
14658 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
14663 cp_lexer_consume_token (parser->lexer);
14718 token = cp_lexer_peek_token (parser->lexer);
14723 cp_lexer_consume_token (parser->lexer);
14766 token = cp_lexer_peek_token (parser->lexer);
14782 cp_lexer_consume_token (parser->lexer);
14802 cp_lexer_consume_token (parser->lexer);
14814 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
14821 cp_lexer_consume_token (parser->lexer);
14880 token = cp_lexer_peek_token (parser->lexer);
14886 cp_lexer_consume_token (parser->lexer);
14892 token = cp_lexer_peek_token (parser->lexer);
14940 token = cp_lexer_peek_token (parser->lexer);
14945 cp_lexer_consume_token (parser->lexer);
15017 token = cp_lexer_peek_token (parser->lexer);
15065 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
15068 cp_lexer_consume_token (parser->lexer);
15081 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
15112 token = cp_lexer_peek_token (parser->lexer);
15147 token = cp_lexer_peek_token (parser->lexer);
15154 cp_lexer_consume_token (parser->lexer);
15194 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
15197 cp_lexer_consume_token (parser->lexer);
15224 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
15227 cp_lexer_consume_token (parser->lexer);
15257 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
15260 cp_lexer_consume_token (parser->lexer);
15287 token = cp_lexer_peek_token (parser->lexer);
15293 cp_lexer_consume_token (parser->lexer);
15299 token = cp_lexer_peek_token (parser->lexer);
15351 token = cp_lexer_peek_token (parser->lexer);
15358 token = cp_lexer_consume_token (parser->lexer);
15366 token = cp_lexer_peek_token (parser->lexer);
15384 token = cp_lexer_peek_token (parser->lexer);
15392 cp_lexer_consume_token (parser->lexer);
15412 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
15415 cp_lexer_consume_token (parser->lexer);
15453 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15601 || cp_lexer_next_token_is (parser->lexer,
15887 token = cp_lexer_peek_token (parser->lexer);
15893 cp_lexer_consume_token (parser->lexer);
15929 next_token = cp_lexer_peek_token (parser->lexer);
15998 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
15999 && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
16003 && !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer))
16134 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
16137 cp_lexer_consume_token (parser->lexer);
16146 cp_token *token = cp_lexer_peek_token (parser->lexer);
16151 cp_lexer_consume_token (parser->lexer);
16166 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
16240 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
16262 if (cp_lexer_next_token_is_keyword (parser->lexer,
16409 && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
16494 (cp_lexer_peek_token (parser->lexer)))
16504 first = parser->lexer->next_token;
16507 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
16509 last = parser->lexer->next_token;
16563 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
16569 if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
16579 cp_token *token = cp_lexer_peek_token (parser->lexer);
16594 cp_lexer_consume_token (parser->lexer);
16658 /* Push the body of the function onto the lexer stack. */
16754 lexer stack. */
16774 if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
16777 /* Revert to the main lexer. */
16833 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
16842 cp_lexer_consume_token (parser->lexer);
16895 return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
16896 || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
17020 if (cp_lexer_next_token_is (parser->lexer, type))
17021 return cp_lexer_consume_token (parser->lexer);
17055 switch (cp_lexer_peek_token (parser->lexer)->type)
17066 cp_lexer_consume_token (parser->lexer);
17095 cp_lexer_consume_token (parser->lexer);
17152 token = cp_lexer_peek_token (parser->lexer);
17164 token = cp_lexer_peek_token (parser->lexer);
17177 token = cp_lexer_peek_nth_token (parser->lexer, n);
17186 token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
17250 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
17262 cp_lexer_purge_token (parser->lexer);
17268 cp_lexer_consume_token (parser->lexer);
17288 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
17321 && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
17324 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF)
17326 && cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL)))
17329 token = cp_lexer_consume_token (parser->lexer);
17356 cp_lexer_save_tokens (parser->lexer);
17369 cp_lexer *lexer;
17372 lexer = parser->lexer;
17378 while (!cp_lexer_saving_tokens (lexer))
17379 lexer = lexer->next;
17380 cp_lexer_commit_tokens (lexer);
17418 cp_lexer_commit_tokens (parser->lexer);
17426 cp_lexer_rollback_tokens (parser->lexer);
17484 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
17492 kwd = cp_lexer_consume_token (parser->lexer);
17530 cp_lexer_consume_token (parser->lexer); /* Eat '['. */
17551 cp_lexer_consume_token (parser->lexer); /* Eact '.' */
17609 cp_token *token = cp_lexer_peek_token (parser->lexer);
17620 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
17631 token = cp_lexer_peek_token (parser->lexer);
17639 cp_lexer_consume_token (parser->lexer);
17646 token = cp_lexer_peek_token (parser->lexer);
17664 cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */
17685 cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */
17705 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
17735 cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */
17737 token = cp_lexer_peek_token (parser->lexer);
17748 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
17749 && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
17763 token = cp_lexer_consume_token (parser->lexer);
17779 token = cp_lexer_peek_token (parser->lexer);
17800 cp_token *sep = cp_lexer_peek_token (parser->lexer);
17804 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
17808 sep = cp_lexer_peek_token (parser->lexer);
17827 cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */
17845 cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */
17865 if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
17867 cp_lexer_consume_token (parser->lexer); /* Eat '<'. */
17880 cp_token *vis = cp_lexer_peek_token (parser->lexer);
17898 cp_lexer_consume_token (parser->lexer);
17907 (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS
17918 cp_token *token = cp_lexer_peek_token (parser->lexer);
17931 cp_lexer_consume_token (parser->lexer);
17932 token = cp_lexer_peek_token (parser->lexer);
17946 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
17950 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
17955 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
17982 cp_token *token = cp_lexer_consume_token (parser->lexer);
18012 cp_token *token = cp_lexer_peek_token (parser->lexer);
18030 cp_token *token = cp_lexer_peek_token (parser->lexer);
18043 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
18047 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
18068 token = cp_lexer_peek_token (parser->lexer);
18089 cp_token *token = cp_lexer_peek_token (parser->lexer);
18097 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
18098 token = cp_lexer_peek_token (parser->lexer);
18102 cp_lexer_consume_token (parser->lexer); /* Eat '...'. */
18116 token = cp_lexer_peek_token (parser->lexer);
18127 cp_token *token = cp_lexer_peek_token (parser->lexer);
18132 && cp_parser_is_string_literal (cp_lexer_peek_nth_token (parser->lexer, 2)))
18139 cp_lexer_consume_token (parser->lexer);
18170 cp_token *token = cp_lexer_peek_token (parser->lexer);
18192 token = cp_lexer_peek_token (parser->lexer);
18205 cp_token *token = cp_lexer_peek_token (parser->lexer);
18224 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
18225 cp_lexer_consume_token (parser->lexer);
18229 ptk = cp_lexer_peek_token (parser->lexer);
18254 token = cp_lexer_peek_token (parser->lexer);
18267 cp_token *token = cp_lexer_peek_token (parser->lexer);
18272 cp_lexer_consume_token (parser->lexer); /* Eat '{'. */
18273 token = cp_lexer_peek_token (parser->lexer);
18283 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
18295 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
18302 token = cp_lexer_peek_token (parser->lexer);
18307 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
18316 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
18361 token = cp_lexer_peek_token (parser->lexer);
18365 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
18372 token = cp_lexer_peek_token (parser->lexer);
18375 cp_lexer_consume_token (parser->lexer); /* Eat '}'. */
18377 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
18378 cp_lexer_consume_token (parser->lexer);
18390 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
18391 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
18398 tok = cp_lexer_peek_nth_token (parser->lexer, 2);
18427 cp_token *next = cp_lexer_peek_token (parser->lexer);
18433 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
18438 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
18440 next = cp_lexer_peek_token (parser->lexer);
18460 cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */
18496 cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */
18529 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
18539 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
18558 if (cp_lexer_peek_token (parser->lexer)->keyword == RID_AT_INTERFACE)
18560 else if (cp_lexer_peek_token (parser->lexer)->keyword == RID_AT_PROTOCOL)
18604 location = cp_lexer_peek_token (parser->lexer)->location;
18612 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
18617 cp_lexer_consume_token (parser->lexer);
18626 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
18628 cp_lexer_consume_token (parser->lexer);
18629 location = cp_lexer_peek_token (parser->lexer)->location;
18655 location = cp_lexer_peek_token (parser->lexer)->location;
18682 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
18695 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
19739 cp_lexer_consume_token (parser->lexer); /* eat '^' */
19742 if (cp_lexer_peek_token (parser->lexer)->keyword == RID_ATTRIBUTE)
19746 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
19749 cp_lexer_consume_token (parser->lexer);
19765 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
19847 if (cp_lexer_peek_token (parser->lexer)->keyword == RID_ATTRIBUTE)
20472 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
20474 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
20476 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
20478 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
20480 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
20523 cp_lexer_consume_token (parser->lexer);
20587 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
20589 cp_lexer_consume_token (parser->lexer);
20632 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
20634 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
20655 cp_lexer_consume_token (parser->lexer);
20780 switch (cp_lexer_peek_token (parser->lexer)->type)
20814 cp_lexer_consume_token (parser->lexer);
20843 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
20845 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
20872 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
20876 cp_lexer_consume_token (parser->lexer);
20878 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
20880 cp_lexer_consume_token (parser->lexer);
20921 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
21090 switch (cp_lexer_peek_token (parser->lexer)->type)
21124 cp_lexer_consume_token (parser->lexer);
21159 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
21161 cp_lexer_consume_token (parser->lexer);
21189 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
21204 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
21209 loc = cp_lexer_consume_token (parser->lexer)->location;
21215 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
21269 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
21274 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
21373 if (cp_lexer_peek_token (parser->lexer)->pragma_kind != PRAGMA_OMP_SECTION)
21384 tok = cp_lexer_peek_token (parser->lexer);
21401 tok = cp_lexer_peek_token (parser->lexer);
21409 cp_lexer_consume_token (parser->lexer);
21485 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
21487 cp_lexer_consume_token (parser->lexer);
21493 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
21495 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
21499 cp_lexer_consume_token (parser->lexer);
21635 first pragma without benefit of an existing lexer structure.
21677 regular lexer. */
21685 pragma_tok = cp_lexer_consume_token (parser->lexer);
21687 parser->lexer->in_pragma = true;
21762 /* The interface the pragma parsers have to the lexer. */
21770 tok = cp_lexer_peek_token (the_parser->lexer);
21781 cp_lexer_consume_token (the_parser->lexer);