Example #1
0
// static inline int complexCheck(PyObject *o) { return PyComplex_Check(o); }
import "C"

import (
	"fmt"
	"unsafe"
)

type Complex struct {
	AbstractObject
	NumberProtocol
	o C.PyComplexObject
}

// ComplexType is the Type object that represents the Complex type.
var ComplexType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyComplex_Type)))

func complexCheck(obj Object) bool {
	return C.complexCheck(c(obj)) != 0
}

func newComplex(obj *C.PyObject) *Complex {
	return (*Complex)(unsafe.Pointer(obj))
}

func NewComplex(v complex128) (*Complex, error) {
	ret := C.PyComplex_FromDoubles(C.double(real(v)), C.double(imag(v)))
	if ret == nil {
		return nil, exception()
	}
	return newComplex(ret), nil
Example #2
0
// static inline int floatCheck(PyObject *o) { return PyFloat_Check(o); }
import "C"

import (
	"fmt"
	"unsafe"
)

type Float struct {
	AbstractObject
	NumberProtocol
	o C.PyFloatObject
}

// FloatType is the Type object that represents the Float type.
var FloatType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyFloat_Type)))

func floatCheck(obj Object) bool {
	return C.floatCheck(c(obj)) != 0
}

func newFloat(obj *C.PyObject) *Float {
	return (*Float)(unsafe.Pointer(obj))
}

func NewFloat(v float64) (*Float, error) {
	ret := C.PyFloat_FromDouble(C.double(v))
	if ret == nil {
		return nil, exception()
	}
	return newFloat(ret), nil
Example #3
0
import (
	"fmt"
	"unsafe"
)

// *Dict represents a Python dictionary.  In addition to satisfying the Object
// interface, Dict pointers also have a number of methods defined - representing
// the PyDict_XXX functions from the Python C API.
type Dict struct {
	AbstractObject
	o C.PyDictObject
}

// DictType is the Type object that represents the Dict type.
var DictType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyDict_Type)))

func dictCheck(obj Object) bool {
	if obj == nil {
		return false
	}
	return C.dictCheck(c(obj)) != 0
}

func newDict(obj *C.PyObject) *Dict {
	return (*Dict)(unsafe.Pointer(obj))
}

// NewDict creates a new empty dictionary.
//
// Return value: New Reference.
Example #4
0
func newObject(obj *C.PyObject) Object {
	if obj == nil {
		return nil
	}

	o := unsafe.Pointer(obj)
	if o == unsafe.Pointer(None) {
		return None
	}

	pyType := (*C.PyTypeObject)(obj.ob_type)
	class, ok := getType(pyType)
	if ok {
		ret, ok := obj2Class(class, obj)
		if ok {
			return ret
		}
	}
	for pyType.tp_base != nil {
		pyType = (*C.PyTypeObject)(unsafe.Pointer(pyType.tp_base))
		class, ok := getType(pyType)
		if ok {
			ret, ok := obj2Class(class, obj)
			if ok {
				return ret
			}
		}
	}

	switch C.getBasePyType(obj) {
	case &C.PyList_Type:
		return (*List)(o)
	case &C.PyTuple_Type:
		return (*Tuple)(o)
	case &C.PyDict_Type:
		return (*Dict)(o)
	case &C.PyString_Type:
		return (*String)(o)
	case &C.PyBool_Type:
		return newBool(obj)
	case &C.PyInt_Type:
		return (*Int)(o)
	case &C.PyLong_Type:
		return (*Long)(o)
	case &C.PyFloat_Type:
		return (*Float)(o)
	case &C.PyModule_Type:
		return (*Module)(o)
	case &C.PyType_Type:
		return (*Type)(o)
	case &C.PyCode_Type:
		return (*Code)(o)
	case &C.PyCFunction_Type:
		return (*CFunction)(o)
	case &C.PyComplex_Type:
		return (*Complex)(o)
	case &C.PyFrozenSet_Type:
		return (*FrozenSet)(o)
	case &C.PySet_Type:
		return (*Set)(o)
	case &C.PyFunction_Type:
		return (*Function)(o)
	}

	if C.exceptionCheck(obj) != 0 {
		return newException(obj)
	}

	return newBaseObject(obj)
}
Example #5
0
package py

// #include "utils.h"
// static inline int unicodeCheck(PyObject *o) { return PyUnicode_Check(o); }
import "C"

import "unsafe"

type Unicode struct {
	AbstractObject
	o C.PyUnicodeObject
}

// UnicodeType is the Type object that represents the Unicode type.
var UnicodeType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyUnicode_Type)))

func unicodeCheck(obj Object) bool {
	return C.unicodeCheck(c(obj)) != 0
}

func newUnicode(obj *C.PyObject) *Unicode {
	return (*Unicode)(unsafe.Pointer(obj))
}

func NewUnicode(s string) (*Unicode, error) {
	cs := C.CString(s)
	defer C.free(unsafe.Pointer(cs))
	ret := C.PyUnicode_FromStringAndSize(cs, C.Py_ssize_t(len(s)))
	if ret == nil {
		return nil, exception()
Example #6
0
import (
	"fmt"
	"unsafe"
)

// *Bool is the representation of the Python bool type.  There are only two
// possible values for a Bool, True and False.  Every True value refers to the
// same instance, and every False value refers to the same value.
type Bool struct {
	AbstractObject
	o C.PyObject
}

// BoolType is the Type object that represents the Bool type.
var BoolType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyBool_Type)))

// True is the true value of the Bool type.  It is a singleton value, all true
// values refer to the same instance.
var True = (*Bool)(C.pyTrue())

