From c86b06b048af668d062d471e9028bf4194a19d31 Mon Sep 17 00:00:00 2001 From: Nuno Cruces Date: Tue, 16 May 2023 17:25:36 +0100 Subject: [PATCH] Refactor. --- internal/vfs/vfs.go | 42 ++++++++-------- sqlite3/sqlite_cfg.h | 10 ++-- sqlite3/vfs.c | 117 ++++++++++++++++++++----------------------- 3 files changed, 80 insertions(+), 89 deletions(-) diff --git a/internal/vfs/vfs.go b/internal/vfs/vfs.go index 9e7d742..e9ac57b 100644 --- a/internal/vfs/vfs.go +++ b/internal/vfs/vfs.go @@ -18,27 +18,27 @@ import ( ) func Export(env wazero.HostModuleBuilder) wazero.HostModuleBuilder { - util.RegisterFuncIIJ(env, "os_localtime", vfsLocaltime) - util.RegisterFuncIIII(env, "os_randomness", vfsRandomness) - util.RegisterFuncIII(env, "os_sleep", vfsSleep) - util.RegisterFuncIII(env, "os_current_time", vfsCurrentTime) - util.RegisterFuncIII(env, "os_current_time_64", vfsCurrentTime64) - util.RegisterFuncIIIII(env, "os_full_pathname", vfsFullPathname) - util.RegisterFuncIIII(env, "os_delete", vfsDelete) - util.RegisterFuncIIIII(env, "os_access", vfsAccess) - util.RegisterFuncIIIIII(env, "os_open", vfsOpen) - util.RegisterFuncII(env, "os_close", vfsClose) - util.RegisterFuncIIIIJ(env, "os_read", vfsRead) - util.RegisterFuncIIIIJ(env, "os_write", vfsWrite) - util.RegisterFuncIIJ(env, "os_truncate", vfsTruncate) - util.RegisterFuncIII(env, "os_sync", vfsSync) - util.RegisterFuncIII(env, "os_file_size", vfsFileSize) - util.RegisterFuncIIII(env, "os_file_control", vfsFileControl) - util.RegisterFuncII(env, "os_sector_size", vfsSectorSize) - util.RegisterFuncII(env, "os_device_characteristics", vfsDeviceCharacteristics) - util.RegisterFuncIII(env, "os_lock", vfsLock) - util.RegisterFuncIII(env, "os_unlock", vfsUnlock) - util.RegisterFuncIII(env, "os_check_reserved_lock", vfsCheckReservedLock) + util.RegisterFuncIIJ(env, "go_localtime", vfsLocaltime) + util.RegisterFuncIIII(env, "go_randomness", vfsRandomness) + util.RegisterFuncIII(env, "go_sleep", vfsSleep) + util.RegisterFuncIII(env, "go_current_time", vfsCurrentTime) + util.RegisterFuncIII(env, "go_current_time_64", vfsCurrentTime64) + util.RegisterFuncIIIII(env, "go_full_pathname", vfsFullPathname) + util.RegisterFuncIIII(env, "go_delete", vfsDelete) + util.RegisterFuncIIIII(env, "go_access", vfsAccess) + util.RegisterFuncIIIIII(env, "go_open", vfsOpen) + util.RegisterFuncII(env, "go_close", vfsClose) + util.RegisterFuncIIIIJ(env, "go_read", vfsRead) + util.RegisterFuncIIIIJ(env, "go_write", vfsWrite) + util.RegisterFuncIIJ(env, "go_truncate", vfsTruncate) + util.RegisterFuncIII(env, "go_sync", vfsSync) + util.RegisterFuncIII(env, "go_file_size", vfsFileSize) + util.RegisterFuncIIII(env, "go_file_control", vfsFileControl) + util.RegisterFuncII(env, "go_sector_size", vfsSectorSize) + util.RegisterFuncII(env, "go_device_characteristics", vfsDeviceCharacteristics) + util.RegisterFuncIII(env, "go_lock", vfsLock) + util.RegisterFuncIII(env, "go_unlock", vfsUnlock) + util.RegisterFuncIII(env, "go_check_reserved_lock", vfsCheckReservedLock) return env } diff --git a/sqlite3/sqlite_cfg.h b/sqlite3/sqlite_cfg.h index 34fd489..25e0a76 100644 --- a/sqlite3/sqlite_cfg.h +++ b/sqlite3/sqlite_cfg.h @@ -56,12 +56,12 @@ // #define SQLITE_ENABLE_PREUPDATE_HOOK // https://stackoverflow.com/a/50616684 -#define SECOND(...) SECOND_I(__VA_ARGS__,,) -#define SECOND_I(A,B,...) B -#define GLUE(A,B) GLUE_I(A,B) -#define GLUE_I(A,B) A##B +#define SECOND(...) SECOND_I(__VA_ARGS__, , ) +#define SECOND_I(A, B, ...) B +#define GLUE(A, B) GLUE_I(A, B) +#define GLUE_I(A, B) A##B #define REPLACE_DEFAULT(a, prefix) SECOND(GLUE(prefix, __LINE__), a) -#define REPLACE_AT_LINE(a) ,a +#define REPLACE_AT_LINE(a) , a // Implemented in vfs.c. int localtime_s(struct tm *const pTm, time_t const *const pTime); \ No newline at end of file diff --git a/sqlite3/vfs.c b/sqlite3/vfs.c index ccb21c5..88ded40 100644 --- a/sqlite3/vfs.c +++ b/sqlite3/vfs.c @@ -2,95 +2,86 @@ #include "sqlite3.h" -int os_localtime(struct tm *, sqlite3_int64); +int go_localtime(struct tm *, sqlite3_int64); -int os_randomness(sqlite3_vfs *, int nByte, char *zOut); -int os_sleep(sqlite3_vfs *, int microseconds); -int os_current_time(sqlite3_vfs *, double *); -int os_current_time_64(sqlite3_vfs *, sqlite3_int64 *); +int go_randomness(sqlite3_vfs *, int nByte, char *zOut); +int go_sleep(sqlite3_vfs *, int microseconds); +int go_current_time(sqlite3_vfs *, double *); +int go_current_time_64(sqlite3_vfs *, sqlite3_int64 *); -int os_open(sqlite3_vfs *, sqlite3_filename zName, sqlite3_file *, int flags, +int go_open(sqlite3_vfs *, sqlite3_filename zName, sqlite3_file *, int flags, int *pOutFlags); -int os_delete(sqlite3_vfs *, const char *zName, int syncDir); -int os_access(sqlite3_vfs *, const char *zName, int flags, int *pResOut); -int os_full_pathname(sqlite3_vfs *, const char *zName, int nOut, char *zOut); +int go_delete(sqlite3_vfs *, const char *zName, int syncDir); +int go_access(sqlite3_vfs *, const char *zName, int flags, int *pResOut); +int go_full_pathname(sqlite3_vfs *, const char *zName, int nOut, char *zOut); -struct os_file { - sqlite3_file base; - int handle; -}; +int go_close(sqlite3_file *); +int go_read(sqlite3_file *, void *, int iAmt, sqlite3_int64 iOfst); +int go_write(sqlite3_file *, const void *, int iAmt, sqlite3_int64 iOfst); +int go_truncate(sqlite3_file *, sqlite3_int64 size); +int go_sync(sqlite3_file *, int flags); +int go_file_size(sqlite3_file *, sqlite3_int64 *pSize); +int go_file_control(sqlite3_file *, int op, void *pArg); +int go_sector_size(sqlite3_file *file); +int go_device_characteristics(sqlite3_file *file); -static_assert(offsetof(struct os_file, handle) == 4, "Unexpected offset"); +int go_lock(sqlite3_file *, int eLock); +int go_unlock(sqlite3_file *, int eLock); +int go_check_reserved_lock(sqlite3_file *, int *pResOut); -int os_close(sqlite3_file *); -int os_read(sqlite3_file *, void *, int iAmt, sqlite3_int64 iOfst); -int os_write(sqlite3_file *, const void *, int iAmt, sqlite3_int64 iOfst); -int os_truncate(sqlite3_file *, sqlite3_int64 size); -int os_sync(sqlite3_file *, int flags); -int os_file_size(sqlite3_file *, sqlite3_int64 *pSize); -int os_file_control(sqlite3_file *, int op, void *pArg); -int os_sector_size(sqlite3_file *file); -int os_device_characteristics(sqlite3_file *file); - -int os_lock(sqlite3_file *, int eLock); -int os_unlock(sqlite3_file *, int eLock); -int os_check_reserved_lock(sqlite3_file *, int *pResOut); - -static int os_file_control_w(sqlite3_file *file, int op, void *pArg) { - if (op == SQLITE_FCNTL_VFSNAME) { - *(char **)pArg = sqlite3_mprintf("%s", "os"); - return SQLITE_OK; - } - return os_file_control(file, op, pArg); -} - -static int os_open_w(sqlite3_vfs *vfs, sqlite3_filename zName, - sqlite3_file *file, int flags, int *pOutFlags) { +static int go_open_wrapper(sqlite3_vfs *vfs, sqlite3_filename zName, + sqlite3_file *file, int flags, int *pOutFlags) { static const sqlite3_io_methods os_io = { .iVersion = 1, - .xClose = os_close, - .xRead = os_read, - .xWrite = os_write, - .xTruncate = os_truncate, - .xSync = os_sync, - .xFileSize = os_file_size, - .xLock = os_lock, - .xUnlock = os_unlock, - .xCheckReservedLock = os_check_reserved_lock, - .xFileControl = os_file_control_w, - .xSectorSize = os_sector_size, - .xDeviceCharacteristics = os_device_characteristics, + .xClose = go_close, + .xRead = go_read, + .xWrite = go_write, + .xTruncate = go_truncate, + .xSync = go_sync, + .xFileSize = go_file_size, + .xLock = go_lock, + .xUnlock = go_unlock, + .xCheckReservedLock = go_check_reserved_lock, + .xFileControl = go_file_control, + .xSectorSize = go_sector_size, + .xDeviceCharacteristics = go_device_characteristics, }; - memset(file, 0, sizeof(struct os_file)); - int rc = os_open(vfs, zName, file, flags, pOutFlags); + memset(file, 0, vfs->szOsFile); + int rc = go_open(vfs, zName, file, flags, pOutFlags); if (rc) { return rc; } - file->pMethods = &os_io; return SQLITE_OK; } +struct go_file { + sqlite3_file base; + int handle; +}; + +static_assert(offsetof(struct go_file, handle) == 4, "Unexpected offset"); + sqlite3_vfs *os_vfs() { static sqlite3_vfs os_vfs = { .iVersion = 2, - .szOsFile = sizeof(struct os_file), + .szOsFile = sizeof(struct go_file), .mxPathname = 512, .zName = "os", - .xOpen = os_open_w, - .xDelete = os_delete, - .xAccess = os_access, - .xFullPathname = os_full_pathname, + .xOpen = go_open_wrapper, + .xDelete = go_delete, + .xAccess = go_access, + .xFullPathname = go_full_pathname, - .xRandomness = os_randomness, - .xSleep = os_sleep, - .xCurrentTime = os_current_time, - .xCurrentTimeInt64 = os_current_time_64, + .xRandomness = go_randomness, + .xSleep = go_sleep, + .xCurrentTime = go_current_time, + .xCurrentTimeInt64 = go_current_time_64, }; return &os_vfs; } int localtime_s(struct tm *const pTm, time_t const *const pTime) { - return os_localtime(pTm, (sqlite3_int64)*pTime); + return go_localtime(pTm, (sqlite3_int64)*pTime); }