typenative 0.1.2 → 0.2.0

package/govendor/github.com/ncruces/go-sqlite3/wrap.go

@@ -0,0 +1,48 @@
+// Package sqlite3 wraps the C SQLite API.
+package sqlite3
+
+import (
+	"context"
+	"math/bits"
+
+	sqlite3_wasm "github.com/ncruces/go-sqlite3-wasm/v6"
+	"github.com/ncruces/go-sqlite3/internal/errutil"
+	"github.com/ncruces/go-sqlite3/internal/sqlite3_wrap"
+	"github.com/ncruces/go-sqlite3/vfs"
+)
+
+type configKey struct{}
+
+// WithMaxMemory returns a derived context that configures
+// each SQLite connection not to use more than max amount of memory.
+func WithMaxMemory(ctx context.Context, max int64) context.Context {
+	if max < 0 || max > 65536*65536 {
+		panic(errutil.OOMErr)
+	}
+	return context.WithValue(ctx, configKey{}, max/65536)
+}
+
+type env struct{ *sqlite3_wrap.Wrapper }
+
+func createWrapper(ctx context.Context) (*sqlite3_wrap.Wrapper, error) {
+	mem := &sqlite3_wrap.Memory{Max: 4096} // 256MB
+	if bits.UintSize < 64 {
+		mem.Max = 512 // 32MB
+	}
+	if cfg, ok := ctx.Value(configKey{}).(int64); ok {
+		mem.Max = max(cfg, int64(len(mem.Buf))/65536)
+	}
+	mem.Grow(5 /*320KB*/, mem.Max)
+
+	env := env{&sqlite3_wrap.Wrapper{Memory: mem}}
+	env.Module = sqlite3_wasm.New(env)
+	env.X_initialize()
+	return env.Wrapper, nil
+}
+
+func (e env) Xgo_vfs_find(zVfsName int32) int32 {
+	if vfs.Find(e.ReadString(ptr_t(zVfsName), _MAX_NAME)) != nil {
+		return 1
+	}
+	return 0
+}

package/govendor/github.com/ncruces/go-sqlite3-wasm/v6/LICENSE

@@ -0,0 +1,18 @@
+MIT No Attribution License
+
+Copyright (c) 2026 Nuno Cruces
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/govendor/github.com/ncruces/go-sqlite3-wasm/v6/README.md