// False is the false value of the Bool type.  It is a singleton value, all
// false values refer to the same instance.
var False = (*Bool)(C.pyFalse())

func boolCheck(obj Object) bool {
	return C.boolCheck(c(obj)) != 0
}

func newBool(obj *C.PyObject) *Bool {
	if obj == c(True) {
Example #7
0
File: type.go Project: hexid/gopy
//    return ((PyTypeObject *)t)->tp_alloc((PyTypeObject *)t, n);
// }
// static inline int typeInit(PyObject *t, PyObject *o, PyObject *a, PyObject *k) {
//    return ((PyTypeObject *)t)->tp_init(o, a, k);
// }
import "C"

import "unsafe"

type Type struct {
	AbstractObject
	o C.PyTypeObject
}

// TypeType is the Type object that represents the Type type.
var TypeType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyType_Type)))

func typeCheck(obj Object) bool {
	if obj == nil {
		return false
	}
	return C.typeCheck(c(obj)) != 0
}

func newType(obj *C.PyObject) *Type {
	return (*Type)(unsafe.Pointer(obj))
}

func (t *Type) Alloc(n int64) (Object, error) {
	ret := C.typeAlloc(c(t), C.Py_ssize_t(n))
	return obj2ObjErr(ret)
Example #8
0
// #include "utils.h"
// static inline int functionCheck(PyObject *o) { return PyFunction_Check(o); }
import "C"

import "unsafe"

// *Function represents a Python function.  In Python this is a function created
// using the "def" statement.
type Function struct {
	AbstractObject
	o C.PyFunctionObject
}

// FunctionType is the Type object that represents the Function type.
var FunctionType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyFunction_Type)))

func newFunction(obj *C.PyObject) *Function {
	return (*Function)(unsafe.Pointer(obj))
}

func functionCheck(obj Object) bool {
	if obj == nil {
		return false
	}
	return C.functionCheck(c(obj)) != 0
}

// NewFunction returns a new Function object that is associated with the given
// "code" and "globals".  "globals" must be a dictionary, and it should hold the
// global variables for the function.
Example #9
0
// static inline int moduleCheck(PyObject *o) { return PyModule_Check(o); }
// static inline int moduleCheckE(PyObject *o) { return PyModule_CheckExact(o); }
// static inline void decref(PyObject *obj) { Py_DECREF(obj); }
import "C"

import (
	"unsafe"
)

type Module struct {
	AbstractObject
	o C.PyObject
}

// ModuleType is the Type object that represents the Module type.
var ModuleType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyModule_Type)))

func moduleCheck(obj Object) bool {
	if obj == nil {
		return false
	}
	return C.moduleCheck(c(obj)) != 0
}

func newModule(obj *C.PyObject) *Module {
	return (*Module)(unsafe.Pointer(obj))
}

func Import(name string) (*Module, error) {
	s := C.CString(name)
	defer C.free(unsafe.Pointer(s))
Example #10
0
File: set.go Project: gbbr/textmate
import "unsafe"

// *Set represents a Python set.  In addition to satisfying the Object
// interface, Set pointers also have a number of methods defined - representing
// the PySet_XXX functions from the Python C API.
type Set struct {
	AbstractObject
	o C.PySetObject
}

type FrozenSet struct {
	Set
}

// SetType is the Type object that represents the Set type.
var SetType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPySet_Type)))

// FrozenSetType is the Type object that represents the FrozenSet type.
var FrozenSetType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyFrozenSet_Type)))

func setCheck(obj Object) bool {
	return C.setCheck(c(obj)) != 0
}

func frozenSetCheck(obj Object) bool {
	return C.frozenSetCheck(c(obj)) != 0
}

func newSet(obj *C.PyObject) *Set {
	return (*Set)(unsafe.Pointer(obj))
}
Example #11
0
import "unsafe"

// *BaseObject is the concrete representation of the Python "Object *".  It is
// used less than in the C API, as the Object interface is mostly used when the
// type is not fixed.  Any Object "o" can be turned into a *BaseObject using the
// Base() method (i.e. o.Base() returns a *BaseObject that refers to the same
// underlying Python object as "o").  This allows the Python functions that
// accept any type of object to be defined as methods on *BaseObject.
type BaseObject struct {
	AbstractObject
	o C.PyObject
}

// BaseType is the Type object that represents the BaseObject type.
var BaseType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyBaseObject_Type)))

func newBaseObject(obj *C.PyObject) *BaseObject {
	return (*BaseObject)(unsafe.Pointer(obj))
}

// HasAttr returns true if "obj" has the attribute "name".  This is equivalent
// to the Python "hasattr(obj, name)".
func (obj *BaseObject) HasAttr(name Object) bool {
	ret := C.PyObject_HasAttr(c(obj), c(name))
	if ret == 1 {
		return true
	}
	return false
}
Example #12
0
// static inline long longCheck(PyObject *o) { return PyLong_Check(o); }
import "C"

import (
	"fmt"
	"unsafe"
)

type Long struct {
	AbstractObject
	NumberProtocol
	o C.PyLongObject
}

// LongType is the Type object that represents the Long type.
var LongType = (*Type)(unsafe.Pointer(C.getBasePyType(C.GoPyLong_Type)))

func longCheck(obj Object) bool {
	if obj == nil {
		return false
	}
	return C.longCheck(c(obj)) != 0
}

func newLong(obj *C.PyObject) *Long {
	return (*Long)(unsafe.Pointer(obj))
}

func NewLong(i int64) *Long {
	return newLong(C.PyLong_FromLongLong(C.PY_LONG_LONG(i)))
}