slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/ebitengine/purego/internal/fakecgo/symbols.go

@@ -19,6 +19,7 @@ func setg_trampoline(setg uintptr, G uintptr)
 func call5(fn, a1, a2, a3, a4, a5 uintptr) uintptr
 
 //go:nosplit
+//go:norace
 func malloc(size uintptr) unsafe.Pointer {
 	ret := call5(mallocABI0, uintptr(size), 0, 0, 0, 0)
 	// this indirection is to avoid go vet complaining about possible misuse of unsafe.Pointer
@@ -26,176 +27,195 @@ func malloc(size uintptr) unsafe.Pointer {
 }
 
 //go:nosplit
+//go:norace
 func free(ptr unsafe.Pointer) {
 	call5(freeABI0, uintptr(ptr), 0, 0, 0, 0)
 }
 
 //go:nosplit
+//go:norace
 func setenv(name *byte, value *byte, overwrite int32) int32 {
 	return int32(call5(setenvABI0, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)), uintptr(overwrite), 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func unsetenv(name *byte) int32 {
 	return int32(call5(unsetenvABI0, uintptr(unsafe.Pointer(name)), 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func sigfillset(set *sigset_t) int32 {
 	return int32(call5(sigfillsetABI0, uintptr(unsafe.Pointer(set)), 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func nanosleep(ts *syscall.Timespec, rem *syscall.Timespec) int32 {
 	return int32(call5(nanosleepABI0, uintptr(unsafe.Pointer(ts)), uintptr(unsafe.Pointer(rem)), 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func abort() {
 	call5(abortABI0, 0, 0, 0, 0, 0)
 }
 
 //go:nosplit
+//go:norace
 func pthread_attr_init(attr *pthread_attr_t) int32 {
 	return int32(call5(pthread_attr_initABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_create(thread *pthread_t, attr *pthread_attr_t, start unsafe.Pointer, arg unsafe.Pointer) int32 {
 	return int32(call5(pthread_createABI0, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(start), uintptr(arg), 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_detach(thread pthread_t) int32 {
 	return int32(call5(pthread_detachABI0, uintptr(thread), 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_sigmask(how sighow, ign *sigset_t, oset *sigset_t) int32 {
 	return int32(call5(pthread_sigmaskABI0, uintptr(how), uintptr(unsafe.Pointer(ign)), uintptr(unsafe.Pointer(oset)), 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_self() pthread_t {
 	return pthread_t(call5(pthread_selfABI0, 0, 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_get_stacksize_np(thread pthread_t) size_t {
 	return size_t(call5(pthread_get_stacksize_npABI0, uintptr(thread), 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_attr_getstacksize(attr *pthread_attr_t, stacksize *size_t) int32 {
 	return int32(call5(pthread_attr_getstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(stacksize)), 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_attr_setstacksize(attr *pthread_attr_t, size size_t) int32 {
 	return int32(call5(pthread_attr_setstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(size), 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_attr_destroy(attr *pthread_attr_t) int32 {
 	return int32(call5(pthread_attr_destroyABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_mutex_lock(mutex *pthread_mutex_t) int32 {
 	return int32(call5(pthread_mutex_lockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_mutex_unlock(mutex *pthread_mutex_t) int32 {
 	return int32(call5(pthread_mutex_unlockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_cond_broadcast(cond *pthread_cond_t) int32 {
 	return int32(call5(pthread_cond_broadcastABI0, uintptr(unsafe.Pointer(cond)), 0, 0, 0, 0))
 }
 
 //go:nosplit
+//go:norace
 func pthread_setspecific(key pthread_key_t, value unsafe.Pointer) int32 {
 	return int32(call5(pthread_setspecificABI0, uintptr(key), uintptr(value), 0, 0, 0))
 }
 
 //go:linkname _malloc _malloc
-var _malloc uintptr
+var _malloc uint8
 var mallocABI0 = uintptr(unsafe.Pointer(&_malloc))
 
 //go:linkname _free _free
-var _free uintptr
+var _free uint8
 var freeABI0 = uintptr(unsafe.Pointer(&_free))
 
 //go:linkname _setenv _setenv
-var _setenv uintptr
+var _setenv uint8
 var setenvABI0 = uintptr(unsafe.Pointer(&_setenv))
 
 //go:linkname _unsetenv _unsetenv
-var _unsetenv uintptr
+var _unsetenv uint8
 var unsetenvABI0 = uintptr(unsafe.Pointer(&_unsetenv))
 
 //go:linkname _sigfillset _sigfillset
-var _sigfillset uintptr
+var _sigfillset uint8
 var sigfillsetABI0 = uintptr(unsafe.Pointer(&_sigfillset))
 
 //go:linkname _nanosleep _nanosleep
-var _nanosleep uintptr
+var _nanosleep uint8
 var nanosleepABI0 = uintptr(unsafe.Pointer(&_nanosleep))
 
 //go:linkname _abort _abort
-var _abort uintptr
+var _abort uint8
 var abortABI0 = uintptr(unsafe.Pointer(&_abort))
 
 //go:linkname _pthread_attr_init _pthread_attr_init
-var _pthread_attr_init uintptr
+var _pthread_attr_init uint8
 var pthread_attr_initABI0 = uintptr(unsafe.Pointer(&_pthread_attr_init))
 
 //go:linkname _pthread_create _pthread_create
-var _pthread_create uintptr
+var _pthread_create uint8
 var pthread_createABI0 = uintptr(unsafe.Pointer(&_pthread_create))
 
 //go:linkname _pthread_detach _pthread_detach
-var _pthread_detach uintptr
+var _pthread_detach uint8
 var pthread_detachABI0 = uintptr(unsafe.Pointer(&_pthread_detach))
 
 //go:linkname _pthread_sigmask _pthread_sigmask
-var _pthread_sigmask uintptr
+var _pthread_sigmask uint8
 var pthread_sigmaskABI0 = uintptr(unsafe.Pointer(&_pthread_sigmask))
 
 //go:linkname _pthread_self _pthread_self
-var _pthread_self uintptr
+var _pthread_self uint8
 var pthread_selfABI0 = uintptr(unsafe.Pointer(&_pthread_self))
 
 //go:linkname _pthread_get_stacksize_np _pthread_get_stacksize_np
-var _pthread_get_stacksize_np uintptr
+var _pthread_get_stacksize_np uint8
 var pthread_get_stacksize_npABI0 = uintptr(unsafe.Pointer(&_pthread_get_stacksize_np))
 
 //go:linkname _pthread_attr_getstacksize _pthread_attr_getstacksize
-var _pthread_attr_getstacksize uintptr
+var _pthread_attr_getstacksize uint8
 var pthread_attr_getstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_getstacksize))
 
 //go:linkname _pthread_attr_setstacksize _pthread_attr_setstacksize
-var _pthread_attr_setstacksize uintptr
+var _pthread_attr_setstacksize uint8
 var pthread_attr_setstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_setstacksize))
 
 //go:linkname _pthread_attr_destroy _pthread_attr_destroy
-var _pthread_attr_destroy uintptr
+var _pthread_attr_destroy uint8
 var pthread_attr_destroyABI0 = uintptr(unsafe.Pointer(&_pthread_attr_destroy))
 
 //go:linkname _pthread_mutex_lock _pthread_mutex_lock
-var _pthread_mutex_lock uintptr
+var _pthread_mutex_lock uint8
 var pthread_mutex_lockABI0 = uintptr(unsafe.Pointer(&_pthread_mutex_lock))
 
 //go:linkname _pthread_mutex_unlock _pthread_mutex_unlock
-var _pthread_mutex_unlock uintptr
+var _pthread_mutex_unlock uint8
 var pthread_mutex_unlockABI0 = uintptr(unsafe.Pointer(&_pthread_mutex_unlock))
 
 //go:linkname _pthread_cond_broadcast _pthread_cond_broadcast
-var _pthread_cond_broadcast uintptr
+var _pthread_cond_broadcast uint8
 var pthread_cond_broadcastABI0 = uintptr(unsafe.Pointer(&_pthread_cond_broadcast))
 
 //go:linkname _pthread_setspecific _pthread_setspecific
-var _pthread_setspecific uintptr
+var _pthread_setspecific uint8
 var pthread_setspecificABI0 = uintptr(unsafe.Pointer(&_pthread_setspecific))

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.1] - 2025-05-12
+
+### Fixed
+- The dependency `github.com/ebitengine/purego` had to be upgraded to version 0.8.3 due to a [bug](https://github.com/golang/go/issues/73617) in Go 1.23.9 and 1.24.3.
+
+## [0.4.0] - 2025-03-13
+
+### Changed
+- `Fun.Call` panics now, if the number of arguments doesn't match the prepared Cif.
+
 ## [0.3.0] - 2025-01-18
 
 ### Added
@@ -12,7 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     - `func ClosureAlloc(size uintptr, code *unsafe.Pointer) *Closure`
     - `func ClosureFree(writable *Closure)`
     - `func PrepClosureLoc(closure *Closure, cif *Cif, fun uintptr, userData, codeLoc unsafe.Pointer) Status`
-- The new types `Fun` and `Lib` can reduce boilerplate and eliminate platform dependant code:
+- The new types `Fun` and `Lib` can reduce boilerplate and eliminate platform-dependent code:
     - `func (f Fun) Call(ret any, args ...any)`
     - `func Load(name string) (l Lib, err error)`
     - `func (l Lib) Close() error`
@@ -49,6 +59,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Dependencies `github.com/ebitengine/purego` and `golang.org/x/sys` updated.
 
+[0.4.1]: https://github.com/JupiterRider/ffi/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/JupiterRider/ffi/compare/v0.3.0...v0.4.0
+[0.3.0]: https://github.com/JupiterRider/ffi/compare/v0.2.2...v0.3.0
 [0.3.0]: https://github.com/JupiterRider/ffi/compare/v0.2.2...v0.3.0
 [0.2.2]: https://github.com/JupiterRider/ffi/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/JupiterRider/ffi/compare/v0.2.0...v0.2.1

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/ffi.go

@@ -141,7 +141,7 @@ func NewCallback(fn Callback) uintptr {
 //   - abi is the ABI to use. Normally [DefaultAbi] is what you want.
 //   - nArgs is the number of arguments. Use 0 if the function has none.
 //   - rType is the return type. Use [TypeVoid] if the function has none.
-//   - aTypes are the arguments. Leave empty or provide nil if the function has none.
+//   - aTypes are the arguments. Leave empty if the function has none.
 //
 // The returned status code will be [OK], if everything worked properly.
 //
@@ -220,7 +220,7 @@ func PrepCifVar(cif *Cif, abi Abi, nFixedArgs, nTotalArgs uint32, rType *Type, a
 //   - fn is the address of the desired function. Use [purego.Dlsym] to get one.
 //   - rValue is a pointer to a variable that will hold the result of the function call. Provide nil if the function has no return value.
 //     You cannot use integer types smaller than 8 bytes here (float32 and structs are not affected). Use [Arg] instead and typecast afterwards.
-//   - aValues are pointers to the argument values. Leave empty or provide nil if the function takes none.
+//   - aValues are pointers to the argument values. Leave empty if the function takes none.
 //
 // Example:
 //

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/fun.go

@@ -15,10 +15,11 @@ type Fun struct {
 	Cif  *Cif
 }
 
-// Call calls the function's address according to the description given in Cif.
+// Call calls the function's address according to the description given in [Cif].
 //   - ret is a pointer to a variable that will hold the result of the function call. Provide nil if the function has no return value.
 //     You cannot use integer types smaller than 8 bytes here (float32 and structs are not affected). Use [Arg] instead and typecast afterwards.
-//   - args are pointers to the argument values. Leave empty or provide nil if the function takes none.
+//   - args are pointers to the argument values. Leave empty if the function takes none.
+//     It panics if the number of arguments doesn't match the prepared Cif.
 //
 // Example:
 //
@@ -36,6 +37,13 @@ func (f Fun) Call(ret any, args ...any) {
 	}
 
 	nArgs := len(args)
+
+	if nArgs > int(f.Cif.NArgs) {
+		panic("ffi: calling with too many arguments")
+	} else if nArgs < int(f.Cif.NArgs) {
+		panic("ffi: calling with too few arguments")
+	}
+
 	aV := make([]unsafe.Pointer, nArgs)
 
 	for i := 0; i < nArgs; i++ {

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/lib.go

@@ -14,7 +14,7 @@ type Lib struct {
 // Prep is used to get and describe a library's function.
 //   - name is the name of the function.
 //   - ret is the return type. Use [TypeVoid] if the function has none.
-//   - args are the arguments. Leave empty or provide nil if the function has none.
+//   - args are the arguments. Leave empty if the function has none.
 //
 // For variadic functions use [Lib.PrepVar] instead.
 //

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/lib_unix.go

@@ -24,7 +24,7 @@ import (
 //		filename = "libraylib.dylib"
 //	}
 //
-//	raylib, err := Load(filename)
+//	raylib, err := ffi.Load(filename)
 func Load(name string) (l Lib, err error) {
 	l.Addr, err = purego.Dlopen(name, purego.RTLD_LAZY)
 	return

slidge_whatsapp/vendor/github.com/jupiterrider/ffi/lib_windows.go

@@ -25,7 +25,7 @@ import (
 //		filename = "libraylib.dylib"
 //	}
 //
-//	raylib, err := Load(filename)
+//	raylib, err := ffi.Load(filename)
 func Load(name string) (l Lib, err error) {
 	handle, err := syscall.LoadLibrary(name)
 	if err != nil {

slidge_whatsapp/vendor/github.com/mattn/go-sqlite3/README.md

@@ -35,7 +35,7 @@ This package follows the official [Golang Release Policy](https://golang.org/doc
   - [Android](#android)
 - [ARM](#arm)
 - [Cross Compile](#cross-compile)
-- [Google Cloud Platform](#google-cloud-platform)
+- [Compiling](#compiling)
   - [Linux](#linux)
     - [Alpine](#alpine)
     - [Fedora](#fedora)
@@ -70,7 +70,6 @@ This package can be installed with the `go get` command:
 
 _go-sqlite3_ is *cgo* package.
 If you want to build your app using go-sqlite3, you need gcc.
-However, after you have built and installed _go-sqlite3_ with `go install github.com/mattn/go-sqlite3` (which requires gcc), you can build your app without relying on gcc in future.
 
 ***Important: because this is a `CGO` enabled package, you are required to set the environment variable `CGO_ENABLED=1` and have a `gcc` compiler present within your path.***
 
@@ -228,11 +227,7 @@ Steps:
 
 Please refer to the project's [README](https://github.com/FiloSottile/homebrew-musl-cross#readme) for further information.
 
-# Google Cloud Platform
-
-Building on GCP is not possible because Google Cloud Platform does not allow `gcc` to be executed.
-
-Please work only with compiled final binaries.
+# Compiling
 
 ## Linux
 

slidge_whatsapp/vendor/github.com/mattn/go-sqlite3/callback.go

@@ -345,7 +345,8 @@ func callbackRetText(ctx *C.sqlite3_context, v reflect.Value) error {
 	if v.Type().Kind() != reflect.String {
 		return fmt.Errorf("cannot convert %s to TEXT", v.Type())
 	}
-	C._sqlite3_result_text(ctx, C.CString(v.Interface().(string)))
+	cstr := C.CString(v.Interface().(string))
+	C._sqlite3_result_text(ctx, cstr)
 	return nil
 }