Register_PyString_Type(IntPtr address) { // not quite trivial to autogenerate CPyMarshal.Zero(address, Marshal.SizeOf(typeof(PyTypeObject))); CPyMarshal.WriteIntField(address, typeof(PyTypeObject), "ob_refcnt", 1); CPyMarshal.WriteIntField(address, typeof(PyTypeObject), "tp_basicsize", Marshal.SizeOf(typeof(PyStringObject)) - 1); CPyMarshal.WriteIntField(address, typeof(PyTypeObject), "tp_itemsize", 1); CPyMarshal.WriteCStringField(address, typeof(PyTypeObject), "tp_name", "str"); CPyMarshal.WritePtrField(address, typeof(PyTypeObject), "tp_str", this.GetFuncPtr("IC_PyString_Str")); CPyMarshal.WritePtrField(address, typeof(PyTypeObject), "tp_repr", this.GetFuncPtr("PyObject_Repr")); uint sqSize = (uint)Marshal.SizeOf(typeof(PySequenceMethods)); IntPtr sqPtr = this.allocator.Alloc(sqSize); CPyMarshal.Zero(sqPtr, sqSize); CPyMarshal.WritePtrField(sqPtr, typeof(PySequenceMethods), "sq_concat", this.GetFuncPtr("IC_PyString_Concat_Core")); CPyMarshal.WritePtrField(address, typeof(PyTypeObject), "tp_as_sequence", sqPtr); uint bfSize = (uint)Marshal.SizeOf(typeof(PyBufferProcs)); IntPtr bfPtr = this.allocator.Alloc(bfSize); CPyMarshal.Zero(bfPtr, bfSize); CPyMarshal.WritePtrField(bfPtr, typeof(PyBufferProcs), "bf_getreadbuffer", this.GetFuncPtr("IC_str_getreadbuffer")); CPyMarshal.WritePtrField(bfPtr, typeof(PyBufferProcs), "bf_getwritebuffer", this.GetFuncPtr("IC_str_getwritebuffer")); CPyMarshal.WritePtrField(bfPtr, typeof(PyBufferProcs), "bf_getsegcount", this.GetFuncPtr("IC_str_getsegcount")); CPyMarshal.WritePtrField(bfPtr, typeof(PyBufferProcs), "bf_getcharbuffer", this.GetFuncPtr("IC_str_getreadbuffer")); CPyMarshal.WritePtrField(address, typeof(PyTypeObject), "tp_as_buffer", bfPtr); CPyMarshal.WriteIntField(address, typeof(PyTypeObject), "tp_flags", (Int32)Py_TPFLAGS.HAVE_GETCHARBUFFER); this.map.Associate(address, TypeCache.String); }
PyList_New(int length) { if (length == 0) { return(this.IC_PyList_New_Zero()); } PyListObject list = new PyListObject(); list.ob_refcnt = 1; list.ob_type = this.PyList_Type; list.ob_size = length; list.allocated = length; int bytes = length * CPyMarshal.PtrSize; list.ob_item = this.allocator.Alloc((uint)bytes); CPyMarshal.Zero(list.ob_item, bytes); IntPtr listPtr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyListObject))); Marshal.StructureToPtr(list, listPtr, false); this.incompleteObjects[listPtr] = UnmanagedDataMarker.PyListObject; return(listPtr); }
_PyObject_New(IntPtr typePtr) { uint tp_basicsize = CPyMarshal.ReadUIntField(typePtr, typeof(PyTypeObject), "tp_basicsize"); IntPtr objPtr = this.allocator.Alloc(tp_basicsize); CPyMarshal.Zero(objPtr, tp_basicsize); return(this.PyObject_Init(objPtr, typePtr)); }
public ThreadState(PythonMapper mapper) { this.mapper = mapper; uint size = (uint)Marshal.SizeOf(typeof(PyThreadState)); this.ptr = this.mapper.PyMem_Malloc(size); // leaka leaka leaka CPyMarshal.Zero(this.ptr, size); }
Register_PyBool_Type(IntPtr address) { // not quite trivial to autogenerate CPyMarshal.Zero(address, Marshal.SizeOf(typeof(PyTypeObject))); CPyMarshal.WriteIntField(address, typeof(PyTypeObject), "ob_refcnt", 1); CPyMarshal.WritePtrField(address, typeof(PyTypeObject), "tp_base", this.PyInt_Type); CPyMarshal.WriteCStringField(address, typeof(PyTypeObject), "tp_name", "bool"); this.map.Associate(address, TypeCache.Boolean); }
_PyObject_NewVar(IntPtr typePtr, int nitems) { int tp_basicsize = CPyMarshal.ReadIntField(typePtr, typeof(PyTypeObject), "tp_basicsize"); int tp_itemsize = CPyMarshal.ReadIntField(typePtr, typeof(PyTypeObject), "tp_itemsize"); uint size = (uint)(tp_basicsize + nitems * tp_itemsize); IntPtr objPtr = this.allocator.Alloc(size); CPyMarshal.Zero(objPtr, size); return(this.PyObject_Init(objPtr, typePtr)); }
Register_PyEllipsis_Type(IntPtr address) { // not quite trivial to autogenerate // (but surely there's a better way to get the Ellipsis object...) CPyMarshal.Zero(address, Marshal.SizeOf(typeof(PyTypeObject))); CPyMarshal.WriteIntField(address, typeof(PyTypeObject), "ob_refcnt", 1); CPyMarshal.WriteCStringField(address, typeof(PyTypeObject), "tp_name", "ellipsis"); object ellipsisType = PythonCalls.Call(Builtin.type, new object[] { PythonOps.Ellipsis }); this.map.Associate(address, ellipsisType); }
StoreTyped(PythonFunction func) { uint size = (uint)Marshal.SizeOf(typeof(PyFunctionObject)); IntPtr ptr = this.allocator.Alloc(size); CPyMarshal.Zero(ptr, size); CPyMarshal.WriteIntField(ptr, typeof(PyIntObject), "ob_refcnt", 1); CPyMarshal.WritePtrField(ptr, typeof(PyIntObject), "ob_type", this.PyFunction_Type); this.map.Associate(ptr, func); return(ptr); }
StoreTyped(PythonFile obj) { IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyFileObject))); CPyMarshal.Zero(ptr, Marshal.SizeOf(typeof(PyFileObject))); CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 1); CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.PyFile_Type); CPyMarshal.WriteIntField(ptr, typeof(PyFileObject), "f_fp", -2); CPyMarshal.WritePtrField(ptr, typeof(PyFileObject), "f_name", this.Store(obj.name)); CPyMarshal.WritePtrField(ptr, typeof(PyFileObject), "f_mode", this.Store(obj.mode)); this.map.Associate(ptr, obj); return(ptr); }
AddNumberMethodsWithoutIndex(IntPtr typePtr) { uint nmSize = (uint)Marshal.SizeOf(typeof(PyNumberMethods)); IntPtr nmPtr = this.allocator.Alloc(nmSize); CPyMarshal.Zero(nmPtr, nmSize); CPyMarshal.WritePtrField(nmPtr, typeof(PyNumberMethods), "nb_int", this.GetFuncPtr("PyNumber_Int")); CPyMarshal.WritePtrField(nmPtr, typeof(PyNumberMethods), "nb_long", this.GetFuncPtr("PyNumber_Long")); CPyMarshal.WritePtrField(nmPtr, typeof(PyNumberMethods), "nb_float", this.GetFuncPtr("PyNumber_Float")); CPyMarshal.WritePtrField(nmPtr, typeof(PyNumberMethods), "nb_multiply", this.GetFuncPtr("PyNumber_Multiply")); CPyMarshal.WritePtrField(typePtr, typeof(PyTypeObject), "tp_as_number", nmPtr); }
StoreTyped(Method meth) { uint size = (uint)Marshal.SizeOf(typeof(PyMethodObject)); IntPtr methPtr = this.allocator.Alloc(size); CPyMarshal.Zero(methPtr, size); CPyMarshal.WriteIntField(methPtr, typeof(PyMethodObject), "ob_refcnt", 1); CPyMarshal.WritePtrField(methPtr, typeof(PyMethodObject), "ob_type", this.PyMethod_Type); CPyMarshal.WritePtrField(methPtr, typeof(PyMethodObject), "im_func", this.Store(meth.im_func)); CPyMarshal.WritePtrField(methPtr, typeof(PyMethodObject), "im_self", this.Store(meth.im_self)); CPyMarshal.WritePtrField(methPtr, typeof(PyMethodObject), "im_class", this.Store(meth.im_class)); this.map.Associate(methPtr, meth); return(methPtr); }
StoreTyped(OldInstance inst) { uint size = (uint)Marshal.SizeOf(typeof(PyInstanceObject)); IntPtr ptr = this.allocator.Alloc(size); CPyMarshal.Zero(ptr, size); CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 1); CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.PyInstance_Type); CPyMarshal.WritePtrField(ptr, typeof(PyInstanceObject), "in_class", this.Store(Builtin.getattr(this.scratchContext, inst, "__class__"))); CPyMarshal.WritePtrField(ptr, typeof(PyInstanceObject), "in_dict", this.Store(Builtin.getattr(this.scratchContext, inst, "__dict__"))); this.map.Associate(ptr, inst); return(ptr); }
StoreTyped(OldClass cls) { uint size = (uint)Marshal.SizeOf(typeof(PyClassObject)); IntPtr ptr = this.allocator.Alloc(size); CPyMarshal.Zero(ptr, size); CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 2); // leak classes deliberately CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.PyClass_Type); CPyMarshal.WritePtrField(ptr, typeof(PyClassObject), "cl_bases", this.Store(Builtin.getattr(this.scratchContext, cls, "__bases__"))); CPyMarshal.WritePtrField(ptr, typeof(PyClassObject), "cl_dict", this.Store(Builtin.getattr(this.scratchContext, cls, "__dict__"))); CPyMarshal.WritePtrField(ptr, typeof(PyClassObject), "cl_name", this.Store(Builtin.getattr(this.scratchContext, cls, "__name__"))); this.map.Associate(ptr, cls); return(ptr); }
CreateTuple(int size) { PyTupleObject tuple = new PyTupleObject(); tuple.ob_refcnt = 1; tuple.ob_type = this.PyTuple_Type; tuple.ob_size = size; int baseSize = Marshal.SizeOf(typeof(PyTupleObject)); int extraSize = (CPyMarshal.PtrSize * (size - 1)); IntPtr tuplePtr = this.allocator.Alloc((uint)(baseSize + extraSize)); Marshal.StructureToPtr(tuple, tuplePtr, false); IntPtr itemsPtr = CPyMarshal.Offset( tuplePtr, Marshal.OffsetOf(typeof(PyTupleObject), "ob_item")); CPyMarshal.Zero(itemsPtr, CPyMarshal.PtrSize * size); return(tuplePtr); }
PyType_GenericAlloc(IntPtr typePtr, int nItems) { int size = CPyMarshal.ReadIntField(typePtr, typeof(PyTypeObject), "tp_basicsize"); if (nItems > 0) { int itemsize = CPyMarshal.ReadIntField(typePtr, typeof(PyTypeObject), "tp_itemsize"); size += (nItems * itemsize); } IntPtr newInstance = this.allocator.Alloc((uint)size); CPyMarshal.Zero(newInstance, size); CPyMarshal.WriteUIntField(newInstance, typeof(PyObject), "ob_refcnt", 1); CPyMarshal.WritePtrField(newInstance, typeof(PyObject), "ob_type", typePtr); if (nItems > 0) { CPyMarshal.WriteIntField(newInstance, typeof(PyVarObject), "ob_size", nItems); } return(newInstance); }
StoreTyped(PythonType _type) { uint typeSize = (uint)Marshal.SizeOf(typeof(PyTypeObject)); IntPtr typePtr = this.allocator.Alloc(typeSize); CPyMarshal.Zero(typePtr, typeSize); CPyMarshal.WriteIntField(typePtr, typeof(PyTypeObject), "ob_refcnt", 2); object ob_type = PythonCalls.Call(this.scratchContext, Builtin.type, new object[] { _type }); CPyMarshal.WritePtrField(typePtr, typeof(PyTypeObject), "ob_type", this.Store(ob_type)); string tp_name = (string)_type.__getattribute__(this.scratchContext, "__name__"); CPyMarshal.WritePtrField(typePtr, typeof(PyTypeObject), "tp_name", this.Store(tp_name)); PythonTuple tp_bases = (PythonTuple)_type.__getattribute__(this.scratchContext, "__bases__"); object tp_base = tp_bases[0]; CPyMarshal.WritePtrField(typePtr, typeof(PyTypeObject), "tp_base", this.Store(tp_base)); if (tp_bases.__len__() > 1) { CPyMarshal.WritePtrField(typePtr, typeof(PyTypeObject), "tp_bases", this.Store(tp_bases)); } this.scratchModule.Get__dict__()["_ironclad_bases"] = tp_bases; this.scratchModule.Get__dict__()["_ironclad_metaclass"] = ob_type; this.ExecInModule(CodeSnippets.CLASS_STUB_CODE, this.scratchModule); this.classStubs[typePtr] = this.scratchModule.Get__dict__()["_ironclad_class_stub"]; this.actualisableTypes[typePtr] = new ActualiseDelegate(this.ActualiseArbitraryObject); this.map.Associate(typePtr, _type); this.PyType_Ready(typePtr); return(typePtr); }