Fluorine Manager: full Linux port of Mod Organizer 2

Complete native Linux port with FUSE-based virtual filesystem,
Proton/umu-run integration, and Flatpak packaging.

Key features:
- FUSE VFS replacing Windows USVFS (in-process + standalone helper for Flatpak)
- Proton/GE-Proton/umu-run launcher with env var forwarding
- Flatpak support (sandbox-aware VFS, NXM handler, umu-run)
- Wine prefix management UI
- Case-insensitive path resolution for Linux filesystems
- QSettings-safe INI handling (avoids Bethesda INI corruption)
- Portable instance support with auto-generated launcher scripts

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

1 files changed, 194 insertions, 0 deletions

diff --git a/libs/usvfs/src/shared/wildcard.cpp b/libs/usvfs/src/shared/wildcard.cpp
new file mode 100644
index 0000000..a2efe6d
--- /dev/null
+++ b/libs/usvfs/src/shared/wildcard.cpp
@@ -0,0 +1,194 @@
+/*
+Userspace Virtual Filesystem
+
+Copyright (C) 2015 Sebastian Herbord. All rights reserved.
+
+This file is part of usvfs.
+
+usvfs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+usvfs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with usvfs. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "wildcard.h"
+#include "logging.h"
+#include "windows_sane.h"
+
+static bool IsInnerMatch(LPCWSTR pszString, LPCWSTR pszMatch)
+{
+  while (*pszMatch != L'\0') {
+    if ((*pszMatch == L'?') || (*pszMatch == L'>')) {
+      if (!*pszString) {
+        // ? must match exactly one character
+        return false;
+      }
+
+      ++pszString;
+      ++pszMatch;
+    } else if ((*pszMatch == L'*') || (*pszMatch == L'<')) {
+      if (IsInnerMatch(pszString, pszMatch + 1)) {
+        // * may match empty string or we may have matched something already
+        return true;
+      }
+
+      return *pszString && IsInnerMatch(pszString + 1, pszMatch);
+
+      // the rest of the string can't be matched
+    } else {
+      if (CharUpperW(MAKEINTRESOURCEW(MAKELONG(*pszString++, 0))) !=
+          CharUpperW(MAKEINTRESOURCEW(MAKELONG(*pszMatch++, 0)))) {
+        // regular chars compare
+        return false;
+      }
+    }
+  }
+
+  return !*pszString && !*pszMatch;
+}
+
+static LPCSTR InnerMatch(LPCSTR pszString, LPCSTR pszMatch)
+{
+  // We have a special case where string is empty ("") and the mask is "*".
+  // We need to handle this too. So we can't test on !*pszString here.
+  // The loop breaks when the match string is exhausted.
+  while (*pszString != '\0') {
+    // Single wildcard character
+    if ((*pszMatch == '?') || (*pszMatch == '>')) {
+      // can't match directory separator
+      if ((*pszString == '\\') || (*pszString == '/'))
+        return nullptr;
+
+      // Matches any character except empty string
+      if (*pszString == '\0') {
+        // string consumed, part of the pattern is left
+        return pszMatch;
+      }
+
+      // OK next
+      ++pszString;
+      ++pszMatch;
+    } else if ((*pszMatch == '*') || (*pszMatch == '<')) {
+      // * doesn't match directory separators
+      if ((*pszString == '\\') || (*pszString == '/')) {
+        ++pszMatch;
+        continue;
+      }
+
+      // Need to do some tricks.
+
+      // 1. The wildcard * is ignored.
+      //    So just an empty string matches. This is done by recursion.
+      //      Because we eat one character from the match string, the
+      //      recursion will stop.
+      {
+        LPCSTR remainder = InnerMatch(pszString, pszMatch + 1);
+        if (remainder != nullptr) {
+          // we have a match and the * replaces no other character
+          return remainder;
+        }
+      }
+
+      // 2. Chance we eat the next character and try it again, with a
+      //    wildcard * match. This is done by recursion. Because we eat
+      //      one character from the string, the recursion will stop.
+      if (*pszString != '\0') {
+        LPCSTR remainder = InnerMatch(pszString + 1, pszMatch);
+        if (remainder != nullptr) {
+          return remainder;
+        }
+      }
+
+      // Nothing worked with this wildcard.
+      return nullptr;
+    } else {
+      // Standard compare of 2 chars. Note that *pszSring might be 0
+      // here, but then we never get a match on *pszMask that has always
+      // a value while inside this loop.
+      if (CharUpperA(MAKEINTRESOURCEA(MAKELONG(*pszString++, 0))) !=
+          CharUpperA(MAKEINTRESOURCEA(MAKELONG(*pszMatch++, 0))))
+        return nullptr;
+    }
+  }
+
+  // successful match if the input string was completely consumed
+  if (*pszString == '\0') {
+    while ((*pszMatch == '*') || (*pszMatch == '<')) {
+      ++pszMatch;
+    }
+    return pszMatch;
+  } else {
+    return nullptr;
+  }
+}
+
+namespace usvfs::shared::wildcard
+{
+
+bool Match(LPCWSTR pszString, LPCWSTR pszMatch)
+{
+  if (*pszString == L'.') {
+    // cmd.exe seems to ignore
+    return Match(pszString + 1, pszMatch);
+  } else {
+    size_t len = wcslen(pszMatch);
+    if ((len > 2) && (wcscmp(pszMatch + len - 2, L".*") == 0)) {
+      // cmd.exe seems to completely ignore .* at the end.
+      std::wstring temp(pszMatch, pszMatch + len - 2);
+      return IsInnerMatch(pszString, temp.c_str());
+    }
+    return IsInnerMatch(pszString, pszMatch);
+  }
+}
+
+bool Match(LPCSTR pszString, LPCSTR pszMatch)
+{
+  if (*pszString == '.') {
+    // cmd.exe seems to ignore
+    return Match(pszString + 1, pszMatch);
+  } else {
+    size_t len = strlen(pszMatch);
+    LPCSTR res = nullptr;
+    if ((len > 2) && (strcmp(pszMatch + len - 2, ".*") == 0)) {
+      // cmd.exe seems to completely ignore .* at the end.
+      std::string temp(pszMatch, pszMatch + len - 2);
+      res = InnerMatch(pszString, temp.c_str());
+    } else {
+      res = InnerMatch(pszString, pszMatch);
+    }
+    return ((res != nullptr) && (*res == '\0'));
+  }
+}
+
+LPCSTR PartialMatch(LPCSTR pszString, LPCSTR pszMatch)
+{
+  if (*pszString == '.') {
+    // cmd.exe seems to ignore dots at the start
+    return PartialMatch(pszString + 1, pszMatch);
+  } else {
+    size_t len = strlen(pszMatch);
+    if ((len > 2) && (strcmp(pszMatch + len - 2, ".*") == 0)) {
+      // in cmd.exe there seems to be no difference between <something>* and
+      // <something>*.*
+      std::string temp(pszMatch, pszMatch + len - 2);
+      LPCSTR pos = InnerMatch(pszString, temp.c_str());
+      if (pos != nullptr) {
+        if (*pos == '\0') {
+          return pszMatch + strlen(pszMatch);
+        } else {
+          return pszMatch + (pos - temp.c_str());
+        }
+      }
+    }
+    return InnerMatch(pszString, pszMatch);
+  }
+}
+
+}  // namespace usvfs::shared::wildcard