update

Author: g.ph

ModuleDef.go

@@ -0,0 +1,14 @@
+package py3_go
+
+type PyModuleDef struct {
+	Name       string
+	Doc        string
+	MethodDefs []*PyMethodDef
+}
+
+func NewModuleDef(name string, doc string) *PyModuleDef {
+	return &PyModuleDef{Name: name, Doc: doc}
+}
+func (m *PyModuleDef) AddMethodDef(methodDef *PyMethodDef) {
+	m.MethodDefs = append(m.MethodDefs, methodDef)
+}

PyDict.go

@@ -0,0 +1,18 @@
+package py3_go
+
+import "unsafe"
+
+type PyDict struct {
+	PyObject
+}
+
+// PyDictFromInst
+// 新建一个对象来自已经存在的对象实例指针。
+//
+// Create a new object from an existing object instance pointer.
+func PyDictFromInst(inst uintptr) *PyDict {
+	dl := new(PyDict)
+	dl.instance = inst
+	dl.ptr = unsafe.Pointer(dl.instance)
+	return dl
+}

PyEval.go

@@ -0,0 +1,16 @@
+package py3_go
+
+import "github.com/aadog/py3-go/cpy3"
+
+func PyEval_GetBuiltins() *PyObject {
+	return PyObjectFromInst(cpy3.PyEval_GetBuiltins())
+}
+func PyEval_GetLocals() *PyObject {
+	return PyObjectFromInst(cpy3.PyEval_GetLocals())
+}
+func PyEval_GetGlobals() *PyObject {
+	return PyObjectFromInst(cpy3.PyEval_GetGlobals())
+}
+func PyEval_GetFrame() *PyFrame {
+	return PyFrameFromInst(cpy3.PyEval_GetFrame())
+}

PyFrame.go

@@ -0,0 +1,28 @@
+package py3_go
+
+import (
+	"github.com/aadog/go-py3/cpy3"
+	"unsafe"
+)
+
+type PyFrame struct {
+	PyObject
+}
+
+func (p *PyFrame) GetBack() *PyObject {
+	return PyObjectFromInst(cpy3.PyFrame_GetBack(p.instance))
+}
+func (p *PyFrame) GetCode() *PyObject {
+	return PyObjectFromInst(cpy3.PyFrame_GetCode(p.instance))
+}
+
+// PyFrameFromInst
+// 新建一个对象来自已经存在的对象实例指针。
+//
+// Create a new object from an existing object instance pointer.
+func PyFrameFromInst(inst uintptr) *PyFrame {
+	dl := new(PyFrame)
+	dl.instance = inst
+	dl.ptr = unsafe.Pointer(dl.instance)
+	return dl
+}

PyImport.go

@@ -0,0 +1,13 @@
+package py3_go
+
+import "github.com/aadog/py3-go/cpy3"
+
+func PyImport_Import(name string) *PyModule {
+	pName := PyUnicode_DecodeFSDefault(name)
+	defer pName.DecRef()
+	return PyModuleFromInst(cpy3.PyImport_Import(pName.instance))
+}
+func PyImport_AppendInittab(name string, initFunc func() *PyObject) int {
+	PyMethodMap.Store(name, initFunc)
+	return cpy3.PyImport_AppendInittab(name, NewModuleInitFuncCallBack(name, initFunc))
+}

PyMethodDef.go

@@ -0,0 +1,17 @@
+package py3_go
+
+type PyMethodDef struct {
+	Name   string
+	Method func(self *PyObject, args *PyObject) *PyObject
+	flags  int
+	Doc    string
+}
+
+func NewMethodDef(name string, meth func(self *PyObject, args *PyObject) *PyObject, doc string, flags int) *PyMethodDef {
+	return &PyMethodDef{
+		Name:   name,
+		Method: meth,
+		flags:  flags,
+		Doc:    doc,
+	}
+}

PyModule.go

