static ManagedDataOffsets()
{
NameMapping = TypeOffset.GetOffsets();
FieldInfo[] fields = typeof(DataOffsets).GetFields(BindingFlags.Static | BindingFlags.Public);
size = fields.Length * IntPtr.Size;
}
//====================================================================
// Dealloc implementation. This is called when a Python type generated
// by this metatype is no longer referenced from the Python runtime.
//====================================================================
public static void tp_dealloc(IntPtr tp)
{
// Fix this when we dont cheat on the handle for subclasses!
int flags = (int)Marshal.ReadIntPtr(tp, TypeOffset.tp_flags);
if ((flags & TypeFlags.Subclass) == 0)
{
IntPtr gc = Marshal.ReadIntPtr(tp, TypeOffset.magic());
((GCHandle)gc).Free();
}
IntPtr op = Marshal.ReadIntPtr(tp, TypeOffset.ob_type);
Runtime.Decref(op);
// Delegate the rest of finalization the Python metatype. Note
// that the PyType_Type implementation of tp_dealloc will call
// tp_free on the type of the type being deallocated - in this
// case our CLR metatype. That is why we implement tp_free.
op = Marshal.ReadIntPtr(Runtime.PyTypeType, TypeOffset.tp_dealloc);
NativeCall.Void_Call_1(op, tp);
return;
}
/// <summary>
/// Given a Python object, return the associated managed object or null.
/// </summary>
internal static ManagedType GetManagedObject(IntPtr ob)
{
if (ob != IntPtr.Zero)
{
IntPtr tp = Runtime.PyObject_TYPE(ob);
if (tp == Runtime.PyTypeType || tp == Runtime.PyCLRMetaType)
{
tp = ob;
}
var flags = Util.ReadCLong(tp, TypeOffset.tp_flags);
if ((flags & TypeFlags.Managed) != 0)
{
IntPtr op = tp == ob
? Marshal.ReadIntPtr(tp, TypeOffset.magic())
: Marshal.ReadIntPtr(ob, ObjectOffset.magic(tp));
if (op == IntPtr.Zero)
{
return(null);
}
var gc = (GCHandle)op;
return((ManagedType)gc.Target);
}
}
return(null);
}
/// <summary>
/// Helper for InitializeSlots.
///
/// Initializes one slot to point to a function pointer.
/// The function pointer might be a thunk for C#, or it may be
/// an address in the NativeCodePage.
/// </summary>
/// <param name="type">Type being initialized.</param>
/// <param name="slot">Function pointer.</param>
/// <param name="name">Name of the method.</param>
/// <param name="canOverride">Can override the slot when it existed</param>
static void InitializeSlot(IntPtr type, IntPtr slot, string name, bool canOverride = true)
{
var offset = TypeOffset.GetSlotOffset(name);
if (!canOverride && Marshal.ReadIntPtr(type, offset) != IntPtr.Zero)
{
return;
}
Marshal.WriteIntPtr(type, offset, slot);
}
internal static IntPtr CreateSubType(IntPtr args)
{
IntPtr py_name = Runtime.PyTuple_GetItem(args, 0);
IntPtr bases = Runtime.PyTuple_GetItem(args, 1);
IntPtr dict = Runtime.PyTuple_GetItem(args, 2);
IntPtr base_ = Runtime.PyTuple_GetItem(bases, 0);
string name = Runtime.GetManagedString(py_name);
IntPtr type = AllocateTypeObject(name);
Marshal.WriteIntPtr(type, TypeOffset.ob_type, Runtime.PyCLRMetaType);
Runtime.Incref(Runtime.PyCLRMetaType);
Marshal.WriteIntPtr(type, TypeOffset.tp_basicsize, (IntPtr)obSize);
Marshal.WriteIntPtr(type, TypeOffset.tp_itemsize, IntPtr.Zero);
IntPtr offset = (IntPtr)ObjectOffset.ob_dict;
Marshal.WriteIntPtr(type, TypeOffset.tp_dictoffset, offset);
IntPtr dc = Runtime.PyDict_Copy(dict);
Marshal.WriteIntPtr(type, TypeOffset.tp_dict, dc);
Marshal.WriteIntPtr(type, TypeOffset.tp_base, base_);
Runtime.Incref(base_);
int flags = TypeFlags.Default;
flags |= TypeFlags.Managed;
flags |= TypeFlags.HeapType;
flags |= TypeFlags.BaseType;
flags |= TypeFlags.Subclass;
flags |= TypeFlags.HaveGC;
Marshal.WriteIntPtr(type, TypeOffset.tp_flags, (IntPtr)flags);
CopySlot(base_, type, TypeOffset.tp_traverse);
CopySlot(base_, type, TypeOffset.tp_clear);
CopySlot(base_, type, TypeOffset.tp_is_gc);
Runtime.PyType_Ready(type);
IntPtr tp_dict = Marshal.ReadIntPtr(type, TypeOffset.tp_dict);
IntPtr mod = Runtime.PyString_FromString("CLR");
Runtime.PyDict_SetItemString(tp_dict, "__module__", mod);
// for now, move up hidden handle...
IntPtr gc = Marshal.ReadIntPtr(base_, TypeOffset.magic());
Marshal.WriteIntPtr(type, TypeOffset.magic(), gc);
return(type);
}
protected override void OnLoad(InterDomainContext context)
{
base.OnLoad(context);
if (pyHandle != tpHandle)
{
IntPtr dict = context.Storage.GetValue <IntPtr>("dict");
SetObjectDict(pyHandle, dict);
}
gcHandle = AllocGCHandle();
Marshal.WriteIntPtr(pyHandle, TypeOffset.magic(), (IntPtr)gcHandle);
}
static void InitializeSlot(IntPtr type, ThunkInfo thunk, string name, SlotsHolder slotsHolder = null, bool canOverride = true)
{
int offset = TypeOffset.GetSlotOffset(name);
if (!canOverride && Marshal.ReadIntPtr(type, offset) != IntPtr.Zero)
{
return;
}
Marshal.WriteIntPtr(type, offset, thunk.Address);
if (slotsHolder != null)
{
slotsHolder.Set(offset, thunk);
}
}
public void ResetSlots()
{
if (_alreadyReset)
{
return;
}
_alreadyReset = true;
#if DEBUG
IntPtr tp_name = Marshal.ReadIntPtr(_type, TypeOffset.tp_name);
string typeName = Marshal.PtrToStringAnsi(tp_name);
#endif
foreach (var offset in _slots.Keys)
{
IntPtr ptr = GetDefaultSlot(offset);
#if DEBUG
//DebugUtil.Print($"Set slot<{TypeOffsetHelper.GetSlotNameByOffset(offset)}> to 0x{ptr.ToString("X")} at {typeName}<0x{_type}>");
#endif
Marshal.WriteIntPtr(_type, offset, ptr);
}
foreach (var action in _deallocators)
{
action();
}
foreach (var pair in _customResetors)
{
int offset = pair.Key;
var resetor = pair.Value;
resetor?.Invoke(_type, offset);
}
_customResetors.Clear();
_slots.Clear();
_keepalive.Clear();
_deallocators.Clear();
// Custom reset
IntPtr handlePtr = Marshal.ReadIntPtr(_type, TypeOffset.magic());
if (handlePtr != IntPtr.Zero)
{
GCHandle handle = GCHandle.FromIntPtr(handlePtr);
if (handle.IsAllocated)
{
handle.Free();
}
Marshal.WriteIntPtr(_type, TypeOffset.magic(), IntPtr.Zero);
}
}
internal static IntPtr CreateMetaType(Type impl, out SlotsHolder slotsHolder)
{
// The managed metatype is functionally little different than the
// standard Python metatype (PyType_Type). It overrides certain of
// the standard type slots, and has to subclass PyType_Type for
// certain functions in the C runtime to work correctly with it.
IntPtr type = AllocateTypeObject("CLR Metatype", metatype: Runtime.PyTypeType);
IntPtr py_type = Runtime.PyTypeType;
Marshal.WriteIntPtr(type, TypeOffset.tp_base, py_type);
Runtime.XIncref(py_type);
int size = TypeOffset.magic() + IntPtr.Size;
Marshal.WriteIntPtr(type, TypeOffset.tp_basicsize, new IntPtr(size));
const TypeFlags flags = TypeFlags.Default
| TypeFlags.Managed
| TypeFlags.HeapType
| TypeFlags.HaveGC;
Util.WriteCLong(type, TypeOffset.tp_flags, (int)flags);
// Slots will inherit from TypeType, it's not neccesary for setting them.
// Inheried slots:
// tp_basicsize, tp_itemsize,
// tp_dictoffset, tp_weaklistoffset,
// tp_traverse, tp_clear, tp_is_gc, etc.
slotsHolder = SetupMetaSlots(impl, type);
if (Runtime.PyType_Ready(type) != 0)
{
throw new PythonException();
}
IntPtr dict = Marshal.ReadIntPtr(type, TypeOffset.tp_dict);
IntPtr mod = Runtime.PyString_FromString("CLR");
Runtime.PyDict_SetItemString(dict, "__module__", mod);
// The type has been modified after PyType_Ready has been called
// Refresh the type
Runtime.PyType_Modified(type);
//DebugUtil.DumpType(type);
return(type);
}
/// <summary>
/// Given a Python object, return the associated managed object type or null.
/// </summary>
internal static ManagedType GetManagedObjectType(IntPtr ob)
{
if (ob != IntPtr.Zero)
{
IntPtr tp = Runtime.PyObject_TYPE(ob);
var flags = Util.ReadCLong(tp, TypeOffset.tp_flags);
if ((flags & TypeFlags.Managed) != 0)
{
tp = Marshal.ReadIntPtr(tp, TypeOffset.magic());
var gc = (GCHandle)tp;
return((ManagedType)gc.Target);
}
}
return(null);
}
internal static void DumpType(BorrowedReference type)
{
IntPtr op = Util.ReadIntPtr(type, TypeOffset.tp_name);
string name = Marshal.PtrToStringAnsi(op);
Console.WriteLine("Dump type: {0}", name);
var objMember = Util.ReadRef(type, TypeOffset.ob_type);
Print(" type: ", objMember);
objMember = Util.ReadRef(type, TypeOffset.tp_base);
Print(" base: ", objMember);
objMember = Util.ReadRef(type, TypeOffset.tp_bases);
Print(" bases: ", objMember);
//op = Util.ReadIntPtr(type, TypeOffset.tp_mro);
//DebugUtil.Print(" mro: ", op);
var slots = TypeOffset.GetOffsets();
int size = IntPtr.Size;
foreach (var entry in slots)
{
int offset = entry.Value;
name = entry.Key;
op = Util.ReadIntPtr(type, offset);
Console.WriteLine(" {0}: {1}", name, op);
}
Console.WriteLine("");
Console.WriteLine("");
objMember = Util.ReadRef(type, TypeOffset.tp_dict);
if (objMember == null)
{
Console.WriteLine(" dict: null");
}
else
{
Print(" dict: ", objMember);
}
}
/// <summary>
/// Given a newly allocated Python type object and a managed Type that
/// provides the implementation for the type, connect the type slots of
/// the Python object to the managed methods of the implementing Type.
/// </summary>
internal static void InitializeSlots(IntPtr type, Type impl, SlotsHolder slotsHolder = null)
{
// We work from the most-derived class up; make sure to get
// the most-derived slot and not to override it with a base
// class's slot.
var seen = new HashSet <string>();
while (impl != null)
{
MethodInfo[] methods = impl.GetMethods(tbFlags);
foreach (MethodInfo method in methods)
{
string name = method.Name;
if (!name.StartsWith("tp_") && !TypeOffset.IsSupportedSlotName(name))
{
Debug.Assert(!name.Contains("_") || name.StartsWith("_") || method.IsSpecialName);
continue;
}
if (seen.Contains(name))
{
continue;
}
InitializeSlot(type, Interop.GetThunk(method), name, slotsHolder);
seen.Add(name);
}
impl = impl.BaseType;
}
foreach (string slot in _requiredSlots)
{
if (seen.Contains(slot))
{
continue;
}
var offset = ManagedDataOffsets.GetSlotOffset(slot);
Marshal.WriteIntPtr(type, offset, SlotsHolder.GetDefaultSlot(offset));
}
}
internal IntPtr tpHandle; // PyType *
//====================================================================
// Given a Python object, return the associated managed object or null.
//====================================================================
internal static ManagedType GetManagedObject(IntPtr ob)
{
if (ob != IntPtr.Zero)
{
IntPtr tp = Runtime.PyObject_TYPE(ob);
if (tp == Runtime.PyTypeType || tp == Runtime.PyCLRMetaType)
{
tp = ob;
}
int flags = (int)Marshal.ReadIntPtr(tp, TypeOffset.tp_flags);
if ((flags & TypeFlags.Managed) != 0)
{
IntPtr op = (tp == ob) ?
Marshal.ReadIntPtr(tp, TypeOffset.magic()) :
Marshal.ReadIntPtr(ob, ObjectOffset.magic());
GCHandle gc = (GCHandle)op;
return((ManagedType)gc.Target);
}
// In certain situations, we need to recognize a wrapped
// exception class and be willing to unwrap the class :(
if (Runtime.wrap_exceptions)
{
IntPtr e = Exceptions.UnwrapExceptionClass(ob);
if ((e != IntPtr.Zero) && (e != ob))
{
ManagedType m = GetManagedObject(e);
Runtime.Decref(e);
return(m);
}
}
}
return(null);
}
/// <summary>
/// Metatype __new__ implementation. This is called to create a new
/// class / type when a reflected class is subclassed.
/// </summary>
public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw)
{
int len = Runtime.PyTuple_Size(args);
if (len < 3)
{
return(Exceptions.RaiseTypeError("invalid argument list"));
}
IntPtr name = Runtime.PyTuple_GetItem(args, 0);
IntPtr bases = Runtime.PyTuple_GetItem(args, 1);
IntPtr dict = Runtime.PyTuple_GetItem(args, 2);
// We do not support multiple inheritance, so the bases argument
// should be a 1-item tuple containing the type we are subtyping.
// That type must itself have a managed implementation. We check
// that by making sure its metatype is the CLR metatype.
if (Runtime.PyTuple_Size(bases) != 1)
{
return(Exceptions.RaiseTypeError("cannot use multiple inheritance with managed classes"));
}
IntPtr base_type = Runtime.PyTuple_GetItem(bases, 0);
IntPtr mt = Runtime.PyObject_TYPE(base_type);
if (!(mt == PyCLRMetaType || mt == Runtime.PyTypeType))
{
return(Exceptions.RaiseTypeError("invalid metatype"));
}
// Ensure that the reflected type is appropriate for subclassing,
// disallowing subclassing of delegates, enums and array types.
var cb = GetManagedObject(base_type) as ClassBase;
if (cb != null)
{
if (!cb.CanSubclass())
{
return(Exceptions.RaiseTypeError("delegates, enums and array types cannot be subclassed"));
}
}
IntPtr slots = Runtime.PyDict_GetItemString(dict, "__slots__");
if (slots != IntPtr.Zero)
{
return(Exceptions.RaiseTypeError("subclasses of managed classes do not support __slots__"));
}
// If __assembly__ or __namespace__ are in the class dictionary then create
// a managed sub type.
// This creates a new managed type that can be used from .net to call back
// into python.
if (IntPtr.Zero != dict)
{
Runtime.XIncref(dict);
using (var clsDict = new PyDict(dict))
{
if (clsDict.HasKey("__assembly__") || clsDict.HasKey("__namespace__"))
{
return(TypeManager.CreateSubType(name, base_type, dict));
}
}
}
// otherwise just create a basic type without reflecting back into the managed side.
IntPtr func = Marshal.ReadIntPtr(Runtime.PyTypeType, TypeOffset.tp_new);
IntPtr type = NativeCall.Call_3(func, tp, args, kw);
if (type == IntPtr.Zero)
{
return(IntPtr.Zero);
}
int flags = TypeFlags.Default;
flags |= TypeFlags.Managed;
flags |= TypeFlags.HeapType;
flags |= TypeFlags.BaseType;
flags |= TypeFlags.Subclass;
flags |= TypeFlags.HaveGC;
Util.WriteCLong(type, TypeOffset.tp_flags, flags);
TypeManager.CopySlot(base_type, type, TypeOffset.tp_dealloc);
// Hmm - the standard subtype_traverse, clear look at ob_size to
// do things, so to allow gc to work correctly we need to move
// our hidden handle out of ob_size. Then, in theory we can
// comment this out and still not crash.
TypeManager.CopySlot(base_type, type, TypeOffset.tp_traverse);
TypeManager.CopySlot(base_type, type, TypeOffset.tp_clear);
// for now, move up hidden handle...
IntPtr gc = Marshal.ReadIntPtr(base_type, TypeOffset.magic());
Marshal.WriteIntPtr(type, TypeOffset.magic(), gc);
return(type);
}
internal static IntPtr CreateType(ManagedType impl, Type clrType)
{
// Cleanup the type name to get rid of funny nested type names.
string name = "CLR." + clrType.FullName;
int i = name.LastIndexOf('+');
if (i > -1)
{
name = name.Substring(i + 1);
}
i = name.LastIndexOf('.');
if (i > -1)
{
name = name.Substring(i + 1);
}
IntPtr base_ = IntPtr.Zero;
if (clrType.BaseType != null)
{
ClassBase bc = ClassManager.GetClass(clrType.BaseType);
base_ = bc.pyHandle;
}
IntPtr type = AllocateTypeObject(name);
Marshal.WriteIntPtr(type, TypeOffset.ob_type, Runtime.PyCLRMetaType);
Runtime.Incref(Runtime.PyCLRMetaType);
Marshal.WriteIntPtr(type, TypeOffset.tp_basicsize, (IntPtr)obSize);
Marshal.WriteIntPtr(type, TypeOffset.tp_itemsize, IntPtr.Zero);
IntPtr offset = (IntPtr)ObjectOffset.ob_dict;
Marshal.WriteIntPtr(type, TypeOffset.tp_dictoffset, offset);
InitializeSlots(type, impl.GetType());
if (base_ != IntPtr.Zero)
{
Marshal.WriteIntPtr(type, TypeOffset.tp_base, base_);
Runtime.Incref(base_);
}
int flags = TypeFlags.Default;
flags |= TypeFlags.Managed;
flags |= TypeFlags.HeapType;
flags |= TypeFlags.BaseType;
flags |= TypeFlags.HaveGC;
Marshal.WriteIntPtr(type, TypeOffset.tp_flags, (IntPtr)flags);
// Leverage followup initialization from the Python runtime. Note
// that the type of the new type must PyType_Type at the time we
// call this, else PyType_Ready will skip some slot initialization.
Runtime.PyType_Ready(type);
IntPtr dict = Marshal.ReadIntPtr(type, TypeOffset.tp_dict);
string mn = clrType.Namespace != null ? clrType.Namespace : "";
IntPtr mod = Runtime.PyString_FromString(mn);
Runtime.PyDict_SetItemString(dict, "__module__", mod);
// Hide the gchandle of the implementation in a magic type slot.
GCHandle gc = GCHandle.Alloc(impl);
Marshal.WriteIntPtr(type, TypeOffset.magic(), (IntPtr)gc);
// Set the handle attributes on the implementing instance.
impl.tpHandle = Runtime.PyCLRMetaType;
impl.gcHandle = gc;
impl.pyHandle = type;
//DebugUtil.DumpType(type);
return(type);
}
internal static IntPtr CreateType(ManagedType impl, Type clrType)
{
// Cleanup the type name to get rid of funny nested type names.
string name = "CLR." + clrType.FullName;
int i = name.LastIndexOf('+');
if (i > -1)
{
name = name.Substring(i + 1);
}
i = name.LastIndexOf('.');
if (i > -1)
{
name = name.Substring(i + 1);
}
IntPtr base_ = IntPtr.Zero;
int ob_size = ObjectOffset.Size(Runtime.PyTypeType);
// XXX Hack, use a different base class for System.Exception
// Python 2.5+ allows new style class exceptions but they *must*
// subclass BaseException (or better Exception).
if (typeof(Exception).IsAssignableFrom(clrType))
{
ob_size = ObjectOffset.Size(Exceptions.Exception);
}
int tp_dictoffset = ob_size + ManagedDataOffsets.ob_dict;
if (clrType == typeof(Exception))
{
base_ = Exceptions.Exception;
}
else if (clrType.BaseType != null)
{
ClassBase bc = ClassManager.GetClass(clrType.BaseType);
base_ = bc.pyHandle;
}
IntPtr type = AllocateTypeObject(name);
Marshal.WriteIntPtr(type, TypeOffset.ob_type, Runtime.PyCLRMetaType);
Runtime.XIncref(Runtime.PyCLRMetaType);
Marshal.WriteIntPtr(type, TypeOffset.tp_basicsize, (IntPtr)ob_size);
Marshal.WriteIntPtr(type, TypeOffset.tp_itemsize, IntPtr.Zero);
Marshal.WriteIntPtr(type, TypeOffset.tp_dictoffset, (IntPtr)tp_dictoffset);
// add a __len__ slot for inheritors of ICollection and ICollection<>
if (typeof(ICollection).IsAssignableFrom(clrType) || clrType.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(ICollection <>)))
{
InitializeSlot(type, TypeOffset.mp_length, typeof(mp_length_slot).GetMethod(nameof(mp_length_slot.mp_length)));
}
// we want to do this after the slot stuff above in case the class itself implements a slot method
InitializeSlots(type, impl.GetType());
if (!typeof(IEnumerable).IsAssignableFrom(clrType) &&
!typeof(IEnumerator).IsAssignableFrom(clrType))
{
// The tp_iter slot should only be set for enumerable types.
Marshal.WriteIntPtr(type, TypeOffset.tp_iter, IntPtr.Zero);
}
// Only set mp_subscript and mp_ass_subscript for types with indexers
if (impl is ClassBase cb)
{
if (!(impl is ArrayObject))
{
if (cb.indexer == null || !cb.indexer.CanGet)
{
Marshal.WriteIntPtr(type, TypeOffset.mp_subscript, IntPtr.Zero);
}
if (cb.indexer == null || !cb.indexer.CanSet)
{
Marshal.WriteIntPtr(type, TypeOffset.mp_ass_subscript, IntPtr.Zero);
}
}
}
else
{
Marshal.WriteIntPtr(type, TypeOffset.mp_subscript, IntPtr.Zero);
Marshal.WriteIntPtr(type, TypeOffset.mp_ass_subscript, IntPtr.Zero);
}
if (base_ != IntPtr.Zero)
{
Marshal.WriteIntPtr(type, TypeOffset.tp_base, base_);
Runtime.XIncref(base_);
}
int flags = TypeFlags.Default;
flags |= TypeFlags.Managed;
flags |= TypeFlags.HeapType;
flags |= TypeFlags.BaseType;
flags |= TypeFlags.HaveGC;
Util.WriteCLong(type, TypeOffset.tp_flags, flags);
// Leverage followup initialization from the Python runtime. Note
// that the type of the new type must PyType_Type at the time we
// call this, else PyType_Ready will skip some slot initialization.
Runtime.PyType_Ready(type);
IntPtr dict = Marshal.ReadIntPtr(type, TypeOffset.tp_dict);
string mn = clrType.Namespace ?? "";
IntPtr mod = Runtime.PyString_FromString(mn);
Runtime.PyDict_SetItemString(dict, "__module__", mod);
// Hide the gchandle of the implementation in a magic type slot.
GCHandle gc = GCHandle.Alloc(impl);
Marshal.WriteIntPtr(type, TypeOffset.magic(), (IntPtr)gc);
// Set the handle attributes on the implementing instance.
impl.tpHandle = Runtime.PyCLRMetaType;
impl.gcHandle = gc;
impl.pyHandle = type;
//DebugUtil.DumpType(type);
return(type);
}
public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw)
{
int len = Runtime.PyTuple_Size(args);
if (len < 3)
{
return(Exceptions.RaiseTypeError("invalid argument list"));
}
IntPtr name = Runtime.PyTuple_GetItem(args, 0);
IntPtr bases = Runtime.PyTuple_GetItem(args, 1);
IntPtr dict = Runtime.PyTuple_GetItem(args, 2);
// We do not support multiple inheritance, so the bases argument
// should be a 1-item tuple containing the type we are subtyping.
// That type must itself have a managed implementation. We check
// that by making sure its metatype is the CLR metatype.
if (Runtime.PyTuple_Size(bases) != 1)
{
return(Exceptions.RaiseTypeError(
"cannot use multiple inheritance with managed classes"
));
}
IntPtr base_type = Runtime.PyTuple_GetItem(bases, 0);
IntPtr mt = Runtime.PyObject_TYPE(base_type);
if (!((mt == PyCLRMetaType) || (mt == Runtime.PyTypeType)))
{
return(Exceptions.RaiseTypeError("invalid metatype"));
}
// Ensure that the reflected type is appropriate for subclassing,
// disallowing subclassing of delegates, enums and array types.
ClassBase cb = GetManagedObject(base_type) as ClassBase;
if (cb != null)
{
if (!cb.CanSubclass())
{
return(Exceptions.RaiseTypeError(
"delegates, enums and array types cannot be subclassed"
));
}
}
IntPtr slots = Runtime.PyDict_GetItemString(dict, "__slots__");
if (slots != IntPtr.Zero)
{
return(Exceptions.RaiseTypeError(
"subclasses of managed classes do not support __slots__"
));
}
// hack for now... fix for 1.0
//return TypeManager.CreateSubType(args);
// right way
IntPtr func = Marshal.ReadIntPtr(Runtime.PyTypeType,
TypeOffset.tp_new);
IntPtr type = NativeCall.Call_3(func, tp, args, kw);
if (type == IntPtr.Zero)
{
return(IntPtr.Zero);
}
int flags = TypeFlags.Default;
flags |= TypeFlags.Managed;
flags |= TypeFlags.HeapType;
flags |= TypeFlags.BaseType;
flags |= TypeFlags.Subclass;
flags |= TypeFlags.HaveGC;
Marshal.WriteIntPtr(type, TypeOffset.tp_flags, (IntPtr)flags);
TypeManager.CopySlot(base_type, type, TypeOffset.tp_dealloc);
// Hmm - the standard subtype_traverse, clear look at ob_size to
// do things, so to allow gc to work correctly we need to move
// our hidden handle out of ob_size. Then, in theory we can
// comment this out and still not crash.
TypeManager.CopySlot(base_type, type, TypeOffset.tp_traverse);
TypeManager.CopySlot(base_type, type, TypeOffset.tp_clear);
// for now, move up hidden handle...
IntPtr gc = Marshal.ReadIntPtr(base_type, TypeOffset.magic());
Marshal.WriteIntPtr(type, TypeOffset.magic(), gc);
//DebugUtil.DumpType(base_type);
//DebugUtil.DumpType(type);
return(type);
}
internal static IntPtr CreateType(ManagedType impl, Type clrType)
{
// Cleanup the type name to get rid of funny nested type names.
string name = $"clr.{clrType.FullName}";
int i = name.LastIndexOf('+');
if (i > -1)
{
name = name.Substring(i + 1);
}
i = name.LastIndexOf('.');
if (i > -1)
{
name = name.Substring(i + 1);
}
IntPtr base_ = IntPtr.Zero;
int ob_size = ObjectOffset.Size(Runtime.PyTypeType);
// XXX Hack, use a different base class for System.Exception
// Python 2.5+ allows new style class exceptions but they *must*
// subclass BaseException (or better Exception).
if (typeof(Exception).IsAssignableFrom(clrType))
{
ob_size = ObjectOffset.Size(Exceptions.Exception);
}
int tp_dictoffset = ob_size + ManagedDataOffsets.ob_dict;
if (clrType == typeof(Exception))
{
base_ = Exceptions.Exception;
}
else if (clrType.BaseType != null)
{
ClassBase bc = ClassManager.GetClass(clrType.BaseType);
base_ = bc.pyHandle;
}
IntPtr type = AllocateTypeObject(name, Runtime.PyCLRMetaType);
Marshal.WriteIntPtr(type, TypeOffset.ob_type, Runtime.PyCLRMetaType);
Runtime.XIncref(Runtime.PyCLRMetaType);
Marshal.WriteIntPtr(type, TypeOffset.tp_basicsize, (IntPtr)ob_size);
Marshal.WriteIntPtr(type, TypeOffset.tp_itemsize, IntPtr.Zero);
Marshal.WriteIntPtr(type, TypeOffset.tp_dictoffset, (IntPtr)tp_dictoffset);
// we want to do this after the slot stuff above in case the class itself implements a slot method
SlotsHolder slotsHolder = CreateSolotsHolder(type);
InitializeSlots(type, impl.GetType(), slotsHolder);
if (Marshal.ReadIntPtr(type, TypeOffset.mp_length) == IntPtr.Zero &&
mp_length_slot.CanAssign(clrType))
{
InitializeSlot(type, TypeOffset.mp_length, mp_length_slot.Method, slotsHolder);
}
if (!typeof(IEnumerable).IsAssignableFrom(clrType) &&
!typeof(IEnumerator).IsAssignableFrom(clrType))
{
// The tp_iter slot should only be set for enumerable types.
Marshal.WriteIntPtr(type, TypeOffset.tp_iter, IntPtr.Zero);
}
// Only set mp_subscript and mp_ass_subscript for types with indexers
if (impl is ClassBase cb)
{
if (!(impl is ArrayObject))
{
if (cb.indexer == null || !cb.indexer.CanGet)
{
Marshal.WriteIntPtr(type, TypeOffset.mp_subscript, IntPtr.Zero);
}
if (cb.indexer == null || !cb.indexer.CanSet)
{
Marshal.WriteIntPtr(type, TypeOffset.mp_ass_subscript, IntPtr.Zero);
}
}
}
else
{
Marshal.WriteIntPtr(type, TypeOffset.mp_subscript, IntPtr.Zero);
Marshal.WriteIntPtr(type, TypeOffset.mp_ass_subscript, IntPtr.Zero);
}
if (base_ != IntPtr.Zero)
{
Marshal.WriteIntPtr(type, TypeOffset.tp_base, base_);
Runtime.XIncref(base_);
}
const TypeFlags flags = TypeFlags.Default
| TypeFlags.Managed
| TypeFlags.HeapType
| TypeFlags.BaseType
| TypeFlags.HaveGC;
Util.WriteCLong(type, TypeOffset.tp_flags, (int)flags);
OperatorMethod.FixupSlots(type, clrType);
// Leverage followup initialization from the Python runtime. Note
// that the type of the new type must PyType_Type at the time we
// call this, else PyType_Ready will skip some slot initialization.
if (Runtime.PyType_Ready(type) != 0)
{
throw new PythonException();
}
var dict = new BorrowedReference(Marshal.ReadIntPtr(type, TypeOffset.tp_dict));
string mn = clrType.Namespace ?? "";
var mod = NewReference.DangerousFromPointer(Runtime.PyString_FromString(mn));
Runtime.PyDict_SetItem(dict, PyIdentifier.__module__, mod);
mod.Dispose();
// Hide the gchandle of the implementation in a magic type slot.
GCHandle gc = impl.AllocGCHandle();
Marshal.WriteIntPtr(type, TypeOffset.magic(), (IntPtr)gc);
// Set the handle attributes on the implementing instance.
impl.tpHandle = type;
impl.pyHandle = type;
//DebugUtil.DumpType(type);
return(type);
}
internal static IntPtr CreateType(ManagedType impl, Type clrType)
{
// Cleanup the type name to get rid of funny nested type names.
string name = "CLR." + clrType.FullName;
int i = name.LastIndexOf('+');
if (i > -1)
{
name = name.Substring(i + 1);
}
i = name.LastIndexOf('.');
if (i > -1)
{
name = name.Substring(i + 1);
}
IntPtr base_ = IntPtr.Zero;
int ob_size = ObjectOffset.Size(Runtime.PyTypeType);
int tp_dictoffset = ObjectOffset.DictOffset(Runtime.PyTypeType);
// XXX Hack, use a different base class for System.Exception
// Python 2.5+ allows new style class exceptions but they *must*
// subclass BaseException (or better Exception).
if (typeof(Exception).IsAssignableFrom(clrType))
{
ob_size = ObjectOffset.Size(Exceptions.Exception);
tp_dictoffset = ObjectOffset.DictOffset(Exceptions.Exception);
}
if (clrType == typeof(Exception))
{
base_ = Exceptions.Exception;
}
else if (clrType.BaseType != null)
{
ClassBase bc = ClassManager.GetClass(clrType.BaseType);
base_ = bc.pyHandle;
}
IntPtr type = AllocateTypeObject(name);
Marshal.WriteIntPtr(type, TypeOffset.ob_type, Runtime.PyCLRMetaType);
Runtime.XIncref(Runtime.PyCLRMetaType);
Marshal.WriteIntPtr(type, TypeOffset.tp_basicsize, (IntPtr)ob_size);
Marshal.WriteIntPtr(type, TypeOffset.tp_itemsize, IntPtr.Zero);
Marshal.WriteIntPtr(type, TypeOffset.tp_dictoffset, (IntPtr)tp_dictoffset);
InitializeSlots(type, impl.GetType());
if (base_ != IntPtr.Zero)
{
Marshal.WriteIntPtr(type, TypeOffset.tp_base, base_);
Runtime.XIncref(base_);
}
int flags = TypeFlags.Default;
flags |= TypeFlags.Managed;
flags |= TypeFlags.HeapType;
flags |= TypeFlags.BaseType;
flags |= TypeFlags.HaveGC;
Util.WriteCLong(type, TypeOffset.tp_flags, flags);
// Leverage followup initialization from the Python runtime. Note
// that the type of the new type must PyType_Type at the time we
// call this, else PyType_Ready will skip some slot initialization.
Runtime.PyType_Ready(type);
IntPtr dict = Marshal.ReadIntPtr(type, TypeOffset.tp_dict);
string mn = clrType.Namespace ?? "";
IntPtr mod = Runtime.PyString_FromString(mn);
Runtime.PyDict_SetItemString(dict, "__module__", mod);
// Hide the gchandle of the implementation in a magic type slot.
GCHandle gc = GCHandle.Alloc(impl);
Marshal.WriteIntPtr(type, TypeOffset.magic(), (IntPtr)gc);
// Set the handle attributes on the implementing instance.
impl.tpHandle = Runtime.PyCLRMetaType;
impl.gcHandle = gc;
impl.pyHandle = type;
//DebugUtil.DumpType(type);
return(type);
}
static bool IsSlotSet(IntPtr type, string name)
{
int offset = TypeOffset.GetSlotOffset(name);
return(Marshal.ReadIntPtr(type, offset) != IntPtr.Zero);
}
