Extensions.

conn.go

@@ -105,7 +105,6 @@ func (c *Conn) openDB(filename string, flags OpenFlag) (uint32, error) {
 		}
 	}
 
-	c.call(c.api.timeCollation, uint64(handle))
 	return handle, nil
 }
 

driver/driver.go

@@ -386,8 +386,7 @@ func (r rows) Next(dest []driver.Value) error {
 		case sqlite3.TEXT:
 			dest[i] = maybeTime(r.stmt.ColumnText(i))
 		case sqlite3.BLOB:
-			buf, _ := dest[i].([]byte)
-			dest[i] = r.stmt.ColumnBlob(i, buf)
+			dest[i] = r.stmt.ColumnRawBlob(i)
 		case sqlite3.NULL:
 			if buf, ok := dest[i].([]byte); ok {
 				dest[i] = buf[0:0]

driver/driver_test.go

@@ -308,7 +308,7 @@ func Test_QueryRow_blob_null(t *testing.T) {
 
 	want := [][]byte{nil, {0xca, 0xfe}, {0xba, 0xbe}, nil}
 	for i := 0; rows.Next(); i++ {
-		var buf []byte
+		var buf sql.RawBytes
 		err = rows.Scan(&buf)
 		if err != nil {
 			t.Fatal(err)

embed/README.md

@@ -1,14 +1,21 @@
 # Embeddable WASM build of SQLite
 
-This folder includes an embeddable WASM build of SQLite 3.41.0 for use with
+This folder includes an embeddable WASM build of SQLite 3.41.1 for use with
 [`github.com/ncruces/go-sqlite3`](https://pkg.go.dev/github.com/ncruces/go-sqlite3).
 
 The following optional features are compiled in:
-- math functions
-- FTS3/4/5
-- JSON
-- R*Tree
-- GeoPoly
+- [math functions](https://www.sqlite.org/lang_mathfunc.html)
+- [FTS3/4](https://www.sqlite.org/fts3.html)/[5](https://www.sqlite.org/fts5.html)
+- [JSON](https://www.sqlite.org/json1.html)
+- [R*Tree](https://www.sqlite.org/rtree.html)
+- [GeoPoly](https://www.sqlite.org/geopoly.html)
+- [base64](https://github.com/sqlite/sqlite/blob/master/ext/misc/base64.c)
+- [decimal](https://github.com/sqlite/sqlite/blob/master/ext/misc/decimal.c)
+- [regexp](https://github.com/sqlite/sqlite/blob/master/ext/misc/regexp.c)
+- [series](https://github.com/sqlite/sqlite/blob/master/ext/misc/series.c)
+- [uint](https://github.com/sqlite/sqlite/blob/master/ext/misc/uint.c)
+- [uuid](https://github.com/sqlite/sqlite/blob/master/ext/misc/uuid.c)
+- [time](../sqlite3/time.c)
 
 See the [configuration options](../sqlite3/sqlite_cfg.h).
 

embed/build.sh

@@ -3,12 +3,10 @@ set -eo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-# download SQLite
-../sqlite3/download.sh
-
 # build SQLite
 zig cc --target=wasm32-wasi -flto -g0 -Os \
   -o sqlite3.wasm ../sqlite3/main.c \
+	-I../sqlite3/ \
 	-mmutable-globals \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \

embed/exports.txt

@@ -45,5 +45,4 @@ sqlite3_backup_step
 sqlite3_backup_finish
 sqlite3_backup_remaining
 sqlite3_backup_pagecount
-sqlite3_time_collation
 sqlite3_interrupt_offset

module.go

@@ -155,7 +155,6 @@ func newModule(mod api.Module) (m *module, err error) {
 		backupFinish:    getFun("sqlite3_backup_finish"),
 		backupRemaining: getFun("sqlite3_backup_remaining"),
 		backupPageCount: getFun("sqlite3_backup_pagecount"),
-		timeCollation:   getFun("sqlite3_time_collation"),
 		interrupt:       getVal("sqlite3_interrupt_offset"),
 	}
 	if err != nil {
@@ -349,6 +348,5 @@ type sqliteAPI struct {
 	backupFinish    api.Function
 	backupRemaining api.Function
 	backupPageCount api.Function
-	timeCollation   api.Function
 	interrupt       uint32
 }

sqlite3/download.sh

@@ -3,11 +3,29 @@ set -eo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-if [ ! -f "sqlite3.c" ]; then
-	url="https://sqlite.org/2023/sqlite-amalgamation-3410100.zip"
-	curl "$url" > sqlite.zip
-	unzip -d . sqlite.zip
-	mv sqlite-amalgamation-*/sqlite3* .
-	rm -rf sqlite-amalgamation-*
-	rm sqlite.zip
-fi
+curl -#OL "https://sqlite.org/2023/sqlite-amalgamation-3410100.zip"
+unzip -d . sqlite-amalgamation-*.zip
+mv sqlite-amalgamation-*/sqlite3* .
+rm -rf sqlite-amalgamation-*
+
+cd ext/
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/ext/misc/decimal.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/ext/misc/uint.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/ext/misc/uuid.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/ext/misc/base64.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/ext/misc/regexp.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/ext/misc/series.c"
+cd ~-
+
+cd ../tests/mptest/testdata/
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/mptest.c"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/config01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/config02.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/crash01.test"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/crash02.subtest"
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/multiwrite01.test"
+cd ~-
+
+cd ../tests/speedtest1/testdata/
+curl -#OL "https://github.com/sqlite/sqlite/raw/version-3.41.1/test/speedtest1.c"
+cd ~-

sqlite3/ext/.gitignore

@@ -0,0 +1 @@
+*.c

sqlite3/main.c

@@ -5,6 +5,13 @@
 //
 #include "os.c"
 #include "qsort.c"
+//
+#include "ext/base64.c"
+#include "ext/decimal.c"
+#include "ext/regexp.c"
+#include "ext/series.c"
+#include "ext/uint.c"
+#include "ext/uuid.c"
 #include "time.c"
 
 sqlite3_destructor_type malloc_destructor = &free;
@@ -17,4 +24,25 @@ int sqlite3_os_init() {
 int main() {
   int rc = sqlite3_initialize();
   if (rc != SQLITE_OK) return 1;
+
+  rc = sqlite3_auto_extension((void (*)(void))sqlite3_base_init);
+  if (rc != SQLITE_OK) return 1;
+
+  rc = sqlite3_auto_extension((void (*)(void))sqlite3_decimal_init);
+  if (rc != SQLITE_OK) return 1;
+
+  rc = sqlite3_auto_extension((void (*)(void))sqlite3_regexp_init);
+  if (rc != SQLITE_OK) return 1;
+
+  rc = sqlite3_auto_extension((void (*)(void))sqlite3_series_init);
+  if (rc != SQLITE_OK) return 1;
+
+  rc = sqlite3_auto_extension((void (*)(void))sqlite3_uint_init);
+  if (rc != SQLITE_OK) return 1;
+
+  rc = sqlite3_auto_extension((void (*)(void))sqlite3_uuid_init);
+  if (rc != SQLITE_OK) return 1;
+
+  rc = sqlite3_auto_extension((void (*)(void))sqlite3_time_init);
+  if (rc != SQLITE_OK) return 1;
 }

sqlite3/time.c

@@ -26,6 +26,7 @@ static int time_collation(void *pArg, int nKey1, const void *pKey1, int nKey2,
   return rc;
 }
 
-int sqlite3_time_collation(sqlite3 *db) {
-  return sqlite3_create_collation(db, "TIME", SQLITE_UTF8, 0, time_collation);
+int sqlite3_time_init(sqlite3 *db, char **pzErrMsg,
+                      const sqlite3_api_routines *pApi) {
+  return sqlite3_create_collation(db, "time", SQLITE_UTF8, 0, time_collation);
 }

stmt.go

@@ -334,21 +334,7 @@ func (s *Stmt) ColumnTime(col int, format TimeFormat) time.Time {
 //
 // https://www.sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnText(col int) string {
-	r := s.c.call(s.c.api.columnText,
-		uint64(s.handle), uint64(col))
-
-	ptr := uint32(r[0])
-	if ptr == 0 {
-		r = s.c.call(s.c.api.errcode, uint64(s.c.handle))
-		s.err = s.c.error(r[0])
-		return ""
-	}
-
-	r = s.c.call(s.c.api.columnBytes,
-		uint64(s.handle), uint64(col))
-
-	mem := s.c.mem.view(ptr, r[0])
-	return string(mem)
+	return string(s.ColumnRawText(col))
 }
 
 // ColumnBlob appends to buf and returns
@@ -357,6 +343,39 @@ func (s *Stmt) ColumnText(col int) string {
 //
 // https://www.sqlite.org/c3ref/column_blob.html
 func (s *Stmt) ColumnBlob(col int, buf []byte) []byte {
+	return append(buf, s.ColumnRawBlob(col)...)
+}
+
+// ColumnRawText returns the value of the result column as a []byte.
+// The []byte is owned by SQLite and may be invalidated by
+// subsequent calls to [Stmt] methods.
+// The leftmost column of the result set has the index 0.
+//
+// https://www.sqlite.org/c3ref/column_blob.html
+func (s *Stmt) ColumnRawText(col int) []byte {
+	r := s.c.call(s.c.api.columnText,
+		uint64(s.handle), uint64(col))
+
+	ptr := uint32(r[0])
+	if ptr == 0 {
+		r = s.c.call(s.c.api.errcode, uint64(s.c.handle))
+		s.err = s.c.error(r[0])
+		return nil
+	}
+
+	r = s.c.call(s.c.api.columnBytes,
+		uint64(s.handle), uint64(col))
+
+	return s.c.mem.view(ptr, r[0])
+}
+
+// ColumnRawBlob returns the value of the result column as a []byte.
+// The []byte is owned by SQLite and may be invalidated by
+// subsequent calls to [Stmt] methods.
+// The leftmost column of the result set has the index 0.
+//
+// https://www.sqlite.org/c3ref/column_blob.html
+func (s *Stmt) ColumnRawBlob(col int) []byte {
 	r := s.c.call(s.c.api.columnBlob,
 		uint64(s.handle), uint64(col))
 
@@ -364,14 +383,13 @@ func (s *Stmt) ColumnBlob(col int, buf []byte) []byte {
 	if ptr == 0 {
 		r = s.c.call(s.c.api.errcode, uint64(s.c.handle))
 		s.err = s.c.error(r[0])
-		return buf[0:0]
+		return nil
 	}
 
 	r = s.c.call(s.c.api.columnBytes,
 		uint64(s.handle), uint64(col))
 
-	mem := s.c.mem.view(ptr, r[0])
-	return append(buf[0:0], mem...)
+	return s.c.mem.view(ptr, r[0])
 }
 
 // Return true if stmt is an empty SQL statement.

tests/bradfitz/sql_test.go

@@ -126,7 +126,7 @@ func testTxQuery(t params) {
 		if r.Err() != nil {
 			t.Fatal(err)
 		}
-		t.Fatal("expected one rows")
+		t.Fatal("expected one row")
 	}
 
 	var name string

tests/ext_test.go

@@ -0,0 +1,77 @@
+package tests
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3"
+)
+
+func Test_base64(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	// base64
+	stmt, _, err := db.Prepare(`SELECT base64('TWFueSBoYW5kcyBtYWtlIGxpZ2h0IHdvcmsu')`)
+	if err != nil {
+		t.Error(err)
+	}
+	defer stmt.Close()
+
+	if !stmt.Step() {
+		t.Fatal("expected one row")
+	}
+	if got := stmt.ColumnText(0); got != "Many hands make light work." {
+		t.Errorf("got %q", got)
+	}
+}
+
+func Test_decimal(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	stmt, _, err := db.Prepare(`SELECT decimal_add(decimal('0.1'), decimal('0.2')) = decimal('0.3')`)
+	if err != nil {
+		t.Error(err)
+	}
+	defer stmt.Close()
+
+	if !stmt.Step() {
+		t.Fatal("expected one row")
+	}
+	if !stmt.ColumnBool(0) {
+		t.Error("want true")
+	}
+}
+
+func Test_uint(t *testing.T) {
+	t.Parallel()
+
+	db, err := sqlite3.Open(":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+
+	stmt, _, err := db.Prepare(`SELECT 'z2' < 'z11' COLLATE UINT`)
+	if err != nil {
+		t.Error(err)
+	}
+	defer stmt.Close()
+
+	if !stmt.Step() {
+		t.Fatal("expected one row")
+	}
+	if !stmt.ColumnBool(0) {
+		t.Error("want true")
+	}
+}

tests/mptest/testdata/build.sh

@@ -3,18 +3,9 @@ set -eo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-if [ ! -f "mptest.c" ]; then
-	curl -sOL	"https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/mptest.c"
-	curl -sOL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/config01.test"
-  curl -sOL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/config02.test"
-  curl -sOL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/crash01.test"
-  curl -sOL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/crash02.subtest"
-  curl -sOL "https://github.com/sqlite/sqlite/raw/version-3.41.1/mptest/multiwrite01.test"
-fi
-
 zig cc --target=wasm32-wasi -flto -g0 -Os \
   -o mptest.wasm main.c \
-	-I../../../sqlite3 \
+	-I../../../sqlite3/ \
 	-mmutable-globals \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \

tests/mptest/testdata/main.c

@@ -5,7 +5,6 @@
 //
 #include "os.c"
 #include "qsort.c"
-#include "time.c"
 
 sqlite3_destructor_type malloc_destructor = &free;
 size_t sqlite3_interrupt_offset = offsetof(sqlite3, u1.isInterrupted);

tests/speedtest1/testdata/build.sh

@@ -3,13 +3,9 @@ set -eo pipefail
 
 cd -P -- "$(dirname -- "$0")"
 
-if [ ! -f "mptest.c" ]; then
-	curl -sOL	"https://github.com/sqlite/sqlite/raw/version-3.41.1/test/speedtest1.c"
-fi
-
 zig cc --target=wasm32-wasi -flto -g0 -Os \
   -o speedtest1.wasm main.c \
-	-I../../../sqlite3 \
+	-I../../../sqlite3/ \
 	-mmutable-globals \
 	-mbulk-memory -mreference-types \
 	-mnontrapping-fptoint -msign-ext \

tests/speedtest1/testdata/main.c

@@ -5,7 +5,6 @@
 //
 #include "os.c"
 #include "qsort.c"
-#include "time.c"
 
 sqlite3_destructor_type malloc_destructor = &free;
 size_t sqlite3_interrupt_offset = offsetof(sqlite3, u1.isInterrupted);
@@ -14,7 +13,5 @@ int sqlite3_os_init() {
   return sqlite3_vfs_register(os_vfs(), /*default=*/true);
 }
 
-__attribute__((constructor)) void premain() { sqlite3_initialize(); }
-
 #define randomFunc(args...) randomFunc2(args)
 #include "speedtest1.c"

tests/speedtest1/testdata/speedtest1.wasm

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:996c2445ad12c91dce1a59ab5929cfaa3a09a4ac82859fecc7de5e5f9c955f80
-size 1001607
+oid sha256:2058b59b052ce9e3ed74c241f06122e8acfe0b5d4a18f36130e625b34eecd161
+size 1001469

vfs.go

@@ -19,7 +19,7 @@ import (
 
 func vfsInstantiate(ctx context.Context, r wazero.Runtime) {
 	wasi := r.NewHostModuleBuilder("wasi_snapshot_preview1")
-	wasi.NewFunctionBuilder().WithFunc(vfsExit).Export("proc_exit")
+	vfsRegisterFunc(wasi, "proc_exit", vfsExit)
 	_, err := wasi.Instantiate(ctx)
 	if err != nil {
 		panic(err)
@@ -34,25 +34,25 @@ func vfsInstantiate(ctx context.Context, r wazero.Runtime) {
 
 func vfsNewEnvModuleBuilder(r wazero.Runtime) wazero.HostModuleBuilder {
 	env := r.NewHostModuleBuilder("env")
-	env.NewFunctionBuilder().WithFunc(vfsLocaltime).Export("os_localtime")
-	env.NewFunctionBuilder().WithFunc(vfsRandomness).Export("os_randomness")
-	env.NewFunctionBuilder().WithFunc(vfsSleep).Export("os_sleep")
-	env.NewFunctionBuilder().WithFunc(vfsCurrentTime).Export("os_current_time")
-	env.NewFunctionBuilder().WithFunc(vfsCurrentTime64).Export("os_current_time_64")
-	env.NewFunctionBuilder().WithFunc(vfsFullPathname).Export("os_full_pathname")
-	env.NewFunctionBuilder().WithFunc(vfsDelete).Export("os_delete")
-	env.NewFunctionBuilder().WithFunc(vfsAccess).Export("os_access")
-	env.NewFunctionBuilder().WithFunc(vfsOpen).Export("os_open")
-	env.NewFunctionBuilder().WithFunc(vfsClose).Export("os_close")
-	env.NewFunctionBuilder().WithFunc(vfsRead).Export("os_read")
-	env.NewFunctionBuilder().WithFunc(vfsWrite).Export("os_write")
-	env.NewFunctionBuilder().WithFunc(vfsTruncate).Export("os_truncate")
-	env.NewFunctionBuilder().WithFunc(vfsSync).Export("os_sync")
-	env.NewFunctionBuilder().WithFunc(vfsFileSize).Export("os_file_size")
-	env.NewFunctionBuilder().WithFunc(vfsLock).Export("os_lock")
-	env.NewFunctionBuilder().WithFunc(vfsUnlock).Export("os_unlock")
-	env.NewFunctionBuilder().WithFunc(vfsCheckReservedLock).Export("os_check_reserved_lock")
-	env.NewFunctionBuilder().WithFunc(vfsFileControl).Export("os_file_control")
+	vfsRegisterFunc(env, "os_localtime", vfsLocaltime)
+	vfsRegisterFunc3(env, "os_randomness", vfsRandomness)
+	vfsRegisterFunc2(env, "os_sleep", vfsSleep)
+	vfsRegisterFunc2(env, "os_current_time", vfsCurrentTime)
+	vfsRegisterFunc2(env, "os_current_time_64", vfsCurrentTime64)
+	vfsRegisterFunc4(env, "os_full_pathname", vfsFullPathname)
+	vfsRegisterFunc3(env, "os_delete", vfsDelete)
+	vfsRegisterFunc4(env, "os_access", vfsAccess)
+	vfsRegisterFunc5(env, "os_open", vfsOpen)
+	vfsRegisterFunc1(env, "os_close", vfsClose)
+	vfsRegisterFuncRW(env, "os_read", vfsRead)
+	vfsRegisterFuncRW(env, "os_write", vfsWrite)
+	vfsRegisterFunc(env, "os_truncate", vfsTruncate)
+	vfsRegisterFunc2(env, "os_sync", vfsSync)
+	vfsRegisterFunc2(env, "os_file_size", vfsFileSize)
+	vfsRegisterFunc2(env, "os_lock", vfsLock)
+	vfsRegisterFunc2(env, "os_unlock", vfsUnlock)
+	vfsRegisterFunc2(env, "os_check_reserved_lock", vfsCheckReservedLock)
+	vfsRegisterFunc3(env, "os_file_control", vfsFileControl)
 	return env
 }
 
@@ -121,7 +121,7 @@ func vfsRandomness(ctx context.Context, mod api.Module, pVfs, nByte, zByte uint3
 	return uint32(n)
 }
 
-func vfsSleep(ctx context.Context, pVfs, nMicro uint32) uint32 {
+func vfsSleep(ctx context.Context, mod api.Module, pVfs, nMicro uint32) uint32 {
 	time.Sleep(time.Duration(nMicro) * time.Microsecond)
 	return _OK
 }
@@ -146,10 +146,6 @@ func vfsFullPathname(ctx context.Context, mod api.Module, pVfs, zRelative, nFull
 		return uint32(CANTOPEN_FULLPATH)
 	}
 
-	// Consider either using [filepath.EvalSymlinks] to canonicalize the path (as the Unix VFS does).
-	// Or using [os.Readlink] to resolve a symbolic link (as the Unix VFS did).
-	// This might be buggy on Windows (the Windows VFS doesn't try).
-
 	size := uint64(len(abs) + 1)
 	if size > uint64(nFull) {
 		return uint32(CANTOPEN_FULLPATH)
@@ -368,3 +364,67 @@ func vfsFileMoved(ctx context.Context, mod api.Module, pFile, pResOut uint32) ui
 	memory{mod}.writeUint32(pResOut, res)
 	return _OK
 }
+
+func vfsRegisterFunc(mod wazero.HostModuleBuilder, name string, fn any) {
+	mod.NewFunctionBuilder().WithFunc(fn).Export(name)
+}
+
+func vfsRegisterFunc1(mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ uint32) uint32) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(api.GoModuleFunc(
+			func(ctx context.Context, mod api.Module, stack []uint64) {
+				stack[0] = uint64(fn(ctx, mod, uint32(stack[0])))
+			}),
+			[]api.ValueType{api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
+		Export(name)
+}
+
+func vfsRegisterFunc2[T0, T1 ~uint32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1) uint32) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(api.GoModuleFunc(
+			func(ctx context.Context, mod api.Module, stack []uint64) {
+				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1])))
+			}),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
+		Export(name)
+}
+
+func vfsRegisterFunc3[T0, T1, T2 ~uint32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2) uint32) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(api.GoModuleFunc(
+			func(ctx context.Context, mod api.Module, stack []uint64) {
+				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2])))
+			}),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
+		Export(name)
+}
+
+func vfsRegisterFunc4[T0, T1, T2, T3 ~uint32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3) uint32) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(api.GoModuleFunc(
+			func(ctx context.Context, mod api.Module, stack []uint64) {
+				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3])))
+			}),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
+		Export(name)
+}
+
+func vfsRegisterFunc5[T0, T1, T2, T3, T4 ~uint32](mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _ T0, _ T1, _ T2, _ T3, _ T4) uint32) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(api.GoModuleFunc(
+			func(ctx context.Context, mod api.Module, stack []uint64) {
+				stack[0] = uint64(fn(ctx, mod, T0(stack[0]), T1(stack[1]), T2(stack[2]), T3(stack[3]), T4(stack[4])))
+			}),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32}, []api.ValueType{api.ValueTypeI32}).
+		Export(name)
+}
+
+func vfsRegisterFuncRW(mod wazero.HostModuleBuilder, name string, fn func(ctx context.Context, mod api.Module, _, _, _ uint32, _ uint64) uint32) {
+	mod.NewFunctionBuilder().
+		WithGoModuleFunction(api.GoModuleFunc(
+			func(ctx context.Context, mod api.Module, stack []uint64) {
+				stack[0] = uint64(fn(ctx, mod, uint32(stack[0]), uint32(stack[1]), uint32(stack[2]), stack[3]))
+			}),
+			[]api.ValueType{api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI32, api.ValueTypeI64}, []api.ValueType{api.ValueTypeI32}).
+		Export(name)
+}

vfs_test.go

@@ -60,8 +60,9 @@ func Test_vfsLocaltime(t *testing.T) {
 
 func Test_vfsRandomness(t *testing.T) {
 	mem := newMemory(128)
+	ctx := context.TODO()
 
-	rc := vfsRandomness(context.TODO(), mem.mod, 0, 16, 4)
+	rc := vfsRandomness(ctx, mem.mod, 0, 16, 4)
 	if rc != 16 {
 		t.Fatal("returned", rc)
 	}
@@ -73,10 +74,11 @@ func Test_vfsRandomness(t *testing.T) {
 }
 
 func Test_vfsSleep(t *testing.T) {
+	mem := newMemory(128)
 	ctx := context.TODO()
 
 	now := time.Now()
-	rc := vfsSleep(ctx, 0, 123456)
+	rc := vfsSleep(ctx, mem.mod, 0, 123456)
 	if rc != 0 {
 		t.Fatal("returned", rc)
 	}