@@ -0,0 +1,134 @@
+package py3_go
+
+import (
+	"fmt"
+	"github.com/aadog/py3-go/cpy3"
+	"sync"
+	"syscall"
+	"unsafe"
+)
+
+var PyMethodMap = sync.Map{}
+var pyModuleInitMap = sync.Map{}
+var PyMethodCallBack = syscall.NewCallback(func(self uintptr, args uintptr) uintptr {
+	pyArgs := PyTupleFromInst(args)
+	pyArgsLen := pyArgs.Size()
+	if pyArgsLen < 1 {
+		return Py_RETURN_NONE().instance
+	}
+	code := pyArgs.GetItem(0)
+
+	ifn, ok := PyMethodMap.Load(code.Str())
+	if ok == false {
+		return Py_RETURN_NONE().Instance()
+	}
+	//处理参数
+	newArgs := pyArgs.GetSlice(1, pyArgsLen)
+	defer newArgs.DecRef()
+	fn := ifn.(func(self *PyObject, args *PyObject) *PyObject)
+	return fn(PyObjectFromInst(self), PyObjectFromInst(newArgs.Instance())).Instance()
+})
+
+type PyMethodType = func(self *PyObject, args *PyObject) *PyObject
+
+type PyModule struct {
+	PyObject
+}
+
+func (p *PyModule) GetName() string {
+	return cpy3.PyModule_GetName(p.instance)
+}
+func (p *PyModule) GetDict() *PyDict {
+	return PyDictFromInst(cpy3.PyModule_GetDict(p.instance))
+}
+func (p *PyModule) AddFunctions(functionsDef []PyMethodDef) int {
+	methods := make([]cpy3.PyMethodDef, 0)
+	moduleName := p.GetName()
+	for _, method := range functionsDef {
+		methodName := method.Name
+		methods = append(methods, cpy3.PyMethodDef{
+			Ml_name:  cpy3.GoStrToCStr(method.Name),
+			Ml_meth:  NewMethodCallBack(moduleName, methodName, method.Method),
+			Ml_flags: method.flags,
+			Ml_doc:   cpy3.GoStrToCStr(method.Doc),
+		})
+	}
+	methods = append(methods, cpy3.PyMethodDef{
+		Ml_name:  0,
+		Ml_meth:  0,
+		Ml_flags: 0,
+		Ml_doc:   0,
+	})
+	return cpy3.PyModule_AddFunctions(p.instance, uintptr(unsafe.Pointer(&methods[0])))
+}
+func (p *PyModule) AddIntConstant(name string, value int64) int {
+	return cpy3.PyModule_AddIntConstant(p.instance, name, value)
+}
+func (p *PyModule) AddStringConstant(name string, value string) int {
+	return cpy3.PyModule_AddStringConstant(p.instance, name, value)
+}
+func (p *PyModule) AddObject(name string, value *PyObject) int {
+	return cpy3.PyModule_AddObject(p.instance, name, value.instance)
+}
+func (p *PyModule) AddObjectRef(name string, value *PyObject) int {
+	return cpy3.PyModule_AddObjectRef(p.instance, name, value.instance)
+}
+
+// PyModuleFromInst
+// 新建一个对象来自已经存在的对象实例指针。
+//
+// Create a new object from an existing object instance pointer.
+func PyModuleFromInst(inst uintptr) *PyModule {
+	dl := new(PyModule)
+	dl.instance = inst
+	dl.ptr = unsafe.Pointer(dl.instance)
+	return dl
+}
+
+func NewModuleInitFuncCallBack(moduleName string, fn func() *PyObject) uintptr {
+	c := syscall.NewCallback(func() uintptr {
+		return fn().Instance()
+	})
+	pyModuleInitMap.Store(moduleName, c)
+	return c
+}
+func NewMethodCallBack(moduleName string, methodName string, fn func(self *PyObject, args *PyObject) *PyObject) uintptr {
+	PyMethodMap.Store(fmt.Sprintf("%s.%s", moduleName, methodName), fn)
+	return PyMethodCallBack
+}
+
+func CreateModule(def *PyModuleDef) *PyObject {
+	moduleName := def.Name
+	methods := make([]cpy3.PyMethodDef, 0)
+	for _, method := range def.MethodDefs {
+		methodName := method.Name
+		methods = append(methods, cpy3.PyMethodDef{
+			Ml_name:  cpy3.GoStrToCStr(method.Name),
+			Ml_meth:  NewMethodCallBack(moduleName, methodName, method.Method),
+			Ml_flags: method.flags,
+			Ml_doc:   cpy3.GoStrToCStr(method.Doc),
+		})
+	}
+	methods = append(methods, cpy3.PyMethodDef{
+		Ml_name:  0,
+		Ml_meth:  0,
+		Ml_flags: 0,
+		Ml_doc:   0,
+	})
+
+	moduleDef := cpy3.PyModuleDef{
+		M_base: cpy3.PyModuleDef_Base{
+			Ob_base: cpy3.PyObject_HEAD_INIT(0),
+		},
+		M_name:     cpy3.GoStrToCStr(def.Name),
+		M_doc:      cpy3.GoStrToCStr(def.Doc),
+		M_size:     -1,
+		M_methods:  uintptr(unsafe.Pointer(&methods[0])),
+		M_slots:    0,
+		M_traverse: 0,
+		M_clear:    0,
+		M_free:     0,
+	}
+	ptr := cpy3.PyModule_Create2(uintptr(unsafe.Pointer(&moduleDef)), 1013)
+	return PyObjectFromInst(ptr)
+}

