testing new non-autotools build system

[chaz/yoink] / src / stlplus / portability / wildcard.cpp

diff --git a/src/stlplus/portability/wildcard.cpp b/src/stlplus/portability/wildcard.cpp
new file mode 100644 (file)
index 0000000..c15252e
--- /dev/null
+++ b/src/stlplus/portability/wildcard.cpp
@@ -0,0 +1,164 @@
+////////////////////////////////////////////////////////////////////////////////\r
+\r
+//   Author:    Andy Rushton\r
+//   Copyright: (c) Southampton University 1999-2004\r
+//              (c) Andy Rushton           2004-2009\r
+//   License:   BSD License, see ../docs/license.html\r
+\r
+//   Simple wildcard matching function.\r
+\r
+//   WARNING: wheel re-invention follows\r
+//   Given that all shells perform wildcard matching, why don't the library writers put it in the C run-time????????\r
+\r
+////////////////////////////////////////////////////////////////////////////////\r
+#include "wildcard.hpp"\r
+\r
+namespace stlplus\r
+{\r
+\r
+  // function for testing whether a character matches a set\r
+  // I can't remember the exact rules and I have no definitive references but:\r
+  // a set contains characters, escaped characters (I think) and ranges in the form a-z\r
+  // The character '-' can only appear at the start of the set where it is not interpreted as a range\r
+  // This is a horrible mess - blame the Unix folks for making a hash of wildcards\r
+  // first expand any ranges and remove escape characters to make life more palatable\r
+\r
+  static bool match_set (const std::string& set, char match)\r
+  {\r
+    std::string simple_set;\r
+    for (std::string::const_iterator i = set.begin(); i != set.end(); ++i)\r
+    {\r
+      switch(*i)\r
+      {\r
+      case '-':\r
+      {\r
+        if (i == set.begin())\r
+        {\r
+          simple_set += *i;\r
+        }\r
+        else if (i+1 == set.end())\r
+        {\r
+          return false;\r
+        }\r
+        else\r
+        {\r
+          // found a set. The first character is already in the result, so first remove it (the set might be empty)\r
+          simple_set.erase(simple_set.end()-1);\r
+          char last = *++i;\r
+          for (char ch = *(i-2); ch <= last; ch++)\r
+          {\r
+            simple_set += ch;\r
+          }\r
+        }\r
+        break;\r
+      }\r
+      case '\\':\r
+        if (i+1 == set.end()) {return false;}\r
+        simple_set += *++i;\r
+        break;\r
+      default:\r
+        simple_set += *i;\r
+        break;\r
+      }\r
+    }\r
+    std::string::size_type result = simple_set.find(match);\r
+    return result != std::string::npos;\r
+  }\r
+\r
+  // the recursive bit - basically whenever a * is found you recursively call this for each candidate substring match\r
+  // until either it succeeds or you run out of string to match\r
+  // for each * in the wildcard another level of recursion is created\r
+\r
+  static bool match_remainder (const std::string& wild, std::string::const_iterator wildi, const std::string& match, std::string::const_iterator matchi)\r
+  {\r
+    //cerr << "match_remainder called at " << *matchi << " with wildcard " << *wildi << endl;\r
+    while (wildi != wild.end() && matchi != match.end())\r
+    {\r
+      //cerr << "trying to match " << *matchi << " with wildcard " << *wildi << endl;\r
+      switch(*wildi)\r
+      {\r
+      case '*':\r
+      {\r
+        ++wildi;\r
+        ++matchi;\r
+        for (std::string::const_iterator i = matchi; i != match.end(); ++i)\r
+        {\r
+          // deal with * at the end of the wildcard - there is no remainder then\r
+          if (wildi == wild.end())\r
+          {\r
+            if (i == match.end()-1)\r
+              return true;\r
+          }\r
+          else if (match_remainder(wild, wildi, match, i))\r
+          {\r
+            return true;\r
+          }\r
+        }\r
+        return false;\r
+      }\r
+      case '[':\r
+      {\r
+        // scan for the end of the set using a similar method for avoiding escaped characters\r
+        bool found = false;\r
+        std::string::const_iterator end = wildi + 1;\r
+        for (; !found && end != wild.end(); ++end)\r
+        {\r
+          switch(*end)\r
+          {\r
+          case ']':\r
+          {\r
+            // found the set, now match with its contents excluding the brackets\r
+            if (!match_set(wild.substr(wildi - wild.begin() + 1, end - wildi - 1), *matchi))\r
+              return false;\r
+            found = true;\r
+            break;\r
+          }\r
+          case '\\':\r
+            if (end == wild.end()-1)\r
+              return false;\r
+            ++end;\r
+            break;\r
+          default:\r
+            break;\r
+          }\r
+        }\r
+        if (!found)\r
+          return false;\r
+        ++matchi;\r
+        wildi = end;\r
+        break;\r
+      }\r
+      case '?':\r
+        ++wildi;\r
+        ++matchi;\r
+        break;\r
+      case '\\':\r
+        if (wildi == wild.end()-1)\r
+          return false;\r
+        ++wildi;\r
+        if (*wildi != *matchi)\r
+          return false;\r
+        ++wildi;\r
+        ++matchi;\r
+        break;\r
+      default:\r
+        if (*wildi != *matchi)\r
+          return false;\r
+        ++wildi;\r
+        ++matchi;\r
+        break;\r
+      }\r
+    }\r
+    bool result = wildi == wild.end() && matchi == match.end();\r
+    return result;\r
+  }\r
+\r
+  // like all recursions the exported function has a simpler interface than the\r
+  // recursive function and is just a 'seed' to the recursion itself\r
+\r
+  bool wildcard(const std::string& wild, const std::string& match)\r
+  {\r
+    return match_remainder(wild, wild.begin(), match, match.begin());\r
+  }\r
+\r
+} // end namespace stlplus\r