implement creating tar.gz package in release.cc.

runtime/include/icppex.hpp

@@ -49,7 +49,10 @@ execute(const std::string &program, const strings &args,
 static inline std::string execute(const std::string &program,
                                   const strings &args) {
   std::string output;
-  execute(program, args, [&output](std::string_view line) { output += line; });
+  execute(program, args, [&output](std::string_view line) {
+    output += line;
+    output += "\n";
+  });
   return output;
 }
 

src/icpp-gadget.cpp

@@ -59,6 +59,16 @@ class gadget {
   bool running_ = true;
 } icppsvr;
 
+// Don't need these implementations at all in icpp-gadget
+int exec_string(const char *argv0, std::string_view snippet, bool whole,
+                int argc, const char **argv) {
+  return -1;
+}
+int exec_source(const char *argv0, std::string_view path, int argc,
+                const char **argv) {
+  return -1;
+}
+
 static void send_buffer(ip::tcp::socket *s, iopad::CommandID id,
                         const std::string_view &respbuf) {
   std::string buff;

src/icpp-main.cpp

@@ -253,6 +253,7 @@ extern "C" __ICPP_EXPORT__ int icpp_main(int argc, char **argv) {
                                    &argv[idoubledash + 1], validcache);
       } else {
         // execute as a dynamic code snippet
+        icpp::RunConfig::repl = true;
         exitcode = icpp::exec_string(argv[0], std::string(sp));
         if (exitcode)
           icpp::log_print(

src/icpp-mod.cpp

@@ -76,6 +76,19 @@ void ObjectDisassembler::init(CObjectFile *, std::string_view) {}
 void Object::decodeInsns(TextSection &) {}
 void Object::parseSections(void) {}
 extern "C" void exec_engine_main(StubContext *ctx, ContextICPP *regs) {}
+int exec_main(std::string_view path, const std::vector<std::string> &deps,
+              std::string_view srcpath, int iargc, char **iargv,
+              bool &validcache) {
+  return -1;
+}
+int exec_string(const char *argv0, std::string_view snippet, bool whole,
+                int argc, const char **argv) {
+  return -1;
+}
+int exec_source(const char *argv0, std::string_view path, int argc,
+                const char **argv) {
+  return -1;
+}
 } // namespace icpp
 
 template <typename FILTER, typename PACKER>

src/icpp-repl.cpp

@@ -21,8 +21,6 @@ namespace icpp {
 
 int exec_string(const char *argv0, std::string_view snippet, bool whole,
                 int argc, const char **argv) {
-  RunConfig::repl = true;
-
   // construct a temporary source path
   auto srcpath = fs::temp_directory_path() / icpp::rand_filename(8, ".cc");
   std::ofstream outf(srcpath);
@@ -104,6 +102,7 @@ int exec_repl(const char *argv0) {
   std::cout << std::format("ICPP {}. Copyright (c) vpand.com.\nRunning C++ in "
                            "anywhere like a script.\n",
                            version_string());
+  RunConfig::repl = true;
   RunConfig::inst(argv0, "");
   return icpp::repl_entry(
       [&](std::string_view dyncode) { exec_string(argv0, dyncode, true); });

src/loader.cpp

@@ -130,6 +130,13 @@ struct ModuleLoader {
     // currently, the clang cpp module initializer is a nop function,
     // and we will skip to call it in ctor caller
     syms_.insert({"__ZGIW3std", reinterpret_cast<const void *>(&nop_function)});
+
+    syms_.insert(
+        {"___cxa_atexit", reinterpret_cast<const void *>(&__cxa_atexit)});
+    syms_.insert(
+        {"___cxa_throw", reinterpret_cast<const void *>(&__cxa_throw)});
+    syms_.insert({"___stack_chk_fail",
+                  reinterpret_cast<const void *>(&__stack_chk_fail)});
 #else
     syms_.insert({"_ZGIW3std", reinterpret_cast<const void *>(&nop_function)});
 #endif
@@ -222,55 +229,64 @@ struct ModuleLoader {
 #else
 #define apisym(n) #n + 1
 #endif
-    syms_.insert({apisym(__ZN4icpp7programEv), api::program});
-    syms_.insert({apisym(__ZN4icpp7versionEv), api::version});
-    syms_.insert({apisym(__ZN4icpp14home_directoryEv), api::home_directory});
+    syms_.insert({apisym(__ZN4icpp7programEv),
+                  reinterpret_cast<const void *>(&api::program)});
+    syms_.insert({apisym(__ZN4icpp7versionEv),
+                  reinterpret_cast<const void *>(&api::version)});
+    syms_.insert({apisym(__ZN4icpp14home_directoryEv),
+                  reinterpret_cast<const void *>(&api::home_directory)});
     syms_.insert(
         {apisym(
              __ZN4icpp15exec_expressionENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE),
-         api::exec_expression});
+         reinterpret_cast<const void *>(&api::exec_expression)});
     syms_.insert(
         {apisym(
              __ZN4icpp11exec_stringENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEiPPKc),
-         api::exec_string});
+         reinterpret_cast<const void *>(&api::exec_string)});
     syms_.insert(
         {apisym(
              __ZN4icpp11exec_sourceENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEiPPKc),
-         api::exec_source});
+         reinterpret_cast<const void *>(&api::exec_source)});
     syms_.insert(
         {apisym(
              __ZN4icpp11exec_moduleENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEiPPKc),
-         api::exec_module});
-    syms_.insert({apisym(__ZN4icpp10result_getEv), api::result_get});
-    syms_.insert({apisym(__ZN4icpp11result_getsEv), api::result_gets});
+         reinterpret_cast<const void *>(&api::exec_module)});
+    syms_.insert({apisym(__ZN4icpp10result_getEv),
+                  reinterpret_cast<const void *>(&api::result_get)});
+    syms_.insert({apisym(__ZN4icpp11result_getsEv),
+                  reinterpret_cast<const void *>(&api::result_gets)});
     syms_.insert(
         {apisym(
              __ZN4icpp13is_cpp_sourceENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE),
-         api::is_cpp_source});
-    syms_.insert({apisym(__ZN4icpp10rand_valueEv), api::rand_value});
-    syms_.insert({apisym(__ZN4icpp11rand_stringEi), api::rand_string});
+         reinterpret_cast<const void *>(&api::is_cpp_source)});
+    syms_.insert({apisym(__ZN4icpp10rand_valueEv),
+                  reinterpret_cast<const void *>(&api::rand_value)});
+    syms_.insert({apisym(__ZN4icpp11rand_stringEi),
+                  reinterpret_cast<const void *>(&api::rand_string)});
     syms_.insert(
         {apisym(
              __ZN4icpp13rand_filenameEiNSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE),
-         api::rand_filename});
+         reinterpret_cast<const void *>(&api::rand_filename)});
     syms_.insert(
         {apisym(
              __ZN4icpp12load_libraryENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE),
-         api::load_library});
-    syms_.insert({apisym(__ZN4icpp14unload_libraryEPv), api::unload_library});
+         reinterpret_cast<const void *>(&api::load_library)});
+    syms_.insert({apisym(__ZN4icpp14unload_libraryEPv),
+                  reinterpret_cast<const void *>(&api::unload_library)});
     syms_.insert(
         {apisym(
              __ZN4icpp14resolve_symbolENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPv),
-         api::resolve_symbol});
+         reinterpret_cast<const void *>(&api::resolve_symbol)});
     syms_.insert(
         {apisym(
              __ZN4icpp15iterate_modulesERKNSt3__18functionIFbyNS0_17basic_string_viewIcNS0_11char_traitsIcEEEEEEE),
-         api::iterate_modules});
-    syms_.insert({apisym(__ZN4icpp10result_setEl), api::result_set});
+         reinterpret_cast<const void *>(&api::iterate_modules)});
+    syms_.insert({apisym(__ZN4icpp10result_setEl),
+                  reinterpret_cast<const void *>(&api::result_set)});
     syms_.insert(
         {apisym(
              __ZN4icpp10result_setERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE),
-         api::result_sets});
+         reinterpret_cast<const void *>(&api::result_sets)});
 #endif
   }
 

