GenerateProtocolMagicMethods(IntPtr protocolPtr, Type protocol, string[] fields)
{
if (protocolPtr == IntPtr.Zero)
{
return;
}
foreach (string field in fields)
{
if (CPyMarshal.ReadPtrField(protocolPtr, protocol, field) != IntPtr.Zero)
{
string name;
string template;
Type dgtType;
bool needGetSwappedInfo;
MagicMethods.GetInfo(field, out name, out template, out dgtType, out needGetSwappedInfo);
this.methodTable[this.tablePrefix + name] = CPyMarshal.ReadFunctionPtrField(protocolPtr, protocol, field, dgtType);
this.code.Append(String.Format(template, name, "", this.tablePrefix));
if (needGetSwappedInfo)
{
MagicMethods.GetSwappedInfo(field, out name, out template, out dgtType);
this.methodTable[this.tablePrefix + name] = CPyMarshal.ReadFunctionPtrField(protocolPtr, protocol, field, dgtType);;
this.code.Append(String.Format(template, name, "", this.tablePrefix));
}
}
}
}
AttemptToMap(IntPtr ptr)
{
if (this.HasPtr(ptr))
{
return;
}
if (ptr == IntPtr.Zero)
{
throw new CannotInterpretException("cannot map IntPtr.Zero");
}
IntPtr typePtr = CPyMarshal.ReadPtrField(ptr, typeof(PyTypeObject), "ob_type");
this.AttemptToMap(typePtr);
if (!this.actualisableTypes.ContainsKey(typePtr))
{
string msg = "cannot map object at {0} with type at {1} ({2})";
string type_ = CPyMarshal.ReadCStringField(typePtr, typeof(PyTypeObject), "tp_name");
throw new CannotInterpretException(String.Format(msg, ptr.ToString("x"), typePtr.ToString("x"), type_));
}
this.actualisableTypes[typePtr](ptr);
}
PySequence_Repeat(IntPtr objPtr, int count)
{
try
{
IntPtr typePtr = CPyMarshal.ReadPtrField(objPtr, typeof(PyObject), "ob_type");
IntPtr seqPtr = CPyMarshal.ReadPtrField(typePtr, typeof(PyTypeObject), "tp_as_sequence");
if (seqPtr != IntPtr.Zero)
{
IntPtr sq_repeat = CPyMarshal.ReadPtrField(seqPtr, typeof(PySequenceMethods), "sq_repeat");
if (sq_repeat != IntPtr.Zero)
{
dgt_ptr_ptrint dgt = (dgt_ptr_ptrint)CPyMarshal.ReadFunctionPtrField(
seqPtr, typeof(PySequenceMethods), "sq_repeat", typeof(dgt_ptr_ptrint));
return(dgt(objPtr, count));
}
}
object obj = this.Retrieve(objPtr);
if ((!Builtin.isinstance(obj, TypeCache.PythonType)) &&
Builtin.hasattr(this.scratchContext, obj, "__len__") &&
Builtin.hasattr(this.scratchContext, obj, "__getitem__"))
{
return(this.Store(PythonOperator.mul(this.scratchContext, obj, (int)count)));
}
throw PythonOps.TypeError("PySequence_Repeat: failed to convert {0} to sequence", obj);
}
catch (Exception e)
{
this.LastException = e;
return(IntPtr.Zero);
}
}
PySequence_GetItem(IntPtr objPtr, int idx)
{
try
{
if (CPyMarshal.ReadPtrField(objPtr, typeof(PyObject), "ob_type") == this.PyTuple_Type)
{
IntPtr storagePtr = CPyMarshal.Offset(objPtr, Marshal.OffsetOf(typeof(PyTupleObject), "ob_item"));
int size = CPyMarshal.ReadIntField(objPtr, typeof(PyTupleObject), "ob_size");
if (idx >= size)
{
throw PythonOps.IndexError("PySequence_GetItem: tuple index {0} out of range", idx);
}
IntPtr slotPtr = CPyMarshal.Offset(storagePtr, idx * CPyMarshal.PtrSize);
IntPtr itemPtr = CPyMarshal.ReadPtr(slotPtr);
uint refcnt = CPyMarshal.ReadUIntField(itemPtr, typeof(PyObject), "ob_refcnt");
CPyMarshal.WriteUIntField(itemPtr, typeof(PyObject), "ob_refcnt", refcnt + 1);
return(itemPtr);
}
object sequence = this.Retrieve(objPtr);
object getitem;
if (PythonOps.TryGetBoundAttr(sequence, "__getitem__", out getitem))
{
return(this.Store(PythonCalls.Call(getitem, idx)));
}
throw PythonOps.TypeError("PySequence_GetItem: failed to convert {0} to sequence", sequence);
}
catch (Exception e)
{
this.LastException = e;
return(IntPtr.Zero);
}
}
ActualiseArbitraryObject(IntPtr ptr)
{
IntPtr typePtr = CPyMarshal.ReadPtrField(ptr, typeof(PyObject), "ob_type");
PythonType type_ = (PythonType)this.Retrieve(typePtr);
object[] args = new object[] {};
if (Builtin.issubclass(this.scratchContext, type_, TypeCache.Int32))
{
args = new object[] { CPyMarshal.ReadIntField(ptr, typeof(PyIntObject), "ob_ival") };
}
if (Builtin.issubclass(this.scratchContext, type_, TypeCache.Double))
{
args = new object[] { CPyMarshal.ReadDoubleField(ptr, typeof(PyFloatObject), "ob_fval") };
}
if (Builtin.issubclass(this.scratchContext, type_, TypeCache.String))
{
args = new object[] { this.ReadPyString(ptr) };
}
if (Builtin.issubclass(this.scratchContext, type_, TypeCache.PythonType))
{
string name = CPyMarshal.ReadCStringField(ptr, typeof(PyTypeObject), "tp_name");
PythonTuple tp_bases = this.ExtractBases(typePtr);
args = new object[] { name, tp_bases, new PythonDictionary() };
}
object obj = PythonCalls.Call(this.classStubs[typePtr], args);
Builtin.setattr(this.scratchContext, obj, "__class__", type_);
this.StoreBridge(ptr, obj);
this.IncRef(ptr);
GC.KeepAlive(obj); // TODO: please test me, if you can work out how to
}
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);
}
PyString_AsStringAndSize(IntPtr strPtr, IntPtr dataPtrPtr, IntPtr sizePtr)
{
try
{
if (CPyMarshal.ReadPtrField(strPtr, typeof(PyObject), "ob_type") != this.PyString_Type)
{
throw PythonOps.TypeError("PyString_AsStringAndSize: not a string");
}
IntPtr dataPtr = CPyMarshal.GetField(strPtr, typeof(PyStringObject), "ob_sval");
CPyMarshal.WritePtr(dataPtrPtr, dataPtr);
int length = CPyMarshal.ReadIntField(strPtr, typeof(PyStringObject), "ob_size");
if (sizePtr == IntPtr.Zero)
{
for (int i = 0; i < length; ++i)
{
if (CPyMarshal.ReadByte(CPyMarshal.Offset(dataPtr, i)) == 0)
{
throw PythonOps.TypeError("PyString_AsStringAndSize: string contains embedded 0s, but sizePtr is null");
}
}
}
else
{
CPyMarshal.WriteInt(sizePtr, length);
}
return(0);
}
catch (Exception e)
{
this.LastException = e;
return(-1);
}
}
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));
}
}
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_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);
}
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);
}
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);
}
IC_file_dealloc(IntPtr ptr)
{
if (this.FILEs.ContainsKey(ptr))
{
Unmanaged.fclose(this.FILEs[ptr]);
this.FILEs.Remove(ptr);
}
IntPtr _type = CPyMarshal.ReadPtrField(ptr, typeof(PyObject), "ob_type");
dgt_void_ptr freeDgt = (dgt_void_ptr)
CPyMarshal.ReadFunctionPtrField(
_type, typeof(PyTypeObject), "tp_free", typeof(dgt_void_ptr));
freeDgt(ptr);
}
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));
}
}
}
GenerateProperties()
{
IntPtr getsetPtr = CPyMarshal.ReadPtrField(this.ptr, typeof(PyTypeObject), "tp_getset");
if (getsetPtr == IntPtr.Zero)
{
return;
}
while (CPyMarshal.ReadInt(getsetPtr) != 0)
{
this.GenerateProperty(getsetPtr);
getsetPtr = CPyMarshal.Offset(getsetPtr, Marshal.SizeOf(typeof(PyGetSetDef)));
}
}
GenerateMembers()
{
IntPtr memberPtr = CPyMarshal.ReadPtrField(this.ptr, typeof(PyTypeObject), "tp_members");
if (memberPtr == IntPtr.Zero)
{
return;
}
while (CPyMarshal.ReadInt(memberPtr) != 0)
{
this.GenerateMember(memberPtr);
memberPtr = CPyMarshal.Offset(memberPtr, Marshal.SizeOf(typeof(PyMemberDef)));
}
}
IC_PyInstance_Dealloc(IntPtr objPtr)
{
IntPtr dictPtr = CPyMarshal.ReadPtrField(objPtr, typeof(PyInstanceObject), "in_dict");
if (dictPtr != IntPtr.Zero)
{
this.DecRef(dictPtr);
}
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);
}
ExtractBases(IntPtr typePtr)
{
PythonTuple tp_bases = null;
IntPtr tp_basesPtr = CPyMarshal.ReadPtrField(typePtr, typeof(PyTypeObject), "tp_bases");
if (tp_basesPtr != IntPtr.Zero)
{
tp_bases = (PythonTuple)this.Retrieve(tp_basesPtr);
}
if (tp_bases == null)
{
IntPtr tp_basePtr = CPyMarshal.ReadPtrField(typePtr, typeof(PyTypeObject), "tp_base");
tp_bases = new PythonTuple(new object[] { this.Retrieve(tp_basePtr) });
}
return(tp_bases);
}
PyString_AsString(IntPtr strPtr)
{
try
{
if (CPyMarshal.ReadPtrField(strPtr, typeof(PyObject), "ob_type") != this.PyString_Type)
{
throw PythonOps.TypeError("PyString_AsString: not a string");
}
return(CPyMarshal.Offset(strPtr, Marshal.OffsetOf(typeof(PyStringObject), "ob_sval")));
}
catch (Exception e)
{
this.LastException = e;
return(IntPtr.Zero);
}
}
ReadPyString(IntPtr ptr)
{
IntPtr typePtr = CPyMarshal.ReadPtrField(ptr, typeof(PyObject), "ob_type");
if (PyType_IsSubtype(typePtr, this.PyString_Type) == 0)
{
throw new ArgumentTypeException("ReadPyString: Expected a str, or subclass thereof");
}
IntPtr buffer = CPyMarshal.Offset(ptr, Marshal.OffsetOf(typeof(PyStringObject), "ob_sval"));
int length = CPyMarshal.ReadIntField(ptr, typeof(PyStringObject), "ob_size");
byte[] bytes = new byte[length];
Marshal.Copy(buffer, bytes, 0, length);
char[] chars = Array.ConvertAll <byte, char>(
bytes, new Converter <byte, char>(CharFromByte));
return(new string(chars));
}
PySequence_Tuple(IntPtr seqPtr)
{
try
{
if (CPyMarshal.ReadPtrField(seqPtr, typeof(PyObject), "ob_type") == this.PyTuple_Type)
{
this.IncRef(seqPtr);
return(seqPtr);
}
object seq = this.Retrieve(seqPtr);
return(this.Store(PythonCalls.Call(TypeCache.PythonTuple, new object[] { seq })));
}
catch (Exception e)
{
this.LastException = e;
return(IntPtr.Zero);
}
}
DecRef(IntPtr ptr)
{
this.AttemptToMap(ptr);
if (!this.HasPtr(ptr))
{
throw new KeyNotFoundException(String.Format(
"DecRef: missing key in pointer map: {0}", ptr.ToString("x")));
}
int count = CPyMarshal.ReadIntField(ptr, typeof(PyObject), "ob_refcnt");
if (count == 0)
{
throw new BadRefCountException("Trying to DecRef an object with ref count 0");
}
else if (count == 1)
{
IntPtr typePtr = CPyMarshal.ReadPtrField(ptr, typeof(PyObject), "ob_type");
if (typePtr == IntPtr.Zero)
{
throw new CannotInterpretException(String.Format(
"Cannot destroy object at {0}: null type", ptr.ToString("x")));
}
if (CPyMarshal.ReadPtrField(typePtr, typeof(PyTypeObject), "tp_dealloc") == IntPtr.Zero)
{
throw new CannotInterpretException(String.Format(
"Cannot destroy object at {0} with type at {1}: no dealloc function", ptr.ToString("x"), typePtr.ToString("x")));
}
dgt_void_ptr deallocDgt = (dgt_void_ptr)CPyMarshal.ReadFunctionPtrField(
typePtr, typeof(PyTypeObject), "tp_dealloc", typeof(dgt_void_ptr));
deallocDgt(ptr);
}
else
{
CPyMarshal.WriteIntField(ptr, typeof(PyObject), "ob_refcnt", count - 1);
if (this.map.HasPtr(ptr))
{
this.map.UpdateStrength(ptr);
}
}
}
DumpPtr(IntPtr ptr)
{
if (!this.allocator.Contains(ptr))
{
// we don't own this memory; not our problem.
return;
}
try
{
IntPtr typePtr = CPyMarshal.ReadPtrField(ptr, typeof(PyObject), "ob_type");
if (typePtr == IntPtr.Zero)
{
// no type
return;
}
if (CPyMarshal.ReadPtrField(typePtr, typeof(PyTypeObject), "tp_dealloc") == IntPtr.Zero)
{
// no dealloc function
return;
}
dgt_void_ptr dealloc = (dgt_void_ptr)
CPyMarshal.ReadFunctionPtrField(
typePtr, typeof(PyTypeObject), "tp_dealloc", typeof(dgt_void_ptr));
dealloc(ptr);
}
// not really surprised to see these errors...
catch (BadMappingException) {}
catch (AccessViolationException) {}
catch (NullReferenceException) {}
// may be worth mentioning other errors though
catch (Exception e)
{
if (this.logErrors)
{
Console.WriteLine("unexpected error during DumpPtr:\n{0}", e);
}
}
}
PyList_SetItem(IntPtr listPtr, int index, IntPtr itemPtr)
{
if (!this.HasPtr(listPtr))
{
this.DecRef(itemPtr);
return(-1);
}
IntPtr typePtr = CPyMarshal.ReadPtrField(listPtr, typeof(PyObject), "ob_type");
if (typePtr != this.PyList_Type)
{
this.DecRef(itemPtr);
return(-1);
}
uint length = CPyMarshal.ReadUIntField(listPtr, typeof(PyListObject), "ob_size");
if (index < 0 || index >= length)
{
this.DecRef(itemPtr);
return(-1);
}
IntPtr dataPtr = CPyMarshal.ReadPtrField(listPtr, typeof(PyListObject), "ob_item");
IntPtr oldItemPtrPtr = CPyMarshal.Offset(dataPtr, (int)(index * CPyMarshal.PtrSize));
IntPtr oldItemPtr = CPyMarshal.ReadPtr(oldItemPtrPtr);
if (oldItemPtr != IntPtr.Zero)
{
this.DecRef(oldItemPtr);
}
CPyMarshal.WritePtr(oldItemPtrPtr, itemPtr);
if (this.map.HasPtr(listPtr))
{
object item = this.Retrieve(itemPtr);
List list = (List)this.Retrieve(listPtr);
list[index] = item;
}
return(0);
}
ActualiseList(IntPtr ptr)
{
if (this.listsBeingActualised.ContainsKey(ptr))
{
throw new Exception("Fatal error: PythonMapper.listsBeingActualised is somehow corrupt");
}
List newList = new List();
this.listsBeingActualised[ptr] = newList;
int length = CPyMarshal.ReadIntField(ptr, typeof(PyListObject), "ob_size");
if (length != 0)
{
IntPtr itemPtrPtr = CPyMarshal.ReadPtrField(ptr, typeof(PyListObject), "ob_item");
for (int i = 0; i < length; i++)
{
IntPtr itemPtr = CPyMarshal.ReadPtr(itemPtrPtr);
if (itemPtr == IntPtr.Zero)
{
// We have *no* idea what to do here.
throw new ArgumentException("Attempted to Retrieve uninitialised PyListObject -- expect strange bugs");
}
if (this.listsBeingActualised.ContainsKey(itemPtr))
{
newList.append(this.listsBeingActualised[itemPtr]);
}
else
{
newList.append(this.Retrieve(itemPtr));
}
itemPtrPtr = CPyMarshal.Offset(itemPtrPtr, CPyMarshal.PtrSize);
}
}
this.listsBeingActualised.Remove(ptr);
this.incompleteObjects.Remove(ptr);
this.map.Associate(ptr, newList);
}
PySequence_SetItem(IntPtr objPtr, int idx, IntPtr valuePtr)
{
try
{
IntPtr typePtr = CPyMarshal.ReadPtrField(objPtr, typeof(PyObject), "ob_type");
if (typePtr == this.PyList_Type)
{
int newIdx = idx;
int length = CPyMarshal.ReadIntField(objPtr, typeof(PyListObject), "ob_size");
if (newIdx < 0)
{
newIdx += length;
}
if (newIdx >= 0 && newIdx < length)
{
this.IncRef(valuePtr);
return(this.PyList_SetItem(objPtr, newIdx, valuePtr));
}
// otherwise, fall through and allow normal exception to occur
}
object sequence = this.Retrieve(objPtr);
object setitem;
if (PythonOps.TryGetBoundAttr(sequence, "__setitem__", out setitem))
{
PythonCalls.Call(setitem, idx, this.Retrieve(valuePtr));
return(0);
}
throw PythonOps.TypeError("PySequence_SetItem: failed to convert {0} to sequence", sequence);
}
catch (Exception e)
{
this.LastException = e;
return(-1);
}
}
PyType_Ready(IntPtr typePtr)
{
if (typePtr == IntPtr.Zero)
{
return(-1);
}
Py_TPFLAGS flags = (Py_TPFLAGS)CPyMarshal.ReadIntField(typePtr, typeof(PyTypeObject), "tp_flags");
if ((Int32)(flags & (Py_TPFLAGS.READY | Py_TPFLAGS.READYING)) != 0)
{
return(0);
}
flags |= Py_TPFLAGS.READYING;
CPyMarshal.WriteIntField(typePtr, typeof(PyTypeObject), "tp_flags", (Int32)flags);
IntPtr typeTypePtr = CPyMarshal.ReadPtrField(typePtr, typeof(PyTypeObject), "ob_type");
if ((typeTypePtr == IntPtr.Zero) && (typePtr != this.PyType_Type))
{
CPyMarshal.WritePtrField(typePtr, typeof(PyTypeObject), "ob_type", this.PyType_Type);
}
IntPtr typeBasePtr = CPyMarshal.ReadPtrField(typePtr, typeof(PyTypeObject), "tp_base");
if ((typeBasePtr == IntPtr.Zero) && (typePtr != this.PyBaseObject_Type))
{
typeBasePtr = this.PyBaseObject_Type;
CPyMarshal.WritePtrField(typePtr, typeof(PyTypeObject), "tp_base", typeBasePtr);
}
PyType_Ready(typeBasePtr);
this.InheritSubclassFlags(typePtr);
this.InheritPtrField(typePtr, "tp_alloc");
this.InheritPtrField(typePtr, "tp_new");
this.InheritPtrField(typePtr, "tp_dealloc");
this.InheritPtrField(typePtr, "tp_free");
this.InheritPtrField(typePtr, "tp_doc");
this.InheritPtrField(typePtr, "tp_call");
this.InheritPtrField(typePtr, "tp_as_number");
this.InheritPtrField(typePtr, "tp_as_sequence");
this.InheritPtrField(typePtr, "tp_as_mapping");
this.InheritPtrField(typePtr, "tp_as_buffer");
this.InheritIntField(typePtr, "tp_basicsize");
this.InheritIntField(typePtr, "tp_itemsize");
if (!this.HasPtr(typePtr))
{
this.Retrieve(typePtr);
}
else
{
object klass = this.Retrieve(typePtr);
if (Builtin.hasattr(this.scratchContext, klass, "__dict__"))
{
object typeDict = Builtin.getattr(this.scratchContext, klass, "__dict__");
CPyMarshal.WritePtrField(typePtr, typeof(PyTypeObject), "tp_dict", this.Store(typeDict));
}
}
flags = (Py_TPFLAGS)CPyMarshal.ReadIntField(typePtr, typeof(PyTypeObject), "tp_flags");
flags |= Py_TPFLAGS.READY | Py_TPFLAGS.HAVE_CLASS;
flags &= ~Py_TPFLAGS.READYING;
CPyMarshal.WriteIntField(typePtr, typeof(PyTypeObject), "tp_flags", (Int32)flags);
return(0);
}
GenerateMethods()
{
IntPtr methodsPtr = CPyMarshal.ReadPtrField(this.ptr, typeof(PyTypeObject), "tp_methods");
CallableBuilder.GenerateMethods(this.code, methodsPtr, this.methodTable, this.tablePrefix);
}
GenerateNamedProtocolMagicMethods(string protocolName, Type protocolType, string[] fields)
{
IntPtr pPtr = CPyMarshal.ReadPtrField(this.ptr, typeof(PyTypeObject), protocolName);
this.GenerateProtocolMagicMethods(pPtr, protocolType, fields);
}
