koffi 2.1.4 → 2.2.0

package/src/core/libcc/libcc.cc

@@ -1764,10 +1764,11 @@ const char *GetQualifiedEnv(const char *name)
     // Each accessed environment variable is kept in memory and thus leaked once
     static HashMap<const char *, const char *> values;
 
-    std::pair<const char **, bool> ret = values.TrySet(name, nullptr);
+    bool inserted;
+    const char **ptr = values.TrySet(name, nullptr, &inserted);
 
-    if (ret.second) {
-        const char *ptr = (const char *)EM_ASM_INT({
+    if (inserted) {
+        const char *str = (const char *)EM_ASM_INT({
             try {
                 var name = UTF8ToString($0);
                 var str = process.env[name];
@@ -1785,10 +1786,10 @@ const char *GetQualifiedEnv(const char *name)
             }
         }, buf.data);
 
-        *ret.first = ptr;
+        *ptr = str;
     }
 
-    return *ret.first;
+    return *ptr;
 #else
     return getenv(buf.data);
 #endif
@@ -2131,6 +2132,7 @@ StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info
     out_info->type = FileAttributesToType(attr.dwFileAttributes);
     out_info->size = ((uint64_t)attr.nFileSizeHigh << 32) | attr.nFileSizeLow;
     out_info->mtime = FileTimeToUnixTime(attr.ftLastWriteTime);
+    out_info->btime = FileTimeToUnixTime(attr.ftCreationTime);
     out_info->mode = (out_info->type == FileType::Directory) ? 0755 : 0644;
 
     return StatResult::Success;
@@ -2281,6 +2283,42 @@ static FileType FileModeToType(mode_t mode)
 
 StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info)
 {
+#ifdef __linux__
+    int stat_flags = (flags & (int)StatFlag::FollowSymlink) ? 0 : AT_SYMLINK_NOFOLLOW;
+    int stat_mask = STATX_TYPE | STATX_MODE | STATX_MTIME | STATX_BTIME | STATX_SIZE;
+
+    struct statx sxb;
+    if (statx(AT_FDCWD, filename, stat_flags, stat_mask, &sxb) < 0) {
+        switch (errno) {
+            case ENOENT: {
+                if (!(flags & (int)StatFlag::IgnoreMissing)) {
+                    LogError("Cannot stat '%1': %2", filename, strerror(errno));
+                }
+                return StatResult::MissingPath;
+            } break;
+            case EACCES: {
+                LogError("Cannot stat '%1': %2", filename, strerror(errno));
+                return StatResult::AccessDenied;
+            } break;
+            default: {
+                LogError("Cannot stat '%1': %2", filename, strerror(errno));
+                return StatResult::OtherError;
+            } break;
+        }
+    }
+
+    out_info->type = FileModeToType(sxb.stx_mode);
+    out_info->size = (int64_t)sxb.stx_size;
+    out_info->mtime = (int64_t)sxb.stx_mtime.tv_sec * 1000 +
+                      (int64_t)sxb.stx_mtime.tv_nsec / 1000000;
+    if (sxb.stx_mask & STATX_BTIME) {
+        out_info->btime = (int64_t)sxb.stx_btime.tv_sec * 1000 +
+                          (int64_t)sxb.stx_btime.tv_nsec / 1000000;
+    } else {
+        out_info->btime = out_info->mtime;
+    }
+    out_info->mode = (unsigned int)sxb.stx_mode & ~S_IFMT;
+#else
     int stat_flags = (flags & (int)StatFlag::FollowSymlink) ? 0 : AT_SYMLINK_NOFOLLOW;
 
     struct stat sb;
@@ -2305,16 +2343,24 @@ StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info
 
     out_info->type = FileModeToType(sb.st_mode);
     out_info->size = (int64_t)sb.st_size;
-#if defined(__linux__)
-    out_info->mtime = (int64_t)sb.st_mtim.tv_sec * 1000 +
-                                  (int64_t)sb.st_mtim.tv_nsec / 1000000;
-#elif defined(__APPLE__)
+#if defined(__APPLE__)
     out_info->mtime = (int64_t)sb.st_mtimespec.tv_sec * 1000 +
-                                  (int64_t)sb.st_mtimespec.tv_nsec / 1000000;
+                      (int64_t)sb.st_mtimespec.tv_nsec / 1000000;
+    out_info->btime = (int64_t)sb.st_birthtimespec.tv_sec * 1000 +
+                      (int64_t)sb.st_birthtimespec.tv_nsec / 1000000;
+#elif defined(__OpenBSD__)
+    out_info->mtime = (int64_t)sb.st_mtim.tv_sec * 1000 +
+                      (int64_t)sb.st_mtim.tv_nsec / 1000000;
+    out_info->btime = (int64_t)sb.__st_birthtim.tv_sec * 1000 +
+                      (int64_t)sb.__st_birthtim.tv_nsec / 1000000;
 #else
-    out_info->mtime = (int64_t)sb.st_mtime * 1000;
+    out_info->mtime = (int64_t)sb.st_mtim.tv_sec * 1000 +
+                      (int64_t)sb.st_mtim.tv_nsec / 1000000;
+    out_info->btime = (int64_t)sb.st_birthtim.tv_sec * 1000 +
+                      (int64_t)sb.st_birthtim.tv_nsec / 1000000;
 #endif
     out_info->mode = (unsigned int)sb.st_mode;
+#endif
 
     return StatResult::Success;
 }
@@ -2540,6 +2586,14 @@ bool TestFile(const char *filename, FileType type)
     return true;
 }
 
+bool IsDirectory(const char *filename)
+{
+    FileInfo file_info;
+    if (StatFile(filename, (int)StatFlag::IgnoreMissing, &file_info) != StatResult::Success)
+        return false;
+    return file_info.type == FileType::Directory;
+}
+
 static Size MatchPathItem(const char *path, const char *spec)
 {
     Size i = 0;
@@ -2843,7 +2897,7 @@ const char *GetApplicationExecutable()
     static char executable_path[4096];
 
     if (!executable_path[0]) {
-        int name[4] = {CTL_KERN, KERN_PROC_ARGS, getpid(), KERN_PROC_ARGV};
+        int name[4] = { CTL_KERN, KERN_PROC_ARGS, getpid(), KERN_PROC_ARGV };
 
         size_t argc;
         {
@@ -2879,7 +2933,7 @@ const char *GetApplicationExecutable()
     static char executable_path[4096];
 
     if (!executable_path[0]) {
-        int name[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
+        int name[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
         size_t len = sizeof(executable_path);
 
         int ret = sysctl(name, RG_LEN(name), executable_path, &len, NULL, 0);
@@ -3431,7 +3485,8 @@ OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int
         RG_ASSERT(!(flags & (int)OpenFlag::Exclusive));
         RG_ASSERT(!(flags & (int)OpenFlag::Append));
 
-        oflags &= ~O_CREAT;
+        oflags &= ~(O_CREAT | O_WRONLY | O_RDWR | O_TRUNC);
+        oflags |= O_RDONLY;
     }
     if (flags & (int)OpenFlag::Exists) {
         RG_ASSERT(!(flags & (int)OpenFlag::Exclusive));
@@ -3951,8 +4006,8 @@ bool ExecuteCommandLine(const char *cmd_line, FunctionRef<Span<const uint8_t>()>
 #if defined(__OpenBSD__) || defined(__FreeBSD__)
 static const pthread_t main_thread = pthread_self();
 #endif
-static std::atomic_bool flag_interrupt {false};
-static std::atomic_bool explicit_interrupt {false};
+static std::atomic_bool flag_interrupt { false };
+static std::atomic_bool explicit_interrupt { false };
 static int interrupt_pfd[2] = {-1, -1};
 
 void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev)
@@ -4141,15 +4196,15 @@ bool ExecuteCommandLine(const char *cmd_line, FunctionRef<Span<const uint8_t>()>
         int in_idx = -1, out_idx = -1, term_idx = -1;
         if (in_pfd[1] >= 0) {
             in_idx = pfds.len;
-            pfds.Append({in_pfd[1], POLLOUT});
+            pfds.Append({ in_pfd[1], POLLOUT, 0 });
         }
         if (out_pfd[0] >= 0) {
             out_idx = pfds.len;
-            pfds.Append({out_pfd[0], POLLIN});
+            pfds.Append({ out_pfd[0], POLLIN, 0 });
         }
         if (interrupt_pfd[0] >= 0) {
             term_idx = pfds.len;
-            pfds.Append({interrupt_pfd[0], POLLIN});
+            pfds.Append({ interrupt_pfd[0], POLLIN, 0 });
         }
 
         if (RG_POSIX_RESTART_EINTR(poll(pfds.data, (nfds_t)pfds.len, -1), < 0) < 0) {
@@ -4378,7 +4433,7 @@ void WaitDelay(int64_t delay)
 
 WaitForResult WaitForInterrupt(int64_t timeout)
 {
-    static std::atomic_bool message {false};
+    static std::atomic_bool message { false };
 
     flag_interrupt = true;
     SetSignalHandler(SIGUSR1, [](int) { message = true; });
@@ -5262,7 +5317,7 @@ class AsyncPool {
 
     HeapArray<TaskQueue> queues;
     int next_queue_idx = 0;
-    std::atomic_int pending_tasks {0};
+    std::atomic_int pending_tasks { 0 };
 
 public:
     AsyncPool(int threads, bool leak);
@@ -5325,7 +5380,9 @@ Async::Async(Async *parent, bool stop_after_error)
 
 Async::~Async()
 {
+    success = false;
     Sync();
+
     pool->UnregisterAsync();
 }
 
@@ -5409,7 +5466,7 @@ void AsyncPool::AddTask(Async *async, const std::function<bool()> &func)
 
             std::unique_lock<std::mutex> lock_queue(queue->queue_mutex, std::try_to_lock);
             if (lock_queue.owns_lock()) {
-                queue->tasks.Append({async, func});
+                queue->tasks.Append({ async, func });
                 break;
             }
         }
@@ -5417,7 +5474,7 @@ void AsyncPool::AddTask(Async *async, const std::function<bool()> &func)
         TaskQueue *queue = &queues[async_running_worker_idx];
 
         std::lock_guard<std::mutex> lock_queue(queue->queue_mutex);
-        queue->tasks.Append({async, func});
+        queue->tasks.Append({ async, func });
     }
 
     async->remaining_tasks++;
@@ -7168,19 +7225,24 @@ IniParser::LineType IniParser::FindNextLine(IniProperty *out_prop)
             }
 
             current_section.RemoveFrom(0);
+            current_section.Grow(section.len + 1);
             current_section.Append(section);
+            current_section.ptr[current_section.len] = 0;
 
             err_guard.Disable();
             return LineType::Section;
         } else {
             Span<char> value;
-            Span<const char> key = TrimStr(SplitStr(line, '=', &value));
+
+            Span<char> key = TrimStr(SplitStr(line, '=', &value));
             if (!key.len || key.end() == line.end()) {
                 LogError("Expected [section] or <key> = <value> pair");
                 return LineType::Exit;
             }
             if (!CheckIniKey(key))
                 return LineType::Exit;
+            key.ptr[key.len] = 0;
+
             value = TrimStr(value);
             *value.end() = 0;
 
@@ -8245,15 +8307,15 @@ Vec2<int> ConsolePrompter::GetConsoleSize()
 
     CONSOLE_SCREEN_BUFFER_INFO screen;
     if (GetConsoleScreenBufferInfo(h, &screen))
-        return {screen.dwSize.X, screen.dwSize.Y};
+        return { screen.dwSize.X, screen.dwSize.Y };
 #else
     struct winsize ws;
     if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) >= 0 && ws.ws_col)
-        return {ws.ws_col, ws.ws_row};
+        return { ws.ws_col, ws.ws_row };
 #endif
 
     // Give up!
-    return {80, 24};
+    return { 80, 24 };
 }
 
 int32_t ConsolePrompter::ReadChar()

package/src/core/libcc/libcc.hh

@@ -31,6 +31,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <thread>
 #include <type_traits>
 #include <utility>
 #if defined(_WIN32)
@@ -38,8 +39,6 @@
 #elif !defined(__APPLE__) && (!defined(__linux__) || defined(__GLIBC__)) && __has_include(<ucontext.h>)
     #define RG_FIBER_USE_UCONTEXT
     #include <ucontext.h>
-#else
-    #include <thread>
 #endif
 #ifdef __EMSCRIPTEN__
     #include <emscripten.h>
@@ -1123,7 +1122,7 @@ public:
 template <typename T>
 class RetainObject {
     mutable void (*delete_func)(T *) = nullptr;
-    mutable std::atomic_int refcount {0};
+    mutable std::atomic_int refcount { 0 };
 
 public:
     void Ref() const { refcount++; }
@@ -2143,36 +2142,56 @@ public:
     ValueType *Set(const ValueType &value)
     {
         const KeyType &key = Handler::GetKey(value);
-        ValueType *it = Insert(key).first;
-        *it = value;
-        return it;
+
+        bool inserted;
+        ValueType *ptr = Insert(key, &inserted);
+
+        *ptr = value;
+
+        return ptr;
     }
     ValueType *SetDefault(const KeyType &key)
     {
-        std::pair<ValueType *, bool> ret = Insert(key);
-        if (!ret.second) {
-            ret.first->~ValueType();
+        bool inserted;
+        ValueType *ptr = Insert(key, &inserted);
+
+        if (!inserted) {
+            ptr->~ValueType();
         }
-        new (ret.first) ValueType();
-        return ret.first;
+        new (ptr) ValueType();
+
+        return ptr;
     }
 
-    std::pair<ValueType *, bool> TrySet(const ValueType &value)
+    ValueType *TrySet(const ValueType &value, bool *out_inserted = nullptr)
     {
         const KeyType &key = Handler::GetKey(value);
-        std::pair<ValueType *, bool> ret = Insert(key);
-        if (ret.second) {
-            *ret.first = value;
+
+        bool inserted;
+        ValueType *ptr = Insert(key, &inserted);
+
+        if (inserted) {
+            *ptr = value;
         }
-        return ret;
+
+        if (out_inserted) {
+            *out_inserted = inserted;
+        }
+        return ptr;
     }
-    std::pair<ValueType *, bool> TrySetDefault(const KeyType &key)
+    ValueType *TrySetDefault(const KeyType &key, bool *out_inserted = nullptr)
     {
-        std::pair<ValueType *, bool> ret = Insert(key);
-        if (ret.second) {
-            new (ret.first) ValueType();
+        bool inserted;
+        ValueType *ptr = Insert(key, &inserted);
+
+        if (inserted) {
+            new (ptr) ValueType();
         }
-        return ret;
+
+        if (out_inserted) {
+            *out_inserted = inserted;
+        }
+        return ptr;
     }
 
     void Remove(ValueType *it)
@@ -2257,7 +2276,7 @@ private:
         }
     }
 
-    std::pair<ValueType *, bool> Insert(const KeyType &key)
+    ValueType *Insert(const KeyType &key, bool *out_inserted)
     {
         uint64_t hash = Handler::HashKey(key);
 
@@ -2274,9 +2293,12 @@ private:
                 }
                 count++;
                 MarkUsed(idx);
-                return {&data[idx], true};
+
+                *out_inserted = true;
+                return &data[idx];
             } else {
-                return {it, false};
+                *out_inserted = false;
+                return it;
             }
         } else {
             Rehash(RG_HASHTABLE_BASE_CAPACITY);
@@ -2284,7 +2306,9 @@ private:
             Size idx = HashToIndex(hash);
             count++;
             MarkUsed(idx);
-            return {&data[idx], true};
+
+            *out_inserted = true;
+            return &data[idx];
         }
     }
 
@@ -2566,7 +2590,7 @@ public:
     }
 
     ValueType *Set(const KeyType &key, const ValueType &value)
-        { return &table.Set({key, value})->value; }
+        { return &table.Set({ key, value })->value; }
     ValueType *SetDefault(const KeyType &key)
     {
         Bucket *table_it = table.SetDefault(key);
@@ -2574,16 +2598,24 @@ public:
         return &table_it->value;
     }
 
-    std::pair<ValueType *, bool> TrySet(const KeyType &key, const ValueType &value)
+    ValueType *TrySet(const KeyType &key, const ValueType &value, bool *out_inserted = nullptr)
     {
-        std::pair<Bucket *, bool> ret = table.TrySet({key, value});
-        return { &ret.first->value, ret.second };
+        Bucket *ptr = table.TrySet({ key, value }, out_inserted);
+        return &ptr->value;
     }
-    std::pair<ValueType *, bool> TrySetDefault(const KeyType &key)
+    ValueType *TrySetDefault(const KeyType &key, bool *out_inserted = nullptr)
     {
-        std::pair<Bucket *, bool> ret = table.TrySetDefault(key);
-        ret.first->key = key;
-        return { &ret.first->value, ret.second };
+        bool inserted;
+        Bucket *ptr = table.TrySetDefault(key, &inserted);
+
+        if (inserted) {
+            ptr->key = key;
+        }
+
+        if (out_inserted) {
+            *out_inserted = inserted;
+        }
+        return &ptr->value;
     }
 
     void Remove(ValueType *it)
@@ -2636,7 +2668,8 @@ public:
         { return table.FindValue(value, default_value); }
 
     ValueType *Set(const ValueType &value) { return table.Set(value); }
-    std::pair<ValueType *, bool> TrySet(const ValueType &value) { return table.TrySet(value); }
+    ValueType *TrySet(const ValueType &value, bool *out_inserted = nullptr)
+        { return table.TrySet(value, out_inserted); }
 
     void Remove(ValueType *it) { table.Remove(it); }
     template <typename T = ValueType>
@@ -2666,10 +2699,10 @@ union LocalDate {
     LocalDate() = default;
 #ifdef RG_BIG_ENDIAN
     LocalDate(int16_t year, int8_t month, int8_t day)
-        : st({year, month, day}) { RG_ASSERT(IsValid()); }
+        : st({ year, month, day }) { RG_ASSERT(IsValid()); }
 #else
     LocalDate(int16_t year, int8_t month, int8_t day)
-        : st({day, month, year}) { RG_ASSERT(IsValid()); }
+        : st({ day, month, year }) { RG_ASSERT(IsValid()); }
 #endif
 
     static inline bool IsLeapYear(int16_t year)
@@ -2678,7 +2711,7 @@ union LocalDate {
     }
     static inline int8_t DaysInMonth(int16_t year, int8_t month)
     {
-        static const int8_t DaysPerMonth[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+        static const int8_t DaysPerMonth[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
         return (int8_t)(DaysPerMonth[month - 1] + (month == 2 && IsLeapYear(year)));
     }
 
@@ -3799,6 +3832,7 @@ struct FileInfo {
 
     int64_t size;
     int64_t mtime;
+    int64_t btime;
     unsigned int mode;
 };
 
@@ -3842,6 +3876,7 @@ bool IsDirectoryEmpty(const char *dirname);
 
 bool TestFile(const char *filename);
 bool TestFile(const char *filename, FileType type);
+bool IsDirectory(const char *filename);
 
 bool MatchPathName(const char *path, const char *spec);
 bool MatchPathSpec(const char *path, const char *spec);
@@ -4080,8 +4115,8 @@ class Async {
     RG_DELETE_COPY(Async)
 
     bool stop_after_error;
-    std::atomic_bool success {true};
-    std::atomic_int remaining_tasks {0};
+    std::atomic_bool success { true };
+    std::atomic_int remaining_tasks { 0 };
 
     class AsyncPool *pool;
 

package/src/koffi/qemu/qemu.js

@@ -296,7 +296,9 @@ async function pack() {
     if (!success)
         return false;
 
-    execFileSync('npm', ['pack', '--pack-destination', pack_dir], {
+    let npm = (process.platform == 'win32') ? 'npm.cmd' : 'npm';
+
+    execFileSync(npm, ['pack', '--pack-destination', pack_dir], {
         cwd: dist_dir,
         stdio: 'inherit',
     });
@@ -309,7 +311,9 @@ async function publish() {
     if (!success)
         return false;
 
-    execFileSync('npm', ['publish'], {
+    let npm = (process.platform == 'win32') ? 'npm.cmd' : 'npm';
+
+    execFileSync(npm, ['publish'], {
         cwd: dist_dir,
         stdio: 'inherit'
     });
@@ -483,8 +487,12 @@ async function prepare(dist_dir) {
         pkg.cnoke.require = "./src/koffi/build/koffi.node";
 
         fs.writeFileSync(dist_dir + '/package.json', JSON.stringify(pkg, null, 4));
-        fs.unlinkSync(dist_dir + '/src/koffi/package.json', '');
-        fs.unlinkSync(dist_dir + '/src/koffi/.gitignore', '');
+        fs.unlinkSync(dist_dir + '/src/koffi/package.json');
+        fs.unlinkSync(dist_dir + '/src/koffi/.gitignore');
+        fs.renameSync(dist_dir + '/src/koffi/README.md', dist_dir + '/README.md');
+        fs.renameSync(dist_dir + '/src/koffi/LICENSE.txt', dist_dir + '/LICENSE.txt');
+        fs.renameSync(dist_dir + '/src/koffi/ChangeLog.md', dist_dir + '/ChangeLog.md');
+        fs.renameSync(dist_dir + '/web/koffi.dev', dist_dir + '/doc');
     }
 
     return true;
@@ -498,7 +506,7 @@ function snapshot() {
 
     console.log('>> Snapshot code...');
     copy_recursive(root_dir, snapshot_dir, filename => {
-        let parts = filename.split(/[\/\\]/);
+        let parts = filename.split('/');
 
         if (parts[0] == 'src' && parts[1] == 'core') {
             return parts[2] == null || parts[2] == 'libcc';
@@ -512,6 +520,8 @@ function snapshot() {
                                        parts[1] == 'node-addon-api' ||
                                        parts[1] == 'raylib' ||
                                        parts[1] == 'sqlite3mc';
+        } else if (parts[0] == 'web') {
+            return parts[1] == null || parts[1] == 'koffi.dev';
         } else {
             return false;
         }
@@ -783,7 +793,7 @@ function check_qemu() {
 
 function copy_recursive(src, dest, validate = filename => true) {
     let proc = spawnSync('git', ['ls-files', '-i', '-o', '--exclude-standard', '--directory'], { cwd: src });
-    let ignored = new Set(proc.stdout.toString().split('\n').map(it => it.trim().replace(/[\\\/+]$/, '')).filter(it => it));
+    let ignored = new Set(proc.stdout.toString().split('\n').map(it => it.trim().replace(/[\\\/+]$/, '').replaceAll('\\', '/')).filter(it => it));
 
     recurse(src, dest, '');
 
@@ -793,7 +803,7 @@ function copy_recursive(src, dest, validate = filename => true) {
         for (let entry of entries) {
             let src_filename = path.join(src, entry.name);
             let dest_filename = path.join(dest, entry.name);
-            let filename = path.join(nice, entry.name);
+            let filename = nice + (nice ? '/' : '') + entry.name;
 
             if (ignored.has(filename))
                 continue;