gcc/rust/expand/rust-macro-substitute-ctx.h

   1 // Copyright (C) 2020-2024 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-ast.h"
  20 #include "rust-macro-expand.h"
  21
  22 namespace Rust {
  23 class SubstituteCtx
  24 {
  25   std::vector<std::unique_ptr<AST::Token>> &input;
  26   std::vector<std::unique_ptr<AST::Token>> &macro;
  27   std::map<std::string, MatchedFragmentContainer *> &fragments;
  28
  29   /**
  30    * Find the repetition amount to use when expanding a repetition, and
  31    * check that all fragments used respect that repetition amount
  32    *
  33    * @param pattern_start Start of the repetition pattern
  34    * @param pattern_end End of the repetition pattern
  35    * @param repeat_amount Reference to fill with the matched repetition amount
  36    */
  37   bool check_repetition_amount (size_t pattern_start, size_t pattern_end,
  38                                 size_t &repeat_amount);
  39
  40 public:
  41   SubstituteCtx (std::vector<std::unique_ptr<AST::Token>> &input,
  42                  std::vector<std::unique_ptr<AST::Token>> &macro,
  43                  std::map<std::string, MatchedFragmentContainer *> &fragments)
  44     : input (input), macro (macro), fragments (fragments)
  45   {}
  46
  47   /**
  48    * Substitute a metavariable by its given fragment in a transcribing context,
  49    * i.e. replacing $var with the associated fragment.
  50    *
  51    * @param metavar Metavariable to try and replace
  52    * @param expanded Reference to a vector upon which expanded tokens will be
  53    * pushed
  54    *
  55    * @return True iff the substitution succeeded
  56    */
  57   bool substitute_metavar (std::unique_ptr<AST::Token> &metavar,
  58                            std::vector<std::unique_ptr<AST::Token>> &expanded);
  59
  60   /**
  61    * Substitute a macro repetition by its given fragments
  62    *
  63    * @param pattern_start Start index of the pattern tokens
  64    * @param pattern_end End index of the patterns tokens
  65    * @param separator Optional separator to include when expanding tokens
  66    *
  67    * @return A vector containing the repeated pattern
  68    */
  69   std::vector<std::unique_ptr<AST::Token>>
  70   substitute_repetition (size_t pattern_start, size_t pattern_end,
  71                          std::unique_ptr<AST::Token> separator);
  72
  73   /**
  74    * Substitute a given token by its appropriate representation
  75    *
  76    * @param token_idx Current token to try and substitute
  77    *
  78    * @return A token containing the associated fragment expanded into tokens if
  79    * any, or the cloned token if no fragment was associated, as well as the
  80    * amount of tokens that should be skipped before the next invocation. Since
  81    * this function may consume more than just one token, it is important to skip
  82    * ahead of the input to avoid mis-substitutions
  83    */
  84   std::pair<std::vector<std::unique_ptr<AST::Token>>, size_t>
  85   substitute_token (size_t token_idx);
  86
  87   /**
  88    * Substitute all tokens by their appropriate representation
  89    *
  90    * @return A vector containing the substituted tokens
  91    */
  92   std::vector<std::unique_ptr<AST::Token>> substitute_tokens ();
  93 };
  94 } // namespace Rust