summaryrefslogtreecommitdiff
path: root/vendor/github.com/ncruces/go-sqlite3/vtab.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/ncruces/go-sqlite3/vtab.go')
-rw-r--r--vendor/github.com/ncruces/go-sqlite3/vtab.go186
1 files changed, 92 insertions, 94 deletions
diff --git a/vendor/github.com/ncruces/go-sqlite3/vtab.go b/vendor/github.com/ncruces/go-sqlite3/vtab.go
index 1998a5281..278195e92 100644
--- a/vendor/github.com/ncruces/go-sqlite3/vtab.go
+++ b/vendor/github.com/ncruces/go-sqlite3/vtab.go
@@ -2,6 +2,7 @@ package sqlite3
import (
"context"
+ "errors"
"reflect"
"github.com/tetratelabs/wazero/api"
@@ -58,15 +59,15 @@ func CreateModule[T VTab](db *Conn, name string, create, connect VTabConstructor
flags |= VTAB_SHADOWTABS
}
- var modulePtr uint32
+ var modulePtr ptr_t
defer db.arena.mark()()
namePtr := db.arena.string(name)
if connect != nil {
modulePtr = util.AddHandle(db.ctx, module[T]{create, connect})
}
- r := db.call("sqlite3_create_module_go", uint64(db.handle),
- uint64(namePtr), uint64(flags), uint64(modulePtr))
- return db.error(r)
+ rc := res_t(db.call("sqlite3_create_module_go", stk_t(db.handle),
+ stk_t(namePtr), stk_t(flags), stk_t(modulePtr)))
+ return db.error(rc)
}
func implements[T any](typ reflect.Type) bool {
@@ -80,8 +81,8 @@ func implements[T any](typ reflect.Type) bool {
func (c *Conn) DeclareVTab(sql string) error {
defer c.arena.mark()()
sqlPtr := c.arena.string(sql)
- r := c.call("sqlite3_declare_vtab", uint64(c.handle), uint64(sqlPtr))
- return c.error(r)
+ rc := res_t(c.call("sqlite3_declare_vtab", stk_t(c.handle), stk_t(sqlPtr)))
+ return c.error(rc)
}
// VTabConflictMode is a virtual table conflict resolution mode.
@@ -101,8 +102,7 @@ const (
//
// https://sqlite.org/c3ref/vtab_on_conflict.html
func (c *Conn) VTabOnConflict() VTabConflictMode {
- r := c.call("sqlite3_vtab_on_conflict", uint64(c.handle))
- return VTabConflictMode(r)
+ return VTabConflictMode(c.call("sqlite3_vtab_on_conflict", stk_t(c.handle)))
}
// VTabConfigOption is a virtual table configuration option.
@@ -121,14 +121,14 @@ const (
//
// https://sqlite.org/c3ref/vtab_config.html
func (c *Conn) VTabConfig(op VTabConfigOption, args ...any) error {
- var i uint64
+ var i int32
if op == VTAB_CONSTRAINT_SUPPORT && len(args) > 0 {
if b, ok := args[0].(bool); ok && b {
i = 1
}
}
- r := c.call("sqlite3_vtab_config_go", uint64(c.handle), uint64(op), i)
- return c.error(r)
+ rc := res_t(c.call("sqlite3_vtab_config_go", stk_t(c.handle), stk_t(op), stk_t(i)))
+ return c.error(rc)
}
// VTabConstructor is a virtual table constructor function.
@@ -263,7 +263,7 @@ type IndexInfo struct {
// Inputs
Constraint []IndexConstraint
OrderBy []IndexOrderBy
- ColumnsUsed int64
+ ColumnsUsed uint64
// Outputs
ConstraintUsage []IndexConstraintUsage
IdxNum int
@@ -274,7 +274,7 @@ type IndexInfo struct {
EstimatedRows int64
// Internal
c *Conn
- handle uint32
+ handle ptr_t
}
// An IndexConstraint describes virtual table indexing constraint information.
@@ -309,14 +309,14 @@ type IndexConstraintUsage struct {
func (idx *IndexInfo) RHSValue(column int) (Value, error) {
defer idx.c.arena.mark()()
valPtr := idx.c.arena.new(ptrlen)
- r := idx.c.call("sqlite3_vtab_rhs_value", uint64(idx.handle),
- uint64(column), uint64(valPtr))
- if err := idx.c.error(r); err != nil {
+ rc := res_t(idx.c.call("sqlite3_vtab_rhs_value", stk_t(idx.handle),
+ stk_t(column), stk_t(valPtr)))
+ if err := idx.c.error(rc); err != nil {
return Value{}, err
}
return Value{
c: idx.c,
- handle: util.ReadUint32(idx.c.mod, valPtr),
+ handle: util.Read32[ptr_t](idx.c.mod, valPtr),
}, nil
}
@@ -324,26 +324,26 @@ func (idx *IndexInfo) RHSValue(column int) (Value, error) {
//
// https://sqlite.org/c3ref/vtab_collation.html
func (idx *IndexInfo) Collation(column int) string {
- r := idx.c.call("sqlite3_vtab_collation", uint64(idx.handle),
- uint64(column))
- return util.ReadString(idx.c.mod, uint32(r), _MAX_NAME)
+ ptr := ptr_t(idx.c.call("sqlite3_vtab_collation", stk_t(idx.handle),
+ stk_t(column)))
+ return util.ReadString(idx.c.mod, ptr, _MAX_NAME)
}
// Distinct determines if a virtual table query is DISTINCT.
//
// https://sqlite.org/c3ref/vtab_distinct.html
func (idx *IndexInfo) Distinct() int {
- r := idx.c.call("sqlite3_vtab_distinct", uint64(idx.handle))
- return int(r)
+ i := int32(idx.c.call("sqlite3_vtab_distinct", stk_t(idx.handle)))
+ return int(i)
}
// In identifies and handles IN constraints.
//
// https://sqlite.org/c3ref/vtab_in.html
func (idx *IndexInfo) In(column, handle int) bool {
- r := idx.c.call("sqlite3_vtab_in", uint64(idx.handle),
- uint64(column), uint64(handle))
- return r != 0
+ b := int32(idx.c.call("sqlite3_vtab_in", stk_t(idx.handle),
+ stk_t(column), stk_t(handle)))
+ return b != 0
}
func (idx *IndexInfo) load() {
@@ -351,34 +351,35 @@ func (idx *IndexInfo) load() {
mod := idx.c.mod
ptr := idx.handle
- idx.Constraint = make([]IndexConstraint, util.ReadUint32(mod, ptr+0))
- idx.ConstraintUsage = make([]IndexConstraintUsage, util.ReadUint32(mod, ptr+0))
- idx.OrderBy = make([]IndexOrderBy, util.ReadUint32(mod, ptr+8))
+ nConstraint := util.Read32[int32](mod, ptr+0)
+ idx.Constraint = make([]IndexConstraint, nConstraint)
+ idx.ConstraintUsage = make([]IndexConstraintUsage, nConstraint)
+ idx.OrderBy = make([]IndexOrderBy, util.Read32[int32](mod, ptr+8))
- constraintPtr := util.ReadUint32(mod, ptr+4)
+ constraintPtr := util.Read32[ptr_t](mod, ptr+4)
constraint := idx.Constraint
for i := range idx.Constraint {
constraint[i] = IndexConstraint{
- Column: int(int32(util.ReadUint32(mod, constraintPtr+0))),
- Op: IndexConstraintOp(util.ReadUint8(mod, constraintPtr+4)),
- Usable: util.ReadUint8(mod, constraintPtr+5) != 0,
+ Column: int(util.Read32[int32](mod, constraintPtr+0)),
+ Op: util.Read[IndexConstraintOp](mod, constraintPtr+4),
+ Usable: util.Read[byte](mod, constraintPtr+5) != 0,
}
constraintPtr += 12
}
- orderByPtr := util.ReadUint32(mod, ptr+12)
+ orderByPtr := util.Read32[ptr_t](mod, ptr+12)
orderBy := idx.OrderBy
for i := range orderBy {
orderBy[i] = IndexOrderBy{
- Column: int(int32(util.ReadUint32(mod, orderByPtr+0))),
- Desc: util.ReadUint8(mod, orderByPtr+4) != 0,
+ Column: int(util.Read32[int32](mod, orderByPtr+0)),
+ Desc: util.Read[byte](mod, orderByPtr+4) != 0,
}
orderByPtr += 8
}
idx.EstimatedCost = util.ReadFloat64(mod, ptr+40)
- idx.EstimatedRows = int64(util.ReadUint64(mod, ptr+48))
- idx.ColumnsUsed = int64(util.ReadUint64(mod, ptr+64))
+ idx.EstimatedRows = util.Read64[int64](mod, ptr+48)
+ idx.ColumnsUsed = util.Read64[uint64](mod, ptr+64)
}
func (idx *IndexInfo) save() {
@@ -386,26 +387,26 @@ func (idx *IndexInfo) save() {
mod := idx.c.mod
ptr := idx.handle
- usagePtr := util.ReadUint32(mod, ptr+16)
+ usagePtr := util.Read32[ptr_t](mod, ptr+16)
for _, usage := range idx.ConstraintUsage {
- util.WriteUint32(mod, usagePtr+0, uint32(usage.ArgvIndex))
+ util.Write32(mod, usagePtr+0, int32(usage.ArgvIndex))
if usage.Omit {
- util.WriteUint8(mod, usagePtr+4, 1)
+ util.Write(mod, usagePtr+4, int8(1))
}
usagePtr += 8
}
- util.WriteUint32(mod, ptr+20, uint32(idx.IdxNum))
+ util.Write32(mod, ptr+20, int32(idx.IdxNum))
if idx.IdxStr != "" {
- util.WriteUint32(mod, ptr+24, idx.c.newString(idx.IdxStr))
- util.WriteUint32(mod, ptr+28, 1) // needToFreeIdxStr
+ util.Write32(mod, ptr+24, idx.c.newString(idx.IdxStr))
+ util.Write32(mod, ptr+28, int32(1)) // needToFreeIdxStr
}
if idx.OrderByConsumed {
- util.WriteUint32(mod, ptr+32, 1)
+ util.Write32(mod, ptr+32, int32(1))
}
util.WriteFloat64(mod, ptr+40, idx.EstimatedCost)
- util.WriteUint64(mod, ptr+48, uint64(idx.EstimatedRows))
- util.WriteUint32(mod, ptr+56, uint32(idx.IdxFlags))
+ util.Write64(mod, ptr+48, idx.EstimatedRows)
+ util.Write32(mod, ptr+56, idx.IdxFlags)
}
// IndexConstraintOp is a virtual table constraint operator code.
@@ -442,42 +443,39 @@ const (
INDEX_SCAN_UNIQUE IndexScanFlag = 1
)
-func vtabModuleCallback(i vtabConstructor) func(_ context.Context, _ api.Module, _, _, _, _, _ uint32) uint32 {
- return func(ctx context.Context, mod api.Module, pMod, nArg, pArg, ppVTab, pzErr uint32) uint32 {
+func vtabModuleCallback(i vtabConstructor) func(_ context.Context, _ api.Module, _ ptr_t, _ int32, _, _, _ ptr_t) res_t {
+ return func(ctx context.Context, mod api.Module, pMod ptr_t, nArg int32, pArg, ppVTab, pzErr ptr_t) res_t {
arg := make([]reflect.Value, 1+nArg)
arg[0] = reflect.ValueOf(ctx.Value(connKey{}))
- for i := uint32(0); i < nArg; i++ {
- ptr := util.ReadUint32(mod, pArg+i*ptrlen)
+ for i := range nArg {
+ ptr := util.Read32[ptr_t](mod, pArg+ptr_t(i)*ptrlen)
arg[i+1] = reflect.ValueOf(util.ReadString(mod, ptr, _MAX_SQL_LENGTH))
}
module := vtabGetHandle(ctx, mod, pMod)
- res := reflect.ValueOf(module).Index(int(i)).Call(arg)
- err, _ := res[1].Interface().(error)
+ val := reflect.ValueOf(module).Index(int(i)).Call(arg)
+ err, _ := val[1].Interface().(error)
if err == nil {
- vtabPutHandle(ctx, mod, ppVTab, res[0].Interface())
+ vtabPutHandle(ctx, mod, ppVTab, val[0].Interface())
}
return vtabError(ctx, mod, pzErr, _PTR_ERROR, err)
}
}
-func vtabDisconnectCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+func vtabDisconnectCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
err := vtabDelHandle(ctx, mod, pVTab)
return vtabError(ctx, mod, 0, _PTR_ERROR, err)
}
-func vtabDestroyCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+func vtabDestroyCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabDestroyer)
- err := vtab.Destroy()
- if cerr := vtabDelHandle(ctx, mod, pVTab); err == nil {
- err = cerr
- }
+ err := errors.Join(vtab.Destroy(), vtabDelHandle(ctx, mod, pVTab))
return vtabError(ctx, mod, 0, _PTR_ERROR, err)
}
-func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo uint32) uint32 {
+func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo ptr_t) res_t {
var info IndexInfo
info.handle = pIdxInfo
info.c = ctx.Value(connKey{}).(*Conn)
@@ -490,7 +488,7 @@ func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab, nArg, pArg, pRowID uint32) uint32 {
+func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab ptr_t, nArg int32, pArg, pRowID ptr_t) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabUpdater)
db := ctx.Value(connKey{}).(*Conn)
@@ -498,33 +496,33 @@ func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab, nArg, pArg,
callbackArgs(db, args, pArg)
rowID, err := vtab.Update(args...)
if err == nil {
- util.WriteUint64(mod, pRowID, uint64(rowID))
+ util.Write64(mod, pRowID, rowID)
}
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func vtabRenameCallback(ctx context.Context, mod api.Module, pVTab, zNew uint32) uint32 {
+func vtabRenameCallback(ctx context.Context, mod api.Module, pVTab, zNew ptr_t) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabRenamer)
err := vtab.Rename(util.ReadString(mod, zNew, _MAX_NAME))
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func vtabFindFuncCallback(ctx context.Context, mod api.Module, pVTab uint32, nArg int32, zName, pxFunc uint32) uint32 {
+func vtabFindFuncCallback(ctx context.Context, mod api.Module, pVTab ptr_t, nArg int32, zName, pxFunc ptr_t) int32 {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabOverloader)
f, op := vtab.FindFunction(int(nArg), util.ReadString(mod, zName, _MAX_NAME))
if op != 0 {
- var wrapper uint32
+ var wrapper ptr_t
wrapper = util.AddHandle(ctx, func(c Context, arg ...Value) {
defer util.DelHandle(ctx, wrapper)
f(c, arg...)
})
- util.WriteUint32(mod, pxFunc, wrapper)
+ util.Write32(mod, pxFunc, wrapper)
}
- return uint32(op)
+ return int32(op)
}
-func vtabIntegrityCallback(ctx context.Context, mod api.Module, pVTab, zSchema, zTabName, mFlags, pzErr uint32) uint32 {
+func vtabIntegrityCallback(ctx context.Context, mod api.Module, pVTab, zSchema, zTabName ptr_t, mFlags uint32, pzErr ptr_t) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabChecker)
schema := util.ReadString(mod, zSchema, _MAX_NAME)
table := util.ReadString(mod, zTabName, _MAX_NAME)
@@ -536,49 +534,49 @@ func vtabIntegrityCallback(ctx context.Context, mod api.Module, pVTab, zSchema,
return code
}
-func vtabBeginCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+func vtabBeginCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
err := vtab.Begin()
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func vtabSyncCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+func vtabSyncCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
err := vtab.Sync()
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func vtabCommitCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+func vtabCommitCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
err := vtab.Commit()
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func vtabRollbackCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
+func vtabRollbackCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
err := vtab.Rollback()
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func vtabSavepointCallback(ctx context.Context, mod api.Module, pVTab uint32, id int32) uint32 {
+func vtabSavepointCallback(ctx context.Context, mod api.Module, pVTab ptr_t, id int32) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer)
err := vtab.Savepoint(int(id))
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func vtabReleaseCallback(ctx context.Context, mod api.Module, pVTab uint32, id int32) uint32 {
+func vtabReleaseCallback(ctx context.Context, mod api.Module, pVTab ptr_t, id int32) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer)
err := vtab.Release(int(id))
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func vtabRollbackToCallback(ctx context.Context, mod api.Module, pVTab uint32, id int32) uint32 {
+func vtabRollbackToCallback(ctx context.Context, mod api.Module, pVTab ptr_t, id int32) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer)
err := vtab.RollbackTo(int(id))
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func cursorOpenCallback(ctx context.Context, mod api.Module, pVTab, ppCur uint32) uint32 {
+func cursorOpenCallback(ctx context.Context, mod api.Module, pVTab, ppCur ptr_t) res_t {
vtab := vtabGetHandle(ctx, mod, pVTab).(VTab)
cursor, err := vtab.Open()
@@ -589,12 +587,12 @@ func cursorOpenCallback(ctx context.Context, mod api.Module, pVTab, ppCur uint32
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
}
-func cursorCloseCallback(ctx context.Context, mod api.Module, pCur uint32) uint32 {
+func cursorCloseCallback(ctx context.Context, mod api.Module, pCur ptr_t) res_t {
err := vtabDelHandle(ctx, mod, pCur)
return vtabError(ctx, mod, 0, _VTAB_ERROR, err)
}
-func cursorFilterCallback(ctx context.Context, mod api.Module, pCur uint32, idxNum int32, idxStr, nArg, pArg uint32) uint32 {
+func cursorFilterCallback(ctx context.Context, mod api.Module, pCur ptr_t, idxNum int32, idxStr ptr_t, nArg int32, pArg ptr_t) res_t {
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
db := ctx.Value(connKey{}).(*Conn)
args := make([]Value, nArg)
@@ -607,7 +605,7 @@ func cursorFilterCallback(ctx context.Context, mod api.Module, pCur uint32, idxN
return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
}
-func cursorEOFCallback(ctx context.Context, mod api.Module, pCur uint32) uint32 {
+func cursorEOFCallback(ctx context.Context, mod api.Module, pCur ptr_t) int32 {
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
if cursor.EOF() {
return 1
@@ -615,25 +613,25 @@ func cursorEOFCallback(ctx context.Context, mod api.Module, pCur uint32) uint32
return 0
}
-func cursorNextCallback(ctx context.Context, mod api.Module, pCur uint32) uint32 {
+func cursorNextCallback(ctx context.Context, mod api.Module, pCur ptr_t) res_t {
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
err := cursor.Next()
return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
}
-func cursorColumnCallback(ctx context.Context, mod api.Module, pCur, pCtx uint32, n int32) uint32 {
+func cursorColumnCallback(ctx context.Context, mod api.Module, pCur, pCtx ptr_t, n int32) res_t {
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
db := ctx.Value(connKey{}).(*Conn)
err := cursor.Column(Context{db, pCtx}, int(n))
return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
}
-func cursorRowIDCallback(ctx context.Context, mod api.Module, pCur, pRowID uint32) uint32 {
+func cursorRowIDCallback(ctx context.Context, mod api.Module, pCur, pRowID ptr_t) res_t {
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
rowID, err := cursor.RowID()
if err == nil {
- util.WriteUint64(mod, pRowID, uint64(rowID))
+ util.Write64(mod, pRowID, rowID)
}
return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
@@ -645,7 +643,7 @@ const (
_CURSOR_ERROR
)
-func vtabError(ctx context.Context, mod api.Module, ptr, kind uint32, err error) uint32 {
+func vtabError(ctx context.Context, mod api.Module, ptr ptr_t, kind uint32, err error) res_t {
const zErrMsgOffset = 8
msg, code := errorCode(err, ERROR)
if msg != "" && ptr != 0 {
@@ -653,32 +651,32 @@ func vtabError(ctx context.Context, mod api.Module, ptr, kind uint32, err error)
case _VTAB_ERROR:
ptr = ptr + zErrMsgOffset // zErrMsg
case _CURSOR_ERROR:
- ptr = util.ReadUint32(mod, ptr) + zErrMsgOffset // pVTab->zErrMsg
+ ptr = util.Read32[ptr_t](mod, ptr) + zErrMsgOffset // pVTab->zErrMsg
}
db := ctx.Value(connKey{}).(*Conn)
- if ptr := util.ReadUint32(mod, ptr); ptr != 0 {
+ if ptr := util.Read32[ptr_t](mod, ptr); ptr != 0 {
db.free(ptr)
}
- util.WriteUint32(mod, ptr, db.newString(msg))
+ util.Write32(mod, ptr, db.newString(msg))
}
return code
}
-func vtabGetHandle(ctx context.Context, mod api.Module, ptr uint32) any {
+func vtabGetHandle(ctx context.Context, mod api.Module, ptr ptr_t) any {
const handleOffset = 4
- handle := util.ReadUint32(mod, ptr-handleOffset)
+ handle := util.Read32[ptr_t](mod, ptr-handleOffset)
return util.GetHandle(ctx, handle)
}
-func vtabDelHandle(ctx context.Context, mod api.Module, ptr uint32) error {
+func vtabDelHandle(ctx context.Context, mod api.Module, ptr ptr_t) error {
const handleOffset = 4
- handle := util.ReadUint32(mod, ptr-handleOffset)
+ handle := util.Read32[ptr_t](mod, ptr-handleOffset)
return util.DelHandle(ctx, handle)
}
-func vtabPutHandle(ctx context.Context, mod api.Module, pptr uint32, val any) {
+func vtabPutHandle(ctx context.Context, mod api.Module, pptr ptr_t, val any) {
const handleOffset = 4
handle := util.AddHandle(ctx, val)
- ptr := util.ReadUint32(mod, pptr)
- util.WriteUint32(mod, ptr-handleOffset, handle)
+ ptr := util.Read32[ptr_t](mod, pptr)
+ util.Write32(mod, ptr-handleOffset, handle)
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 05:39:44 +0000