@@ -0,0 +1,11 @@
+# Go SQLite translation
+
+This repo contains a Go translation of SQLite (and other supporting libraries)
+for use with [`github.com/ncruces/go-sqlite3`](https://github.com/ncruces/go-sqlite3).
+
+Most of the code here is machine translated using
+[`wasm2go`](https://github.com/ncruces/wasm2go).
+As such, the original authors retain copyright
+and the original licenses remain in effect.
+
+Everything else is licensed under [MIT-0](LICENSE).

package/govendor/github.com/ncruces/go-sqlite3-wasm/v6/go.mod

@@ -0,0 +1,3 @@
+module github.com/ncruces/go-sqlite3-wasm/v6
+
+go 1.26.0

package/govendor/github.com/ncruces/go-sqlite3-wasm/v6/libc.go

@@ -0,0 +1,215 @@
+// Code generated by libc-gen. DO NOT EDIT.
+
+package sqlite3_wasm
+
+import (
+	"bytes"
+	"math"
+	"math/bits"
+	"strconv"
+	"time"
+	"unsafe"
+)
+
+func (m *Module) _acos(x float64) float64     { return math.Acos(x) }
+func (m *Module) _acosh(x float64) float64    { return math.Acosh(x) }
+func (m *Module) _asin(x float64) float64     { return math.Asin(x) }
+func (m *Module) _asinh(x float64) float64    { return math.Asinh(x) }
+func (m *Module) _atan(x float64) float64     { return math.Atan(x) }
+func (m *Module) _atan2(y, x float64) float64 { return math.Atan2(y, x) }
+func (m *Module) _atanh(x float64) float64    { return math.Atanh(x) }
+
+func (m *Module) _cos(x float64) float64  { return math.Cos(x) }
+func (m *Module) _cosh(x float64) float64 { return math.Cosh(x) }
+
+func (m *Module) _exp(x float64) float64 { return math.Exp(x) }
+
+func (m *Module) _fmod(x, y float64) float64 { return math.Mod(x, y) }
+func (m *Module) _localtime_r(timer, buf int32) int32 {
+	t := load64((*m.memory), uint32(timer))
+	m._storetime_r((*m.memory)[uint32(buf):], time.Unix(int64(t), 0))
+	return buf
+}
+
+func (m *Module) _log(x float64) float64   { return math.Log(x) }
+func (m *Module) _log10(x float64) float64 { return math.Log10(x) }
+
+func (m *Module) _log2(x float64) float64 { return math.Log2(x) }
+func (m *Module) _memchr(s int32, c int32, n int32) int32 {
+	b := (*m.memory)[uint32(s):]
+	if uint(len(b)) > uint(uint32(n)) {
+		b = b[:uint32(n)]
+	}
+	if i := bytes.IndexByte(b, byte(c)); i >= 0 {
+		return s + int32(i)
+	}
+	return 0
+}
+
+func (m *Module) _memcmp(s1, s2, n int32) int32 {
+	if s1 == s2 {
+		return 0
+	}
+	e1, e2 := s1+n, s2+n
+	b1 := (*m.memory)[uint32(s1):uint32(e1)]
+	b2 := (*m.memory)[uint32(s2):uint32(e2)]
+	return int32(bytes.Compare(b1, b2))
+}
+func (m *Module) _pow(x, y float64) float64 { return math.Pow(x, y) }
+
+func (m *Module) _sin(x float64) float64  { return math.Sin(x) }
+func (m *Module) _sinh(x float64) float64 { return math.Sinh(x) }
+
+func (m *Module) _strchr(s int32, c int32) int32 {
+	s = m._strchrnul(s, c)
+	if (*m.memory)[uint32(s)] == byte(c) {
+		return s
+	}
+	return 0
+}
+
+func (m *Module) _strchrnul(s int32, c int32) int32 {
+	b := (*m.memory)[uint32(s):]
+	b = b[:bytes.IndexByte(b, 0)]
+	sz := len(b)
+	if c := byte(c); c != 0 {
+		if i := bytes.IndexByte(b, c); i >= 0 {
+			sz = i
+		}
+	}
+	return s + int32(sz)
+}
+
+func (m *Module) _strcmp(s1, s2 int32) int32 {
+	if s1 == s2 {
+		return 0
+	}
+	b1 := (*m.memory)[uint32(s1):]
+	b2 := (*m.memory)[uint32(s2):]
+	sz := min(len(b1), len(b2))
+	if i := bytes.IndexByte(b2[:sz], 0); i >= 0 {
+		sz = i + 1
+	}
+	return int32(bytes.Compare(b1[:sz], b2[:sz]))
+}
+
+func (m *Module) _strcspn(s, reject int32) int32 {
+	b := (*m.memory)[uint32(s):]
+	r := (*m.memory)[uint32(reject):]
+	r = r[:bytes.IndexByte(r, 0)+1]
+
+	set := m._makeByteSet(r)
+	for i, c := range b {
+		if set[c/bits.UintSize]&(1<<(c%bits.UintSize)) != 0 {
+			return int32(i)
+		}
+	}
+	return int32(len(b))
+}
+func (m *Module) _strlen(s int32) int32 {
+	return int32(bytes.IndexByte((*m.memory)[uint32(s):], 0))
+}
+
+func (m *Module) _strncmp(s1, s2, n int32) int32 {
+	if s1 == s2 {
+		return 0
+	}
+	b1 := (*m.memory)[uint32(s1):]
+	b2 := (*m.memory)[uint32(s2):]
+	sz := int(min(uint(len(b1)), uint(len(b2)), uint(uint32(n))))
+	if i := bytes.IndexByte(b2[:sz], 0); i >= 0 {
+		sz = i + 1
+	}
+	return int32(bytes.Compare(b1[:sz], b2[:sz]))
+}
+func (m *Module) _strrchr(s int32, c int32) int32 {
+	b := (*m.memory)[uint32(s):]
+	b = b[:bytes.IndexByte(b, 0)+1]
+	if i := bytes.LastIndexByte(b, byte(c)); i >= 0 {
+		return s + int32(i)
+	}
+	return 0
+}
+
+func (m *Module) _strspn(s, accept int32) int32 {
+	b := (*m.memory)[uint32(s):]
+	a := (*m.memory)[uint32(accept):]
+	a = a[:bytes.IndexByte(a, 0)]
+
+	set := m._makeByteSet(a)
+	for i, c := range b {
+		if set[c/bits.UintSize]&(1<<(c%bits.UintSize)) == 0 {
+			return int32(i)
+		}
+	}
+	return int32(len(b))
+}
+func (m *Module) _strstr(haystack, needle int32) int32 {
+	h := (*m.memory)[uint32(haystack):]
+	n := (*m.memory)[uint32(needle):]
+	h = h[:bytes.IndexByte(h, 0)]
+	n = n[:bytes.IndexByte(n, 0)]
+	i := bytes.Index(h, n)
+	if i < 0 {
+		return 0
+	}
+	return haystack + int32(i)
+}
+func (m *Module) _strtol(s, endptr int32, base int32) int32 {
+	return int32(m._strtoll_helper(s, endptr, base, 32))
+}
+
+func (m *Module) _tan(x float64) float64  { return math.Tan(x) }
+func (m *Module) _tanh(x float64) float64 { return math.Tanh(x) }
+func (m *Module) _storetime_r(buf []byte, t time.Time) {
+	const size uint32 = 32 / 8
+	var isdst uint32
+	if t.IsDST() {
+		isdst = 1
+	}
+	_, zone := t.Zone()
+
+	store32(buf, 0*size, uint32(t.Second()))
+	store32(buf, 1*size, uint32(t.Minute()))
+	store32(buf, 2*size, uint32(t.Hour()))
+	store32(buf, 3*size, uint32(t.Day()))
+	store32(buf, 4*size, uint32(t.Month()-time.January))
+	store32(buf, 5*size, uint32(t.Year()-1900))
+	store32(buf, 6*size, uint32(t.Weekday()-time.Sunday))
+	store32(buf, 7*size, uint32(t.YearDay()-1))
+	store32(buf, 8*size, isdst)
+	store32(buf, 9*size, uint32(zone))
+	store32(buf, 10*size, 0)
+}
+
+func (m *Module) _makeByteSet(chars []byte) (set [256 / bits.UintSize]uint) {
+	for _, c := range chars {
+		set[c/bits.UintSize] |= 1 << (c % bits.UintSize)
+	}
+	return set
+}
+func (m *Module) _strtoll_helper(s, endptr int32, base int32, bitSize int) int64 {
+	m0 := (*m.memory)[uint32(s):]
+	m1 := bytes.TrimLeft(m0, " \t\n\v\f\r")
+	m2 := bytes.TrimLeft(m1, "+-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+	prefix := len(m0) - len(m1)
+	digits := len(m1) - len(m2)
+
+	var val int64
+	for ; digits > 0; digits-- {
+		var err error
+		str := unsafe.String(&m1[0], digits)
+		val, err = strconv.ParseInt(str, int(base), bitSize)
+		if e, ok := err.(*strconv.NumError); !ok || e.Err == strconv.ErrRange {
+			break
+		}
+	}
+
+	if endptr != 0 {
+		if digits > 0 {
+			s += int32(prefix + digits)
+		}
+		store32((*m.memory), uint32(endptr), uint32(s))
+	}
+	return val
+}