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

slidge_whatsapp/vendor/github.com/beeper/argo-go/wirecodec/decode.go

@@ -0,0 +1,341 @@
+package wirecodec
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math"
+
+	"github.com/beeper/argo-go/block"
+	"github.com/beeper/argo-go/codec"
+	"github.com/beeper/argo-go/header"
+	"github.com/beeper/argo-go/label"
+	"github.com/beeper/argo-go/pkg/buf"
+	"github.com/beeper/argo-go/wire"
+)
+
+type anyBlockReader interface {
+	Read(parent buf.Read) (interface{}, error)
+}
+
+type genericBlockReaderWrapper struct {
+	coreRead        func(parentBuf buf.Read) (interface{}, error)
+	blockDataBuffer buf.Read
+}
+
+func (g *genericBlockReaderWrapper) Read(parentBuf buf.Read) (interface{}, error) {
+	return g.coreRead(parentBuf)
+}
+
+type Decoder struct {
+	r       buf.Read
+	slicer  *codec.MessageSlicer
+	readers map[wire.BlockKey]anyBlockReader
+}
+
+func NewFromSlicer(s *codec.MessageSlicer) *Decoder {
+	return &Decoder{
+		r:       s.Core(),
+		slicer:  s,
+		readers: make(map[wire.BlockKey]anyBlockReader),
+	}
+}
+
+func (d *Decoder) DecodeWireType() (wire.Type, error) {
+	lbl, err := label.Read(d.r)
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	// ---------- scalars ----------
+	case label.WireTypeMarkerString.Is(lbl):
+		return wire.String, nil
+	case label.WireTypeMarkerBoolean.Is(lbl):
+		return wire.Boolean, nil
+	case label.WireTypeMarkerVarint.Is(lbl):
+		return wire.Varint, nil
+	case label.WireTypeMarkerFloat64.Is(lbl):
+		return wire.Float64, nil
+	case label.WireTypeMarkerBytes.Is(lbl):
+		return wire.Bytes, nil
+	case label.WireTypeMarkerFixed.Is(lbl):
+		lengthLbl, err := label.Read(d.r)
+		if err != nil {
+			return nil, err
+		}
+		n := int(lengthLbl.Value().Int64())
+		if n < 0 {
+			return nil, fmt.Errorf("wirecodec: negative FIXED length %d", n)
+		}
+		return wire.FixedType{Length: n}, nil
+
+	// ---------- block ----------
+	case label.WireTypeMarkerBlock.Is(lbl):
+		// Only scalar/desc allowed for block element
+		elem, err := d.decodeScalarWireType()
+		if err != nil {
+			return nil, err
+		}
+		key, err := d.readBlockString()
+		if err != nil {
+			return nil, err
+		}
+		dedupe, err := d.readBlockBool()
+		if err != nil {
+			return nil, err
+		}
+		return wire.NewBlockType(elem, wire.BlockKey(key), dedupe), nil
+
+	// ---------- wrappers ----------
+	case label.WireTypeMarkerNullable.Is(lbl):
+		of, err := d.DecodeWireType()
+		if err != nil {
+			return nil, err
+		}
+		return wire.NewNullableType(of), nil
+
+	case label.WireTypeMarkerArray.Is(lbl):
+		of, err := d.DecodeWireType()
+		if err != nil {
+			return nil, err
+		}
+		return wire.ArrayType{Of: of}, nil
+
+	// ---------- record ----------
+	case label.WireTypeMarkerRecord.Is(lbl):
+		lenLbl, err := label.Read(d.r)
+		if err != nil {
+			return nil, err
+		}
+		n := int(lenLbl.Value().Int64())
+		if n < 0 {
+			return nil, fmt.Errorf("wirecodec: negative record-field count %d", n)
+		}
+		return d.decodeRecord(n)
+
+	// ---------- simple markers ----------
+	case label.WireTypeMarkerDesc.Is(lbl):
+		return wire.Desc, nil
+	case label.WireTypeMarkerError.Is(lbl):
+		return wire.Error, nil
+	case label.WireTypeMarkerPath.Is(lbl):
+		return wire.Path, nil
+	case label.WireTypeMarkerExtensions.Is(lbl):
+		return wire.Extensions, nil
+	}
+
+	return nil, fmt.Errorf("wirecodec: unknown wire-type label %s", lbl.Value().String())
+}
+
+func (d *Decoder) DecodeWireTypeStore() (map[string]wire.Type, error) {
+	objLbl, err := label.Read(d.r)
+	if err != nil {
+		return nil, err
+	}
+	if !wire.SelfDescribingTypeMarkerObject.Is(objLbl) {
+		return nil, fmt.Errorf("wirecodec: expected object marker, found %v", objLbl.Value())
+	}
+
+	cntLbl, err := label.Read(d.r)
+	if err != nil {
+		return nil, err
+	}
+	n := int(cntLbl.Value().Int64())
+	if n < 0 {
+		return nil, fmt.Errorf("wirecodec: negative type-store length %d", n)
+	}
+
+	out := make(map[string]wire.Type, n)
+	for i := 0; i < n; i++ {
+		name, err := d.readBlockString()
+		if err != nil {
+			return nil, fmt.Errorf("wirecodec: read store name: %w", err)
+		}
+		wt, err := d.DecodeWireType()
+		if err != nil {
+			return nil, fmt.Errorf("wirecodec: decode type %q: %w", name, err)
+		}
+		out[name] = wt
+	}
+	return out, nil
+}
+
+func (d *Decoder) decodeScalarWireType() (wire.Type, error) {
+	lbl, err := label.Read(d.r)
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	case label.WireTypeMarkerString.Is(lbl):
+		return wire.String, nil
+	case label.WireTypeMarkerBoolean.Is(lbl):
+		return wire.Boolean, nil
+	case label.WireTypeMarkerVarint.Is(lbl):
+		return wire.Varint, nil
+	case label.WireTypeMarkerFloat64.Is(lbl):
+		return wire.Float64, nil
+	case label.WireTypeMarkerBytes.Is(lbl):
+		return wire.Bytes, nil
+	case label.WireTypeMarkerFixed.Is(lbl):
+		lenLbl, err := label.Read(d.r)
+		if err != nil {
+			return nil, err
+		}
+		n := int(lenLbl.Value().Int64())
+		if n < 0 {
+			return nil, fmt.Errorf("wirecodec: negative FIXED length %d", n)
+		}
+		return wire.FixedType{Length: n}, nil
+	case label.WireTypeMarkerDesc.Is(lbl):
+		return wire.Desc, nil
+	}
+	return nil, fmt.Errorf("wirecodec: invalid scalar wire-type label %s", lbl.Value().String())
+}
+
+func (d *Decoder) decodeRecord(length int) (wire.Type, error) {
+	if length < 0 {
+		return nil, fmt.Errorf("wirecodec: negative record-field count %d", length)
+	}
+	fields := make([]wire.Field, 0, length)
+	for i := 0; i < length; i++ {
+		name, err := d.readBlockString()
+		if err != nil {
+			return nil, fmt.Errorf("record field %d name: %w", i, err)
+		}
+		ft, err := d.DecodeWireType()
+		if err != nil {
+			return nil, fmt.Errorf("record field %q type: %w", name, err)
+		}
+		omit, err := d.readBlockBool()
+		if err != nil {
+			return nil, fmt.Errorf("record field %q omittable: %w", name, err)
+		}
+		fields = append(fields, wire.Field{Name: name, Of: ft, Omittable: omit})
+	}
+	return wire.RecordType{Fields: fields}, nil
+}
+
+func (d *Decoder) readBlockString() (string, error) {
+	key := wire.BlockKey("String")
+	elem, ok := wire.SelfDescribingBlocks[key]
+	if !ok {
+		return "", fmt.Errorf("wirecodec: self-describing String block not found")
+	}
+	blk := wire.NewBlockType(elem, key, wire.MustDeduplicateByDefault(elem))
+
+	r, err := d.getBlockReader(blk, wire.String)
+	if err != nil {
+		return "", fmt.Errorf("wirecodec: get String block reader: %w", err)
+	}
+	v, err := r.Read(d.r)
+	if err != nil {
+		return "", fmt.Errorf("wirecodec: read String from block: %w", err)
+	}
+	s, ok := v.(string)
+	if !ok {
+		return "", fmt.Errorf("wirecodec: String block reader returned %T", v)
+	}
+	return s, nil
+}
+
+func (d *Decoder) readBlockBool() (bool, error) {
+	lbl, err := label.Read(d.r)
+	if err != nil {
+		return false, err
+	}
+	switch {
+	case label.FalseMarker.Is(lbl):
+		return false, nil
+	case label.TrueMarker.Is(lbl):
+		return true, nil
+	default:
+		return false, fmt.Errorf("wirecodec: expected boolean marker got %v", lbl.Value())
+	}
+}
+
+func DecodeWireTypeStoreFile(msg []byte) (map[string]wire.Type, error) {
+	slicer, err := codec.NewMessageSlicer(buf.NewBufReadonly(msg))
+	if err != nil {
+		return nil, err
+	}
+	return NewFromSlicer(slicer).DecodeWireTypeStore()
+}
+
+func (d *Decoder) getBlockReader(blockDef wire.BlockType, valueWireType wire.Type) (anyBlockReader, error) {
+	if r, ok := d.readers[blockDef.Key]; ok {
+		return r, nil
+	}
+	r, err := d.makeBlockReader(valueWireType, blockDef.Dedupe, blockDef.Key)
+	if err != nil {
+		return nil, err
+	}
+	d.readers[blockDef.Key] = r
+	return r, nil
+}
+
+func (d *Decoder) makeBlockReader(valueWireType wire.Type, dedupe bool, key wire.BlockKey) (anyBlockReader, error) {
+	blockData := d.slicer.NextBlock()
+	if blockData == nil {
+		if !d.slicer.Header().GetFlag(header.HeaderInlineEverythingFlag) {
+			return nil, fmt.Errorf("wirecodec: no more block segments for key %s", key)
+		}
+		blockData = d.slicer.Core()
+		if blockData == nil {
+			return nil, fmt.Errorf("wirecodec: core buffer nil in inline-everything mode for %s", key)
+		}
+	}
+
+	var coreRead func(parentBuf buf.Read) (interface{}, error)
+
+	switch t := valueWireType.(type) {
+	case wire.StringType:
+		nt := d.slicer.Header().GetFlag(header.HeaderNullTerminatedStringsFlag)
+		fromBytes := func(b []byte) string { return string(b) }
+		if dedupe {
+			r := block.NewDeduplicatingLabelBlockReader[string](blockData, fromBytes, nt)
+			coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+		} else {
+			r := block.NewLabelBlockReader[string](blockData, fromBytes, nt)
+			coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+		}
+
+	case wire.BytesType:
+		fromBytes := func(b []byte) []byte { return b }
+		if dedupe {
+			r := block.NewDeduplicatingLabelBlockReader[[]byte](blockData, fromBytes, false)
+			coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+		} else {
+			r := block.NewLabelBlockReader[[]byte](blockData, fromBytes, false)
+			coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+		}
+
+	case wire.VarintType:
+		if dedupe {
+			return nil, fmt.Errorf("wirecodec: deduping VARINT via label blocks not supported for %s", key)
+		}
+		r := block.NewUnlabeledVarIntBlockReader(blockData)
+		coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+
+	case wire.Float64Type:
+		if dedupe {
+			return nil, fmt.Errorf("wirecodec: deduping FLOAT64 not supported for %s", key)
+		}
+		fromBytes := func(b []byte) float64 { return math.Float64frombits(binary.LittleEndian.Uint64(b)) }
+		r := block.NewFixedSizeBlockReader[float64](blockData, fromBytes, 8)
+		coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+
+	case wire.FixedType:
+		if dedupe {
+			return nil, fmt.Errorf("wirecodec: deduping FIXED not supported for %s", key)
+		}
+		fromBytes := func(b []byte) []byte { return b }
+		r := block.NewFixedSizeBlockReader[[]byte](blockData, fromBytes, t.Length)
+		coreRead = func(p buf.Read) (interface{}, error) { return r.Read(p) }
+
+	default:
+		return nil, fmt.Errorf("wirecodec: unsupported block value type %s for key %s", wire.Print(valueWireType), key)
+	}
+
+	return &genericBlockReaderWrapper{coreRead: coreRead, blockDataBuffer: blockData}, nil
+}

