feat: Windows portability — POSIX guards + Win32 API alternatives

- bmi_cache.cppm: flock() → LockFileEx/UnlockFileEx on Windows
- probe.cppm, xlings.cppm, cli.cppm, config.cppm, pack.cppm:
  popen/pclose → _popen/_pclose on Windows
- ninja_backend.cppm: GetModuleFileNameA for exe path on Windows
- config.cppm: GetModuleFileNameA for MCPP_HOME detection

These are the minimum changes needed for MSVC compilation.

Author: Sunrisepeak

src/bmi_cache.cppm

@@ -15,9 +15,14 @@
 // dep cache without trashing manifest.txt (docs/26 §5.4 V2).
 
 module;
+#if defined(_WIN32)
+#include <io.h>
+#include <windows.h>
+#else
 #include <fcntl.h>
 #include <sys/file.h>
 #include <unistd.h>
+#endif
 
 export module mcpp.bmi_cache;
 
@@ -184,9 +189,35 @@ stage_into(const CacheKey& key,
 
 namespace {
 
-// Acquire an exclusive non-blocking flock on <dir>/.lock. Returns the fd on
-// success (caller closes it to release), or -1 if another mcpp is already
-// populating this entry — in which case the caller should skip writing.
+// Acquire an exclusive non-blocking lock on <dir>/.lock. Returns a handle
+// on success, or -1/INVALID_HANDLE if another mcpp is already populating.
+#if defined(_WIN32)
+// Windows: use LockFileEx on a file handle
+HANDLE try_lock_dir(const std::filesystem::path& dir) {
+    std::error_code ec;
+    std::filesystem::create_directories(dir, ec);
+    auto lockPath = dir / ".lock";
+    HANDLE h = CreateFileW(lockPath.wstring().c_str(),
+        GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
+        NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (h == INVALID_HANDLE_VALUE) return h;
+    OVERLAPPED ov = {};
+    if (!LockFileEx(h, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY,
+                    0, 1, 0, &ov)) {
+        CloseHandle(h);
+        return INVALID_HANDLE_VALUE;
+    }
+    return h;
+}
+
+void release_lock(HANDLE h) {
+    if (h == INVALID_HANDLE_VALUE) return;
+    OVERLAPPED ov = {};
+    UnlockFileEx(h, 0, 1, 0, &ov);
+    CloseHandle(h);
+}
+#else
+// POSIX: use flock(2)
 int try_lock_dir(const std::filesystem::path& dir) {
     std::error_code ec;
     std::filesystem::create_directories(dir, ec);
@@ -205,6 +236,7 @@ void release_lock(int fd) {
     ::flock(fd, LOCK_UN);
     ::close(fd);
 }
+#endif
 
 } // namespace
 
@@ -214,6 +246,16 @@ populate_from(const CacheKey& key,
               const DepArtifacts& arts)
 {
     auto cacheDir = key.dir();
+#if defined(_WIN32)
+    HANDLE lockHandle = try_lock_dir(cacheDir);
+    if (lockHandle == INVALID_HANDLE_VALUE) {
+        return {};
+    }
+    struct LockGuard {
+        HANDLE h;
+        ~LockGuard() { release_lock(h); }
+    } guard{ lockHandle };
+#else
     int lockFd = try_lock_dir(cacheDir);
     if (lockFd < 0) {
         // Another writer holds the lock; treat as success (they'll do it).
@@ -223,6 +265,7 @@ populate_from(const CacheKey& key,
         int fd;
         ~LockGuard() { release_lock(fd); }
     } guard{ lockFd };
+#endif
 
     auto cacheBmi = key.bmiDir();
     auto cacheObj = key.objDir();

src/build/ninja_backend.cppm

@@ -14,7 +14,9 @@
 module;
 #include <cstdio>
 #include <cstdlib>
-#if defined(__APPLE__)
+#if defined(_WIN32)
+#include <windows.h>
+#elif defined(__APPLE__)
 #include <mach-o/dyld.h>  // _NSGetExecutablePath
 #endif
 
@@ -116,8 +118,14 @@ bool dyndep_mode_enabled() {
 
 std::filesystem::path mcpp_exe_path() {
     std::error_code ec;
-#if defined(__APPLE__)
-    // macOS: use _NSGetExecutablePath
+#if defined(_WIN32)
+    char buf[MAX_PATH];
+    DWORD len = GetModuleFileNameA(NULL, buf, MAX_PATH);
+    if (len > 0 && len < MAX_PATH) {
+        auto p = std::filesystem::canonical(buf, ec);
+        if (!ec) return p;
+    }
+#elif defined(__APPLE__)
     char buf[4096];
     uint32_t size = sizeof(buf);
     if (_NSGetExecutablePath(buf, &size) == 0) {

src/cli.cppm

@@ -11,6 +11,10 @@
 module;
 #include <cstdio>
 #include <cstdlib>
+#if defined(_WIN32)
+#define popen  _popen
+#define pclose _pclose
+#endif
 
 export module mcpp.cli;
 

src/config.cppm

@@ -16,7 +16,11 @@
 module;
 #include <cstdio>
 #include <cstdlib>
-#if defined(__APPLE__)
+#if defined(_WIN32)
+#include <windows.h>
+#define popen  _popen
+#define pclose _pclose
+#elif defined(__APPLE__)
 #include <mach-o/dyld.h>  // _NSGetExecutablePath
 #endif
 
@@ -164,7 +168,13 @@ std::filesystem::path home_dir() {
         return std::filesystem::path(e);
 
     std::error_code ec;
-#if defined(__APPLE__)
+#if defined(_WIN32)
+    char _exe_buf[MAX_PATH];
+    DWORD _exe_len = GetModuleFileNameA(NULL, _exe_buf, MAX_PATH);
+    std::filesystem::path exe;
+    if (_exe_len > 0 && _exe_len < MAX_PATH)
+        exe = std::filesystem::canonical(_exe_buf, ec);
+#elif defined(__APPLE__)
     char _exe_buf[4096];
     uint32_t _exe_size = sizeof(_exe_buf);
     std::filesystem::path exe;

src/pack/pack.cppm

@@ -17,6 +17,10 @@
 
 module;
 #include <cstdio>      // popen, pclose
+#if defined(_WIN32)
+#define popen  _popen
+#define pclose _pclose
+#endif
 
 export module mcpp.pack;
 

src/toolchain/probe.cppm

@@ -3,6 +3,10 @@
 module;
 #include <cstdio>      // popen, pclose, fgets, FILE
 #include <cstdlib>     // getenv
+#if defined(_WIN32)
+#define popen  _popen
+#define pclose _pclose
+#endif
 
 export module mcpp.toolchain.probe;
 

src/xlings.cppm

@@ -10,6 +10,10 @@
 module;
 #include <cstdio>
 #include <cstdlib>
+#if defined(_WIN32)
+#define popen  _popen
+#define pclose _pclose
+#endif
 
 export module mcpp.xlings;