Cross Reference: /src/external/gpl3/gcc.old/dist/gcc/cp/parser.cc

Lines Matching defs:lexer
52 /* The lexer.  */
54 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
498   next_token = parser->lexer->next_token;
499   first_token = parser->lexer->buffer->address ();
503   cp_lexer_dump_tokens (file, parser->lexer->buffer, start_token, window_size,
523 	   vec_safe_length (parser->lexer->buffer));
589   token = parser->lexer->next_token;
614 /* Allocate memory for a new lexer object and return it.  */
620   cp_lexer *lexer = ggc_cleared_alloc<cp_lexer> ();
623   lexer->debugging_p = false;
625   lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK);
628   vec_alloc (lexer->buffer, CP_LEXER_BUFFER_SIZE);
630   return lexer;
633 /* Create a new main C++ lexer, the lexer that gets tokens from the
648   cp_lexer *lexer = cp_lexer_alloc ();
650   cp_token *tok = lexer->buffer->quick_push (token);
663       tok = vec_safe_push (lexer->buffer, cp_token ());
667   lexer->next_token = lexer->buffer->address ();
668   lexer->last_token = lexer->next_token
669                       + lexer->buffer->length ()
672   if (lexer->buffer->length () != 1)
691   gcc_assert (!lexer->next_token->purged_p);
692   return lexer;
695 /* Create a new lexer whose token stream is primed with the tokens in
703   cp_lexer *lexer = ggc_cleared_alloc<cp_lexer> ();
706   lexer->buffer = NULL;
709   lexer->saved_type = last->type;
710   lexer->saved_keyword = last->keyword;
714   lexer->next_token = first;
715   lexer->last_token = last;
717   lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK);
720   lexer->debugging_p = false;
722   gcc_assert (!lexer->next_token->purged_p
723 	      && !lexer->last_token->purged_p);
724   return lexer;
727 /* Frees all resources associated with LEXER.  */
730 cp_lexer_destroy (cp_lexer *lexer)
732   if (lexer->buffer)
733     vec_free (lexer->buffer);
737       lexer->last_token->type = lexer->saved_type;
738       lexer->last_token->keyword = lexer->saved_keyword;
740   lexer->saved_tokens.release ();
741   ggc_free (lexer);
744 /* This needs to be set to TRUE before the lexer-debugging infrastructure can
747    lexer is not being debugged.  */
754 cp_lexer_debugging_p (cp_lexer *lexer)
759   return lexer->debugging_p;
764 cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
766   return lexer->next_token - previous_p;
770 cp_lexer_token_at (cp_lexer * /*lexer*/, cp_token_position pos)
776 cp_lexer_set_token_position (cp_lexer *lexer, cp_token_position pos)
778   lexer->next_token = cp_lexer_token_at (lexer, pos);
782 cp_lexer_previous_token_position (cp_lexer *lexer)
784   return cp_lexer_token_position (lexer, true);
788 cp_lexer_previous_token (cp_lexer *lexer)
790   cp_token_position tp = cp_lexer_previous_token_position (lexer);
795       gcc_assert (tp != vec_safe_address (lexer->buffer));
799   return cp_lexer_token_at (lexer, tp);
802 /* Same as above, but return NULL when the lexer doesn't own the token
807 cp_lexer_safe_previous_token (cp_lexer *lexer)
809   if (lexer->buffer
810       && lexer->next_token != lexer->buffer->address ())
812       cp_token_position tp = cp_lexer_previous_token_position (lexer);
817 	  if (tp == lexer->buffer->address ())
821       return cp_lexer_token_at (lexer, tp);
827 /* Overload for make_location, taking the lexer to mean the location of the
831 make_location (location_t caret, location_t start, cp_lexer *lexer)
833   cp_token *t = cp_lexer_previous_token (lexer);
848 cp_lexer_saving_tokens (const cp_lexer* lexer)
850   return lexer->saved_tokens.length () != 0;
854    if we reach EOF.  If LEXER is NULL, assume we are handling an
855    initial #pragma pch_preprocess, and thus want the lexer to return
959 /* Update the globals input_location and the input file stack from LEXER.  */
961 cp_lexer_set_source_position (cp_lexer *lexer)
963   cp_token *token = cp_lexer_peek_token (lexer);
971 cp_lexer_peek_token (cp_lexer *lexer)
973   if (cp_lexer_debugging_p (lexer))
976       cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
979   return lexer->next_token;
985 cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
987   return cp_lexer_peek_token (lexer)->type == type;
993 cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
995   return !cp_lexer_next_token_is (lexer, type);
1001 cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
1003   return cp_lexer_peek_token (lexer)->keyword == keyword;
1007 cp_lexer_nth_token_is (cp_lexer* lexer, size_t n, enum cpp_ttype type)
1009   return cp_lexer_peek_nth_token (lexer, n)->type == type;
1013 cp_lexer_nth_token_is_keyword (cp_lexer* lexer, size_t n, enum rid keyword)
1015   return cp_lexer_peek_nth_token (lexer, n)->keyword == keyword;
1088 cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
1092   token = cp_lexer_peek_token (lexer);
1108 cp_lexer_next_token_is_decltype (cp_lexer *lexer)
1110   cp_token *t = cp_lexer_peek_token (lexer);
1143 cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
1150   if (cp_lexer_debugging_p (lexer))
1155   token = lexer->next_token;
1163   if (cp_lexer_debugging_p (lexer))
1172 /* Return the next token, and advance the lexer's next_token pointer
1176 cp_lexer_consume_token (cp_lexer* lexer)
1178   cp_token *token = lexer->next_token;
1183       lexer->next_token++;
1185   while (lexer
1190   if (cp_lexer_debugging_p (lexer))
1205 cp_lexer_purge_token (cp_lexer *lexer)
1207   cp_token *tok = lexer->next_token;
1218   lexer->next_token = tok;
1226 cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
1228   cp_token *peek = lexer->next_token;
1245 cp_lexer_save_tokens (cp_lexer* lexer)
1248   if (cp_lexer_debugging_p (lexer))
1251   lexer->saved_tokens.safe_push (lexer->next_token);
1257 cp_lexer_commit_tokens (cp_lexer* lexer)
1260   if (cp_lexer_debugging_p (lexer))
1263   lexer->saved_tokens.pop ();
1270 cp_lexer_rollback_tokens (cp_lexer* lexer)
1273   if (cp_lexer_debugging_p (lexer))
1276   lexer->next_token = lexer->saved_tokens.pop ();
1299   cp_lexer *lexer;
1304     : lexer (_lexer), mode (_mode)
1306     len = lexer->saved_tokens.length ();
1307     cp_lexer_save_tokens (lexer);
1311     cp_lexer_rollback_tokens (lexer);
1313       (cp_lexer_previous_token (lexer));
1319       cp_lexer_commit_tokens (lexer);
1323     gcc_assert (lexer->saved_tokens.length () == len);
1403 cp_lexer_start_debugging (cp_lexer* lexer)
1409   lexer->debugging_p = true;
1416 cp_lexer_stop_debugging (cp_lexer* lexer)
1422   lexer->debugging_p = false;
2907    These come through the lexer as three pairs and a single,
2913 cp_lexer_peek_conflict_marker (cp_lexer *lexer, enum cpp_ttype tok1_kind,
2916   cp_token *token2 = cp_lexer_peek_nth_token (lexer, 2);
2919   cp_token *token3 = cp_lexer_peek_nth_token (lexer, 3);
2922   cp_token *token4 = cp_lexer_peek_nth_token (lexer, 4);
2927   location_t start_loc = cp_lexer_peek_token (lexer)->location;
3016   cp_token *token = cp_lexer_peek_token (parser->lexer);
3035       if (cp_lexer_peek_conflict_marker (parser->lexer, token->type, &loc))
3042 	      cp_lexer_consume_token (parser->lexer);
3043 	      cp_token *next = cp_lexer_peek_token (parser->lexer);
3066     if (cp_token *prev_token = cp_lexer_safe_previous_token (parser->lexer))
3091     if (cp_token *prev_token = cp_lexer_safe_previous_token (parser->lexer))
3305   if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3322 	start = cp_lexer_token_position (parser->lexer, true);
3324       cp_lexer_consume_token (parser->lexer);
3330 	cp_lexer_purge_tokens_after (parser->lexer, start);
3598 	  if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3645 	  if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3674 	  else if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3708   cp_token *token = cp_lexer_peek_token (parser->lexer);
3713       cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
3727   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
3769       cp_token * token = cp_lexer_peek_token (parser->lexer);
3779 	  if (!parser->lexer->in_pragma)
3818 		cp_lexer_consume_token (parser->lexer);
3850       cp_lexer_consume_token (parser->lexer);
3885       cp_token *token = cp_lexer_peek_token (parser->lexer);
3890 	  if (!parser->lexer->in_pragma)
3927 	      cp_lexer_consume_token (parser->lexer);
3955       cp_lexer_consume_token (parser->lexer);
3973       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
3974 	cp_lexer_consume_token (parser->lexer);
3992       cp_token *token = cp_lexer_peek_token (parser->lexer);
3997 	  if (!parser->lexer->in_pragma)
4044       cp_lexer_consume_token (parser->lexer);
4059       cp_token *token = cp_lexer_peek_token (parser->lexer);
4064 	  if (!parser->lexer->in_pragma)
4089       cp_lexer_consume_token (parser->lexer);
4109       gcc_checking_assert (cp_lexer_next_token_is_not (parser->lexer, CPP_EOF));
4110       token = cp_lexer_consume_token (parser->lexer);
4116       parser->lexer->in_pragma = false;
4117       if (parser->lexer->in_omp_attribute_pragma
4118 	  && cp_lexer_next_token_is (parser->lexer, CPP_EOF))
4120 	  parser->lexer = parser->lexer->next;
4122 	     lexer was pushed.  */
4123 	  cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4134   parser->lexer->in_pragma = false;
4137   else if (parser->lexer->in_omp_attribute_pragma
4138 	   && cp_lexer_next_token_is (parser->lexer, CPP_EOF))
4140       parser->lexer = parser->lexer->next;
4142 	 lexer was pushed.  */
4143       cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4201 cp_parser_new (cp_lexer *lexer)
4209   parser->lexer = lexer;
4285    and push it onto the parser's lexer stack.  This is used for delayed
4291   cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
4292   lexer->next = parser->lexer;
4293   parser->lexer = lexer;
4296      new lexer.  */
4297   cp_lexer_set_source_position_from_token (lexer->next_token);
4300 /* Pop the top lexer off the parser stack.  This is never used for the
4301    "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens.  */
4305   cp_lexer *lexer = parser->lexer;
4306   parser->lexer = lexer->next;
4307   cp_lexer_destroy (lexer);
4310      lexer was pushed.  */
4311   cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4363   tok = cp_lexer_peek_token (parser->lexer);
4388       (cp_lexer_peek_nth_token (parser->lexer, 2)))
4390       cp_lexer_consume_token (parser->lexer);
4416 	  cp_lexer_consume_token (parser->lexer);
4461 	  tok = cp_lexer_peek_token (parser->lexer);
4604   cp_token *token = cp_lexer_consume_token (parser->lexer);
4702   cp_token *token = cp_lexer_consume_token (parser->lexer);
4936       cp_token *token = cp_lexer_peek_token (parser->lexer);
4942 	  != cp_lexer_peek_token (parser->lexer)->implicit_extern_c)
4964 	      cp_lexer_consume_token (parser->lexer);
4965 	      next = cp_lexer_peek_token (parser->lexer);
5006 	  cp_lexer_consume_token (parser->lexer);
5008 	  if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
5009 	    cp_lexer_consume_token (parser->lexer);
5016   cp_lexer_destroy (parser->lexer);
5017   parser->lexer = NULL;
5051   return cp_lexer_token_position (parser->lexer, false);
5067   cp_token *token = cp_lexer_token_at (parser->lexer, start);
5071   cp_lexer_purge_tokens_after (parser->lexer, start);
5132     m_open_loc = cp_lexer_peek_token (parser->lexer)->location;
5142     cp_token *tok = cp_lexer_consume_token (parser->lexer);
5206   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
5216   location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
5336   cp_token* token = cp_lexer_peek_token (parser->lexer);
5339     cp_lexer_consume_token (parser->lexer);
5358   if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5362       cp_lexer_consume_token (parser->lexer);
5377   const cp_token* token = cp_lexer_peek_token (parser->lexer);
5385   if (cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS))
5390   cp_lexer_consume_token (parser->lexer);
5407   if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
5410   if (cp_lexer_next_token_is_not (parser->lexer, token->type))
5415   cp_lexer_consume_token (parser->lexer);
5492   token = cp_lexer_peek_token (parser->lexer);
5512       token = cp_lexer_consume_token (parser->lexer);
5533 	      next_token = cp_lexer_peek_token (parser->lexer);
5595 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_BRACE))
5614 	      if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
5615 		cp_lexer_consume_token (parser->lexer);
5637 	if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5644 	token = cp_lexer_peek_token (parser->lexer);
5675 	token = cp_lexer_peek_token (parser->lexer);
5720 	  cp_lexer_consume_token (parser->lexer);
5723 	  cp_lexer_consume_token (parser->lexer);
5728 	  cp_lexer_consume_token (parser->lexer);
5733 	  cp_lexer_consume_token (parser->lexer);
5738 	  cp_lexer_consume_token (parser->lexer);
5768 	    token = cp_lexer_consume_token (parser->lexer);
5798 	      = cp_lexer_peek_token (parser->lexer)->location;
5801 	    cp_lexer_consume_token (parser->lexer);
5809 	    type_location = cp_lexer_peek_token (parser->lexer)->location;
5817 	      = cp_lexer_peek_token (parser->lexer)->location;
5883 	      && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
5924 	token = cp_lexer_peek_token (parser->lexer);
5967 		&& cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
5972 		cp_lexer_consume_token (parser->lexer);
6160   cp_token *token = cp_lexer_peek_token (parser->lexer);
6211       token = cp_lexer_peek_token (parser->lexer);
6258       saved_token_sentinel toks (parser->lexer, STS_ROLLBACK);
6263 	  && (cp_lexer_peek_token (parser->lexer)->type
6305   token = cp_lexer_peek_token (parser->lexer);
6342 	cp_lexer_consume_token (parser->lexer);
6385 	    if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
6386 	      cp_lexer_consume_token (parser->lexer);
6396 	    if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
6397 	      cp_lexer_consume_token (parser->lexer);
6411 	token = cp_lexer_peek_token (parser->lexer);
6425 	    && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6431 	    cp_lexer_consume_token (parser->lexer);
6442 	    cp_lexer_consume_token (parser->lexer);
6684       && cp_lexer_next_token_is_not (parser->lexer, CPP_NESTED_NAME_SPECIFIER))
6686       start = cp_lexer_token_position (parser->lexer, false);
6698       token = cp_lexer_peek_token (parser->lexer);
6742 	  token = cp_lexer_peek_nth_token (parser->lexer, 2);
6746 	      && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_NAME
6827 	  if (cp_lexer_next_token_is (parser->lexer, CPP_DECLTYPE)
6828 	      && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6831 	      token = cp_lexer_consume_token (parser->lexer);
6841 	      cp_lexer_consume_token (parser->lexer);
6844 	  if (cp_lexer_next_token_is (parser->lexer, CPP_TEMPLATE_ID)
6845 	      && cp_lexer_nth_token_is (parser->lexer, 2, CPP_SCOPE))
6849 	      token = cp_lexer_peek_token (parser->lexer);
6890 		  cp_lexer_consume_token (parser->lexer);
6891 		  cp_lexer_consume_token (parser->lexer);
6900 	  while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
6901 		 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6903 		 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
6906 	      token = cp_lexer_consume_token (parser->lexer);
6963 	      cp_lexer_consume_token (parser->lexer);
7006       token = cp_lexer_token_at (parser->lexer, start);
7020       cp_lexer_purge_tokens_after (parser->lexer, start);
7092   if (cp_lexer_next_token_is_decltype (parser->lexer))
7138       if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
7139 	  || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
7152   cp_lexer_save_tokens (parser->lexer);
7160        && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
7163   cp_lexer_rollback_tokens (parser->lexer);
7233   token = cp_lexer_peek_token (parser->lexer);
7254 	cp_lexer_consume_token (parser->lexer);
7341 	cp_lexer_consume_token (parser->lexer);
7419 	cp_lexer_consume_token (parser->lexer);
7513 	cp_lexer_consume_token (parser->lexer);
7522 	  = cp_lexer_peek_token (parser->lexer)->location;
7541 	cp_lexer_consume_token (parser->lexer);
7546 	  = cp_lexer_peek_token (parser->lexer)->location;
7590 	    && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
7674 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
7680       token = cp_lexer_peek_token (parser->lexer);
7905 	  cp_lexer_consume_token (parser->lexer);
7918 	  cp_lexer_consume_token (parser->lexer);
7933 	  cp_lexer_consume_token (parser->lexer);
7971   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
7974       cp_lexer_set_source_position (parser->lexer);
7993       && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
7996       cp_lexer_consume_token (parser->lexer);
8022   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
8026   cp_lexer_consume_token (parser->lexer);
8044 	  && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
8068 	      if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
8078 	      cp_lexer_consume_token (parser->lexer);
8083       else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8086 	  cp_lexer_set_source_position (parser->lexer);
8300       cp_token *token = cp_lexer_peek_token (parser->lexer);
8363 	    = make_location (input_location, start_loc, parser->lexer);
8447   if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
8453 	    && cp_lexer_peek_token (parser->lexer
8458 	    token = cp_lexer_consume_token (parser->lexer);
8488 	if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
8492 	cp_lexer_consume_token (parser->lexer);
8496     *close_paren_loc = cp_lexer_peek_token (parser->lexer)->location;
8549   if (cp_lexer_next_token_is (parser->lexer, CPP_COMPL)
8550       && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_AUTO)
8557       cp_lexer_consume_token (parser->lexer);
8558       cp_lexer_consume_token (parser->lexer);
8580       && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
8583       cp_lexer_consume_token (parser->lexer);
8595   else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
8603       if (cp_lexer_peek_token (parser->lexer)->type != CPP_NAME
8604 	  || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE
8605 	  || cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_COMPL)
8676   token = cp_lexer_peek_token (parser->lexer);
8695 	    cp_lexer_consume_token (parser->lexer);
8705 	      = make_location (start_loc, start_loc, parser->lexer);
8780 	    cp_lexer_consume_token (parser->lexer);
8806 	    cp_lexer_consume_token (parser->lexer);
8849 	      = make_location (start_loc, start_loc, parser->lexer);
8861 	    cp_lexer_consume_token (parser->lexer);
8880   if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
8886       keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
8914 	  cp_lexer_consume_token (parser->lexer);
8922 	    = make_location (start_loc, start_loc, parser->lexer);
8940       token = cp_lexer_consume_token (parser->lexer);
8941       enum cpp_ttype op_ttype = cp_lexer_peek_token (parser->lexer)->type;
9071   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
9074   cp_lexer_consume_token (parser->lexer);
9145   location_t atloc = cp_lexer_peek_token (parser->lexer)->location;
9176     = make_location (start_loc, start_loc, parser->lexer);
9202   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
9226   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
9246       token = cp_lexer_peek_token (parser->lexer);
9250       if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
9264   cp_token *token = cp_lexer_peek_token (parser->lexer);
9299 					       parser->lexer);
9448   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
9476       token = cp_lexer_peek_token (parser->lexer);
9510       if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
9531   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
9535       cp_lexer_set_source_position (parser->lexer);
9564   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
9574   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
9577       cp_lexer_consume_token (parser->lexer);
9600 					   parser->lexer);
9614   cp_token *token = cp_lexer_peek_token (parser->lexer);
9660       return cp_lexer_peek_nth_token (parser->lexer, 2)->type
9786   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
9847       cp_lexer_save_tokens (parser->lexer);
9856       cp_lexer_rollback_tokens (parser->lexer);
10035   current.lhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
10047       token = cp_lexer_peek_token (parser->lexer);
10062 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
10086       cp_lexer_consume_token (parser->lexer);
10101       rhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
10108       token = cp_lexer_peek_token (parser->lexer);
10111 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
10259   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10262   cp_lexer_consume_token (parser->lexer);
10263   token = cp_lexer_peek_token (parser->lexer);
10333   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
10337   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CO_YIELD))
10349       if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
10353 	  location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10423   token = cp_lexer_peek_token (parser->lexer);
10478       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
10483     cp_lexer_consume_token (parser->lexer);
10522 	  && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
10545       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
10546 	  || cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
10549       loc = cp_lexer_peek_token (parser->lexer)->location;
10561       cp_lexer_consume_token (parser->lexer);
10643       if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
10702   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
10705   cp_lexer_consume_token (parser->lexer);
10710   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10720   token = cp_lexer_peek_token (parser->lexer);
10732       token = cp_lexer_peek_token (parser->lexer);
10749 	  cp_lexer_consume_token (parser->lexer);
10757 	  finish_loc = cp_lexer_peek_token (parser->lexer)->location;
10758 	  cp_lexer_consume_token (parser->lexer);
10925   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
10928   cp_lexer_consume_token (parser->lexer);
10955       while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
10957 	  cp_lexer_consume_token (parser->lexer);
10959 	  if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
10961 	      cp_lexer_consume_token (parser->lexer);
10971   location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
11010   cp_token *token = cp_lexer_peek_token (parser->lexer);
11122 	  cp_lexer_consume_token (parser->lexer);
11159 						      parser->lexer);
11190   if (cp_lexer_next_token_is (parser->lexer, CPP_AND)
11191       && !cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS)
11192       && !cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME)
11193       && !cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_THIS))
11195   else if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
11200       cp_lexer_consume_token (parser->lexer);
11209   while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_SQUARE))
11224       if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
11236       if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THIS))
11238 	  location_t loc = cp_lexer_peek_token (parser->lexer)->location;
11245 	  cp_lexer_consume_token (parser->lexer);
11258       if (cp_lexer_next_token_is (parser->lexer, CPP_MULT)
11259 	  && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_THIS))
11261 	  location_t loc = cp_lexer_peek_token (parser->lexer)->location;
11266 	  cp_lexer_consume_token (parser->lexer);
11267 	  cp_lexer_consume_token (parser->lexer);
11280       if (cp_lexer_next_token_is (parser->lexer, CPP_AND)
11281 	  && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_THIS))
11283 	  error_at (cp_lexer_peek_token (parser->lexer)->location,
11285 	  cp_lexer_consume_token (parser->lexer);
11286 	  cp_lexer_consume_token (parser->lexer);
11291       if (cp_lexer_next_token_is (parser->lexer, CPP_AND))
11294 	  cp_lexer_consume_token (parser->lexer);
11299       if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11301 	  ellipsis_loc = cp_lexer_peek_token (parser->lexer)->location;
11306 	  cp_lexer_consume_token (parser->lexer);
11312 	  && cp_lexer_next_token_is (parser->lexer, CPP_AND))
11314 	  pedwarn (cp_lexer_peek_token (parser->lexer)->location,
11317 	  cp_lexer_consume_token (parser->lexer);
11321       capture_token = cp_lexer_peek_token (parser->lexer);
11338       if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
11339 	  || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
11340 	  || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
11411 	  if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11413 	      location_t loc = cp_lexer_peek_token (parser->lexer)->location;
11414 	      cp_lexer_consume_token (parser->lexer);
11421 		  if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
11422 		      || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
11423 		      || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
11516   if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
11520 	pedwarn (parser->lexer->next_token->location, OPT_Wc__20_extensions,
11524       cp_lexer_consume_token (parser->lexer);
11551   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
11559 	       cp_lexer_nth_token_is (parser->lexer, n, CPP_KEYWORD); n++)
11561 	      if (cp_lexer_peek_nth_token (parser->lexer, n)->keyword
11596     omitted_parms_loc = cp_lexer_peek_token (parser->lexer)->location;
11601   if (cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer))
11655   if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
11662       cp_lexer_consume_token (parser->lexer);
11986       && !cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
11993   if (cnt && cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
11995       cp_token *token = cp_lexer_peek_token (parser->lexer);
12009   cp_lexer *lexer = cp_lexer_alloc ();
12010   lexer->debugging_p = parser->lexer->debugging_p;
12011   vec_safe_reserve (lexer->buffer, tokens, true);
12025       lexer->buffer->quick_push (tok);
12027 	lexer->buffer->quick_push (*first);
12032       lexer->buffer->quick_push (tok);
12037   tok.location = lexer->buffer->last ().location;
12038   lexer->buffer->quick_push (tok);
12039   lexer->next = parser->lexer;
12040   lexer->next_token = lexer->buffer->address ();
12041   lexer->last_token = lexer->next_token
12042 		      + lexer->buffer->length ()
12044   lexer->in_omp_attribute_pragma = true;
12045   parser->lexer = lexer;
12047      new lexer.  */
12048   cp_lexer_set_source_position_from_token (lexer->next_token);
12195   bool in_omp_attribute_pragma = parser->lexer->in_omp_attribute_pragma;
12204   saved_token_sentinel saved_tokens (parser->lexer);
12205   token = cp_lexer_peek_token (parser->lexer);
12214     attrs_loc = make_location (attrs_loc, attrs_loc, parser->lexer);
12220   has_std_attrs = cp_lexer_peek_token (parser->lexer) != token;
12223   token = cp_lexer_peek_token (parser->lexer);
12268 	  token = cp_lexer_peek_token (parser->lexer);
12292 	  in_omp_attribute_pragma = parser->lexer->in_omp_attribute_pragma;
12367       token = cp_lexer_peek_nth_token (parser->lexer, 2);
12376 	  in_omp_attribute_pragma = parser->lexer->in_omp_attribute_pragma;
12391       cp_lexer *lexer = parser->lexer;
12402       if (parser->lexer != lexer
12403 	  && lexer->in_omp_attribute_pragma
12404 	  && (!in_omp_attribute_pragma || lexer->orphan_p))
12406 	  if (saved_tokens.lexer == lexer)
12409 		cp_lexer_commit_tokens (lexer);
12410 	      gcc_assert (lexer->saved_tokens.length () == saved_tokens.len);
12411 	      saved_tokens.lexer = parser->lexer;
12413 	      saved_tokens.len = parser->lexer->saved_tokens.length ();
12415 	  cp_lexer_destroy (lexer);
12416 	  lexer = parser->lexer;
12420       if (parser->lexer == lexer
12421 	  && lexer->in_omp_attribute_pragma
12423 	parser->lexer->orphan_p = true;
12438       if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
12456 	      cp_lexer_set_token_position (parser->lexer, statement_token);
12461 		  while (cp_lexer_peek_nth_token (parser->lexer, i)->keyword
12464 		  switch (cp_lexer_peek_nth_token (parser->lexer, i)->keyword)
12489 		      token = cp_lexer_peek_token (parser->lexer);
12568   token = cp_lexer_peek_token (parser->lexer);
12589 	cp_lexer_consume_token (parser->lexer);
12595 	ellipsis = cp_lexer_peek_token (parser->lexer);
12599 	    cp_lexer_consume_token (parser->lexer);
12628       cp_lexer_consume_token (parser->lexer);
12669 	  || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
12697   cp_token *token = cp_lexer_peek_token (parser->lexer);
12705   if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
12736   if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
12758       && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
12801   while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
12827       cp_token *token = cp_lexer_peek_token (parser->lexer);
12846 	      token = cp_lexer_consume_token (parser->lexer);
12865   cp_lexer_save_tokens (parser->lexer);
12875   cp_lexer_consume_token (parser->lexer);
12885   cp_lexer_rollback_tokens (parser->lexer);
12896   cp_lexer_save_tokens (parser->lexer);
12905   cp_lexer_rollback_tokens (parser->lexer);
12954 	    && cp_lexer_next_token_is_keyword (parser->lexer,
12958 	    cp_token *tok = cp_lexer_consume_token (parser->lexer);
12967 	    if (cp_lexer_next_token_is_keyword (parser->lexer,
12970 	    else if (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
12971 		     && cp_lexer_nth_token_is_keyword (parser->lexer, 2,
12975 		cp_lexer_consume_token (parser->lexer);
12980 	    cp_token *tok = cp_lexer_consume_token (parser->lexer);
12993 	    if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
13005 		  = cp_lexer_peek_token (parser->lexer)->location;
13015 	    if (cp_lexer_next_token_is_keyword (parser->lexer,
13018 		cp_token *else_tok = cp_lexer_peek_token (parser->lexer);
13022 		cp_lexer_consume_token (parser->lexer);
13026 		if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
13040 		      = cp_lexer_peek_token (parser->lexer)->location;
13083 	      pedwarn (cp_lexer_peek_token (parser->lexer)->location,
13087 	    if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13143 	    if (cp_lexer_next_token_is_keyword (parser->lexer,
13155 		  = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
13157 		cp_lexer_consume_token (parser->lexer);
13160 		    if (cp_lexer_next_token_is_keyword (parser->lexer,
13179 		    else if (!cp_lexer_next_token_is_keyword (parser->lexer,
13269       && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)
13270       && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
13359       location_t loc = cp_lexer_peek_token (parser->lexer)->location;
13380       if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
13381 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
13401 	  declarator->init_loc = cp_lexer_peek_token (parser->lexer)->location;
13403 	  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13409 	  else if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
13412 	      cp_lexer_consume_token (parser->lexer);
13460       && cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13466 	  pedwarn (cp_lexer_peek_token (parser->lexer)->location,
13499   if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13518   if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
13581   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
14151   if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
14163       if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
14169 	    pedwarn (cp_lexer_peek_token (parser->lexer)->location,
14180       if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
14183 	  cp_lexer_consume_token (parser->lexer);
14186 	    pedwarn (cp_lexer_peek_token (parser->lexer)->location,
14290 	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
14292 	    cp_lexer_set_source_position (parser->lexer);
14296 	else if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
14326       if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
14331 	  cp_lexer_consume_token (parser->lexer);
14394   location_t body_loc = cp_lexer_peek_token (parser->lexer)->location;
14397     = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
14403   if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
14405       cp_lexer_consume_token (parser->lexer);
14409 	  && !cp_lexer_next_token_is_keyword (parser->lexer, RID_ELSE))
14417   else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
14432     = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
14454   if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
14457 	= get_token_indent_info (cp_lexer_peek_token (parser->lexer));
14463 	= get_token_indent_info (cp_lexer_peek_token (parser->lexer));
14479       while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
14499   cp_token *token = cp_lexer_peek_token (parser->lexer);
14502       cp_lexer_consume_token (parser->lexer);
14512       cp_lexer_consume_token (parser->lexer);
14517       if (cp_lexer_peek_token (parser->lexer)->type != CPP_NAME)
14523       tree name = cp_lexer_consume_token (parser->lexer)->u.value;
14525       token = cp_lexer_peek_token (parser->lexer);
14531       cp_lexer_consume_token (parser->lexer);
14548   parser->lexer->in_pragma = true;
14549   cp_token *token = cp_lexer_consume_token (parser->lexer);
14558       && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
14561       cp_lexer_consume_token (parser->lexer);
14567 	   && cp_lexer_next_token_is (parser->lexer, CPP_COLON)
14568 	   && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_PRIVATE)
14569 	   && cp_lexer_nth_token_is (parser->lexer, 3, CPP_SEMICOLON))
14571       cp_lexer_consume_token (parser->lexer);
14572       cp_lexer_consume_token (parser->lexer);
14573       cp_lexer_consume_token (parser->lexer);
14619   parser->lexer->in_pragma = true;
14620   cp_token *token = cp_lexer_consume_token (parser->lexer);
14679   gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT));
14680   cp_token *token = cp_lexer_consume_token (parser->lexer);
14687 lexer, CPP_OPEN_BRACE);
14701       cp_lexer_consume_token (parser->lexer);
14710       if (cp_lexer_next_token_is_keyword (parser->lexer, RID__MODULE)
14711 	  || cp_lexer_next_token_is_keyword (parser->lexer, RID__IMPORT)
14712 	  || cp_lexer_next_token_is_keyword (parser->lexer, RID__EXPORT))
14736       cp_token *token = cp_lexer_peek_token (parser->lexer);
14790   cp_token *token1 = cp_lexer_peek_token (parser->lexer);
14792 		      ? token1 : cp_lexer_peek_nth_token (parser->lexer, 2));
14796       cp_lexer_consume_token (parser->lexer);
14803   else if (cp_lexer_nth_token_is (parser->lexer,
14813 	  gcc_assert (!parser->lexer->in_omp_attribute_pragma);
14816 	  if (parser->lexer->in_omp_attribute_pragma)
14818 	      cp_lexer *lexer = parser->lexer;
14819 	      while (parser->lexer->in_omp_attribute_pragma)
14821 		  gcc_assert (cp_lexer_next_token_is (parser->lexer,
14825 	      cp_lexer_destroy (lexer);
14830 	warning_at (make_location (attrs_loc, attrs_loc, parser->lexer),
14832       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
14833 	cp_lexer_consume_token (parser->lexer);
14845       cp_lexer_save_tokens (parser->lexer);
14847       cp_token *t1 = cp_lexer_peek_token (parser->lexer);
14849 		      ? t1 : cp_lexer_peek_nth_token (parser->lexer, 2));
14853 	  cp_lexer_commit_tokens (parser->lexer);
14870 	  cp_lexer_rollback_tokens (parser->lexer);
14895 	  && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
14920 	cp_lexer_consume_token (parser->lexer);
14940 		&& (cp_lexer_peek_nth_token (parser->lexer, 3)->type
14943                    && cp_lexer_peek_nth_token (parser->lexer, 3)->type
14979   cp_token *token = cp_lexer_peek_token (parser->lexer);
15033   cp_token *token1 = cp_lexer_peek_token (parser->lexer);
15057       token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
15066 	       && ((cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ)
15078       cp_lexer_consume_token (parser->lexer);
15082       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15083 	cp_lexer_consume_token (parser->lexer);
15091 	   && cp_lexer_nth_token_is_keyword (parser->lexer, attr_idx,
15093 	   && cp_lexer_nth_token_is_keyword (parser->lexer, attr_idx + 1,
15198     if (cp_lexer_nth_token_is (parser->lexer, n, CPP_AND)
15199 	|| cp_lexer_nth_token_is (parser->lexer, n, CPP_AND_AND))
15201     else if (cp_lexer_nth_token_is (parser->lexer, n, CPP_OPEN_SQUARE)
15202 	     && !cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_SQUARE)
15211 	cp_token *token = cp_lexer_peek_token (parser->lexer);
15233 	    if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15234 	      cp_lexer_consume_token (parser->lexer);
15257   while (cp_lexer_next_token_is_not (parser->lexer,
15268 	  token = cp_lexer_peek_token (parser->lexer);
15270 	  cp_lexer_consume_token (parser->lexer);
15349 	  if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
15351 	      cp_token *token = cp_lexer_peek_token (parser->lexer);
15367       token = cp_lexer_peek_token (parser->lexer);
15393 	  if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15394 	    cp_lexer_consume_token (parser->lexer);
15430   else if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
15455   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
15460   if (!cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
15467 	if (!cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
15469 	cp_lexer_consume_token (parser->lexer);
15472   location_t end_loc = cp_lexer_peek_token (parser->lexer)->location;
15478       if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
15479 	cp_lexer_consume_token (parser->lexer);
15546       || cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
15549       *init_loc = cp_lexer_peek_token (parser->lexer)->location;
15654       token = cp_lexer_peek_token (parser->lexer);
15729 	      cp_lexer_purge_token (parser->lexer);
15735 	      cp_lexer_consume_token (parser->lexer);
15741           cp_lexer_consume_token (parser->lexer);
15746 	  cp_lexer_consume_token (parser->lexer);
15751 	  cp_lexer_consume_token (parser->lexer);
15756           cp_lexer_consume_token (parser->lexer);
15765 	      cp_token *next = cp_lexer_peek_token (parser->lexer);
15777 	  if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
15778 	      && cp_lexer_nth_token_is (parser->lexer, 2, CPP_EQ)
15802 	  cp_lexer_consume_token (parser->lexer);
15830 	      cp_lexer_consume_token (parser->lexer);
15854 	  cp_lexer_consume_token (parser->lexer);
15861 	  cp_lexer_consume_token (parser->lexer);
16012   switch (cp_lexer_peek_token (parser->lexer)->keyword)
16026       return cp_lexer_consume_token (parser->lexer)->u.value;
16050   cp_token *token = cp_lexer_peek_token (parser->lexer);
16070 	tree id = cp_lexer_consume_token (parser->lexer)->u.value;
16073 	if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
16122   return cp_lexer_consume_token (parser->lexer)->u.value;
16141   cp_token *string_token = cp_lexer_peek_token (parser->lexer);
16177   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
16228   token_loc = cp_lexer_peek_token (parser->lexer)->location;
16251   if (cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
16258       cp_lexer_consume_token (parser->lexer);
16307   id_expr_start_token = cp_lexer_peek_token (parser->lexer);
16337           && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
16363           && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
16383           && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
16416   cp_token *start_token = cp_lexer_peek_token (parser->lexer);
16421       cp_lexer_consume_token (parser->lexer);
16449   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO)
16450       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN))
16453       cp_lexer_consume_token (parser->lexer);
16555   loc = make_location (loc, loc, parser->lexer);
16558   cp_lexer_purge_tokens_after (parser->lexer, start_token);
16729 lexer, CPP_COLON))
16738   cp_lexer_consume_token (parser->lexer);
16754   cp_token *token = cp_lexer_peek_token (parser->lexer);
16767       token = cp_lexer_peek_token (parser->lexer);
16771       bool ellipsis = cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS);
16779 	    cp_lexer_consume_token (parser->lexer);
16824       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
16827       cp_lexer_consume_token (parser->lexer);
16857   cp_token *token = cp_lexer_peek_token (parser->lexer);
16860   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
16876   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
16879       cp_lexer_set_source_position (parser->lexer);
16915     = make_location (token->location, token->location, parser->lexer);
16942   cp_token *token = cp_lexer_peek_token (parser->lexer);
16945   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
16950       cp_lexer_consume_token (parser->lexer);
16990   if (cp_lexer_next_token_is_decltype (parser->lexer))
17022   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
17069   token = cp_lexer_peek_token (parser->lexer);
17092 	end_loc = cp_lexer_consume_token (parser->lexer)->location;
17095 	token = cp_lexer_peek_token (parser->lexer);
17102 	    cp_lexer_consume_token (parser->lexer);
17275       cp_lexer_consume_token (parser->lexer);
17297       cp_lexer_consume_token (parser->lexer);
17341 	    token = cp_lexer_peek_token (parser->lexer);
17384 	  = make_location (start_loc, start_loc, parser->lexer);
17399 	cp_lexer_consume_token (parser->lexer);
17445   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
17448       cp_lexer_consume_token (parser->lexer);
17496       parm_loc = cp_lexer_peek_token (parser->lexer)->location;
17514       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
17517       cp_lexer_consume_token (parser->lexer);
17544       bool is_pack = cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS);
17546 	cp_lexer_consume_token (parser->lexer);
17555 	= cp_lexer_peek_token (parser->lexer)->location;
17561       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
17564       cp_lexer_consume_token (parser->lexer);
17768   gcc_assert (cp_lexer_next_token_is (parser->lexer, CPP_EQ));
17771   cp_lexer_consume_token (parser->lexer);
17773   cp_token *token = cp_lexer_peek_token (parser->lexer);
17801   gcc_assert (cp_lexer_next_token_is (parser->lexer, CPP_EQ));
17806   cp_lexer_consume_token (parser->lexer);
17811   const cp_token* token = cp_lexer_peek_token (parser->lexer);
17865   token = cp_lexer_peek_token (parser->lexer);
17885       token = cp_lexer_peek_nth_token (parser->lexer, 2);
17892 	token = cp_lexer_peek_nth_token (parser->lexer, 3);
17926       if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
17928 	cp_lexer_consume_token (parser->lexer);
17994         if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
17997             cp_lexer_consume_token (parser->lexer);
18005 	if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
18014 	if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
18070         if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
18073             cp_lexer_consume_token (parser->lexer);
18082 	if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
18083 	    && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
18084 	    && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
18100 	if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
18167   cp_token *token = cp_lexer_peek_token (parser->lexer);
18171       cp_lexer_consume_token (parser->lexer);
18188     start_of_id = cp_lexer_token_position (parser->lexer, false);
18215   if (((next_token = cp_lexer_peek_token (parser->lexer))->type
18218       && ((next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2))->type
18227       cp_lexer_consume_token (parser->lexer);
18274 	      || cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)))
18289 		error_at (cp_lexer_peek_token (parser->lexer)->location,
18293 		cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
18308     = make_location (token->location, token->location, parser->lexer);
18333 	   && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE));
18397       cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
18475   cp_token *token = cp_lexer_peek_token (parser->lexer);
18479   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
18541 	    start = cp_lexer_token_position (parser->lexer, true);
18544 	  cp_lexer_consume_token (parser->lexer);
18557 	    cp_lexer_purge_tokens_after (parser->lexer, start);
18653 	  && cp_lexer_next_token_is (parser->lexer, CPP_LESS)
18726 	cp_lexer_consume_token (parser->lexer);
18733       if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
18737 	      cp_token *token = cp_lexer_peek_token (parser->lexer);
18742           cp_lexer_consume_token (parser->lexer);
18751   while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
18824       && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
18843   argument_start_token = cp_lexer_peek_token (parser->lexer);
18898   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
18915   address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
18918       loc = cp_lexer_peek_token (parser->lexer)->location;
18919       cp_lexer_consume_token (parser->lexer);
18922   token = cp_lexer_peek_token (parser->lexer);
19011 	  && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
19187   cp_token *token = cp_lexer_peek_token (parser->lexer);
19218       if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
19220 	  if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
19221 	      && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
19306   token = cp_lexer_peek_token (parser->lexer);
19421       return cp_lexer_consume_token (parser->lexer)->u.value;
19497   token = cp_lexer_peek_token (parser->lexer);
19582 	  cp_lexer_consume_token (parser->lexer);
19583 	  while (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
19584 		 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
19585 		 && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
19586 		 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
19588 	      if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
19590 		  cp_lexer_consume_token (parser->lexer);
19598 	      if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
19604 	      cp_lexer_consume_token (parser->lexer);
19650       cp_lexer_set_token_position (parser->lexer, token);
19655       cp_lexer_consume_token (parser->lexer);
19693       && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
19706       cp_lexer_consume_token (parser->lexer);
19727       cp_lexer_consume_token (parser->lexer);
19758       token = cp_lexer_peek_token (parser->lexer);
19805 	       && cp_lexer_next_token_is (parser->lexer, CPP_TEMPLATE_ID))
19876 		= cp_lexer_previous_token (parser->lexer)->location;
20014       if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
20015 	placeholder = cp_lexer_consume_token (parser->lexer);
20016       else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DECLTYPE))
20018 	  placeholder = cp_lexer_consume_token (parser->lexer);
20212   cp_token *token = cp_lexer_peek_token (parser->lexer);
20241 	  && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT))
20298   location_t key_loc = cp_lexer_peek_token (parser->lexer)->location;
20303   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
20306       cp_lexer_consume_token (parser->lexer);
20311       cp_token *token = cp_lexer_peek_token (parser->lexer);
20323 	  cp_lexer_consume_token (parser->lexer);
20334   else if (cp_lexer_next_token_is_keyword (parser->lexer,
20338       cp_lexer_consume_token (parser->lexer);
20345       key_loc = cp_lexer_peek_token (parser->lexer)->location;
20401       token = cp_lexer_peek_token (parser->lexer);
20443 	      && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
20452       token = cp_lexer_peek_token (parser->lexer);
20554           if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
20612 		   && cp_lexer_next_token_is (parser->lexer,
20622 		 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
20747   cp_lexer_consume_token (parser->lexer);
20751   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CLASS)
20752       || cp_lexer_next_token_is_keyword (parser->lexer, RID_STRUCT))
20758       cp_lexer_consume_token (parser->lexer);
20773   type_start_token = cp_lexer_peek_token (parser->lexer);
20821       if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
20836   if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
20841       cp_lexer_consume_token (parser->lexer);
20874   if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
20886 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
20923   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
21010       else if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
21014 	      && cp_lexer_nth_token_is (parser->lexer, 2, CPP_SEMICOLON))
21037       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
21097       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
21100       cp_lexer_consume_token (parser->lexer);
21102       if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
21137   loc = cp_lexer_peek_token (parser->lexer)->location;
21148   if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
21151       cp_lexer_consume_token (parser->lexer);
21190   cp_token *token = cp_lexer_peek_token (parser->lexer);
21283   bool is_inline = cp_lexer_next_token_is_keyword (parser->lexer, RID_INLINE);
21289       cp_lexer_consume_token (parser->lexer);
21303       bool nested_inline_p = cp_lexer_next_token_is_keyword (parser->lexer,
21308 	    pedwarn (cp_lexer_peek_token (parser->lexer)->location,
21312 	  cp_lexer_consume_token (parser->lexer);
21315       if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
21328       if (cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
21351       cp_lexer_consume_token (parser->lexer);
21412   cp_token *token = cp_lexer_peek_token (parser->lexer);
21422       && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
21426       cp_lexer_consume_token (parser->lexer);
21428 	cp_lexer_consume_token (parser->lexer);
21519       diag_token = cp_lexer_peek_token (parser->lexer);
21529       token = cp_lexer_peek_token (parser->lexer);
21536 	  cp_lexer_consume_token (parser->lexer);
21579   token = cp_lexer_peek_token (parser->lexer);
21589       if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
21594   else if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
21596       cp_token *ell = cp_lexer_consume_token (parser->lexer);
21627       && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
21629       cp_token *comma = cp_lexer_consume_token (parser->lexer);
21665   gcc_checking_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM));
21666   cp_lexer_consume_token (parser->lexer);
21668   cp_token *start = cp_lexer_peek_token (parser->lexer);
21673   cp_token *end = cp_lexer_previous_token (parser->lexer);
21740   id_location = cp_lexer_peek_token (parser->lexer)->location;
21745   cp_token *attrs_token = cp_lexer_peek_token (parser->lexer);
21867   if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
21946   location_t asm_loc = cp_lexer_peek_token (parser->lexer)->location;
21969 	cp_token *token = cp_lexer_peek_token (parser->lexer);
21971 	switch (cp_lexer_peek_token (parser->lexer)->keyword)
21987 	    cp_lexer_consume_token (parser->lexer);
22001 	    cp_lexer_consume_token (parser->lexer);
22015 	    cp_lexer_consume_token (parser->lexer);
22021 	    cp_lexer_consume_token (parser->lexer);
22059       && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
22060 	  || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
22070       if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
22073 	  cp_lexer_consume_token (parser->lexer);
22075 	  if (cp_lexer_next_token_is_not (parser->lexer,
22077 	      && cp_lexer_next_token_is_not (parser->lexer,
22079 	      && cp_lexer_next_token_is_not (parser->lexer,
22089       else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
22095 	  || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
22098 	  cp_lexer_consume_token (parser->lexer);
22100 	  if (cp_lexer_next_token_is_not (parser->lexer,
22102 	      && cp_lexer_next_token_is_not (parser->lexer,
22104 	      && cp_lexer_next_token_is_not (parser->lexer,
22112       else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
22118 	  || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
22122 	  cp_lexer_consume_token (parser->lexer);
22124 	  if (cp_lexer_next_token_is_not (parser->lexer,
22126 	      && cp_lexer_next_token_is_not (parser->lexer,
22130       else if (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
22136 	  || (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_COLON)))
22140 	  cp_lexer_consume_token (parser->lexer);
22482   token = cp_lexer_peek_token (parser->lexer);
22525       asm_spec_start_token = cp_lexer_peek_token (parser->lexer);
22536   attributes_start_token = cp_lexer_peek_token (parser->lexer);
22540   token = cp_lexer_peek_token (parser->lexer);
22571 	    = cp_lexer_peek_token (parser->lexer)->location;
22653 	  cp_token *t2 = cp_lexer_peek_nth_token (parser->lexer, 2);
22977 	*parenthesized_p = cp_lexer_next_token_is (parser->lexer,
23039       token = cp_lexer_peek_token (parser->lexer);
23118 		= cp_lexer_peek_token (parser->lexer)->location;
23259 	      close_paren = cp_lexer_peek_token (parser->lexer);
23286 	  cp_lexer_consume_token (parser->lexer);
23288 	  token = cp_lexer_peek_token (parser->lexer);
23358 		    cp_lexer_consume_token (parser->lexer);
23364 	    declarator_id_start_token = cp_lexer_peek_token (parser->lexer);
23550 		&& cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
23691   token = cp_lexer_peek_token (parser->lexer);
23705       cp_lexer_consume_token (parser->lexer);
23727       token = cp_lexer_peek_token (parser->lexer);
23798       token = cp_lexer_peek_token (parser->lexer);
23827 	  cp_lexer_purge_token (parser->lexer);
23831 	  cp_lexer_consume_token (parser->lexer);
23859       cp_token *token = cp_lexer_peek_token (parser->lexer);
23881 	  cp_lexer_purge_token (parser->lexer);
23886 	  cp_lexer_consume_token (parser->lexer);
23902   cp_token *token = cp_lexer_peek_token (parser->lexer);
23914 	      cp_lexer_consume_token (parser->lexer);
23950       token = cp_lexer_peek_token (parser->lexer);
23976 	  cp_lexer_purge_token (parser->lexer);
23980 	  cp_lexer_consume_token (parser->lexer);
24068   token = cp_lexer_peek_token (parser->lexer);
24080       cp_lexer_consume_token (parser->lexer);
24349 	      cp_token *tok = cp_lexer_peek_nth_token (parser->lexer, n);
24363        start_token = cp_lexer_peek_token (parser->lexer);
24472   token = cp_lexer_peek_token (parser->lexer);
24477       cp_lexer_consume_token (parser->lexer);
24485 	   && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
24489       cp_lexer_consume_token (parser->lexer);
24503   token = cp_lexer_peek_token (parser->lexer);
24508       cp_lexer_consume_token (parser->lexer);
24518       cp_lexer_consume_token (parser->lexer);
24622       if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
24623 	  || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
24625 	  || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
24626 	  || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
24629       else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
24634 	  token = cp_lexer_peek_nth_token (parser->lexer, 2);
24640 	  cp_lexer_consume_token (parser->lexer);
24750   cp_token *decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
24779   token = cp_lexer_peek_token (parser->lexer);
24813 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
24815 	  if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
24857   token = cp_lexer_peek_token (parser->lexer);
24876   if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
24890 	  cp_lexer_consume_token (parser->lexer);
24908   if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
24911       token = cp_lexer_peek_token (parser->lexer);
25154   token = cp_lexer_peek_token (parser->lexer);
25165       cp_lexer_consume_token (parser->lexer);
25183       cp_lexer_set_source_position (parser->lexer);
25224   if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
25255   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
25263   if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
25271       if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
25272 	cp_lexer_consume_token (parser->lexer);
25277   location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
25301       cp_token * token = cp_lexer_peek_token (parser->lexer);
25306 	  if (!parser->lexer->in_pragma)
25320 	      cp_lexer_consume_token (parser->lexer);
25330       cp_lexer_consume_token (parser->lexer);
25340   cp_lexer_consume_token (parser->lexer);
25342   cp_lexer_save_tokens (parser->lexer);
25349        && cp_lexer_next_token_is (parser->lexer, CPP_EQ));
25352   cp_lexer_rollback_tokens (parser->lexer);
25413       location_t loc = cp_lexer_peek_token (parser->lexer)->location;
25418 	  && cp_lexer_next_token_is (parser->lexer, CPP_DOT)
25419 	  && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_NAME
25420 	  && (cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ
25421 	      || (cp_lexer_peek_nth_token (parser->lexer, 3)->type
25429 	  cp_lexer_consume_token (parser->lexer);
25431 	  designator = cp_lexer_consume_token (parser->lexer)->u.value;
25432 	  if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
25434 	    cp_lexer_consume_token (parser->lexer);
25440 	       && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
25441 	       && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
25448 	  designator = cp_lexer_consume_token (parser->lexer)->u.value;
25450 	  cp_lexer_consume_token (parser->lexer);
25455 	       && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
25514       if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
25516 	  location_t loc = cp_lexer_peek_token (parser->lexer)->location;
25519           cp_lexer_consume_token (parser->lexer);
25534       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
25538       token = cp_lexer_peek_nth_token (parser->lexer, 2);
25559       cp_lexer_consume_token (parser->lexer);
25627   cp_token *token = cp_lexer_peek_token (parser->lexer);
25664       identifier_token = cp_lexer_peek_token (parser->lexer);
25694 	  if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
25739       && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
25762 	       && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
25927     cp_token *token = cp_lexer_peek_token (parser->lexer);
25974 	    cp_token *lookahead = cp_lexer_peek_nth_token (parser->lexer, 2);
25994 	  = cp_lexer_previous_token_position (parser->lexer);
25995 	cp_token *prev_token = cp_lexer_token_at (parser->lexer, prev);
26024 	cp_lexer_set_token_position (parser->lexer, prev);
26025 	token = cp_lexer_peek_token (parser->lexer);
26318   nested_name_specifier_token_start = cp_lexer_peek_token (parser->lexer);
26332       type_start_token = cp_lexer_peek_token (parser->lexer);
26351       if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
26352 	bad_template_keyword = cp_lexer_consume_token (parser->lexer);
26364 	  type_start_token = cp_lexer_peek_token (parser->lexer);
26385       type_start_token = cp_lexer_peek_token (parser->lexer);
26394 	  if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
26396 	      type_start_token = cp_lexer_peek_token (parser->lexer);
26691   if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
26704   if (type && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
26782   cp_token *token = cp_lexer_peek_token (parser->lexer);
26785       cp_lexer_consume_token (parser->lexer);
26815       token = cp_lexer_peek_token (parser->lexer);
26830 	  cp_lexer_consume_token (parser->lexer);
26912   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
26916       if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
26917 	  && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
26929   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
26934       else if (cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_ENUM))
26961   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
26977   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC_ASSERT))
26990   decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
27008   if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
27021 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
27131       while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
27139 	  token = cp_lexer_peek_token (parser->lexer);
27152 	      token = cp_lexer_peek_nth_token (parser->lexer, n);
27158 		  && token == cp_lexer_peek_token (parser->lexer)
27159 		  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON)
27166 		= cp_lexer_peek_token (parser->lexer)->location;
27177 	      cp_lexer_consume_token (parser->lexer);
27187 		  && (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
27188 		      || cp_lexer_next_token_is (parser->lexer,
27192 		    = cp_lexer_peek_token (parser->lexer)->location;
27275 		  if (cp_lexer_next_token_is (parser->lexer,
27277 		    cp_lexer_consume_token (parser->lexer);
27309 	      if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
27324 		  initializer_token_start = cp_lexer_peek_token (parser->lexer);
27341 		      cp_lexer_consume_token (parser->lexer);
27350 	      else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)
27355 		    = cp_lexer_peek_token (parser->lexer)->location;
27367 	      else if (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
27382 		  if (cp_lexer_next_token_is (parser->lexer,
27384 		    cp_lexer_consume_token (parser->lexer);
27397 		  (cp_lexer_peek_token (parser->lexer)))
27417 		  token = cp_lexer_peek_token (parser->lexer);
27422 			= cp_lexer_consume_token (parser->lexer)->location;
27465 	  if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
27467 	      cp_lexer_consume_token (parser->lexer);
27468 	      if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
27470 		  cp_token *token = cp_lexer_previous_token (parser->lexer);
27478 	  else if (cp_lexer_next_token_is_not (parser->lexer,
27484 	      cp_token *token = cp_lexer_previous_token (parser->lexer);
27542   token = cp_lexer_peek_token (parser->lexer);
27548   cp_lexer_consume_token (parser->lexer);
27594   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
27648       if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
27651           cp_lexer_consume_token (parser->lexer);
27670       token = cp_lexer_peek_token (parser->lexer);
27675       cp_lexer_consume_token (parser->lexer);
27718       token = cp_lexer_peek_token (parser->lexer);
27734 	  cp_lexer_consume_token (parser->lexer);
27754 	  cp_lexer_consume_token (parser->lexer);
27766   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
27768       token = cp_lexer_peek_token (parser->lexer);
27776       cp_lexer_consume_token (parser->lexer);
27804       && cp_lexer_next_token_is_decltype (parser->lexer))
27834   cp_token *first = parser->lexer->next_token;
27837   cp_token *last = parser->lexer->next_token;
27864      lexer stack.  */
27876   /* Revert to the main lexer.  */
27937   token = cp_lexer_peek_token (parser->lexer);
27951 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN)
27953 	  && !((cp_lexer_nth_token_is (parser->lexer, 3, CPP_NUMBER)
27954 		|| cp_lexer_nth_token_is (parser->lexer, 3, CPP_KEYWORD))
27955 	       && cp_lexer_nth_token_is (parser->lexer, 4, CPP_CLOSE_PAREN))
27961       cp_lexer_consume_token (parser->lexer);
27963       if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
28035   token = cp_lexer_peek_token (parser->lexer);
28053   cp_lexer_consume_token (parser->lexer);
28060   token = cp_lexer_peek_token (parser->lexer);
28117       token = cp_lexer_peek_token (parser->lexer);
28129       if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
28132           cp_lexer_consume_token (parser->lexer);
28140       token = cp_lexer_peek_token (parser->lexer);
28145       cp_lexer_consume_token (parser->lexer);
28220       token = cp_lexer_peek_token (parser->lexer);
28268   if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
28271       cp_lexer_consume_token (parser->lexer);
28286   if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
28318   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
28321   token = cp_lexer_peek_token (parser->lexer);
28340 					   parser->lexer);
28359   cp_token *token = cp_lexer_peek_token (parser->lexer);
28364   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
28367       cp_lexer_set_source_position (parser->lexer);
28399   token = cp_lexer_peek_token (parser->lexer);
28406   cp_lexer_consume_token (parser->lexer);
28449       if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
28452 	  cp_lexer_consume_token (parser->lexer);
28485       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
28488       cp_lexer_consume_token (parser->lexer);
28518       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
28521       cp_lexer_consume_token (parser->lexer);
28561       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
28564       cp_lexer_consume_token (parser->lexer);
28594   cp_token *token = cp_lexer_peek_nth_token (parser->lexer, n);
28599 		  && (token = cp_lexer_peek_nth_token (parser->lexer, n + 1))
28609   cp_token *token = cp_lexer_peek_nth_token (parser->lexer, n);
28670       token = cp_lexer_peek_token (parser->lexer);
28676       cp_lexer_consume_token (parser->lexer);
28686       token = cp_lexer_peek_token (parser->lexer);
28746       token = cp_lexer_peek_token (parser->lexer);
28754 	  cp_token *id_token = cp_lexer_consume_token (parser->lexer);
28768 	  token = cp_lexer_peek_token (parser->lexer);
28797 	  token = cp_lexer_peek_token (parser->lexer);
28805       cp_lexer_consume_token (parser->lexer);
28823   cp_token *first = cp_lexer_peek_nth_token (parser->lexer, 2);
28826       cp_lexer_consume_token (parser->lexer);
28828       cp_lexer_consume_token (parser->lexer);
28835       cp_lexer_consume_token (parser->lexer);
28842     cp_lexer_consume_token (parser->lexer);
28843   cp_token *last = cp_lexer_peek_token (parser->lexer);
28844   cp_lexer_consume_token (parser->lexer);
28862       cp_token *token = cp_lexer_peek_token (parser->lexer);
28865 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_SCOPE))
28867 	  cp_lexer_consume_token (parser->lexer);
28868 	  cp_lexer_consume_token (parser->lexer);
28869 	  token = cp_lexer_peek_token (parser->lexer);
28886 	  if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
28888 	  cp_lexer_consume_token (parser->lexer);
28890       cp_lexer_consume_token (parser->lexer);
28891       if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
28898       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
28900       cp_lexer_consume_token (parser->lexer);
28960   token = cp_lexer_peek_token (parser->lexer);
28971   cp_lexer_consume_token (parser->lexer);
28973   token = cp_lexer_peek_token (parser->lexer);
28978       cp_lexer_consume_token (parser->lexer);
28984       token = cp_lexer_peek_token (parser->lexer);
28997       cp_lexer_consume_token (parser->lexer);
29003       token = cp_lexer_peek_token (parser->lexer);
29099 	  cp_lexer_consume_token (parser->lexer);
29172       location_t loc = cp_lexer_peek_token (parser->lexer)->location;
29184       token = cp_lexer_peek_token (parser->lexer);
29187 	  cp_lexer_consume_token (parser->lexer);
29198 	  token = cp_lexer_peek_token (parser->lexer);
29202       cp_lexer_consume_token (parser->lexer);
29225   cp_token *token = cp_lexer_peek_token (parser->lexer);
29228       && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_OPEN_SQUARE)
29232       cp_lexer_consume_token (parser->lexer);
29233       cp_lexer_consume_token (parser->lexer);
29235       if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
29237 	  token = cp_lexer_peek_nth_token (parser->lexer, 2);
29246 	      && cp_lexer_nth_token_is (parser->lexer, 3, CPP_COLON))
29253 	      cp_lexer_consume_token (parser->lexer);
29254 	      cp_lexer_consume_token (parser->lexer);
29255 	      cp_lexer_consume_token (parser->lexer);
29277       token = cp_lexer_peek_token (parser->lexer);
29283       cp_lexer_consume_token (parser->lexer);
29307       if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
29309 	  cp_lexer_consume_token (parser->lexer);
29320 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
29379     switch (cp_lexer_peek_nth_token (parser->lexer, n++)->type)
29382 	if (!parser->lexer->in_pragma)
29422       if (!cp_lexer_nth_token_is_keyword (parser->lexer, n, RID_ATTRIBUTE)
29423 	  || !cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_PAREN)
29424 	  || !cp_lexer_nth_token_is (parser->lexer, n + 2, CPP_OPEN_PAREN))
29430       if (!cp_lexer_nth_token_is (parser->lexer, n2, CPP_CLOSE_PAREN))
29446       if (cp_lexer_nth_token_is (parser->lexer, n, CPP_OPEN_SQUARE)
29447 	  && cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_SQUARE))
29452 	  if (!cp_lexer_nth_token_is (parser->lexer, n2, CPP_CLOSE_SQUARE))
29456       else if (cp_lexer_nth_token_is_keyword (parser->lexer, n, RID_ALIGNAS)
29457 	       && cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_PAREN))
29494   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
29497       cp_lexer_consume_token (parser->lexer);
29535       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
29554   gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_CONCEPT));
29555   cp_lexer_consume_token (parser->lexer);
29620   cp_token *token = cp_lexer_peek_token (parser->lexer);
29638 	  if (cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_DELETE)
29639 	      || cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_DEFAULT))
29701 	  if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_SQUARE))
29734   cp_token *token = cp_lexer_peek_token (parser->lexer);
29789   cp_lexer_save_tokens (parser->lexer);
29808       cp_lexer_commit_tokens (parser->lexer);
29814   cp_lexer_rollback_tokens (parser->lexer);
29842   while (cp_lexer_next_token_is (parser->lexer, CPP_AND_AND))
29844       cp_token *op = cp_lexer_consume_token (parser->lexer);
29861   while (cp_lexer_next_token_is (parser->lexer, CPP_OR_OR))
29863       cp_token *op = cp_lexer_consume_token (parser->lexer);
29924   cp_token *tok = cp_lexer_peek_token (parser->lexer);
29930 	  error_at (cp_lexer_peek_token (parser->lexer)->location,
29934 	  cp_lexer_consume_token (parser->lexer);
29940   cp_token *tok2 = cp_lexer_peek_nth_token (parser->lexer, 2);
29954     cp_lexer_consume_token (parser->lexer);
29974   gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES));
29975   location_t loc = cp_lexer_consume_token (parser->lexer)->location;
30006     if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
30026   loc = make_location (loc, loc, parser->lexer);
30111   while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE)
30112 	 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF));
30133   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
30135   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
30137   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES))
30151   location_t start = cp_lexer_peek_token (parser->lexer)->location;
30200   cp_token *start_tok = cp_lexer_consume_token (parser->lexer);
30201   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
30215   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
30217       cp_lexer_consume_token (parser->lexer);
30244   loc = make_location (loc, start_tok->location, parser->lexer);
30261   cp_token *expr_token = cp_lexer_peek_token (parser->lexer);
30284   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_NOEXCEPT))
30286       cp_lexer_consume_token (parser->lexer);
30292   if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
30294       cp_lexer_consume_token (parser->lexer);
30295       cp_token *tok = cp_lexer_peek_token (parser->lexer);
30308 					   parser->lexer);
30329 				  parser->lexer);
30347   gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES));
30348   cp_token *tok = cp_lexer_consume_token (parser->lexer);
30349   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
30353   loc = make_location (loc, tok->location, parser->lexer);
30566 		       || cp_lexer_next_token_is (parser->lexer,
30861   token = cp_lexer_peek_token (parser->lexer);
30867       cp_lexer_consume_token (parser->lexer);
30905   next_token = cp_lexer_peek_token (parser->lexer);
31036 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
31037 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
31041 	  && !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer)
31060 		cp_lexer_consume_token (parser->lexer);
31232   token = cp_lexer_peek_token (parser->lexer);
31233   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
31236       cp_lexer_consume_token (parser->lexer);
31246 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
31251 	  cp_lexer_consume_token (parser->lexer);
31269   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRANSACTION_ATOMIC))
31271   else if (cp_lexer_next_token_is_keyword (parser->lexer,
31274   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
31336 	   && cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
31339            && cp_lexer_next_token_is_keyword (parser->lexer, RID_CONCEPT)
31340            && !cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_BOOL))
31345       cp_token *token = cp_lexer_peek_token (parser->lexer);
31459   cp_token *start_token = cp_lexer_peek_token (parser->lexer);
31476   cp_token *token = cp_lexer_peek_token (parser->lexer);
31528 					       parser->lexer);
31595   if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
31635   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
31637       cp_lexer_consume_token (parser->lexer);
31689   decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
31759 	      error_at (cp_lexer_peek_token (parser->lexer)->location,
31785       && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
31865   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
31867       cp_lexer_set_source_position (parser->lexer);
31882 					       parser->lexer);
31906 					   parser->lexer);
31949 	  (cp_lexer_peek_token (parser->lexer)))
31959   first = parser->lexer->next_token;
31961   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRANSACTION_RELAXED))
31962     cp_lexer_consume_token (parser->lexer);
31963   else if (cp_lexer_next_token_is_keyword (parser->lexer,
31966       cp_lexer_consume_token (parser->lexer);
31968       if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE)
31969 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_SQUARE)
31970 	  && (cp_lexer_nth_token_is (parser->lexer, 3, CPP_NAME)
31971 	      || cp_lexer_nth_token_is (parser->lexer, 3, CPP_KEYWORD))
31972 	  && cp_lexer_nth_token_is (parser->lexer, 4, CPP_CLOSE_SQUARE)
31973 	  && cp_lexer_nth_token_is (parser->lexer, 5, CPP_CLOSE_SQUARE))
31975 	  cp_lexer_consume_token (parser->lexer);
31976 	  cp_lexer_consume_token (parser->lexer);
31977 	  cp_lexer_consume_token (parser->lexer);
31978 	  cp_lexer_consume_token (parser->lexer);
31979 	  cp_lexer_consume_token (parser->lexer);
31983 	       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
31985 	    cp_lexer_consume_token (parser->lexer);
31992   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
31994       cp_lexer_consume_token (parser->lexer);
31998   if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
32000       cp_lexer_consume_token (parser->lexer);
32001       while (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
32008 	  if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
32009 	    cp_lexer_consume_token (parser->lexer);
32015     while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
32017   last = parser->lexer->next_token;
32073   if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER)
32074       || cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
32083   if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
32103 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
32114 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
32128 	  cp_token *token = cp_lexer_consume_token (parser->lexer);
32192       /* Push the body of the function onto the lexer stack.  */
32203 	  parser->lexer->in_pragma = true;
32268      lexer stack.  */
32300   if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
32308   /* Revert to the main lexer.  */
32430   cp_lexer_consume_token (parser->lexer);
32434   bool paren = cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN);
32438     permerror (cp_lexer_peek_token (parser->lexer)->location,
32441   cp_token *token = cp_lexer_peek_token (parser->lexer);
32483       && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
32511   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
32577   return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
32578 	  || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
33019   if (cp_lexer_next_token_is (parser->lexer, type))
33020     return cp_lexer_consume_token (parser->lexer);
33040   cp_lexer_consume_token (parser->lexer);
33081       switch (cp_lexer_peek_token (parser->lexer)->type)
33099 	      cp_lexer_consume_token (parser->lexer);
33110 	      cp_lexer_consume_token (parser->lexer);
33139       cp_lexer_consume_token (parser->lexer);
33194   token = cp_lexer_peek_token (parser->lexer);
33208   token = cp_lexer_peek_token (parser->lexer);
33224   token = cp_lexer_peek_nth_token (parser->lexer, n);
33233       token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
33865   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
33874 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
33881 	  cp_lexer_purge_token (parser->lexer);
33887 	  cp_lexer_consume_token (parser->lexer);
33903   check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
33921       cp_token *token = cp_lexer_peek_token (parser->lexer);
33938       cp_lexer_consume_token (parser->lexer);
33981   first_token = cp_lexer_peek_token (parser->lexer);
33986       token = cp_lexer_peek_token (parser->lexer);
33993       token = cp_lexer_peek_token (parser->lexer);
34032 		      cp_lexer_consume_token (parser->lexer);
34040 		      peek = cp_lexer_peek_token (parser->lexer);
34053 		  cp_lexer_consume_token (parser->lexer);
34147       token = cp_lexer_consume_token (parser->lexer);
34181   cp_lexer_save_tokens (parser->lexer);
34194   cp_lexer *lexer;
34197   lexer = parser->lexer;
34203       while (!cp_lexer_saving_tokens (lexer))
34204 	lexer = lexer->next;
34205       cp_lexer_commit_tokens (lexer);
34221   cp_lexer *lexer = parser->lexer;
34229       while (!cp_lexer_saving_tokens (lexer))
34230 	lexer = lexer->next;
34231       cp_lexer_commit_tokens (lexer);
34271 	cp_lexer_commit_tokens (parser->lexer);
34279       cp_lexer_rollback_tokens (parser->lexer);
34337   cp_token *kwd = cp_lexer_peek_token (parser->lexer);
34345       kwd = cp_lexer_consume_token (parser->lexer);
34387   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
34388   cp_lexer_consume_token (parser->lexer);  /* Eat '['.  */
34391   location_t end_loc = cp_lexer_peek_token (parser->lexer)->location;
34465   cp_token *token = cp_lexer_peek_token (parser->lexer);
34476 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
34487       token = cp_lexer_peek_token (parser->lexer);
34495       cp_lexer_consume_token (parser->lexer);
34502       token = cp_lexer_peek_token (parser->lexer);
34526   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
34528   cp_lexer_consume_token (parser->lexer);  /* Eat '@encode'.  */
34531   token = cp_lexer_peek_token (parser->lexer);
34560   location_t combined_loc = make_location (start_loc, start_loc, parser->lexer);
34572   cp_lexer_consume_token (parser->lexer);  /* Eat '@defs'.  */
34592   location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
34594   cp_lexer_consume_token (parser->lexer);  /* Eat '@protocol'.  */
34604   location_t combined_loc = make_location (start_loc, start_loc, parser->lexer);
34631   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
34633   cp_lexer_consume_token (parser->lexer);  /* Eat '@selector'.  */
34636   token = cp_lexer_peek_token (parser->lexer);
34647       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
34648 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
34662       token = cp_lexer_consume_token (parser->lexer);
34678       token = cp_lexer_peek_token (parser->lexer);
34689   location_t combined_loc = make_location (loc, loc, parser->lexer);
34716   sep = cp_lexer_peek_token (parser->lexer);
34720       cp_lexer_consume_token (parser->lexer);  /* Eat ','.  */
34727       sep = cp_lexer_peek_token (parser->lexer);
34746   cp_lexer_consume_token (parser->lexer);  /* Eat '@compatibility_alias'.  */
34764   cp_lexer_consume_token (parser->lexer);  /* Eat '@class'.  */
34775       if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
34776 	cp_lexer_consume_token (parser->lexer);
34798   if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
34800       cp_lexer_consume_token (parser->lexer);  /* Eat '<'.  */
34813   cp_token *vis = cp_lexer_peek_token (parser->lexer);
34834   cp_lexer_consume_token (parser->lexer);
34843   if (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS)
34855   cp_token *token = cp_lexer_peek_token (parser->lexer);
34868       cp_lexer_consume_token (parser->lexer);
34869       token = cp_lexer_peek_token (parser->lexer);
34883   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
34893       if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
34938   cp_token *token = cp_lexer_consume_token (parser->lexer);
34971   cp_token *token = cp_lexer_peek_token (parser->lexer);
34986 	  && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
35001       if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
35012       token = cp_lexer_peek_token (parser->lexer);
35025       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
35026 	  || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
35048   cp_token *token = cp_lexer_peek_token (parser->lexer);
35056       cp_lexer_consume_token (parser->lexer);  /* Eat ','.  */
35057       token = cp_lexer_peek_token (parser->lexer);
35061 	  cp_lexer_consume_token (parser->lexer);  /* Eat '...'.  */
35063 	  token = cp_lexer_peek_token (parser->lexer);
35076       token = cp_lexer_peek_token (parser->lexer);
35085 	  if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
35086 	      || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
35107   cp_token *token = cp_lexer_peek_token (parser->lexer);
35113 	 (cp_lexer_peek_nth_token (parser->lexer, 2)))
35120     cp_lexer_consume_token (parser->lexer);
35124       cp_lexer_consume_token (parser->lexer);
35129       cp_lexer_consume_token (parser->lexer);
35137       cp_lexer_consume_token (parser->lexer);
35172   cp_lexer_save_tokens (parser->lexer);
35178   if (cp_lexer_next_token_is (parser->lexer, CPP_PLUS)
35179       || cp_lexer_next_token_is (parser->lexer, CPP_MINUS))
35184   cp_lexer_rollback_tokens (parser->lexer);
35193   cp_token *token = cp_lexer_peek_token (parser->lexer);
35209 	      token = cp_lexer_peek_token (parser->lexer);
35219 	warning_at (cp_lexer_peek_token (parser->lexer)->location,
35226       token = cp_lexer_peek_token (parser->lexer);
35230     cp_lexer_consume_token (parser->lexer);  /* Eat '@end'.  */
35244       cp_token *token = cp_lexer_peek_token (parser->lexer);
35248 	  cp_lexer_consume_token (parser->lexer);  /* Eat '@end'.  */
35271 	      if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
35272 		cp_lexer_consume_token (parser->lexer);
35307   cp_token *token = cp_lexer_peek_token (parser->lexer);
35312   cp_lexer_consume_token (parser->lexer);  /* Eat '{'.  */
35313   token = cp_lexer_peek_token (parser->lexer);
35324       if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
35358       while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
35365 	  token = cp_lexer_peek_token (parser->lexer);
35370 	      && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
35379 	      cp_lexer_consume_token (parser->lexer);  /* Eat ':'.  */
35427 	  token = cp_lexer_peek_token (parser->lexer);
35431 	      cp_lexer_consume_token (parser->lexer);  /* Eat ','.  */
35438       token = cp_lexer_peek_token (parser->lexer);
35447     cp_lexer_consume_token (parser->lexer);  /* Eat '}'.  */
35450   if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
35451     cp_lexer_consume_token (parser->lexer);
35462   cp_lexer_consume_token (parser->lexer);  /* Eat '@protocol'.  */
35463   if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
35465       tok = cp_lexer_peek_token (parser->lexer);
35472   tok = cp_lexer_peek_nth_token (parser->lexer, 2);
35487 	  if(cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
35488 	    cp_lexer_consume_token (parser->lexer);
35513   cp_token *next = cp_lexer_peek_token (parser->lexer);
35519       cp_lexer_consume_token (parser->lexer);  /* Eat ':'.  */
35529       if (iface_p && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
35549   cp_lexer_consume_token (parser->lexer);  /* Eat '@interface'.  */
35550   location_t nam_loc = cp_lexer_peek_token (parser->lexer)->location;
35587   cp_lexer_consume_token (parser->lexer);  /* Eat '@implementation'.  */
35621   cp_lexer_consume_token (parser->lexer);  /* Eat '@end'.  */
35631   cp_token *kwd = cp_lexer_peek_token (parser->lexer);
35713   location = cp_lexer_peek_token (parser->lexer)->location;
35721   while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
35728       cp_lexer_consume_token (parser->lexer);
35731       if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
35738 	  cp_lexer_consume_token (parser->lexer);
35767 	  if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
35768 	    cp_lexer_consume_token (parser->lexer);
35779   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
35781       cp_lexer_consume_token (parser->lexer);
35782       location = cp_lexer_peek_token (parser->lexer)->location;
35808   location = cp_lexer_peek_token (parser->lexer)->location;
35834   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
35838   if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
35852   cp_token *kwd = cp_lexer_peek_token (parser->lexer);
35879   cp_lexer_save_tokens (parser->lexer);
35882       && OBJC_IS_AT_KEYWORD (cp_lexer_peek_token (parser->lexer)->keyword))
35884       cp_lexer_commit_tokens (parser->lexer);
35891   cp_lexer_rollback_tokens (parser->lexer);
35948   while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
35986       token = cp_lexer_peek_token (parser->lexer);
35989 	  cp_lexer_consume_token (parser->lexer);  /* Eat ','.  */
36035   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
36037   cp_lexer_consume_token (parser->lexer);  /* Eat '@property'.  */
36040   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
36044       location_t attr_start = cp_lexer_peek_token (parser->lexer)->location;
36049       location_t attr_end = cp_lexer_peek_token (parser->lexer)->location;
36051       if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
36060 	    cp_token *token = cp_lexer_peek_token (parser->lexer);
36071 		cp_lexer_consume_token (parser->lexer);
36088 	    cp_lexer_consume_token (parser->lexer);
36111 		if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
36120 		token = cp_lexer_peek_token (parser->lexer);
36122 		cp_lexer_consume_token (parser->lexer); /* eat the = */
36125 		     (cp_lexer_peek_token (parser->lexer)->type))
36135 		token = cp_lexer_peek_token (parser->lexer);
36143 		    if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
36154 					       (parser->lexer)->location);
36155 			cp_lexer_consume_token (parser->lexer);
36175 	    if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
36176 	      cp_lexer_consume_token (parser->lexer);
36237   loc = cp_lexer_peek_token (parser->lexer)->location;
36239   cp_lexer_consume_token (parser->lexer);  /* Eat '@synthesize'.  */
36249       if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
36251 	  cp_lexer_consume_token (parser->lexer);
36262       if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
36263 	cp_lexer_consume_token (parser->lexer);
36288   loc = cp_lexer_peek_token (parser->lexer)->location;
36290   cp_lexer_consume_token (parser->lexer);  /* Eat '@dynamic'.  */
36301       if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
36302 	cp_lexer_consume_token (parser->lexer);
36324   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
36326   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
36328   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
36330   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DELETE))
36332   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
36334   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
36336   else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
36338       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
36559     cp_lexer_consume_token (parser->lexer);
36624       token = cp_lexer_peek_token (parser->lexer);
36632 	  cp_lexer_consume_token (parser->lexer);
36681 	      if (cp_lexer_peek_token (parser->lexer)->type != CPP_OPEN_SQUARE)
36692 	      while (cp_lexer_next_token_is (parser->lexer, CPP_DOT)
36694 			 && cp_lexer_next_token_is (parser->lexer, CPP_DEREF)))
36697 		    = cp_lexer_next_token_is (parser->lexer, CPP_DOT)
36700 		    = cp_lexer_peek_token (parser->lexer)->location;
36702 		  cp_lexer_consume_token (parser->lexer);
36718 	      while (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
36725 		  cp_lexer_consume_token (parser->lexer);
36726 		  if (!cp_lexer_next_token_is (parser->lexer, CPP_COLON))
36728 		      loc = cp_lexer_peek_token (parser->lexer)->location;
36736 		  if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
36755 		      if (!cp_lexer_next_token_is (parser->lexer,
36780 		  && (cp_lexer_next_token_is (parser->lexer, CPP_DOT)
36782 			  && cp_lexer_next_token_is (parser->lexer,
36804 	      if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
36805 		  && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
36826       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
36828       cp_lexer_consume_token (parser->lexer);
36834   if (colon != NULL && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
36951   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
36999   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
37047   cp_lexer *lexer = parser->lexer;
37053   if (cp_lexer_next_token_is (lexer, CPP_OPEN_PAREN))
37060 	  cp_token *next = cp_lexer_peek_token (lexer);
37065 	      && cp_lexer_next_token_is_keyword (lexer, RID_STATIC))
37067 	      cp_lexer_consume_token (lexer);
37080 	      if (cp_lexer_next_token_is (lexer, CPP_MULT)
37081 		  && (cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA)
37082 		      || cp_lexer_nth_token_is (parser->lexer, 2,
37085 		  cp_lexer_consume_token (lexer);
37088 		  if (cp_lexer_next_token_is (lexer, CPP_COMMA))
37090 		      cp_lexer_consume_token (lexer);
37097 	  else if (cp_lexer_next_token_is (lexer, CPP_NAME)
37099 		   && cp_lexer_nth_token_is (lexer, 2, CPP_COLON))
37101 	      cp_lexer_consume_token (lexer);  /* id  */
37102 	      cp_lexer_consume_token (lexer);  /* ':'  */
37121 	      && cp_lexer_next_token_is (lexer, CPP_COMMA))
37123 	      cp_lexer_consume_token (lexer);
37176       if (cp_lexer_next_token_is (parser->lexer, CPP_MULT)
37177 	  && (cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA)
37178 	      || cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN)))
37180 	  cp_lexer_consume_token (parser->lexer);
37188   while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN));
37191   cp_lexer_consume_token (parser->lexer);
37257   location_t location = cp_lexer_peek_token (parser->lexer)->location;
37259   if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
37283   loc = cp_lexer_peek_token (parser->lexer)->location;
37335   if (!is_oacc && cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
37338       cp_lexer_consume_token (parser->lexer);
37340   else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
37342       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
37375       cp_lexer_consume_token (parser->lexer);
37458   if (is_omp && cp_lexer_next_token_is (parser->lexer, CPP_NAME))
37460       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
37477 	  if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
37479 	      id = cp_lexer_peek_nth_token (parser->lexer, 2)->u.value;
37494 		    = cp_lexer_peek_nth_token (parser->lexer, 2)->location;
37502 		  if (cp_lexer_nth_token_is (parser->lexer, 3, CPP_NAME))
37504 		      id = cp_lexer_peek_nth_token (parser->lexer, 3)->u.value;
37512 			= cp_lexer_peek_nth_token (parser->lexer, 3)->location;
37521 	  if (cp_lexer_nth_token_is (parser->lexer, n, CPP_COLON))
37524 		cp_lexer_consume_token (parser->lexer);
37531 		    = cp_lexer_peek_nth_token (parser->lexer, n)->location;
37678   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
37679       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
37681       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
37685 	  cp_lexer_consume_token (parser->lexer);
37686 	  cp_lexer_consume_token (parser->lexer);
37726   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
37727       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
37729       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
37733 	  cp_lexer_consume_token (parser->lexer);
37734 	  cp_lexer_consume_token (parser->lexer);
37874   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
37876   else if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
37886       id = cp_lexer_peek_token (parser->lexer)->u.value;
37934   cp_lexer_consume_token (parser->lexer);
37936   if (!cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
37941       if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
37948       id = cp_lexer_peek_token (parser->lexer)->u.value;
37978       cp_lexer_consume_token (parser->lexer);
38055   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
38056       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
38058       id = cp_lexer_peek_token (parser->lexer)->u.value;
38070       cp_lexer_consume_token (parser->lexer);
38071       cp_lexer_consume_token (parser->lexer);
38073   if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38080       id = cp_lexer_peek_token (parser->lexer)->u.value;
38088   cp_lexer_consume_token (parser->lexer);
38121   if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38130       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38139   cp_lexer_consume_token (parser->lexer);
38172   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
38241       if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT)
38242 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA))
38244 	  cp_lexer_consume_token (parser->lexer);
38245 	  cp_lexer_consume_token (parser->lexer);
38247       else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
38248 	       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA))
38250 	  tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38258 	      cp_lexer_consume_token (parser->lexer);
38259 	      cp_lexer_consume_token (parser->lexer);
38264   switch (cp_lexer_peek_token (parser->lexer)->type)
38278     cp_lexer_consume_token (parser->lexer);
38380   while (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38382       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38393       cp_lexer_consume_token (parser->lexer);
38395 	  && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
38397 	  comma = cp_lexer_peek_token (parser->lexer)->location;
38398 	  cp_lexer_consume_token (parser->lexer);
38409   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38411       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38438   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
38440   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
38444   cp_lexer_consume_token (parser->lexer);
38456   if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
38459       cp_lexer_consume_token (parser->lexer);
38461       token = cp_lexer_peek_token (parser->lexer);
38594       && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
38597       cp_lexer_consume_token (parser->lexer);
38711     if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
38712 	&& cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
38714 	tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38718 	cp_lexer_consume_token (parser->lexer);
38736 	if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
38741 	if (mod != 0 || cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
38743 	cp_lexer_consume_token (parser->lexer);
38756   if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
38759       cp_lexer_consume_token (parser->lexer);
38799   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
38800       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
38802       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38808 	  cp_lexer_consume_token (parser->lexer);
38809 	  cp_lexer_consume_token (parser->lexer);
38842   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38844       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38853       if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
38854 	cp_lexer_consume_token (parser->lexer);
38865       colon = cp_lexer_next_token_is (parser->lexer, CPP_COLON);
38878 	  && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
38879 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN))
38881 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
38991   if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
38997   while (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38999       location_t id_loc = cp_lexer_peek_token (parser->lexer)->location;
39009 		 cp_lexer_peek_token (parser->lexer)->location);
39016       if (cp_lexer_next_token_is (parser->lexer, CPP_MINUS))
39018       else if (!cp_lexer_next_token_is (parser->lexer, CPP_PLUS))
39023       cp_lexer_consume_token (parser->lexer);
39025       if (cp_lexer_next_token_is_not (parser->lexer, CPP_NUMBER))
39031       addend = cp_lexer_peek_token (parser->lexer)->u.value;
39037       cp_lexer_consume_token (parser->lexer);
39047       if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
39048 	  || !cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
39051       cp_lexer_consume_token (parser->lexer);
39079   token = cp_lexer_peek_token (parser->lexer);
39130   cp_lexer_consume_token (parser->lexer);
39144       if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
39145 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_EQ))
39159       location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39160       if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
39183       if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
39185 	  cp_lexer_consume_token (parser->lexer);
39201       if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
39203 	  cp_lexer_consume_token (parser->lexer);
39237   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
39239       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39242 			 && (cp_lexer_nth_token_is (parser->lexer, 2,
39247 	  parse_iter = cp_lexer_nth_token_is (parser->lexer, n, CPP_COLON);
39313       if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
39316       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39346   cp_lexer_consume_token (parser->lexer);
39446   while (cp_lexer_peek_nth_token (parser->lexer, pos)->type == CPP_NAME
39447 	 || cp_lexer_peek_nth_token (parser->lexer, pos)->keyword == RID_DELETE)
39449       if (cp_lexer_peek_nth_token (parser->lexer, pos + 1)->type == CPP_COLON)
39455       if (cp_lexer_peek_nth_token (parser->lexer, pos + 1)->type == CPP_COMMA)
39464       cp_token *tok = cp_lexer_peek_token (parser->lexer);
39467 	  cp_lexer_consume_token (parser->lexer);
39510 	cp_lexer_consume_token (parser->lexer);
39513   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
39514       && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
39516       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39537       cp_lexer_consume_token (parser->lexer);
39538       cp_lexer_consume_token (parser->lexer);
39540   else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DELETE)
39541 	   && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
39544       cp_lexer_consume_token (parser->lexer);
39545       cp_lexer_consume_token (parser->lexer);
39577   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
39578       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
39580       cp_token *tok = cp_lexer_peek_token (parser->lexer);
39605       cp_lexer_consume_token (parser->lexer);
39606       cp_lexer_consume_token (parser->lexer);
39644   if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
39646   cp_lexer_consume_token (parser->lexer);
39648   if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
39650       cp_lexer_consume_token (parser->lexer);
39697   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
39699       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39716   cp_lexer_consume_token (parser->lexer);
39749   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
39751       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39766   cp_lexer_consume_token (parser->lexer);
39793   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39797   if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
39834   while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
39842       if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
39843 	cp_lexer_consume_token (parser->lexer);
39845       here = cp_lexer_peek_token (parser->lexer)->location;
40060   while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
40066       if (nested && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
40074 	  || (parser->lexer->in_omp_attribute_pragma && nested != 2))
40076 	  if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
40077 	    cp_lexer_consume_token (parser->lexer);
40079 	    error_at (cp_lexer_peek_token (parser->lexer)->location,
40084       token = cp_lexer_peek_token (parser->lexer);
40493   if (parser->lexer->in_omp_attribute_pragma
40494       && cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
40495       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
40496     cp_lexer_consume_token (parser->lexer);
40498   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40501       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40503       location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
40504       cp_lexer_consume_token (parser->lexer);
40624   while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
40627       if ((!first || parser->lexer->in_omp_attribute_pragma)
40628 	  && cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
40629 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
40630 	cp_lexer_consume_token (parser->lexer);
40634       if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40636 	  tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40637 	  location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
40671 	      cp_lexer_consume_token (parser->lexer);
40675 	      if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40677 		  id = cp_lexer_peek_token (parser->lexer)->u.value;
40690 		  cp_lexer_consume_token (parser->lexer);
40719 	      cp_lexer_consume_token (parser->lexer);
40773 	      cp_lexer_consume_token (parser->lexer);
40899       if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
40901 	  cp_lexer_consume_token (parser->lexer);
40905 	       && cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
40915 	      && cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
40917 	      location_t eloc = cp_lexer_peek_token (parser->lexer)->location;
40927   if (compare && cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
40929       cp_lexer_consume_token (parser->lexer);
40934       location_t eloc = cp_lexer_peek_token (parser->lexer)->location;
40973       eloc = cp_lexer_peek_token (parser->lexer)->location;
40978       if (!cp_lexer_next_token_is (parser->lexer, CPP_EQ))
40983       cp_lexer_consume_token (parser->lexer);
40984       eloc = cp_lexer_peek_token (parser->lexer)->location;
41034       if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ELSE))
41040 	      eloc = cp_lexer_peek_token (parser->lexer)->location;
41045 	  cp_lexer_consume_token (parser->lexer);
41151       if (compare && !cp_lexer_next_token_is (parser->lexer, CPP_EQ))
41156       switch (cp_lexer_peek_token (parser->lexer)->type)
41188 	  cp_lexer_consume_token (parser->lexer);
41197 	  token = cp_lexer_peek_token (parser->lexer);
41245 		  if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
41246 		      && cp_lexer_nth_token_is_keyword (parser->lexer,
41254 			  cp_lexer_consume_token (parser->lexer);
41262 		      && cp_lexer_next_token_is (parser->lexer, CPP_QUERY)
41270 		      cp_lexer_consume_token (parser->lexer);
41347 		  cp_lexer_consume_token (parser->lexer);
41413 	  cp_lexer_consume_token (parser->lexer);
41420 	      if (!cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
41435       cp_lexer_consume_token (parser->lexer);
41482   if (extra_scope && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
41483     cp_lexer_consume_token (parser->lexer);
41486       if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
41487         cp_lexer_consume_token (parser->lexer);
41491 	  if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
41492 	    cp_lexer_consume_token (parser->lexer);
41524   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
41539       if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
41540 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
41541 	cp_lexer_consume_token (parser->lexer);
41585   location_t c_loc = cp_lexer_peek_token (parser->lexer)->location;
41587   if (parser->lexer->in_omp_attribute_pragma
41588       && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
41589     cp_lexer_consume_token (parser->lexer);
41590   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41592       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41595       cp_lexer_consume_token (parser->lexer);
41614 		= cp_lexer_peek_token (parser->lexer)->location;
41615 	      if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41617 		  tree id2 = cp_lexer_peek_token (parser->lexer)->u.value;
41620 		  cp_lexer_consume_token (parser->lexer);
41671   if (parser->lexer->in_omp_attribute_pragma
41672       && cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
41673       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
41674     cp_lexer_consume_token (parser->lexer);
41675   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41677       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
41688 	error_at (cp_lexer_peek_token (parser->lexer)->location,
41691       cp_lexer_consume_token (parser->lexer);
41693   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
41696 	error_at (cp_lexer_peek_token (parser->lexer)->location,
41714       || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
41754   cp_token *token = cp_lexer_peek_token (parser->lexer);
41764       cp_lexer_consume_token (parser->lexer);
41777   token = cp_lexer_peek_token (parser->lexer);
41782       cp_lexer_consume_token (parser->lexer);
41799   token = cp_lexer_peek_token (parser->lexer);
41811       cp_lexer_consume_token (parser->lexer);
41814       token = cp_lexer_peek_token (parser->lexer);
41862   if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
41916 	  if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
41918 	      if (cp_lexer_next_token_is (parser->lexer,
41992 	      cp_lexer_consume_token (parser->lexer);
42017       cp_token *last_tok = cp_lexer_peek_token (parser->lexer);
42025 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
42032 	      && last_tok == cp_lexer_peek_token (parser->lexer))
42275     if (cp_lexer_nth_token_is (parser->lexer, i, CPP_NAME)
42276 	&& cp_lexer_nth_token_is (parser->lexer, i + 1, CPP_OPEN_PAREN)
42277 	&& cp_lexer_nth_token_is (parser->lexer, i + 2, CPP_NAME))
42279 	tree first = cp_lexer_peek_nth_token (parser->lexer, i)->u.value;
42280 	tree second = cp_lexer_peek_nth_token (parser->lexer, i + 2)->u.value;
42289   location_t first_loc = cp_lexer_peek_token (parser->lexer)->location;
42291     = cp_lexer_peek_nth_token (parser->lexer, n - 1)->location;
42348       cp_token *token = cp_lexer_peek_token (parser->lexer);
42390   cp_token *tok = cp_lexer_peek_token (parser->lexer);
42395       cp_lexer_consume_token (parser->lexer);
42397       if (parser->lexer->in_omp_attribute_pragma
42398 	  && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
42399 	cp_lexer_consume_token (parser->lexer);
42401       if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42403 	  tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42412 	  cp_lexer_consume_token (parser->lexer);
42501   loc_first = cp_lexer_peek_token (parser->lexer)->location;
42509       if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
42515       loc = cp_lexer_consume_token (parser->lexer)->location;
42531 	  cp_lexer_save_tokens (parser->lexer);
42542 	  cp_lexer_rollback_tokens (parser->lexer);
42696       if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
42701       if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
42750 	  if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
42752 	  else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
42754 	      cp_lexer_consume_token (parser->lexer);
42758 		   && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
42759 	    cp_lexer_consume_token (parser->lexer);
42762 	      loc = cp_lexer_peek_token (parser->lexer)->location;
42814       if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
42816 	  cp_lexer_consume_token (parser->lexer);
42819       else if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
42820 	cp_lexer_consume_token (parser->lexer);
42825 	      error_at (cp_lexer_peek_token (parser->lexer)->location,
42830 	  if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
42882   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
42931   location_t loc = cp_lexer_peek_token (parser->lexer
42993   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
43005   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43007       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
43016 	  cp_lexer_consume_token (parser->lexer);
43081   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
43085   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43087       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
43096 	  cp_lexer_consume_token (parser->lexer);
43146   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
43151   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43153       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
43162 	  cp_lexer_consume_token (parser->lexer);
43222   if (parser->lexer->in_omp_attribute_pragma
43223       && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
43226   if (cp_lexer_nth_token_is (parser->lexer, n, CPP_NAME))
43228       tree id = cp_lexer_peek_nth_token (parser->lexer, n)->u.value;
43290   if (cp_parser_pragma_kind (cp_lexer_peek_token (parser->lexer))
43302       tok = cp_lexer_peek_token (parser->lexer);
43309 	tok = cp_lexer_peek_token (parser->lexer);
43312 	  cp_lexer_consume_token (parser->lexer);
43356   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
43409   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
43418   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
43424       cp_lexer_consume_token (parser->lexer);
43450   else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43452       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
43459 	  cp_lexer_consume_token (parser->lexer);
43489 	  cp_lexer_consume_token (parser->lexer);
43520 	  cp_lexer_consume_token (parser->lexer);
43546 	  cp_lexer_consume_token (parser->lexer);
43777   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43779       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
43784 	  cp_lexer_consume_token (parser->lexer);
43835   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
43840   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43842       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
43856 	  cp_lexer_consume_token (parser->lexer);
43934   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
43939   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
43941       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
43949 	  cp_lexer_consume_token (parser->lexer);
43977 	  cp_lexer_consume_token (parser->lexer);
44114   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
44116       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
44121 	  cp_lexer_consume_token (parser->lexer);
44205   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
44207       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
44212 	  cp_lexer_consume_token (parser->lexer);
44353   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
44355       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
44371 	  cp_lexer_consume_token (parser->lexer);
44465 	  cp_lexer_consume_token (parser->lexer);
44471 	  cp_lexer_consume_token (parser->lexer);
44476 	  cp_lexer_consume_token (parser->lexer);
44481 	  cp_lexer_consume_token (parser->lexer);
44529   cp_parser_require_pragma_eol (parser, cp_lexer_peek_token (parser->lexer));
44808   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
44809     p = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
44819   cp_lexer_consume_token (parser->lexer);
44983   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
44986 	= IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
44989 	  cp_lexer_consume_token (parser->lexer);
45057   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
45059   if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
45113   while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
45114     cp_lexer_consume_token (parser->lexer);
45117     = cp_token_cache_new (pragma_tok, cp_lexer_peek_token (parser->lexer));
45122       while (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
45176       if (cp_lexer_next_token_is (parser->lexer, CPP_KEYWORD)
45177 	  || cp_lexer_next_token_is (parser->lexer, CPP_NAME))
45178 	selector = cp_lexer_peek_token (parser->lexer)->u.value;
45236 		  cp_lexer_consume_token (parser->lexer);
45251       cp_lexer_consume_token (parser->lexer);
45253       if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
45265 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
45267 	      && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
45269 	      && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
45271 	      cp_lexer_save_tokens (parser->lexer);
45272 	      cp_lexer_consume_token (parser->lexer);
45273 	      cp_lexer_consume_token (parser->lexer);
45276 		  && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
45278 		  cp_lexer_rollback_tokens (parser->lexer);
45279 		  cp_lexer_consume_token (parser->lexer);
45307 		cp_lexer_rollback_tokens (parser->lexer);
45309 	      token = cp_lexer_peek_token (parser->lexer);
45336 		  if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
45337 		    cp_lexer_consume_token (parser->lexer);
45344 	      if (cp_lexer_next_token_is (parser->lexer, CPP_KEYWORD)
45345 		  || cp_lexer_next_token_is (parser->lexer, CPP_NAME))
45347 		  tree prop = cp_lexer_peek_token (parser->lexer)->u.value;
45348 		  cp_lexer_consume_token (parser->lexer);
45361 		  if (cp_lexer_next_token_is (parser->lexer, CPP_KEYWORD)
45362 		      || cp_lexer_next_token_is (parser->lexer, CPP_NAME))
45364 		      prop = cp_lexer_peek_token (parser->lexer)->u.value;
45365 		      cp_lexer_consume_token (parser->lexer);
45367 		  else if (cp_lexer_next_token_is (parser->lexer, CPP_STRING))
45378 		  if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
45379 		    cp_lexer_consume_token (parser->lexer);
45433       if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
45434 	cp_lexer_consume_token (parser->lexer);
45464       if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
45466 	  = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
45495       tree set = cp_lexer_peek_token (parser->lexer)->u.value;
45496       cp_lexer_consume_token (parser->lexer);
45517       if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
45518 	cp_lexer_consume_token (parser->lexer);
45546   cp_token *varid_token = cp_lexer_peek_token (parser->lexer);
45593   if (parser->lexer->in_omp_attribute_pragma
45594       && cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
45595       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
45596     cp_lexer_consume_token (parser->lexer);
45599   location_t match_loc = cp_lexer_peek_token (parser->lexer)->location;
45600   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
45601     clause = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
45608   cp_lexer_consume_token (parser->lexer);
45662       parser->lexer->in_pragma = true;
45663       gcc_assert (cp_lexer_peek_token (parser->lexer)->type == CPP_PRAGMA);
45664       cp_token *pragma_tok = cp_lexer_consume_token (parser->lexer);
45665       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
45667       cp_lexer_consume_token (parser->lexer);
45671 	  if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
45672 	      && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
45673 	    cp_lexer_consume_token (parser->lexer);  */
45695   cp_lexer *lexer = NULL;
45756 		if (lexer == NULL)
45758 		    lexer = cp_lexer_alloc ();
45759 		    lexer->debugging_p = parser->lexer->debugging_p;
45761 		vec_safe_reserve (lexer->buffer, (last - first) + 2);
45767 		lexer->buffer->quick_push (tok);
45769 		  lexer->buffer->quick_push (*first);
45774 		lexer->buffer->quick_push (tok);
45779 		lexer->buffer->quick_push (tok);
45780 		lexer->next = parser->lexer;
45781 		lexer->next_token = lexer->buffer->address ();
45782 		lexer->last_token = lexer->next_token
45783 				    + lexer->buffer->length ()
45785 		lexer->in_omp_attribute_pragma = true;
45786 		parser->lexer = lexer;
45788 		   in the new lexer.  */
45789 		cp_lexer_set_source_position_from_token (lexer->next_token);
45791 		cp_token *pragma_tok = cp_lexer_consume_token (parser->lexer);
45792 		tree id = cp_lexer_peek_token (parser->lexer)->u.value;
45794 		cp_lexer_consume_token (parser->lexer);
45799 		    if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
45800 			&& cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
45801 		      cp_lexer_consume_token (parser->lexer);
45823 		gcc_assert (parser->lexer != lexer);
45824 		vec_safe_truncate (lexer->buffer, 0);
45831   if (lexer)
45832     cp_lexer_destroy (lexer);
45925   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
45927       || (parser->lexer->in_omp_attribute_pragma
45928 	  && cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
45929 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME)))
45933   else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
45943 	= { parser->lexer->in_omp_attribute_pragma };
45976   bool in_omp_attribute_pragma = parser->lexer->in_omp_attribute_pragma;
45977   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
45979       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
45984       cp_lexer_consume_token (parser->lexer);
45986       if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
45988 	  tree id = cp_lexer_peek_token (parser->lexer)->u.value;
45992 	cp_lexer_consume_token (parser->lexer);
46076   if (parser->lexer->in_omp_attribute_pragma
46077       && cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
46078       && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
46079     cp_lexer_consume_token (parser->lexer);
46082   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
46084       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
46090       cp_lexer_consume_token (parser->lexer);
46096       if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
46098 	  tree id = cp_lexer_peek_token (parser->lexer)->u.value;
46119 	  cp_lexer_consume_token (parser->lexer);
46121 	  if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
46122 	      || (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
46123 		  && cp_lexer_peek_nth_token (parser->lexer, 2)->type
46125 		  && cp_lexer_peek_nth_token (parser->lexer, 3)->type
46150 	      || !cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
46191   if (!cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL))
46225   switch (cp_lexer_peek_token (parser->lexer)->type)
46261     cp_lexer_consume_token (parser->lexer);
46285       location_t loc = cp_lexer_peek_token (parser->lexer)->location;
46309       if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
46310 	cp_lexer_consume_token (parser->lexer);
46329   first_token = cp_lexer_peek_token (parser->lexer);
46372 	      while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
46373 		cp_lexer_consume_token (parser->lexer);
46375 				       cp_lexer_peek_nth_token (parser->lexer,
46401 	  parser->lexer->in_pragma = true;
46433 				 cp_lexer_peek_nth_token (parser->lexer, 2));
46458   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
46460       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
46465 	  cp_lexer_consume_token (parser->lexer);
46472 	  cp_lexer_consume_token (parser->lexer);
46480 	  cp_lexer_consume_token (parser->lexer);
46492 	  cp_lexer_consume_token (parser->lexer);
46513   while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
46516       if ((!first || parser->lexer->in_omp_attribute_pragma)
46517 	  && cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
46518 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
46519 	cp_lexer_consume_token (parser->lexer);
46523       if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
46525 	  tree id = cp_lexer_peek_token (parser->lexer)->u.value;
46527 	  location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
46540 	      cp_lexer_consume_token (parser->lexer);
46545 		  if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
46547 		      id = cp_lexer_peek_token (parser->lexer)->u.value;
46562 		      error_at (cp_lexer_peek_token (parser->lexer)->location,
46565 		      switch (cp_lexer_peek_token (parser->lexer)->type)
46572 			  if (cp_lexer_nth_token_is (parser->lexer, 2,
46574 			    cp_lexer_consume_token (parser->lexer);
46579 		    cp_lexer_consume_token (parser->lexer);
46610 	    cp_lexer_consume_token (parser->lexer);
46683   while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
46686       if ((!first || parser->lexer->in_omp_attribute_pragma)
46687 	  && cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
46688 	  && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
46689 	cp_lexer_consume_token (parser->lexer);
46693       if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
46697 	= IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
46698       location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
46721       cp_lexer_consume_token (parser->lexer);
46738 	      if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
46740 		  tree val = cp_lexer_peek_token (parser->lexer)->u.value;
46750 		  error_at (cp_lexer_peek_token (parser->lexer)->location,
46753 		  switch (cp_lexer_peek_token (parser->lexer)->type)
46760 		      if (cp_lexer_nth_token_is (parser->lexer, 2,
46762 			cp_lexer_consume_token (parser->lexer);
46767 		cp_lexer_consume_token (parser->lexer);
46880   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
46889   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
46891       tree id = cp_lexer_peek_token (parser->lexer)->u.value;
46900 	  cp_lexer_consume_token (parser->lexer);
46989   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
46997       location_t name_loc = cp_lexer_peek_token (parser->lexer)->location;
47021 				      cp_lexer_peek_token (parser->lexer));
47059       while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
47060 	cp_lexer_consume_token (parser->lexer);
47063 	= cp_token_cache_new (pragma_tok, cp_lexer_peek_token (parser->lexer));
47068       if (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
47110   parser->lexer->in_pragma = true;
47111   gcc_assert (cp_lexer_peek_token (parser->lexer)->type == CPP_PRAGMA);
47113   cp_token *pragma_tok = cp_lexer_consume_token (parser->lexer);
47336   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
47339   if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
47341   cp_lexer_consume_token (parser->lexer);
47345   token = cp_lexer_peek_token (parser->lexer);
47348       token = cp_lexer_consume_token (parser->lexer);
47382   cp_lexer_consume_token (parser->lexer);
47439   location_t loc = cp_lexer_peek_token (parser->lexer)->location;
47475       || cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
47540   if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
47625    first pragma without benefit of an existing lexer structure.
47681   location_t location = cp_lexer_peek_token (parser->lexer)->location;
47707    regular lexer.  */
47717   pragma_tok = cp_lexer_consume_token (parser->lexer);
47719   parser->lexer->in_pragma = true;
48004 	cp_token *tok = cp_lexer_peek_token (the_parser->lexer);
48008 	    tok = cp_lexer_consume_token (parser->lexer);
48010 	    tok = cp_lexer_peek_token (the_parser->lexer);
48037 	cp_token *tok = cp_lexer_peek_token (the_parser->lexer);
48041 	    tok = cp_lexer_consume_token (parser->lexer);
48043 	    tok = cp_lexer_peek_token (the_parser->lexer);
48073 /* The interface the pragma parsers have to the lexer.  */
48078   cp_token *tok = cp_lexer_peek_token (the_parser->lexer);
48093       cp_lexer_consume_token (the_parser->lexer);
48117   cp_lexer *lexer = cp_lexer_new_main ();
48119   the_parser = cp_parser_new (lexer);
OpenGrok