PyNone.go

@@ -0,0 +1,27 @@
+package py3_go
+
+import (
+	"github.com/aadog/py3-go/cpy3"
+	"unsafe"
+)
+
+type PyNone struct {
+	PyObject
+}
+
+// PyNoneFromInst
+// 新建一个对象来自已经存在的对象实例指针。
+//
+// Create a new object from an existing object instance pointer.
+func PyNoneFromInst(inst uintptr) *PyNone {
+	dl := new(PyNone)
+	dl.instance = inst
+	dl.ptr = unsafe.Pointer(dl.instance)
+	return dl
+}
+
+func Py_RETURN_NONE() *PyNone {
+	none := PyNoneFromInst(cpy3.Py_None())
+	none.IncRef()
+	return none
+}

PyObject.go

@@ -0,0 +1,51 @@
+package py3_go
+
+import (
+	"github.com/aadog/py3-go/cpy3"
+	"unsafe"
+)
+
+type IPyObject interface {
+	SetObject(object *PyObject)
+}
+
+type PyObject struct {
+	CObj
+}
+
+func (p *PyObject) String() string {
+	return p.Str()
+}
+func (p *PyObject) GetAttr(attr_name string) *PyObject {
+	name := PyUnicode_FromString(attr_name)
+	defer name.DecRef()
+	o := cpy3.PyObject_GetAttr(p.instance, name.instance)
+	return PyObjectFromInst(o)
+}
+func (p *PyObject) Str() string {
+	o := PyUnicodeFromInst(cpy3.PyObject_Str(p.instance))
+	defer o.DecRef()
+	return cpy3.PyUnicode_AsUTF8(o.instance)
+}
+func (o *PyObject) DecRef() {
+	cpy3.Py_DecRef(o.instance)
+}
+func (o *PyObject) IncRef() {
+	if o.instance != 0 {
+		cpy3.Py_IncRef(o.instance)
+	}
+}
+func (p *PyObject) AsObj() *PyObject {
+	return p
+}
+
+// PyObjectFromInst
+// 新建一个对象来自已经存在的对象实例指针。
+//
+// Create a new object from an existing object instance pointer.
+func PyObjectFromInst(inst uintptr) *PyObject {
+	dl := new(PyObject)
+	dl.instance = inst
+	dl.ptr = unsafe.Pointer(dl.instance)
+	return dl
+}

PyTuple.go

@@ -0,0 +1,39 @@
+package py3_go
+
+import (
+	"github.com/aadog/py3-go/cpy3"
+	"unsafe"
+)
+
+type PyTuple struct {
+	PyObject
+}
+
+func (p *PyTuple) Size() int64 {
+	return cpy3.PyTuple_Size(p.instance)
+}
+func (p *PyTuple) Check() int64 {
+	return cpy3.PyTuple_Check(p.instance)
+}
+func (p *PyTuple) GetItem(pos int64) *PyObject {
+	return PyObjectFromInst(cpy3.PyTuple_GetItem(p.instance, pos))
+}
+func (p *PyTuple) GetSlice(low int64, high int64) *PyObject {
+	return PyObjectFromInst(cpy3.PyTuple_GetSlice(p.instance, low, high))
+}
+
+// PyTupleFromInst
+// 新建一个对象来自已经存在的对象实例指针。
+//
+// Create a new object from an existing object instance pointer.
+func PyTupleFromInst(inst uintptr) *PyTuple {
+	dl := new(PyTuple)
+	dl.instance = inst
+	dl.ptr = unsafe.Pointer(dl.instance)
+	return dl
+}
+func PyTupleFromObj(obj *PyObject) *PyTuple {
+	dl := new(PyTuple)
+	dl.PyObject = *obj
+	return dl
+}