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);
}
}
StoreTyped(List list)
{
int length = list.__len__();
PyListObject listStruct = new PyListObject();
listStruct.ob_refcnt = 1;
listStruct.ob_type = this.PyList_Type;
listStruct.ob_size = length;
listStruct.allocated = length;
uint bytes = (uint)length * CPyMarshal.PtrSize;
IntPtr data = this.allocator.Alloc(bytes);
listStruct.ob_item = data;
for (int i = 0; i < length; i++)
{
CPyMarshal.WritePtr(data, this.Store(list[i]));
data = CPyMarshal.Offset(data, CPyMarshal.PtrSize);
}
IntPtr listPtr = this.allocator.Alloc((uint)Marshal.SizeOf(typeof(PyListObject)));
Marshal.StructureToPtr(listStruct, listPtr, false);
this.map.Associate(listPtr, list);
return(listPtr);
}
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);
}
}
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);
}
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);
}
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)));
}
}
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)));
}
}
StoreTyped(PythonTuple tuple)
{
int length = tuple.__len__();
IntPtr tuplePtr = this.CreateTuple(length);
IntPtr itemPtr = CPyMarshal.Offset(
tuplePtr, Marshal.OffsetOf(typeof(PyTupleObject), "ob_item"));
for (int i = 0; i < length; i++)
{
CPyMarshal.WritePtr(itemPtr, this.Store(tuple[i]));
itemPtr = CPyMarshal.Offset(itemPtr, CPyMarshal.PtrSize);
}
this.map.Associate(tuplePtr, tuple);
return(tuplePtr);
}
ActualiseTuple(IntPtr ptr)
{
int itemCount = CPyMarshal.ReadIntField(ptr, typeof(PyTupleObject), "ob_size");
IntPtr itemAddressPtr = CPyMarshal.Offset(ptr, Marshal.OffsetOf(typeof(PyTupleObject), "ob_item"));
object[] items = new object[itemCount];
for (int i = 0; i < itemCount; i++)
{
IntPtr itemPtr = CPyMarshal.ReadPtr(itemAddressPtr);
items[i] = this.Retrieve(itemPtr);
itemAddressPtr = CPyMarshal.Offset(itemAddressPtr, CPyMarshal.PtrSize);
}
this.incompleteObjects.Remove(ptr);
this.map.Associate(ptr, new PythonTuple(items));
}
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);
}
}
IC_PyList_Append_NonEmpty(IntPtr listPtr, ref PyListObject listStruct, IntPtr itemPtr)
{
int oldAllocated = listStruct.allocated;
int oldAllocatedBytes = oldAllocated * CPyMarshal.PtrSize;
listStruct.ob_size += 1;
listStruct.allocated += 1;
IntPtr oldDataStore = listStruct.ob_item;
int newAllocatedBytes = listStruct.allocated * CPyMarshal.PtrSize;
listStruct.ob_item = this.allocator.Realloc(listStruct.ob_item, (uint)newAllocatedBytes);
CPyMarshal.WritePtr(CPyMarshal.Offset(listStruct.ob_item, oldAllocatedBytes), itemPtr);
Marshal.StructureToPtr(listStruct, listPtr, false);
}
Zero(IntPtr start, int bytes)
{
int ptrs = bytes / CPyMarshal.PtrSize;
bytes = bytes % CPyMarshal.PtrSize;
for (int i = 0; i < ptrs; i++)
{
CPyMarshal.WritePtr(start, IntPtr.Zero);
start = CPyMarshal.Offset(start, CPyMarshal.PtrSize);
}
for (int i = 0; i < bytes; i++)
{
CPyMarshal.WriteByte(start, 0);
start = CPyMarshal.Offset(start, 1);
}
}
PyString_FromString(IntPtr stringData)
{
IntPtr current = stringData;
List <byte> bytesList = new List <byte>();
while (CPyMarshal.ReadByte(current) != 0)
{
bytesList.Add(CPyMarshal.ReadByte(current));
current = CPyMarshal.Offset(current, 1);
}
byte[] bytes = new byte[bytesList.Count];
bytesList.CopyTo(bytes);
// note: NOT Associate
// couldn't figure out to test this directly
// without this, h5py tests get horribly screwy in PHIL contextmanager
return(this.Store(this.StringFromBytes(bytes)));
}
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));
}
Log(IntPtr start, int bytes)
{
if (start == IntPtr.Zero)
{
Console.WriteLine("I refuse to attempt to read from 0x00000000");
return;
}
for (int i = 0; i < bytes / CPyMarshal.IntSize; i++)
{
if (i % 4 == 0)
{
Console.WriteLine();
}
Console.Write("{0} ", CPyMarshal.ReadPtr(start).ToString("x8"));
start = CPyMarshal.Offset(start, CPyMarshal.IntSize);
}
Console.WriteLine();
}
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);
}
AllocPyString(int length)
{
uint size = (uint)(Marshal.SizeOf(typeof(PyStringObject)) + length);
IntPtr data = this.allocator.Alloc(size);
PyStringObject s = new PyStringObject();
s.ob_refcnt = 1;
s.ob_type = this.PyString_Type;
s.ob_size = length;
s.ob_shash = -1;
s.ob_sstate = 0;
Marshal.StructureToPtr(s, data, false);
IntPtr terminator = CPyMarshal.Offset(data, size - 1);
CPyMarshal.WriteByte(terminator, 0);
return(data);
}
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);
}
public void set_object(object instance, int offset, object value)
{
this.mapper.EnsureGIL();
try
{
IntPtr instancePtr = this.mapper.Store(instance);
IntPtr valuePtr = this.mapper.Store(value);
IntPtr address = CPyMarshal.Offset(instancePtr, offset);
IntPtr oldValuePtr = CPyMarshal.ReadPtr(address);
CPyMarshal.WritePtr(address, valuePtr);
if (oldValuePtr != IntPtr.Zero)
{
this.mapper.DecRef(oldValuePtr);
}
this.mapper.DecRef(instancePtr);
}
finally
{
this.mapper.ReleaseGIL();
}
}
public object get_string(object instance, int offset)
{
this.mapper.EnsureGIL();
try
{
IntPtr instancePtr = this.mapper.Store(instance);
IntPtr address = CPyMarshal.Offset(instancePtr, offset);
IntPtr value = CPyMarshal.ReadPtr(address);
object ret = null;
if (value != IntPtr.Zero)
{
ret = Marshal.PtrToStringAnsi(value);
}
this.mapper.DecRef(instancePtr);
return(ret);
}
finally
{
this.mapper.ReleaseGIL();
}
}
public object get_object(object instance, int offset)
{
this.mapper.EnsureGIL();
try
{
IntPtr instancePtr = this.mapper.Store(instance);
IntPtr address = CPyMarshal.Offset(instancePtr, offset);
IntPtr retptr = CPyMarshal.ReadPtr(address);
object ret = null;
if (retptr != IntPtr.Zero)
{
ret = this.mapper.Retrieve(retptr);
}
this.mapper.DecRef(instancePtr);
return(ret);
}
finally
{
this.mapper.ReleaseGIL();
}
}
IC_PyTuple_Dealloc(IntPtr tuplePtr)
{
int length = CPyMarshal.ReadIntField(tuplePtr, typeof(PyTupleObject), "ob_size");
IntPtr itemsPtr = CPyMarshal.Offset(
tuplePtr, Marshal.OffsetOf(typeof(PyTupleObject), "ob_item"));
for (int i = 0; i < length; i++)
{
IntPtr itemPtr = CPyMarshal.ReadPtr(
CPyMarshal.Offset(
itemsPtr, i * CPyMarshal.PtrSize));
if (itemPtr != IntPtr.Zero)
{
this.DecRef(itemPtr);
}
}
dgt_void_ptr freeDgt = (dgt_void_ptr)
CPyMarshal.ReadFunctionPtrField(
this.PyTuple_Type, typeof(PyTypeObject), "tp_free", typeof(dgt_void_ptr));
freeDgt(tuplePtr);
}
IC_PyList_Dealloc(IntPtr listPtr)
{
PyListObject listStruct = (PyListObject)Marshal.PtrToStructure(listPtr, typeof(PyListObject));
if (listStruct.ob_item != IntPtr.Zero)
{
IntPtr itemsPtr = listStruct.ob_item;
for (int i = 0; i < listStruct.ob_size; i++)
{
IntPtr itemPtr = CPyMarshal.ReadPtr(itemsPtr);
if (itemPtr != IntPtr.Zero)
{
this.DecRef(itemPtr);
}
itemsPtr = CPyMarshal.Offset(itemsPtr, CPyMarshal.PtrSize);
}
this.allocator.Free(listStruct.ob_item);
}
dgt_void_ptr freeDgt = (dgt_void_ptr)
CPyMarshal.ReadFunctionPtrField(
this.PyList_Type, typeof(PyTypeObject), "tp_free", typeof(dgt_void_ptr));
freeDgt(listPtr);
}
GenerateCallablesFromMethodDefs(StringBuilder code,
IntPtr methods,
PythonDictionary methodTable,
string tablePrefix,
string oldargsTemplate,
string noargsTemplate,
string objargTemplate,
string varargsTemplate,
string varargsKwargsTemplate)
{
IntPtr methodPtr = methods;
if (methodPtr == IntPtr.Zero)
{
return;
}
while (CPyMarshal.ReadInt(methodPtr) != 0)
{
PyMethodDef thisMethod = (PyMethodDef)Marshal.PtrToStructure(
methodPtr, typeof(PyMethodDef));
string name = thisMethod.ml_name;
string template = null;
Delegate dgt = null;
// COEXIST flag ignored; which method is chosen depends on order of calls in ClassBuilder.
bool unsupportedFlags = false;
METH flags = (METH)thisMethod.ml_flags & ~METH.COEXIST;
switch (flags)
{
case METH.OLDARGS:
template = oldargsTemplate;
dgt = Marshal.GetDelegateForFunctionPointer(
thisMethod.ml_meth,
typeof(dgt_ptr_ptrptr));
break;
case METH.NOARGS:
template = noargsTemplate;
dgt = Marshal.GetDelegateForFunctionPointer(
thisMethod.ml_meth,
typeof(dgt_ptr_ptrptr));
break;
case METH.O:
template = objargTemplate;
dgt = Marshal.GetDelegateForFunctionPointer(
thisMethod.ml_meth,
typeof(dgt_ptr_ptrptr));
break;
case METH.VARARGS:
template = varargsTemplate;
dgt = Marshal.GetDelegateForFunctionPointer(
thisMethod.ml_meth,
typeof(dgt_ptr_ptrptr));
break;
case METH.KEYWORDS:
case METH.VARARGS | METH.KEYWORDS:
template = varargsKwargsTemplate;
dgt = Marshal.GetDelegateForFunctionPointer(
thisMethod.ml_meth,
typeof(dgt_ptr_ptrptrptr));
break;
default:
unsupportedFlags = true;
break;
}
if (!unsupportedFlags)
{
code.Append(String.Format(template,
name, thisMethod.ml_doc, tablePrefix));
methodTable[tablePrefix + name] = dgt;
}
else
{
Console.WriteLine("Detected unsupported method flags for {0}{1} ({2}); ignoring.",
tablePrefix, name, thisMethod.ml_flags);
}
methodPtr = CPyMarshal.Offset(methodPtr, Marshal.SizeOf(typeof(PyMethodDef)));
}
}
GetField(IntPtr addr, Type type, string field)
{
return(CPyMarshal.Offset(addr, Marshal.OffsetOf(type, field)));
}
