WIP: rename match_rule() to match_rule_impl()

8 files changed, 30 insertions, 27 deletions

diff --git a/libbuild2/algorithm.cxx b/libbuild2/algorithm.cxx
index 5b543cf..88aec85 100644
--- a/libbuild2/algorithm.cxx
+++ b/libbuild2/algorithm.cxx
@@ -553,11 +553,11 @@ namespace build2
   // Return the matching rule or NULL if no match and try_match is true.
   //
   const rule_match*
-  match_rule (action a, target& t,
-              uint64_t options,
-              const rule* skip,
-              bool try_match,
-              match_extra* pme)
+  match_rule_impl (action a, target& t,
+                   uint64_t options,
+                   const rule* skip,
+                   bool try_match,
+                   match_extra* pme)
   {
     using fallback_rule = adhoc_rule_pattern::fallback_rule;
 
@@ -616,11 +616,11 @@ namespace build2
         // a temporary (it shouldn't be modified if unlocked).
         //
         match_extra gme (false /* locked */);
-        if (const rule_match* r = match_rule (a, const_cast<target&> (*g),
-                                              0 /* options */,
-                                              skip,
-                                              true /* try_match */,
-                                              &gme))
+        if (const rule_match* r = match_rule_impl (a, const_cast<target&> (*g),
+                                                   0 /* options */,
+                                                   skip,
+                                                   true /* try_match */,
+                                                   &gme))
         {
           me.new_options = options; // Currently unused but maybe in future.
           return r;
@@ -1195,7 +1195,7 @@ namespace build2
           clear_target (a, t);
 
           const rule_match* r (
-            match_rule (a, t, options, nullptr, try_match));
+            match_rule_impl (a, t, options, nullptr, try_match));
 
           assert (l.offset != target::offset_tried); // Should have failed.
 
diff --git a/libbuild2/algorithm.ixx b/libbuild2/algorithm.ixx
index 016eeed..615cef0 100644
--- a/libbuild2/algorithm.ixx
+++ b/libbuild2/algorithm.ixx
@@ -394,11 +394,11 @@ namespace build2
   }
 
   LIBBUILD2_SYMEXPORT const rule_match*
-  match_rule (action, target&,
-              uint64_t options,
-              const rule* skip,
-              bool try_match = false,
-              match_extra* = nullptr);
+  match_rule_impl (action, target&,
+                   uint64_t options,
+                   const rule* skip,
+                   bool try_match = false,
+                   match_extra* = nullptr);
 
   LIBBUILD2_SYMEXPORT recipe
   apply_impl (action, target&, const rule_match&);
@@ -643,7 +643,7 @@ namespace build2
     // Note: we don't touch any of the t[a] state since that was/will be set
     // for the delegating rule.
     //
-    const rule_match* r (match_rule (a, t, options, &dr, try_match));
+    const rule_match* r (match_rule_impl (a, t, options, &dr, try_match));
     return r != nullptr ? apply_impl (a, t, *r) : empty_recipe;
   }
 
diff --git a/libbuild2/dyndep.cxx b/libbuild2/dyndep.cxx
index e6d0643..c6294bb 100644
--- a/libbuild2/dyndep.cxx
+++ b/libbuild2/dyndep.cxx
@@ -863,7 +863,8 @@ namespace build2
     // whether someone will execute such a member.
     //
     // So instead we now just link the member up to the group and rely on the
-    // special semantics in match_rule() for groups with the dyn_members flag.
+    // special semantics in match_rule_impl() for groups with the dyn_members
+    // flag.
     //
     assert ((g.type ().flags & target_type::flag::dyn_members) ==
             target_type::flag::dyn_members);
@@ -884,7 +885,8 @@ namespace build2
 
     // We don't need to match the group recipe directy from ad hoc
     // recipes/rules due to the special semantics for explicit group members
