update

Author: g.ph

cfuncs.go

@@ -0,0 +1,101 @@
+package cpy3
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+type Pointer = uintptr
+type SIZE_T = uintptr
+
+const sizeOfUintPtr = unsafe.Sizeof(uintptr(0))
+
+func uintptrToBytes(u uintptr) []byte {
+	return (*[sizeOfUintPtr]byte)(unsafe.Pointer(u))[:]
+}
+
+//func CStrToGoStr(ustr uintptr)string{
+//	return copyStr(ustr,G_strlen(ustr))
+//}
+
+func CBytesToGoBytes(ustr uintptr, n int) []byte {
+	return copyBytes(ustr, n)
+}
+
+// 这种跟copyStr3基本一样，只是用go来处理了
+func copyBytes(src uintptr, strLen int) []byte {
+	if strLen == 0 {
+		return nil
+	}
+	str := make([]byte, strLen)
+	for i := 0; i < strLen; i++ {
+		str[i] = *(*byte)(unsafe.Pointer(src + uintptr(i)))
+	}
+	return str
+}
+
+// 这种跟copyStr3基本一样，只是用go来处理了
+func copyStr(src uintptr, strLen int) string {
+	if strLen == 0 {
+		return ""
+	}
+	str := make([]uint8, strLen)
+	for i := 0; i < strLen; i++ {
+		str[i] = *(*uint8)(unsafe.Pointer(src + uintptr(i)))
+	}
+	return string(str)
+}
+
+// Go的string转换为Lazarus的string
+func GoStrToCStr(s string) uintptr {
+	if s == "" {
+		return 0
+	}
+	return uintptr(unsafe.Pointer(StringToUTF8Ptr(s)))
+}
+
+// Go的string转换为Lazarus的string
+func GoByteToCPtr(b []byte) uintptr {
+	if len(b) == 0 {
+		return 0
+	}
+	return uintptr(unsafe.Pointer(&b[0]))
+}
+
+// 字符串到UTF8指针
+func StringToUTF8Ptr(s string) *uint8 {
+	temp := []byte(s)
+	utf8StrArr := make([]uint8, len(temp)+1) // +1是因为Lazarus中PChar为0结尾
+	copy(utf8StrArr, temp)
+	return &utf8StrArr[0]
+}
+
+// 字符串到UTF16指针
+func StringToUTF16Ptr(s string) uintptr {
+	p, _ := syscall.UTF16PtrFromString(s)
+	return uintptr(unsafe.Pointer(p))
+}
+
+// UTF16指针到字符串
+func UTF16PtrToString(p uintptr) string {
+	l := LstrlenW(p)
+	if l == 0 {
+		return ""
+	}
+	buff := make([]uint16, l)
+	Memcpy(uintptr(unsafe.Pointer(&buff[0])), p, uintptr(l*2))
+	return syscall.UTF16ToString(buff)
+}
+
+func LstrlenW(lpString uintptr) int32 {
+	r, _, _ := _lstrlenW.Call(lpString)
+	return int32(r)
+}
+func Lstrlen(lpString uintptr) int32 {
+	r, _, _ := _lstrlen.Call(lpString)
+	return int32(r)
+}
+func Memcpy(dest, src Pointer, count SIZE_T) Pointer {
+	r, _, _ := _memcpy.Call(dest, src, count)
+	return r
+}

cpy3.go

@@ -0,0 +1,77 @@
+package cpy3
+
+import "unsafe"
+
+func Py_Initialize() {
+	py_Initialize.Call()
+}
+func Py_InitializeEx(initsigs int) {
+	py_Initialize.Call(uintptr(initsigs))
+}
+func Py_IsInitialized() int {
+	r, _, _ := py_IsInitialized.Call()
+	return int(r)
+}
+func Py_Finalize() {
+	py_Finalize.Call()
+}
+func Py_FinalizeEx() int {
+	r, _, _ := py_FinalizeEx.Call()
+	return int(r)
+}
+
+func Py_DecodeLocale(arg string, size uintptr) string {
+	r, _, _ := py_DecodeLocale.Call(GoStrToCStr(arg), size)
+	defer PyMem_RawFree(r)
+	return UTF16PtrToString(r)
+}
+func PyMem_Free(obj uintptr) {
+	pyMem_Free.Call(obj)
+}
+func PyMem_RawFree(obj uintptr) {
+	pyMem_RawFree.Call(obj)
+}
+
+func Py_Main(args []string) int {
+	argc := len(args)
+	argv := make([]uintptr, 0)
+	for _, arg := range args {
+		argv = append(argv, StringToUTF16Ptr(arg))
+	}
+	r, _, _ := py_BytesMain.Call(uintptr(argc), uintptr(unsafe.Pointer(&argv[0])))
+	return int(r)
+}
+func Py_BytesMain(args []string) int {
+	argc := len(args)
+	r, _, _ := py_BytesMain.Call(uintptr(argc))
+	return int(r)
+}
+
+func PyRun_AnyFile(fp uintptr, filename string) int {
+	r, _, _ := pyRun_AnyFile.Call(uintptr(fp), GoStrToCStr(filename))
+	return int(r)
+}
+func PyRun_SimpleFile(fp uintptr, filename string) int {
+	r, _, _ := pyRun_SimpleFile.Call(uintptr(fp), GoStrToCStr(filename))
+	return int(r)
+}
+func PyRun_SimpleString(command string) int {
+	r, _, _ := pyRun_SimpleString.Call(GoStrToCStr(command))
+	return int(r)
+}
+
+func Py_SetProgramName(name string) {
+	py_SetProgramName.Call(StringToUTF16Ptr(name))
+}
+func Py_GetProgramName() string {
+	r, _, _ := py_GetProgramName.Call()
+	return UTF16PtrToString(r)
+}
+
+func Py_SetPath(path string) {
+	py_SetPath.Call(StringToUTF16Ptr(path))
+}
+
+func Py_SetPythonHome(home string) {
+	py_SetPythonHome.Call(StringToUTF16Ptr(home))
+}

