gcc/rust/ast/rust-cond-compilation.h

   1 // Copyright (C) 2020-2023 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 #ifndef RUST_AST_CONDCOMPILATION
  20 #define RUST_AST_CONDCOMPILATION
  21 // Conditional compilation-related AST stuff
  22
  23 #include "rust-ast.h"
  24
  25 namespace Rust {
  26 namespace AST {
  27 // Base conditional compilation configuration predicate thing - abstract
  28 class ConfigurationPredicate
  29 {
  30 public:
  31   virtual ~ConfigurationPredicate () {}
  32
  33   // Unique pointer custom clone function
  34   std::unique_ptr<ConfigurationPredicate> clone_configuration_predicate () const
  35   {
  36     return std::unique_ptr<ConfigurationPredicate> (
  37       clone_configuration_predicate_impl ());
  38   }
  39
  40   // not sure if I'll use this but here anyway
  41   virtual void accept_vis (ASTVisitor &vis) = 0;
  42
  43 protected:
  44   // Clone function impl to be overriden in base classes
  45   virtual ConfigurationPredicate *
  46   clone_configuration_predicate_impl () const = 0;
  47 };
  48
  49 // A configuration option - true if option is set, false if option is not set.
  50 class ConfigurationOption : public ConfigurationPredicate
  51 {
  52   Identifier option_name;
  53
  54   // bool has_string_literal_option_body;
  55   std::string option_value; // technically a string or raw string literal
  56
  57 public:
  58   /* Returns whether the configuration option has a "value" part of the
  59    * key-value pair. */
  60   bool has_option_value () const { return !option_value.empty (); }
  61
  62   // Key-value pair constructor
  63   ConfigurationOption (Identifier option_name, std::string option_value)
  64     : option_name (option_name), option_value (option_value)
  65   {}
  66
  67   // Name-only constructor
  68   ConfigurationOption (Identifier option_name) : option_name (option_name) {}
  69
  70   void accept_vis (ASTVisitor &vis) override;
  71
  72 protected:
  73   /* Use covariance to implement clone function as returning this object rather
  74    * than base */
  75   ConfigurationOption *clone_configuration_predicate_impl () const override
  76   {
  77     return new ConfigurationOption (*this);
  78   }
  79 };
  80
  81 // TODO: inline
  82 struct ConfigurationPredicateList
  83 {
  84   std::vector<std::unique_ptr<ConfigurationPredicate>> predicate_list;
  85 };
  86
  87 // Predicate that returns true if all of the supplied predicates return true.
  88 class ConfigurationAll : public ConfigurationPredicate
  89 {
  90   std::vector<std::unique_ptr<ConfigurationPredicate>>
  91     predicate_list; // inlined form
  92
  93 public:
  94   ConfigurationAll (
  95     std::vector<std::unique_ptr<ConfigurationPredicate>> predicate_list)
  96     : predicate_list (predicate_list)
  97   {}
  98
  99   void accept_vis (ASTVisitor &vis) override;
 100
 101 protected:
 102   /* Use covariance to implement clone function as returning this object rather
 103    * than base */
 104   ConfigurationAll *clone_configuration_predicate_impl () const override
 105   {
 106     return new ConfigurationAll (*this);
 107   }
 108 };
 109
 110 // Predicate that returns true if any of the supplied predicates are true.
 111 class ConfigurationAny : public ConfigurationPredicate
 112 {
 113   std::vector<std::unique_ptr<ConfigurationPredicate>>
 114     predicate_list; // inlined form
 115
 116 public:
 117   ConfigurationAny (
 118     std::vector<std::unique_ptr<ConfigurationPredicate>> predicate_list)
 119     : predicate_list (predicate_list)
 120   {}
 121
 122   void accept_vis (ASTVisitor &vis) override;
 123
 124 protected:
 125   /* Use covariance to implement clone function as returning this object rather
 126    * than base */
 127   ConfigurationAny *clone_configuration_predicate_impl () const override
 128   {
 129     return new ConfigurationAny (*this);
 130   }
 131 };
 132
 133 /* Predicate that produces the negation of a supplied other configuration
 134  * predicate. */
 135 class ConfigurationNot : public ConfigurationPredicate
 136 {
 137   std::unique_ptr<ConfigurationPredicate> config_to_negate;
 138
 139 public:
 140   ConfigurationNot (ConfigurationPredicate *config_to_negate)
 141     : config_to_negate (config_to_negate)
 142   {}
 143
 144   // Copy constructor with clone
 145   ConfigurationNot (ConfigurationNot const &other)
 146     : config_to_negate (
 147       other.config_to_negate->clone_configuration_predicate ())
 148   {}
 149
 150   // Overloaded assignment operator to clone
 151   ConfigurationNot &operator= (ConfigurationNot const &other)
 152   {
 153     config_to_negate = other.config_to_negate->clone_configuration_predicate ();
 154
 155     return *this;
 156   }
 157
 158   // move constructors
 159   ConfigurationNot (ConfigurationNot &&other) = default;
 160   ConfigurationNot &operator= (ConfigurationNot &&other) = default;
 161
 162   void accept_vis (ASTVisitor &vis) override;
 163
 164 protected:
 165   /* Use covariance to implement clone function as returning this object rather
 166    * than base */
 167   ConfigurationNot *clone_configuration_predicate_impl () const override
 168   {
 169     return new ConfigurationNot (*this);
 170   }
 171 };
 172
 173 // TODO: relationship to other attributes?
 174 class CfgAttribute
 175 {
 176   std::unique_ptr<ConfigurationPredicate> config_to_include;
 177
 178 public:
 179   CfgAttribute (ConfigurationPredicate *config_to_include)
 180     : config_to_include (config_to_include)
 181   {}
 182
 183   // Copy constructor with clone
 184   CfgAttribute (CfgAttribute const &other)
 185     : config_to_include (
 186       other.config_to_include->clone_configuration_predicate ())
 187   {}
 188
 189   // Overloaded assignment operator to clone
 190   CfgAttribute &operator= (CfgAttribute const &other)
 191   {
 192     config_to_include
 193       = other.config_to_include->clone_configuration_predicate ();
 194
 195     return *this;
 196   }
 197
 198   // move constructors
 199   CfgAttribute (CfgAttribute &&other) = default;
 200   CfgAttribute &operator= (CfgAttribute &&other) = default;
 201 };
 202 /* TODO: ok, best thing to do would be eliminating this class, making Attribute
 203  * has a "is_cfg()" method, and having attribute path as "cfg" and AttrInput as
 204  * ConfigurationPredicate (so make ConfigurationPredicate a subclass of
 205  * AttrInput?). Would need special handling in parser, however. */
 206
 207 // TODO: inline
 208 struct CfgAttrs
 209 {
 210   std::vector<Attribute> cfg_attrs;
 211 };
 212
 213 // TODO: relationship to other attributes?
 214 class CfgAttrAttribute
 215 {
 216   std::unique_ptr<ConfigurationPredicate> config_to_include;
 217   std::vector<Attribute> cfg_attrs;
 218
 219 public:
 220   CfgAttrAttribute (ConfigurationPredicate *config_to_include,
 221                     std::vector<Attribute> cfg_attrs)
 222     : config_to_include (config_to_include), cfg_attrs (cfg_attrs)
 223   {}
 224
 225   // Copy constructor with clone
 226   CfgAttrAttribute (CfgAttrAttribute const &other)
 227     : config_to_include (
 228       other.config_to_include->clone_configuration_predicate ()),
 229       cfg_attrs (cfg_attrs)
 230   {}
 231
 232   // Overloaded assignment operator to clone
 233   CfgAttrAttribute &operator= (CfgAttrAttribute const &other)
 234   {
 235     config_to_include
 236       = other.config_to_include->clone_configuration_predicate ();
 237     cfg_attrs = other.cfg_attrs;
 238
 239     return *this;
 240   }
 241
 242   // move constructors
 243   CfgAttrAttribute (CfgAttrAttribute &&other) = default;
 244   CfgAttrAttribute &operator= (CfgAttrAttribute &&other) = default;
 245 };
 246 } // namespace AST
 247 } // namespace Rust
 248
 249 #endif