From 59db6ff22d090f8b47e278e9ecbeaa049ba3ba55 Mon Sep 17 00:00:00 2001
From: Karen Arutyunov <karen@codesynthesis.com>
Date: Sat, 28 Sep 2019 20:48:35 +0300
Subject: Adapt to swapping of entry and pattern parameters in
 butl::path_match()

---
 libbuild2/dist/operation.cxx       |  2 +-
 libbuild2/functions-filesystem.cxx | 26 +++++++++++++-------------
 libbuild2/parser.cxx               |  6 +++---
 libbuild2/variable.cxx             |  2 +-
 4 files changed, 18 insertions(+), 18 deletions(-)

(limited to 'libbuild2')

diff --git a/libbuild2/dist/operation.cxx b/libbuild2/dist/operation.cxx
index ad2ee7f..f1dd81c 100644
--- a/libbuild2/dist/operation.cxx
+++ b/libbuild2/dist/operation.cxx
@@ -409,7 +409,7 @@ namespace build2
               continue;
           }
 
-          if (path_match (pat.leaf ().string (), t.path ().leaf ().string ()))
+          if (path_match (t.path ().leaf ().string (), pat.leaf ().string ()))
             cb.function (r, *srs, cb.data);
         }
 
diff --git a/libbuild2/functions-filesystem.cxx b/libbuild2/functions-filesystem.cxx
index d0861ba..752f73a 100644
--- a/libbuild2/functions-filesystem.cxx
+++ b/libbuild2/functions-filesystem.cxx
@@ -82,8 +82,8 @@ namespace build2
   // path_match() overloads (below) for details.
   //
   static bool
-  path_match (const path& pattern,
-              const path& entry,
+  path_match (const path& entry,
+              const path& pattern,
               const optional<dir_path>& start)
   {
     // If pattern and entry are both either absolute or relative and
@@ -94,7 +94,7 @@ namespace build2
               !pattern.empty () && !entry.empty ());
 
     if (rel && !path_pattern_self_matching (pattern))
-      return path_match (pattern, entry);
+      return path_match (entry, pattern);
 
     // The start directory must be specified and be absolute.
     //
@@ -114,7 +114,7 @@ namespace build2
          << info << "entry: '" << entry.representation () << "'";
     }
 
-    return path_match (pattern, entry, *start);
+    return path_match (entry, pattern, *start);
   }
 
   void
@@ -179,22 +179,22 @@ namespace build2
     //
     // Name matching.
     //
-    f["path_match"] = [](string pattern, string name)
+    f["path_match"] = [](string name, string pattern)
     {
-      return path_match (pattern, name);
+      return path_match (name, pattern);
     };
 
     // Path matching.
     //
-    f["path_match"] = [](path pat, path ent, optional<dir_path> start)
+    f["path_match"] = [](path ent, path pat, optional<dir_path> start)
     {
-      return path_match (pat, ent, start);
+      return path_match (ent, pat, start);
     };
 
     // The semantics depends on the presence of the start directory or the
     // first two argument syntactic representation.
     //
-    f["path_match"] = [](names pat, names ent, optional<names> start)
+    f["path_match"] = [](names ent, names pat, optional<names> start)
     {
       auto path_arg = [] (const names& a) -> bool
       {
@@ -205,13 +205,13 @@ namespace build2
       };
 
       return start || path_arg (pat) || path_arg (ent)
-        ? path_match (convert<path> (move (pat)),   // Match as paths.
-                      convert<path> (move (ent)),
+        ? path_match (convert<path> (move (ent)),   // Match as paths.
+                      convert<path> (move (pat)),
                       start
                       ? convert<dir_path> (move (*start))
                       : optional<dir_path> ())
-        : path_match (convert<string> (move (pat)), // Match as strings.
-                      convert<string> (move (ent)));
+        : path_match (convert<string> (move (ent)), // Match as strings.
+                      convert<string> (move (pat)));
     };
   }
 }
diff --git a/libbuild2/parser.cxx b/libbuild2/parser.cxx
index 0a5142f..33da1b5 100644
--- a/libbuild2/parser.cxx
+++ b/libbuild2/parser.cxx
@@ -3691,10 +3691,10 @@ namespace build2
 
     // Compare name to pattern as paths and according to dir.
     //
-    auto match = [&dir, sp] (const path& pattern, const name& n) -> bool
+    auto match = [&dir, sp] (const name& n, const path& pattern) -> bool
     {
       const path& p (dir ? path_cast<path> (n.dir) : path (n.value));
-      return path_match (pattern, p, *sp);
+      return path_match (p, pattern, *sp);
     };
 
     // Append name/extension to result according to dir. Store an indication
@@ -3810,7 +3810,7 @@ namespace build2
     {
       for (auto i (r.begin ()); i != r.end (); )
       {
-        if (match (p, *i))
+        if (match (*i, p))
           i = r.erase (i);
         else
           ++i;
diff --git a/libbuild2/variable.cxx b/libbuild2/variable.cxx
index 86109d2..c84a89c 100644
--- a/libbuild2/variable.cxx
+++ b/libbuild2/variable.cxx
@@ -1485,7 +1485,7 @@ namespace build2
         if (pat != "*")
         {
           if (name.size () < pat.size () - 1 || // One for '*' or '?'.
-              !butl::path_match (pat, name))
+              !butl::path_match (name, pat))
             continue;
         }
 
-- 
cgit v1.1