GenerateClass(IntPtr typePtr)
{
ClassBuilder cb = new ClassBuilder(typePtr);
PythonTuple tp_bases = this.ExtractBases(typePtr);
foreach (object _base in tp_bases)
{
this.UpdateMethodTableObj(cb.methodTable, _base);
}
IntPtr ob_typePtr = CPyMarshal.ReadPtrField(typePtr, typeof(PyObject), "ob_type");
this.IncRef(ob_typePtr);
object ob_type = this.Retrieve(ob_typePtr);
this.scratchModule.Get__dict__()["_ironclad_metaclass"] = ob_type;
this.scratchModule.Get__dict__()["_ironclad_bases"] = tp_bases;
this.ExecInModule(cb.code.ToString(), this.scratchModule);
object klass = this.scratchModule.Get__dict__()["_ironclad_class"];
object klass_stub = this.scratchModule.Get__dict__()["_ironclad_class_stub"];
this.classStubs[typePtr] = klass_stub;
Builtin.setattr(this.scratchContext, klass, "_dispatcher", new Dispatcher(this, cb.methodTable));
object typeDict = Builtin.getattr(this.scratchContext, klass, "__dict__");
CPyMarshal.WritePtrField(typePtr, typeof(PyTypeObject), "tp_dict", this.Store(typeDict));
return(klass);
}
IC_PyList_Append_Empty(IntPtr listPtr, ref PyListObject listStruct, IntPtr itemPtr)
{
listStruct.ob_size = 1;
listStruct.allocated = 1;
listStruct.ob_item = this.allocator.Alloc(CPyMarshal.PtrSize);
CPyMarshal.WritePtr(listStruct.ob_item, itemPtr);
Marshal.StructureToPtr(listStruct, listPtr, false);
}
EnsureGIL()
{
this.tempObjects.Push(new List <IntPtr>());
if (this.GIL.Acquire() == 1)
{
CPyMarshal.WritePtr(this._PyThreadState_Current, this.threadState.Ptr);
}
}
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);
}
GenerateRichcmpMethods()
{
if (CPyMarshal.ReadPtrField(this.ptr, typeof(PyTypeObject), "tp_richcompare") != IntPtr.Zero)
{
this.code.Append(String.Format(CodeSnippets.RICHCMP_METHOD_TEMPLATE, tablePrefix));
this.ConnectTypeField("tp_richcompare", typeof(dgt_ptr_ptrptrint));
}
}
_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));
}
ConnectTypeField(string fieldName, Type dgtType)
{
if (CPyMarshal.ReadPtrField(this.ptr, typeof(PyTypeObject), fieldName) != IntPtr.Zero)
{
Delegate dgt = CPyMarshal.ReadFunctionPtrField(this.ptr, typeof(PyTypeObject), fieldName, dgtType);
this.methodTable[this.tablePrefix + fieldName] = dgt;
}
}
IC_str_getsegcount(IntPtr strPtr, IntPtr lenPtr)
{
if (lenPtr != IntPtr.Zero)
{
CPyMarshal.WriteInt(lenPtr, this.PyString_Size(strPtr));
}
return(1);
}
IC_PyBaseObject_Dealloc(IntPtr objPtr)
{
IntPtr objType = CPyMarshal.ReadPtrField(objPtr, typeof(PyObject), "ob_type");
dgt_void_ptr freeDgt = (dgt_void_ptr)
CPyMarshal.ReadFunctionPtrField(
objType, typeof(PyTypeObject), "tp_free", typeof(dgt_void_ptr));
freeDgt(objPtr);
}
StoreTyped(BigInteger value)
{
IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyObject)));
CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 1);
CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.PyLong_Type);
this.map.Associate(ptr, value);
return(ptr);
}
StoreObject(object obj)
{
IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyObject)));
CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 1);
CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.PyBaseObject_Type);
this.map.Associate(ptr, obj);
return(ptr);
}
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);
}
Register_PyFile_Type(IntPtr address)
{
// not worth autogenerating
// we're using the cpy file type by default, with methods patched in C
// to redirect into C# when ipy files turn up
CPyMarshal.WriteIntField(address, typeof(PyTypeObject), "ob_refcnt", 1);
CPyMarshal.WriteCStringField(address, typeof(PyTypeObject), "tp_name", "file");
this.map.Associate(address, TypeCache.PythonFile);
}
CreatePyStringWithBytes(byte[] bytes)
{
IntPtr strPtr = this.AllocPyString(bytes.Length);
IntPtr bufPtr = CPyMarshal.Offset(
strPtr, Marshal.OffsetOf(typeof(PyStringObject), "ob_sval"));
Marshal.Copy(bytes, 0, bufPtr, bytes.Length);
return(strPtr);
}
_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));
}
StoreTyped(double value)
{
IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyFloatObject)));
CPyMarshal.WriteIntField(ptr, typeof(PyFloatObject), "ob_refcnt", 1);
CPyMarshal.WritePtrField(ptr, typeof(PyFloatObject), "ob_type", this.PyFloat_Type);
CPyMarshal.WriteDoubleField(ptr, typeof(PyFloatObject), "ob_fval", value);
this.map.Associate(ptr, value);
return(ptr);
}
StoreTyped(PythonExceptions.BaseException exc)
{
IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyObject)));
CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", 1);
object type_ = PythonCalls.Call(Builtin.type, new object[] { exc });
CPyMarshal.WritePtrField(ptr, typeof(PyObject), "ob_type", this.Store(type_));
this.map.Associate(ptr, exc);
return(ptr);
}
IC__PyString_Resize_NoGrow(IntPtr strPtr, int newSize)
{
CPyMarshal.WriteIntField(strPtr, typeof(PyStringObject), "ob_size", newSize);
IntPtr bufPtr = CPyMarshal.Offset(
strPtr, Marshal.OffsetOf(typeof(PyStringObject), "ob_sval"));
IntPtr terminatorPtr = CPyMarshal.Offset(
bufPtr, newSize);
CPyMarshal.WriteByte(terminatorPtr, 0);
return(0);
}
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);
}
ReadCStringField(IntPtr addr, Type type, string field)
{
IntPtr strPtrAddr = CPyMarshal.GetField(addr, type, field);
IntPtr readAddr = CPyMarshal.ReadPtr(strPtrAddr);
if (readAddr != IntPtr.Zero)
{
return(Marshal.PtrToStringAnsi(readAddr));
}
return("");
}
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);
}
AddNumberMethodsWithIndex(IntPtr typePtr)
{
this.AddNumberMethodsWithoutIndex(typePtr);
IntPtr nmPtr = CPyMarshal.ReadPtrField(typePtr, typeof(PyTypeObject), "tp_as_number");
CPyMarshal.WritePtrField(nmPtr, typeof(PyNumberMethods), "nb_index", this.GetFuncPtr("PyNumber_Index"));
Py_TPFLAGS flags = (Py_TPFLAGS)CPyMarshal.ReadIntField(typePtr, typeof(PyTypeObject), "tp_flags");
flags |= Py_TPFLAGS.HAVE_INDEX;
CPyMarshal.WriteIntField(typePtr, typeof(PyTypeObject), "tp_flags", (Int32)flags);
}
IC_PySlice_Dealloc(IntPtr slicePtr)
{
this.DecRef(CPyMarshal.ReadPtrField(slicePtr, typeof(PySliceObject), "start"));
this.DecRef(CPyMarshal.ReadPtrField(slicePtr, typeof(PySliceObject), "stop"));
this.DecRef(CPyMarshal.ReadPtrField(slicePtr, typeof(PySliceObject), "step"));
dgt_void_ptr freeDgt = (dgt_void_ptr)
CPyMarshal.ReadFunctionPtrField(
this.PySlice_Type, typeof(PyTypeObject), "tp_free", typeof(dgt_void_ptr));
freeDgt(slicePtr);
}
PyString_InternFromString(IntPtr stringData)
{
IntPtr newStrPtr = PyString_FromString(stringData);
IntPtr newStrPtrPtr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(IntPtr)));
CPyMarshal.WritePtr(newStrPtrPtr, newStrPtr);
this.PyString_InternInPlace(newStrPtrPtr);
IntPtr newNewStrPtr = CPyMarshal.ReadPtr(newStrPtrPtr);
this.allocator.Free(newStrPtrPtr);
return(newNewStrPtr);
}
StoreTyped(Slice slice)
{
IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PySliceObject)));
CPyMarshal.WriteIntField(ptr, typeof(PySliceObject), "ob_refcnt", 1);
CPyMarshal.WritePtrField(ptr, typeof(PySliceObject), "ob_type", this.PySlice_Type);
CPyMarshal.WritePtrField(ptr, typeof(PySliceObject), "start", this.Store(slice.start));
CPyMarshal.WritePtrField(ptr, typeof(PySliceObject), "stop", this.Store(slice.stop));
CPyMarshal.WritePtrField(ptr, typeof(PySliceObject), "step", this.Store(slice.step));
this.map.Associate(ptr, slice);
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);
}
StoreTyped(Complex value)
{
IntPtr ptr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyComplexObject)));
CPyMarshal.WriteIntField(ptr, typeof(PyComplexObject), "ob_refcnt", 1);
CPyMarshal.WritePtrField(ptr, typeof(PyComplexObject), "ob_type", this.PyComplex_Type);
IntPtr cpxptr = CPyMarshal.GetField(ptr, typeof(PyComplexObject), "cval");
CPyMarshal.WriteDoubleField(cpxptr, typeof(Py_complex), "real", value.Real);
CPyMarshal.WriteDoubleField(cpxptr, typeof(Py_complex), "imag", value.Imaginary);
this.map.Associate(ptr, value);
return(ptr);
}
IC_PyMethod_Dealloc(IntPtr objPtr)
{
this.DecRef(CPyMarshal.ReadPtrField(objPtr, typeof(PyMethodObject), "im_func"));
this.DecRef(CPyMarshal.ReadPtrField(objPtr, typeof(PyMethodObject), "im_self"));
this.DecRef(CPyMarshal.ReadPtrField(objPtr, typeof(PyMethodObject), "im_class"));
IntPtr objType = CPyMarshal.ReadPtrField(objPtr, typeof(PyObject), "ob_type");
dgt_void_ptr freeDgt = (dgt_void_ptr)
CPyMarshal.ReadFunctionPtrField(
objType, typeof(PyTypeObject), "tp_free", typeof(dgt_void_ptr));
freeDgt(objPtr);
}
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);
}
InheritIntField(IntPtr typePtr, string name)
{
int fieldVal = CPyMarshal.ReadIntField(typePtr, typeof(PyTypeObject), name);
if (fieldVal == 0)
{
IntPtr basePtr = CPyMarshal.ReadPtrField(typePtr, typeof(PyTypeObject), "tp_base");
if (basePtr != IntPtr.Zero)
{
CPyMarshal.WriteIntField(typePtr, typeof(PyTypeObject), name,
CPyMarshal.ReadIntField(basePtr, typeof(PyTypeObject), name));
}
}
}