-    // in match_rule(). This is what skip_match is for.
+    // in match_rule_impl(). This is what skip_match is for.
+    //
     if (l.second)
     {
       l.first.group = &g;
diff --git a/libbuild2/file.cxx b/libbuild2/file.cxx
index 2a09aea..1e6cb4c 100644
--- a/libbuild2/file.cxx
+++ b/libbuild2/file.cxx
@@ -3021,7 +3021,7 @@ namespace build2
     {
       assert (pk.scope != nullptr);
 
-      // Note: similar to/inspired by match_rule().
+      // Note: similar to/inspired by match_rule_impl().
       //
       // Search scopes outwards, stopping at the project root.
       //
diff --git a/libbuild2/parser.cxx b/libbuild2/parser.cxx
index 55c5c6c..3b78072 100644
--- a/libbuild2/parser.cxx
+++ b/libbuild2/parser.cxx
@@ -2180,7 +2180,8 @@ namespace build2
                   fail (l) << "project " << *root_ << " does not support "
                            << "operation " << ctx->operation_table[oi];
 
-                // Note: for now always inner (see match_rule() for details).
+                // Note: for now always inner (see match_rule_impl() for
+                // details).
                 //
                 action a (mi, oi);
 
diff --git a/libbuild2/rule.cxx b/libbuild2/rule.cxx
index e475375..04d6b38 100644
--- a/libbuild2/rule.cxx
+++ b/libbuild2/rule.cxx
@@ -46,7 +46,7 @@ namespace build2
   sub_match (const string& n, operation_id o,
              action a, target& t, match_extra& me) const
   {
-    // First check for an ad hoc recipe (see match_rule() for details).
+    // First check for an ad hoc recipe (see match_rule_impl() for details).
     //
     if (!t.adhoc_recipes.empty ())
     {
diff --git a/libbuild2/rule.hxx b/libbuild2/rule.hxx
index c693f8d..acd22fe 100644
--- a/libbuild2/rule.hxx
+++ b/libbuild2/rule.hxx
@@ -272,8 +272,8 @@ namespace build2
     // is a pattern and returns true otherwise.
     //
     // Note also that in case of a member of a group-based target, match() is
-    // called on the group while apply() on the member (see match_rule() in
-    // algorithms.cxx for details). This means that match() may be called
+    // called on the group while apply() on the member (see match_rule_impl()
+    // in algorithms.cxx for details). This means that match() may be called
     // without having the target locked and as a result match() should (unless
     // known to only match a non-group) treat the target as const and only
     // rely on immutable information (type, name, etc) since the group could
diff --git a/libbuild2/target.hxx b/libbuild2/target.hxx
index fc733b6..78f3e49 100644
--- a/libbuild2/target.hxx
+++ b/libbuild2/target.hxx
@@ -178,7 +178,7 @@ namespace build2
   struct match_extra
   {
     bool locked;   // Normally true (see adhoc_rule::match() for background).
-    bool fallback; // True if matching a fallback rule (see match_rule()).
+    bool fallback; // True if matching a fallback rule (see match_rule_impl()).
 
     // When matching a rule, the caller may wish to request a subset of the
     // full functionality of performing the operation on the target. This is
@@ -327,7 +327,7 @@ namespace build2
 
     // Implementation details.
     //
-    // NOTE: see match_rule() in algorithms.cxx if changing anything here.
+    // NOTE: see match_rule_impl() in algorithms.cxx if changing anything here.
     //
   public:
     explicit
@@ -2278,7 +2278,7 @@ namespace build2
   // in C++, instead deriving from mtime_target directly and using a custom
   // members layout more appropriate for the group's semantics. To put it
   // another way, a group-based target should only be matched by an ad hoc
-  // recipe/rule (see match_rule() in algorithms.cxx for details).
+  // recipe/rule (see match_rule_impl() in algorithms.cxx for details).
   //
   class LIBBUILD2_SYMEXPORT group: public mtime_target
   {