remove std::filesystem usage

Author: salinas-miguel

tools/swift-stdlib-tool/CMakeLists.txt

@@ -2,7 +2,3 @@ add_swift_host_tool(swift-stdlib-tool
   swift-stdlib-tool.cpp
   SWIFT_COMPONENT compiler)
 
-set_target_properties(swift-stdlib-tool PROPERTIES
-  CXX_STANDARD 17
-  CXX_STANDARD_REQUIRED ON)
-

tools/swift-stdlib-tool/swift-stdlib-tool.cpp

@@ -81,11 +81,13 @@ const char *usage =
 #include <libkern/OSByteOrder.h>
 #include <uuid/uuid.h>
 #include <dispatch/dispatch.h>
+#include <copyfile.h>
+#include <dirent.h>
+#include <libgen.h>
 
 #include <algorithm>
 #include <vector>
 #include <string>
-#include <filesystem>
 #include <unordered_map>
 #include <unordered_set>
 #include <mutex>
@@ -424,7 +426,7 @@ ssize_t pread_all(int fd, void *buf, size_t count, off_t offset)
 
 template <typename T> 
 int parse_macho(int fd, uint32_t offset, uint32_t size, 
-                void (^dylibVisitor)(std::filesystem::path const &path),
+                void (^dylibVisitor)(std::string const &path),
                 void (^uuidVisitor)(uuid_t const uuid))
 {
     ssize_t readed;
@@ -485,7 +487,7 @@ int parse_macho(int fd, uint32_t offset, uint32_t size,
 
 
 int parse_macho(int fd, uint32_t offset, uint32_t size, 
-              void (^dylibVisitor)(std::filesystem::path const &path),
+              void (^dylibVisitor)(std::string const &path),
               void (^uuidVisitor)(uuid_t const uuid))
 {
     uint32_t magic;
@@ -513,7 +515,7 @@ int parse_macho(int fd, uint32_t offset, uint32_t size,
 
 
 int parse_fat(int fd, off_t fsize, char *buffer, size_t size, 
-              void (^dylibVisitor)(std::filesystem::path const &path),
+              void (^dylibVisitor)(std::string const &path),
               void (^uuidVisitor)(uuid_t const uuid))
 {
     uint32_t magic;
@@ -607,7 +609,7 @@ int parse_fat(int fd, off_t fsize, char *buffer, size_t size,
 }
 
 
-void process(std::filesystem::path const& path, void(^dylibVisitor)(std::filesystem::path const&),
+void process(std::string const& path, void(^dylibVisitor)(std::string const&),
              void (^uuidVisitor)(uuid_t const))
 {
     log_vv("Scanning %s...", path.c_str());
@@ -640,29 +642,42 @@ bool operator <= (const struct timespec &lhs, const struct timespec &rhs)
     return lhs.tv_sec <= rhs.tv_sec;
 }
 
+std::string parentPath(std::string path) {
+    const char *pathCstr = path.c_str();
+    char parent[MAXPATHLEN];
+
+    return dirname_r(pathCstr, parent) ? parent : pathCstr;
+}
+
+std::string filename(std::string path) {
+    const char *pathCstr = path.c_str();
+    char filename[MAXPATHLEN];
+
+    return basename_r(pathCstr, filename) ? filename : pathCstr;
+}
 
 // This executable's own path.
-std::filesystem::path self_executable = []() -> std::filesystem::path {
+std::string self_executable = []() -> std::string {
     char path[MAXPATHLEN] = {0};
     uint32_t len = sizeof(path);
     _NSGetExecutablePath(path, &len);
-    return std::filesystem::path(path);
+    return std::string(path);
 }();
 
 
 // This executable's own xctoolchain path.
-std::filesystem::path self_toolchain = []() -> std::filesystem::path  {
+std::string self_toolchain = []() -> std::string  {
     auto result = self_executable;
 
     // Remove the executable name.
-    result = result.parent_path();
+    result = parentPath(result);
 
     // Remove trailing /usr/bin, if any
-    if (result.filename() == std::filesystem::path("bin")) {
-        result = result.parent_path();
+    if (filename(result) == "bin") {
+        result = parentPath(result);
     }
-    if (result.filename() == std::filesystem::path("usr")) {
-        result = result.parent_path();
+    if (filename(result) == "usr") {
+        result = parentPath(result);
     }
     return result;
 }();
@@ -761,7 +776,7 @@ int xcrunToolCommand(std::vector<std::string> commandAndArguments, XcrunToolBloc
 }
 
 
-void copyAndStripBitcode(std::filesystem::path src, std::filesystem::path dst)
+void copyAndStripBitcode(std::string src, std::string dst)
 {
     // -r removes bitcode
     std::vector<std::string> commandAndArgs = {"bitcode_strip", src, "-r", "-o", dst};
@@ -774,14 +789,12 @@ void copyAndStripBitcode(std::filesystem::path src, std::filesystem::path dst)
     }
 }
 
-
-void 
-copyFile(std::filesystem::path src, std::filesystem::path dst, bool stripBitcode)
+void copyFile(std::string src, std::string dst, bool stripBitcode)
 {
     if (stripBitcode) {
         copyAndStripBitcode(src, dst);
     } else {
-        if (!std::filesystem::copy_file(src, dst)) {
+        if (copyfile(src.c_str(), dst.c_str(), NULL, COPYFILE_ALL) != 0) {
             fail("Couldn't copy %s to %s: %s", src.c_str(), dst.c_str(), strerror(errno));
         }
    }
@@ -793,16 +806,19 @@ std::string uuidString(uuid_t const uuid) {
     return buffer;
 }
 
-void copyLibraries(std::filesystem::path src_dir, std::filesystem::path dst_dir, 
+void copyLibraries(std::string src_dir, std::string dst_dir,
                    std::unordered_map<std::string,
                    std::unordered_set<std::string>> const &libs,
                    bool stripBitcode)
 {
     mkpath_np(dst_dir.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
 
-    for (auto const &[lib, srcUUIDs]: libs) {
-        std::filesystem::path src = src_dir/lib;
-        std::filesystem::path dst = dst_dir/lib;
+    for (auto const &pair : libs) {
+        auto const &lib = pair.first;
+        auto const &srcUUIDs = pair.second;
+
+        std::string src = src_dir + "/" + lib;
+        std::string dst = dst_dir + "/" + lib;
 
         // Compare UUIDs of src and dst and don't copy if they're the same.
         // Do not use mod times for this task: the dst copy gets code-signed 
@@ -843,7 +859,7 @@ void copyLibraries(std::filesystem::path src_dir, std::filesystem::path dst_dir,
               dst_dir.c_str());
 
         unlink(dst.c_str());
-        copyFile(std::filesystem::canonical(src), dst, stripBitcode);
+        copyFile(src, dst, stripBitcode);
     }
 }
 
@@ -858,11 +874,35 @@ std::vector<uint8_t> query_code_signature(std::string file) {
     return d;
 }
 
+template <typename F>
+void enumerateDirectory(std::string directory, F&& func) {
+    DIR *dir = opendir(directory.c_str());
+    if (dir == NULL) {
+        return;
+    }
+
+    struct dirent *entry;
+    while ((entry = readdir(dir)) != NULL) {
+        std::string path = directory + "/" + entry->d_name;
+        if (entry->d_type == DT_REG) {
+            func(path);
+        } else if (entry->d_type == DT_DIR) {
+            // check if . or ..
+            if (strncmp(entry->d_name, "..", entry->d_namlen)) {
+                continue;
+            }
+            enumerateDirectory(path, func);
+        }
+    }
+}
+
+
+
 int main(int argc, const char *argv[])
 {
     // Executables to scan for Swift references.
     // --scan-executable
-    std::vector<std::filesystem::path> executables;
+    std::vector<std::string> executables;
 
     // Directories to scan for more executables.
     // --scan-folder
@@ -876,12 +916,12 @@ int main(int argc, const char *argv[])
     // Copy source.
     // --source-libraries
     // or /path/to/swift-stdlib-tool/../../lib/swift/<--platform>
-    std::filesystem::path src_dir;
+    std::string src_dir;
 
     // Copy destinations, signed and unsigned.
     // --destination and --unsigned-destination
-    std::filesystem::path dst_dir;
-    std::filesystem::path unsigned_dst_dir;
+    std::string dst_dir;
+    std::string unsigned_dst_dir;
 
     // Resource copy destination.
     // --resource-destination
@@ -923,10 +963,10 @@ int main(int argc, const char *argv[])
         }
 
         if (0 == strcmp(argv[i], "--destination")) {
-            dst_dir = std::filesystem::path(argv[++i]);
+            dst_dir = std::string(argv[++i]);
         }
         if (0 == strcmp(argv[i], "--unsigned-destination")) {
-            unsigned_dst_dir = std::filesystem::path(argv[++i]);
+            unsigned_dst_dir = std::string(argv[++i]);
         }
 
         if (0 == strcmp(argv[i], "--sign")) {
@@ -959,19 +999,19 @@ int main(int argc, const char *argv[])
     } else if (src_dir.empty()) {
         // platform is set but src_dir is not. 
         // Use platform to set src_dir relative to us.
-        src_dir = self_executable.parent_path().parent_path()/
-                  "lib"/"swift-5.0"/platform;
+        src_dir = parentPath(parentPath(self_executable)) + "/" + "lib" +
+                  "swift-5.0" + "/" + platform;
     } else if (platform.empty()) {
         // src_dir is set but platform is not.
         // Pick platform from src_dir's name.
-        platform = src_dir.filename();
+        platform = src_dir;
     }
 
     // Add the platform to unsigned_dst_dir if it is not already present.
     if (!unsigned_dst_dir.empty()) {
-        auto const unsigned_platform = unsigned_dst_dir.filename();
+        auto const unsigned_platform = unsigned_dst_dir;
         if (platform != unsigned_platform) {
-            unsigned_dst_dir = unsigned_dst_dir/platform;
+            unsigned_dst_dir = unsigned_dst_dir + "/" + platform;
         }
     }
 
@@ -985,15 +1025,13 @@ int main(int argc, const char *argv[])
 
     // Collect executables from the --scan-folder locations.
     for (auto const &embedDir : embedDirs) {
-        for (auto const &entry : std::filesystem::recursive_directory_iterator(embedDir)) {
-            if (entry.exists() && !entry.is_directory() &&
-                0 == access(entry.path().c_str(), X_OK))
-            {
-                executables.push_back(entry.path());
+        enumerateDirectory(embedDir, [&](std::string entry) {
+            if (0 == access(entry.c_str(), X_OK)) {
+                executables.push_back(entry);
             } else {
-                log_vv("%s is not an executable file", entry.path().c_str());
+                log_vv("%s is not an executable file", entry.c_str());
             }
-        }
+        });
     }
 
     // Collect Swift library names from the input files.
@@ -1003,9 +1041,9 @@ int main(int argc, const char *argv[])
                     std::unordered_set<std::string>> swiftLibs;
     for (auto const &path : executables) {
         process(path,
-           ^(std::filesystem::path const &linkedLib) {
-                auto const linkedSrc = src_dir/linkedLib;
-                if (std::filesystem::exists(linkedSrc)) {
+           ^(std::string const &linkedLib) {
+                auto const linkedSrc = src_dir + "/" + linkedLib;
+                if (access(linkedSrc.c_str(), F_OK) == 0) {
                     swiftLibs[linkedLib] = std::unordered_set<std::string>();
                 }
             }, 
@@ -1016,18 +1054,18 @@ int main(int argc, const char *argv[])
     // Also collect the Swift libraries' UUIDs.
     __block std::vector<std::string> worklist;
     worklist.reserve(swiftLibs.size());
-    for (auto const &[lib, _] : swiftLibs) {
-        worklist.push_back(lib);
+    for (auto const &pair : swiftLibs) {
+        worklist.push_back(pair.first);
     }
     while (worklist.size()) {
         auto const lib = worklist.back();
         worklist.pop_back();
-        auto const path = src_dir/lib;
+        auto const path = src_dir + "/" + lib;
         process(path,
-            ^(std::filesystem::path const &linkedLib) {
-                auto const linkedSrc = src_dir/linkedLib;
+            ^(std::string const &linkedLib) {
+                auto const linkedSrc = src_dir + "/" + linkedLib;
                 if (swiftLibs.count(linkedLib) == 0 &&
-                    std::filesystem::exists(linkedSrc))
+                    access(linkedSrc.c_str(), F_OK) == 0)
                 {
                     swiftLibs[linkedLib] = std::unordered_set<std::string>();
                     worklist.push_back(linkedLib);
@@ -1043,26 +1081,26 @@ int main(int argc, const char *argv[])
     __block std::unordered_map<std::string,
         std::unordered_set<std::string>> swiftLibsForResources;
     for (auto const &lib : resourceLibraries) {
-        auto const libSrc = src_dir/lib;
-        if (std::filesystem::exists(libSrc)) {
+        auto const libSrc = src_dir + "/" + lib;
+        if (access(libSrc.c_str(), F_OK) == 0) {
             swiftLibsForResources[lib] = std::unordered_set<std::string>();
         }
     }
 
     // Collect dependencies of --resource-library libs.
     worklist.clear();
-    for (auto const &[lib, _] : swiftLibsForResources) {
-        worklist.push_back(lib);
+    for (auto const &pair : swiftLibsForResources) {
+        worklist.push_back(pair.first);
     }
     while (worklist.size()) {
         auto const lib = worklist.back();
         worklist.pop_back();
-        auto const path = src_dir/lib;
+        auto const path = src_dir + "/" + lib;
         process(path,
-            ^(std::filesystem::path const &linkedLib) {
-                auto const linkedSrc = src_dir/linkedLib;
+            ^(std::string const &linkedLib) {
+                auto const linkedSrc = src_dir + "/" + linkedLib;
                 if (swiftLibsForResources.count(linkedLib) == 0 &&
-                    std::filesystem::exists(linkedSrc))
+                    access(linkedSrc.c_str(), F_OK) == 0)
                 {
                     swiftLibsForResources[linkedLib] = std::unordered_set<std::string>();
                     worklist.push_back(linkedLib);
@@ -1076,7 +1114,7 @@ int main(int argc, const char *argv[])
     // Print the Swift libraries (full path to toolchain's copy)
     if (print) {
         for (auto const &lib : swiftLibs) {
-            printf("%s\n", (src_dir/lib.first).c_str());
+            printf("%s\n", (src_dir + "/" + lib.first).c_str());
         }
     }
 
@@ -1111,7 +1149,8 @@ int main(int argc, const char *argv[])
         __block bool signedOne = false;
         std::mutex signingLock;
 
-        for (auto const &[lib, _] : swiftLibs) {
+        for (auto const &pair : swiftLibs) {
+            auto const &lib = pair.first;
             // Work around authentication UI problems
             // by signing one synchronously and then signing the rest.
             signingLock.lock();
@@ -1126,13 +1165,13 @@ int main(int argc, const char *argv[])
             // to preserve it in case it does not change.  We can use
             // this to avoid unnecessary copies during delta installs
             // to devices.
-            auto const dst = dst_dir/lib;
+            auto const dst = dst_dir + "/" + lib;
             auto const oldSignatureData = query_code_signature(dst);
             const char *tmpFilePath = 0;
             if (!oldSignatureData.empty()) {
                 // Make a copy of the existing file, with permissions and
                 // mtime preserved.
-                auto tmpFile = dst.string() + ".original";
+                auto tmpFile = dst + ".original";
                 tmpFilePath = tmpFile.c_str();
                 xcrunToolCommand({"cp", "-p", dst, tmpFile});
             }