syscall_windows.go RawHistoryFolder

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: 2022 The Ebitengine Authors
3
4package purego
5
6import (
7	"reflect"
8	"syscall"
9	"unsafe"
10)
11
12var syscallXABI0 uintptr
13
14func syscall_syscallN(fn uintptr, args ...uintptr) (r1, r2, err uintptr) {
15	r1, r2, errno := syscall.SyscallN(fn, args...)
16	return r1, r2, uintptr(errno)
17}
18
19// NewCallback converts a Go function to a function pointer conforming to the stdcall calling convention.
20// This is useful when interoperating with Windows code requiring callbacks. The argument is expected to be a
21// function with one uintptr-sized result. The function must not have arguments with size larger than the
22// size of uintptr. Only a limited number of callbacks may be created in a single Go process, and any memory
23// allocated for these callbacks is never released. Between NewCallback and NewCallbackCDecl, at least 1024
24// callbacks can always be created. Although this function is similar to the darwin version it may act
25// differently.
26//
27// Every call to NewCallback creates a new callback even for the same function value, so passing a Go callback to C
28// inside a loop (e.g. a qsort comparator) keeps consuming callbacks and eventually panics once they are exhausted.
29// The same happens when a func value is passed to a C function, as [RegisterFunc] creates a new callback for each
30// call. Create the callback once with NewCallback and reuse the returned pointer instead.
31func NewCallback(fn any) uintptr {
32	isCDecl := false
33	ty := reflect.TypeOf(fn)
34	if ty == nil || ty.Kind() != reflect.Func {
35		panic("purego: the type must be a function but was not")
36	}
37	for i := range ty.NumIn() {
38		in := ty.In(i)
39		if !in.AssignableTo(reflect.TypeFor[CDecl]()) {
40			continue
41		}
42		if i != 0 {
43			panic("purego: CDecl must be the first argument")
44		}
45		isCDecl = true
46	}
47	if isCDecl {
48		return syscall.NewCallbackCDecl(fn)
49	}
50	return syscall.NewCallback(fn)
51}
52
53func loadSymbol(handle uintptr, name string) (uintptr, error) {
54	return syscall.GetProcAddress(syscall.Handle(handle), name)
55}
56
57// callbackMaxFrame is a stub definition.
58const callbackMaxFrame = 0
59
60func callbackArgFromStack(argsBase unsafe.Pointer, stackSlot int, stackByteOffset *uintptr, inType reflect.Type) reflect.Value {
61	panic("purego: callbackArgFromStack should not be called on windows")
62}