slidge_whatsapp/vendor/github.com/ebitengine/purego/dlfcn.go

@@ -83,17 +83,17 @@ func loadSymbol(handle uintptr, name string) (uintptr, error) {
 // appear to work if you link directly to the C function on darwin arm64.
 
 //go:linkname dlopen dlopen
-var dlopen uintptr
+var dlopen uint8
 var dlopenABI0 = uintptr(unsafe.Pointer(&dlopen))
 
 //go:linkname dlsym dlsym
-var dlsym uintptr
+var dlsym uint8
 var dlsymABI0 = uintptr(unsafe.Pointer(&dlsym))
 
 //go:linkname dlclose dlclose
-var dlclose uintptr
+var dlclose uint8
 var dlcloseABI0 = uintptr(unsafe.Pointer(&dlclose))
 
 //go:linkname dlerror dlerror
-var dlerror uintptr
+var dlerror uint8
 var dlerrorABI0 = uintptr(unsafe.Pointer(&dlerror))

slidge_whatsapp/vendor/github.com/ebitengine/purego/dlfcn_darwin.go

@@ -17,8 +17,3 @@ const (
 //go:cgo_import_dynamic purego_dlsym dlsym "/usr/lib/libSystem.B.dylib"
 //go:cgo_import_dynamic purego_dlerror dlerror "/usr/lib/libSystem.B.dylib"
 //go:cgo_import_dynamic purego_dlclose dlclose "/usr/lib/libSystem.B.dylib"
-
-//go:cgo_import_dynamic purego_dlopen dlopen "/usr/lib/libSystem.B.dylib"
-//go:cgo_import_dynamic purego_dlsym dlsym "/usr/lib/libSystem.B.dylib"
-//go:cgo_import_dynamic purego_dlerror dlerror "/usr/lib/libSystem.B.dylib"
-//go:cgo_import_dynamic purego_dlclose dlclose "/usr/lib/libSystem.B.dylib"

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

@@ -19,6 +19,7 @@ var (
 )
 
 //go:nosplit
+//go:norace
 func x_cgo_notify_runtime_init_done() {
 	pthread_mutex_lock(&runtime_init_mu)
 	runtime_init_done = 1
@@ -28,6 +29,8 @@ func x_cgo_notify_runtime_init_done() {
 
 // Store the g into a thread-specific value associated with the pthread key pthread_g.
 // And pthread_key_destructor will dropm when the thread is exiting.
+//
+//go:norace
 func x_cgo_bindm(g unsafe.Pointer) {
 	// We assume this will always succeed, otherwise, there might be extra M leaking,
 	// when a C thread exits after a cgo call.

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/elliotchance/orderedmap/v3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Elliot Chance
+
+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, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.