Line data    Source code

       1              : // Copyright (C) 2020-2026 Free Software Foundation, Inc.
       2              : 
       3              : // This file is part of GCC.
       4              : 
       5              : // GCC is free software; you can redistribute it and/or modify it under
       6              : // the terms of the GNU General Public License as published by the Free
       7              : // Software Foundation; either version 3, or (at your option) any later
       8              : // version.
       9              : 
      10              : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      11              : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
      12              : // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      13              : // for more details.
      14              : 
      15              : // You should have received a copy of the GNU General Public License
      16              : // along with GCC; see the file COPYING3.  If not see
      17              : // <http://www.gnu.org/licenses/>.
      18              : 
      19              : #include "rust-macro-invoc-lexer.h"
      20              : #include "rust-token.h"
      21              : 
      22              : namespace Rust {
      23              : 
      24              : const_TokenPtr
      25       927462 : MacroInvocLexer::peek_token (int n)
      26              : {
      27       927462 :   if ((offs + n) >= token_stream.size ())
      28         5292 :     return Token::make (END_OF_FILE, UNDEF_LOCATION);
      29              : 
      30       922170 :   return token_stream.at (offs + n);
      31              : }
      32              : 
      33              : void
      34          156 : MacroInvocLexer::split_current_token (TokenId new_left, TokenId new_right)
      35              : {
      36          156 :   auto &current_token = token_stream.at (offs);
      37          156 :   auto current_pos = token_stream.begin () + offs;
      38              : 
      39          156 :   auto l_tok = Token::make (new_left, current_token->get_locus ());
      40          156 :   auto r_tok = Token::make (new_right, current_token->get_locus ());
      41              : 
      42          156 :   current_pos = token_stream.erase (current_pos);
      43              : 
      44              :   // `insert` inserts before the specified position, so we insert the right one
      45              :   // then the left
      46          312 :   current_pos = token_stream.insert (current_pos, r_tok);
      47          312 :   token_stream.insert (current_pos, l_tok);
      48          156 : }
      49              : 
      50              : void
      51            0 : MacroInvocLexer::split_current_token (std::vector<TokenPtr> new_tokens)
      52              : {
      53            0 :   rust_assert (new_tokens.size () > 0);
      54              : 
      55            0 :   auto current_pos = token_stream.begin () + offs;
      56              : 
      57            0 :   current_pos = token_stream.erase (current_pos);
      58              : 
      59            0 :   for (auto &tk : new_tokens)
      60              :     {
      61            0 :       current_pos = token_stream.insert (current_pos, std::move (tk));
      62            0 :       current_pos++;
      63              :     }
      64            0 : }
      65              : 
      66              : std::vector<std::unique_ptr<AST::Token>>
      67         2543 : MacroInvocLexer::get_token_slice (size_t start_idx, size_t end_idx) const
      68              : {
      69         2543 :   std::vector<std::unique_ptr<AST::Token>> slice;
      70              : 
      71         2543 :   rust_assert (end_idx < token_stream.size ());
      72              : 
      73       131553 :   for (size_t i = start_idx; i < end_idx; i++)
      74       129010 :     slice.emplace_back (
      75       258020 :       std::unique_ptr<AST::Token> (new AST::Token (token_stream[i])));
      76              : 
      77         2543 :   return slice;
      78              : }
      79              : 
      80              : } // namespace Rust