src/object.cpp

@@ -434,7 +434,7 @@ std::string Object::generateCache() {
   // set the original object buffer
   auto errBuff = llvm::MemoryBuffer::getFile(path_);
   if (!errBuff) {
-    log_print(Runtime, "Failed to read when caching '{}' : {}.", path_,
+    log_print(Develop, "Failed to read when caching '{}' : {}.", path_,
               errBuff.getError().message());
     return "";
   }

src/runtime.cpp

@@ -125,7 +125,7 @@ int exec_module(std::string_view module, int argc, const char **argv) {
       iarg = argv;
     }
     bool validcache;
-    return icpp::exec_main(omain.string(), deps, module, iargc,
+    return icpp::exec_main(omain.string(), deps, omain.string(), iargc,
                            const_cast<char **>(iarg), validcache);
   }
   icpp::log_print(

test/command.cc

@@ -1,14 +1,8 @@
 #include <icpp.hpp>
 #include <icppex.hpp>
 
-#if __WIN__
-#define arg_count "-n"s, "1"s
-#else
-#define arg_count "-c"s, "1"s
-#endif
-
 int main(int argc, const char *argv[]) {
   icpp::prints("Command result: {}\n",
-               icppex::command("ping"s, {arg_count, "vpand.com"s}));
+               icppex::execute(icpp::program().data(), {"-version"s}));
   return 0;
 }

tool-icpp/release.cc

@@ -137,8 +137,12 @@ static auto pack_file(const fs::path &srcfile, const fs::path &dstdir,
 }
 
 static auto pack_dir(const fs::path &srcdir, const fs::path &dstroot,
-                     bool symlink = false) {
-  auto dstdir = dstroot / srcdir.filename();
+                     std::string_view dstname = "", bool symlink = false) {
+  auto dstdir = dstroot / (dstname.size() ? dstname : srcdir.filename());
+  if (!dstname.size() && fs::exists(dstdir))
+    log_return(std::format("Ignored packing {}, {} exists.", srcdir.string(),
+                           dstdir.string()),
+               return);
   std::error_code err;
   auto option =
       fs::copy_options::overwrite_existing | fs::copy_options::recursive;
@@ -167,9 +171,9 @@ int main(int argc, char **argv) {
   auto dstroot = fs::path(argv[2]);
   create_dir(dstroot);
   // create icpp package layout
-  auto icpproot =
-      dstroot / std::format("icpp-v{}.{}.{}-{}-{}", icpp::version_major,
+  auto pkgdir = std::format("icpp-v{}.{}.{}-{}-{}", icpp::version_major,
                             icpp::version_minor, icpp::version_patch, os, arch);
+  auto icpproot = dstroot / pkgdir;
   auto bin = icpproot / "bin";
   auto include = icpproot / "include";
   auto lib = icpproot / "lib";
@@ -218,7 +222,7 @@ int main(int argc, char **argv) {
   for (auto &name : incnames) {
     auto srcdir = srcroot / "../../runtime" / name;
     if (fs::exists(srcdir))
-      pack_dir(srcdir, include, true);
+      pack_dir(srcdir, include, "", true);
     else
       log(std::format("There's no {}, ignored packing it.", srcdir.string()));
   }
@@ -238,15 +242,19 @@ int main(int argc, char **argv) {
   auto boostlib = boost / "lib";
 #endif
   if (fs::exists(boostinc) && fs::exists(boostlib)) {
-    auto icppboostlib = lib / "boost";
-    create_dir(icppboostlib);
-    pack_dir(boostinc / ".", icpproot);
-    pack_dir(boostlib / ".", icppboostlib);
+    create_dir(lib / "boost");
+    pack_dir(boostinc / "boost", include);
+    pack_dir(boostlib / ".", lib, "boost");
   } else {
     log(std::format("Can't find boost in {}, skipped packing boost.",
                     boost.string()));
   }
 
-  std::puts("Done.");
+  auto targz = pkgdir + ".tar.gz";
+  log(std::format("Packing icpp release package {}...", targz));
+  std::system(
+      std::format("cd {} && tar czf {} {}", dstroot.string(), targz, pkgdir)
+          .data());
+  log(std::format("Created icpp package {}.", targz));
   return 0;
 }