dylib_nontempdll.go

@@ -0,0 +1,8 @@
+//go:build !tempdll && !memorydll
+// +build !tempdll,!memorydll
+
+package cpy3
+
+func checkAndReleaseDLL() (bool, string) {
+	return false, ""
+}

dylib_tempdll.go

@@ -0,0 +1,9 @@
+//go:build (windows || linux || darwin) && tempdll
+// +build windows linux darwin
+// +build tempdll
+
+package cpy3
+
+func checkAndReleaseDLL() (bool, string) {
+	return false, ""
+}

importfuncs.go

@@ -0,0 +1,35 @@
+package cpy3
+
+import "syscall"
+
+var (
+	py_Initialize    = libpython3.NewProc("Py_Initialize")
+	py_InitializeEx  = libpython3.NewProc("Py_InitializeEx")
+	py_IsInitialized = libpython3.NewProc("Py_IsInitialized")
+	py_Finalize      = libpython3.NewProc("Py_Finalize")
+	py_FinalizeEx    = libpython3.NewProc("Py_FinalizeEx")
+	py_DecodeLocale  = libpython3.NewProc("Py_DecodeLocale")
+	pyMem_Free       = libpython3.NewProc("PyMem_Free")
+	pyMem_RawFree    = libpython3.NewProc("PyMem_RawFree")
+
+	py_SetProgramName         = libpython3.NewProc("Py_SetProgramName")
+	py_GetProgramName         = libpython3.NewProc("Py_GetProgramName")
+	pyEval_ThreadsInitialized = libpython3.NewProc("PyEval_ThreadsInitialized")
+	py_Main                   = libpython3.NewProc("Py_Main")
+	py_BytesMain              = libpython3.NewProc("Py_BytesMain")
+	pyRun_AnyFile             = libpython3.NewProc("PyRun_AnyFile")
+	pyRun_SimpleFile          = libpython3.NewProc("PyRun_SimpleFile")
+	pyRun_SimpleString        = libpython3.NewProc("PyRun_SimpleString")
+	py_SetPath                = libpython3.NewProc("Py_SetPath")
+	py_SetPythonHome          = libpython3.NewProc("Py_SetPythonHome")
+)
+var kernel32dll = syscall.NewLazyDLL("kernel32.dll")
+var (
+	_lstrlenW = kernel32dll.NewProc("lstrlenW")
+	_lstrlen  = kernel32dll.NewProc("lstrlenA")
+)
+
+var msvcrtdll = syscall.NewLazyDLL("msvcrt.dll")
+var (
+	_memcpy = msvcrtdll.NewProc("memcpy")
+)

loadlib.go

@@ -0,0 +1,42 @@
+package cpy3
+
+import (
+	"github.com/aadog/dylib"
+	"runtime"
+)
+
+var libpython3 = loadUILib()
+
+var (
+	platformExtNames = map[string]string{
+		"windows": ".dll",
+		"linux":   ".so",
+		"darwin":  ".dylib",
+	}
+)
+
+// 加载库
+func loadUILib() *dylib.LazyDLL {
+	libName := getDLLName()
+	// 如果支持运行时释放，则使用此种方法
+	if support, newDLLPath := checkAndReleaseDLL(); support {
+		libName = newDLLPath
+	} else {
+		libName = libName
+	}
+	lib := dylib.NewLazyDLL(libName)
+	err := lib.Load()
+	if err != nil {
+		panic(err)
+	}
+
+	return lib
+}
+
+func getDLLName() string {
+	libName := "python310"
+	if ext, ok := platformExtNames[runtime.GOOS]; ok {
+		return libName + ext
+	}
+	return libName
+}