Make dwarfs-universal usable without symlinks

CMakeLists.txt

@@ -482,34 +482,22 @@ add_executable(mkdwarfs src/mkdwarfs.cpp)
 add_executable(dwarfsck src/dwarfsck.cpp)
 add_executable(dwarfsbench src/dwarfsbench.cpp)
 add_executable(dwarfsextract src/dwarfsextract.cpp)
-if(NOT WIN32)
+add_executable(dwarfsuniversal src/universal.cpp)
-  add_executable(dwarfsuniversal src/universal.cpp)
-endif()
 
 target_link_libraries(mkdwarfs mkdwarfs_main)
 target_link_libraries(dwarfsck dwarfsck_main)
 target_link_libraries(dwarfsbench dwarfsbench_main)
 target_link_libraries(dwarfsextract dwarfsextract_main)
-if(NOT WIN32)
+target_link_libraries(dwarfsuniversal mkdwarfs_main dwarfsck_main
-  target_link_libraries(dwarfsuniversal mkdwarfs_main dwarfsck_main
+        dwarfsbench_main dwarfsextract_main)
-          dwarfsbench_main dwarfsextract_main)
+set_target_properties(dwarfsuniversal PROPERTIES
-  set_target_properties(dwarfsuniversal PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY universal
-          RUNTIME_OUTPUT_DIRECTORY universal
+        OUTPUT_NAME dwarfs-universal)
-          OUTPUT_NAME dwarfs-universal)
-  foreach(bin mkdwarfs dwarfsck dwarfsextract dwarfsbench)
-    add_custom_command(OUTPUT  universal/${bin}
-                       COMMAND ${CMAKE_COMMAND} -E create_symlink dwarfs universal/${bin}
-                       DEPENDS dwarfsuniversal)
-    list(APPEND SYMLINKS ${CMAKE_CURRENT_BINARY_DIR}/universal/${bin})
-  endforeach()
-endif()
 
 install(TARGETS mkdwarfs dwarfsck dwarfsbench dwarfsextract RUNTIME DESTINATION bin)
 
 list(APPEND BINARY_TARGETS mkdwarfs dwarfsck dwarfsbench dwarfsextract)
-if(NOT WIN32)
+list(APPEND BINARY_TARGETS dwarfsuniversal)
-  list(APPEND BINARY_TARGETS dwarfsuniversal)
-endif()
 list(APPEND MAIN_TARGETS mkdwarfs_main dwarfsck_main dwarfsbench_main
         dwarfsextract_main)
 

src/universal.cpp

@@ -20,33 +20,68 @@
  */
 
 #include <filesystem>
+#include <iostream>
+#include <map>
 #include <string_view>
-#include <unordered_map>
+#include <vector>
+
+#include <folly/String.h>
+#include <folly/gen/String.h>
 
 #include "dwarfs/error.h"
+#include "dwarfs/tool.h"
 #include "dwarfs_tool_main.h"
 
 namespace {
 
 using namespace dwarfs;
 
-std::unordered_map<std::string_view, int (*)(int, char**)> const functions{
+std::map<std::string_view, int (*)(int, char**)> const functions{
+    {"dwarfs", &dwarfs_main},
     {"mkdwarfs", &mkdwarfs_main},
     {"dwarfsck", &dwarfsck_main},
     {"dwarfsextract", &dwarfsextract_main},
-    {"dwarfsbench", &dwarfsbench_main},
+    // {"dwarfsbench", &dwarfsbench_main},
 };
 
 } // namespace
 
 int main(int argc, char** argv) {
-  auto fun = &dwarfs::dwarfs_main;
+  if (argc > 1) {
+    std::string_view tool_arg(argv[1]);
+    if (tool_arg.starts_with("--tool=")) {
+      if (auto it = functions.find(tool_arg.substr(7)); it != functions.end()) {
+        std::vector<char*> argv_copy;
+        argv_copy.reserve(argc - 1);
+        argv_copy.emplace_back(argv[0]);
+        std::copy(argv + 2, argv + argc, std::back_inserter(argv_copy));
+        return dwarfs::safe_main(
+            [&] { return it->second(argc - 1, argv_copy.data()); });
+      }
+    }
+  }
+
+#ifndef _WIN32
   auto path = std::filesystem::path(argv[0]);
 
   if (auto it = functions.find(path.filename().string());
       it != functions.end()) {
-    fun = it->second;
+    return dwarfs::safe_main([&] { return it->second(argc, argv); });
   }
+#endif
 
-  return dwarfs::safe_main([&] { return fun(argc, argv); });
+  using namespace folly::gen;
+
+  auto tools = from(functions) | get<0>() | unsplit(", ");
+
+  // clang-format off
+  std::cout << tool_header("dwarfs-universal")
+            << "Command line options:\n"
+            << "  --tool=<name>                     "
+                 "which tool to run; available tools are:\n"
+            << "                                    "
+            << tools << "\n";
+  // clang-format on
+
+  return 0;
 }