From f121c44a04f77a02f9b98df798dae91dd7aa8ee0 Mon Sep 17 00:00:00 2001 From: dse Date: Sun, 27 Aug 2017 11:20:50 +0400 Subject: [PATCH 1/2] Interop fix for Py_ssize_t methods (it's produces problems only on NetCoreApp 2.0). --- CHANGELOG.md | 2 + src/embed_tests/TestPySequence.cs | 6 +- src/runtime/exceptions.cs | 2 +- src/runtime/runtime.cs | 266 +++++++++++++++++++++++++----- 4 files changed, 226 insertions(+), 50 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index aac38988b..4568857d4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][]. - Fixed Visual Studio 2017 compat ([#434][i434]) for setup.py - Fixed crashes when integrating pythonnet in Unity3d ([#714][i714]), related to unloading the Application Domain +- Fixed interop methods with Py_ssize_t. NetCoreApp 2.0 is more sensitive than net40 and requires this fix. ([#531][p531]) - Fixed crash on exit of the Python interpreter if a python class derived from a .NET class has a `__namespace__` or `__assembly__` attribute ([#481][i481]) @@ -688,3 +689,4 @@ This document follows the conventions laid out in [Keep a CHANGELOG][]. [p163]: https://github.com/pythonnet/pythonnet/pull/163 [p625]: https://github.com/pythonnet/pythonnet/pull/625 [i131]: https://github.com/pythonnet/pythonnet/issues/131 +[p531]: https://github.com/pythonnet/pythonnet/pull/531 diff --git a/src/embed_tests/TestPySequence.cs b/src/embed_tests/TestPySequence.cs index 1e3ebf144..7c175b1ce 100644 --- a/src/embed_tests/TestPySequence.cs +++ b/src/embed_tests/TestPySequence.cs @@ -69,10 +69,8 @@ public void TestRepeat() PyObject actual = t1.Repeat(3); Assert.AreEqual("FooFooFoo", actual.ToString()); - // On 32 bit system this argument should be int, but on the 64 bit system this should be long value. - // This works on the Framework 4.0 accidentally, it should produce out of memory! - // actual = t1.Repeat(-3); - // Assert.AreEqual("", actual.ToString()); + actual = t1.Repeat(-3); + Assert.AreEqual("", actual.ToString()); } [Test] diff --git a/src/runtime/exceptions.cs b/src/runtime/exceptions.cs index 9023cfcfa..743b5416f 100644 --- a/src/runtime/exceptions.cs +++ b/src/runtime/exceptions.cs @@ -276,7 +276,7 @@ public static void SetError(Exception e) /// public static bool ErrorOccurred() { - return Runtime.PyErr_Occurred() != 0; + return Runtime.PyErr_Occurred() != IntPtr.Zero; } /// diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs index 9423b0138..55b4d1b9d 100644 --- a/src/runtime/runtime.cs +++ b/src/runtime/runtime.cs @@ -527,7 +527,7 @@ internal static int AtExit() /// internal static void CheckExceptionOccurred() { - if (PyErr_Occurred() != 0) + if (PyErr_Occurred() != IntPtr.Zero) { throw new PythonException(); } @@ -1009,8 +1009,13 @@ internal static int PyObject_Compare(IntPtr value1, IntPtr value2) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern int PyObject_Not(IntPtr pointer); - [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyObject_Size(IntPtr pointer); + internal static int PyObject_Size(IntPtr pointer) + { + return (int) _PyObject_Size(pointer); + } + + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyObject_Size")] + private static extern IntPtr _PyObject_Size(IntPtr pointer); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyObject_Hash(IntPtr op); @@ -1240,26 +1245,61 @@ internal static bool PyFloat_Check(IntPtr ob) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern bool PySequence_Check(IntPtr pointer); - [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PySequence_GetItem(IntPtr pointer, int index); + internal static IntPtr PySequence_GetItem(IntPtr pointer, int index) + { + return PySequence_GetItem(pointer, (IntPtr) index); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PySequence_SetItem(IntPtr pointer, int index, IntPtr value); + private static extern IntPtr PySequence_GetItem(IntPtr pointer, IntPtr index); + + internal static int PySequence_SetItem(IntPtr pointer, int index, IntPtr value) + { + return PySequence_SetItem(pointer, (IntPtr)index, value); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PySequence_DelItem(IntPtr pointer, int index); + private static extern int PySequence_SetItem(IntPtr pointer, IntPtr index, IntPtr value); + + internal static int PySequence_DelItem(IntPtr pointer, int index) + { + return PySequence_DelItem(pointer, (IntPtr)index); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PySequence_GetSlice(IntPtr pointer, int i1, int i2); + private static extern int PySequence_DelItem(IntPtr pointer, IntPtr index); + + internal static IntPtr PySequence_GetSlice(IntPtr pointer, int i1, int i2) + { + return PySequence_GetSlice(pointer, (IntPtr)i1, (IntPtr)i2); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PySequence_SetSlice(IntPtr pointer, int i1, int i2, IntPtr v); + private static extern IntPtr PySequence_GetSlice(IntPtr pointer, IntPtr i1, IntPtr i2); + + internal static int PySequence_SetSlice(IntPtr pointer, int i1, int i2, IntPtr v) + { + return PySequence_SetSlice(pointer, (IntPtr) i1, (IntPtr) i2, v); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PySequence_DelSlice(IntPtr pointer, int i1, int i2); + private static extern int PySequence_SetSlice(IntPtr pointer, IntPtr i1, IntPtr i2, IntPtr v); + + internal static int PySequence_DelSlice(IntPtr pointer, int i1, int i2) + { + return PySequence_DelSlice(pointer, (IntPtr) i1, (IntPtr) i2); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PySequence_Size(IntPtr pointer); + private static extern int PySequence_DelSlice(IntPtr pointer, IntPtr i1, IntPtr i2); + + internal static int PySequence_Size(IntPtr pointer) + { + return (int) _PySequence_Size(pointer); + } + + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PySequence_Size")] + private static extern IntPtr _PySequence_Size(IntPtr pointer); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern int PySequence_Contains(IntPtr pointer, IntPtr item); @@ -1267,14 +1307,24 @@ internal static bool PyFloat_Check(IntPtr ob) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PySequence_Concat(IntPtr pointer, IntPtr other); + internal static IntPtr PySequence_Repeat(IntPtr pointer, int count) + { + return PySequence_Repeat(pointer, (IntPtr) count); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PySequence_Repeat(IntPtr pointer, int count); + private static extern IntPtr PySequence_Repeat(IntPtr pointer, IntPtr count); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern int PySequence_Index(IntPtr pointer, IntPtr item); - [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PySequence_Count(IntPtr pointer, IntPtr value); + internal static int PySequence_Count(IntPtr pointer, IntPtr value) + { + return (int) _PySequence_Count(pointer, value); + } + + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PySequence_Count")] + private static extern IntPtr _PySequence_Count(IntPtr pointer, IntPtr value); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PySequence_Tuple(IntPtr pointer); @@ -1311,19 +1361,46 @@ internal static IntPtr PyString_FromString(string value) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyBytes_FromString(string op); - [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyBytes_Size(IntPtr op); + internal static int PyBytes_Size(IntPtr op) + { + return (int) _PyBytes_Size(op); + } + + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyBytes_Size")] + private static extern IntPtr _PyBytes_Size(IntPtr op); internal static IntPtr PyBytes_AS_STRING(IntPtr ob) { return ob + BytesOffset.ob_sval; } + internal static IntPtr PyString_FromStringAndSize(string value, int size) + { + return _PyString_FromStringAndSize(value, (IntPtr) size); + } + + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, + EntryPoint = "PyUnicode_FromStringAndSize")] + internal static extern IntPtr _PyString_FromStringAndSize( + [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8Marshaler))] string value, + IntPtr size + ); + + internal static IntPtr PyUnicode_FromStringAndSize(IntPtr value, int size) + { + return PyUnicode_FromStringAndSize(value, (IntPtr) size); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyUnicode_FromStringAndSize(IntPtr value, int size); + private static extern IntPtr PyUnicode_FromStringAndSize(IntPtr value, IntPtr size); #elif PYTHON2 + internal static IntPtr PyString_FromStringAndSize(string value, int size) + { + return PyString_FromStringAndSize(value, (IntPtr) size); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyString_FromStringAndSize(string value, int size); + private static extern IntPtr PyString_FromStringAndSize(string value, IntPtr size); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyString_AsString(IntPtr op); @@ -1344,11 +1421,16 @@ internal static bool PyUnicode_Check(IntPtr ob) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyUnicode_FromEncodedObject(IntPtr ob, IntPtr enc, IntPtr err); + internal static IntPtr PyUnicode_FromKindAndData(int kind, string s, int size) + { + return PyUnicode_FromKindAndData(kind, s, (IntPtr) size); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyUnicode_FromKindAndData( + private static extern IntPtr PyUnicode_FromKindAndData( int kind, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UcsMarshaler))] string s, - int size + IntPtr size ); internal static IntPtr PyUnicode_FromUnicode(string s, int size) @@ -1356,8 +1438,13 @@ internal static IntPtr PyUnicode_FromUnicode(string s, int size) return PyUnicode_FromKindAndData(_UCS, s, size); } - [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyUnicode_GetSize(IntPtr ob); + internal static int PyUnicode_GetSize(IntPtr ob) + { + return (int)_PyUnicode_GetSize(ob); + } + + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyUnicode_GetSize")] + private static extern IntPtr _PyUnicode_GetSize(IntPtr ob); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyUnicode_AsUnicode(IntPtr ob); @@ -1373,16 +1460,26 @@ internal static IntPtr PyUnicode_FromUnicode(string s, int size) EntryPoint = PyUnicodeEntryPoint + "FromEncodedObject")] internal static extern IntPtr PyUnicode_FromEncodedObject(IntPtr ob, IntPtr enc, IntPtr err); + internal static IntPtr PyUnicode_FromUnicode(string s, int size) + { + return PyUnicode_FromUnicode(s, (IntPtr) size); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = PyUnicodeEntryPoint + "FromUnicode")] - internal static extern IntPtr PyUnicode_FromUnicode( + private static extern IntPtr PyUnicode_FromUnicode( [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UcsMarshaler))] string s, - int size + IntPtr size ); + internal static int PyUnicode_GetSize(IntPtr ob) + { + return (int) _PyUnicode_GetSize(ob); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = PyUnicodeEntryPoint + "GetSize")] - internal static extern int PyUnicode_GetSize(IntPtr ob); + internal static extern IntPtr _PyUnicode_GetSize(IntPtr ob); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = PyUnicodeEntryPoint + "AsUnicode")] @@ -1491,8 +1588,13 @@ internal static bool PyDict_Check(IntPtr ob) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern void PyDict_Clear(IntPtr pointer); - [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyDict_Size(IntPtr pointer); + internal static int PyDict_Size(IntPtr pointer) + { + return (int) _PyDict_Size(pointer); + } + + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyDict_Size")] + internal static extern IntPtr _PyDict_Size(IntPtr pointer); //==================================================================== @@ -1504,20 +1606,40 @@ internal static bool PyList_Check(IntPtr ob) return PyObject_TYPE(ob) == PyListType; } + internal static IntPtr PyList_New(int size) + { + return PyList_New((IntPtr) size); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyList_New(int size); + private static extern IntPtr PyList_New(IntPtr size); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyList_AsTuple(IntPtr pointer); + internal static IntPtr PyList_GetItem(IntPtr pointer, int index) + { + return PyList_GetItem(pointer, (IntPtr) index); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyList_GetItem(IntPtr pointer, int index); + private static extern IntPtr PyList_GetItem(IntPtr pointer, IntPtr index); + + internal static int PyList_SetItem(IntPtr pointer, int index, IntPtr value) + { + return PyList_SetItem(pointer, (IntPtr) index, value); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyList_SetItem(IntPtr pointer, int index, IntPtr value); + private static extern int PyList_SetItem(IntPtr pointer, IntPtr index, IntPtr value); + + internal static int PyList_Insert(IntPtr pointer, int index, IntPtr value) + { + return PyList_Insert(pointer, (IntPtr)index, value); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyList_Insert(IntPtr pointer, int index, IntPtr value); + private static extern int PyList_Insert(IntPtr pointer, IntPtr index, IntPtr value); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern int PyList_Append(IntPtr pointer, IntPtr value); @@ -1528,15 +1650,29 @@ internal static bool PyList_Check(IntPtr ob) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern int PyList_Sort(IntPtr pointer); - [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyList_GetSlice(IntPtr pointer, int start, int end); + internal static IntPtr PyList_GetSlice(IntPtr pointer, int start, int end) + { + return PyList_GetSlice(pointer, (IntPtr) start, (IntPtr) end); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyList_SetSlice(IntPtr pointer, int start, int end, IntPtr value); + private static extern IntPtr PyList_GetSlice(IntPtr pointer, IntPtr start, IntPtr end); + + internal static int PyList_SetSlice(IntPtr pointer, int start, int end, IntPtr value) + { + return PyList_SetSlice(pointer, (IntPtr) start, (IntPtr) end, value); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyList_Size(IntPtr pointer); + private static extern int PyList_SetSlice(IntPtr pointer, IntPtr start, IntPtr end, IntPtr value); + internal static int PyList_Size(IntPtr pointer) + { + return (int) _PyList_Size(pointer); + } + + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyList_Size")] + private static extern IntPtr _PyList_Size(IntPtr pointer); //==================================================================== // Python tuple API @@ -1547,20 +1683,45 @@ internal static bool PyTuple_Check(IntPtr ob) return PyObject_TYPE(ob) == PyTupleType; } - [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyTuple_New(int size); + internal static IntPtr PyTuple_New(int size) + { + return PyTuple_New((IntPtr) size); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyTuple_GetItem(IntPtr pointer, int index); + private static extern IntPtr PyTuple_New(IntPtr size); + + internal static IntPtr PyTuple_GetItem(IntPtr pointer, int index) + { + return PyTuple_GetItem(pointer, (IntPtr) index); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyTuple_SetItem(IntPtr pointer, int index, IntPtr value); + private static extern IntPtr PyTuple_GetItem(IntPtr pointer, IntPtr index); + + internal static int PyTuple_SetItem(IntPtr pointer, int index, IntPtr value) + { + return PyTuple_SetItem(pointer, (IntPtr) index, value); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyTuple_GetSlice(IntPtr pointer, int start, int end); + private static extern int PyTuple_SetItem(IntPtr pointer, IntPtr index, IntPtr value); + + internal static IntPtr PyTuple_GetSlice(IntPtr pointer, int start, int end) + { + return PyTuple_GetSlice(pointer, (IntPtr)start, (IntPtr)end); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyTuple_Size(IntPtr pointer); + private static extern IntPtr PyTuple_GetSlice(IntPtr pointer, IntPtr start, IntPtr end); + + internal static int PyTuple_Size(IntPtr pointer) + { + return (int) _PyTuple_Size(pointer); + } + + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyTuple_Size")] + private static extern IntPtr _PyTuple_Size(IntPtr pointer); //==================================================================== @@ -1666,8 +1827,13 @@ internal static bool PyObject_TypeCheck(IntPtr ob, IntPtr tp) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyType_GenericNew(IntPtr type, IntPtr args, IntPtr kw); + internal static IntPtr PyType_GenericAlloc(IntPtr type, int n) + { + return PyType_GenericAlloc(type, (IntPtr) n); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyType_GenericAlloc(IntPtr type, int n); + private static extern IntPtr PyType_GenericAlloc(IntPtr type, IntPtr n); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern int PyType_Ready(IntPtr type); @@ -1701,11 +1867,21 @@ internal static bool PyObject_TypeCheck(IntPtr ob, IntPtr tp) // Python memory API //==================================================================== + internal static IntPtr PyMem_Malloc(int size) + { + return PyMem_Malloc((IntPtr) size); + } + [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyMem_Malloc(int size); + private static extern IntPtr PyMem_Malloc(IntPtr size); + + internal static IntPtr PyMem_Realloc(IntPtr ptr, int size) + { + return PyMem_Realloc(ptr, (IntPtr) size); + } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern IntPtr PyMem_Realloc(IntPtr ptr, int size); + private static extern IntPtr PyMem_Realloc(IntPtr ptr, IntPtr size); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern void PyMem_Free(IntPtr ptr); @@ -1737,7 +1913,7 @@ internal static bool PyObject_TypeCheck(IntPtr ob, IntPtr tp) internal static extern void PyErr_NormalizeException(IntPtr ob, IntPtr val, IntPtr tb); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] - internal static extern int PyErr_Occurred(); + internal static extern IntPtr PyErr_Occurred(); [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern void PyErr_Fetch(ref IntPtr ob, ref IntPtr val, ref IntPtr tb); From e4d10d6df6a460b4bf72e34087b0ef71f73ea41a Mon Sep 17 00:00:00 2001 From: Benedikt Reinartz Date: Fri, 19 Oct 2018 16:21:47 +0200 Subject: [PATCH 2/2] Use long instead of int in all places that use Py_ssize_t --- src/runtime/arrayobject.cs | 4 +- src/runtime/assemblymanager.cs | 2 +- src/runtime/classobject.cs | 6 +- src/runtime/converter.cs | 2 +- src/runtime/importhook.cs | 2 +- src/runtime/indexer.cs | 6 +- src/runtime/interfaceobject.cs | 2 +- src/runtime/metatype.cs | 2 +- src/runtime/methodbinder.cs | 10 +-- src/runtime/methodbinding.cs | 4 +- src/runtime/pyobject.cs | 4 +- src/runtime/runtime.cs | 144 ++++++++++++++++----------------- 12 files changed, 94 insertions(+), 94 deletions(-) diff --git a/src/runtime/arrayobject.cs b/src/runtime/arrayobject.cs index a10688749..c37295704 100644 --- a/src/runtime/arrayobject.cs +++ b/src/runtime/arrayobject.cs @@ -93,7 +93,7 @@ public static IntPtr mp_subscript(IntPtr ob, IntPtr idx) return IntPtr.Zero; } - int count = Runtime.PyTuple_Size(idx); + var count = Runtime.PyTuple_Size(idx); var args = new int[count]; @@ -186,7 +186,7 @@ public static int mp_ass_subscript(IntPtr ob, IntPtr idx, IntPtr v) return -1; } - int count = Runtime.PyTuple_Size(idx); + var count = Runtime.PyTuple_Size(idx); var args = new int[count]; for (var i = 0; i < count; i++) diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs index 723bb970f..2df7ad2f5 100644 --- a/src/runtime/assemblymanager.cs +++ b/src/runtime/assemblymanager.cs @@ -140,7 +140,7 @@ private static Assembly ResolveHandler(object ob, ResolveEventArgs args) internal static void UpdatePath() { IntPtr list = Runtime.PySys_GetObject("path"); - int count = Runtime.PyList_Size(list); + var count = Runtime.PyList_Size(list); if (count != pypath.Count) { pypath.Clear(); diff --git a/src/runtime/classobject.cs b/src/runtime/classobject.cs index 46257c73f..83d761fd0 100644 --- a/src/runtime/classobject.cs +++ b/src/runtime/classobject.cs @@ -230,10 +230,10 @@ public static int mp_ass_subscript(IntPtr ob, IntPtr idx, IntPtr v) } // Get the args passed in. - int i = Runtime.PyTuple_Size(args); + var i = Runtime.PyTuple_Size(args); IntPtr defaultArgs = cls.indexer.GetDefaultArgs(args); - int numOfDefaultArgs = Runtime.PyTuple_Size(defaultArgs); - int temp = i + numOfDefaultArgs; + var numOfDefaultArgs = Runtime.PyTuple_Size(defaultArgs); + var temp = i + numOfDefaultArgs; IntPtr real = Runtime.PyTuple_New(temp + 1); for (var n = 0; n < i; n++) { diff --git a/src/runtime/converter.cs b/src/runtime/converter.cs index 13498e3dc..799010d32 100644 --- a/src/runtime/converter.cs +++ b/src/runtime/converter.cs @@ -842,7 +842,7 @@ private static void SetConversionError(IntPtr value, Type target) private static bool ToArray(IntPtr value, Type obType, out object result, bool setError) { Type elementType = obType.GetElementType(); - int size = Runtime.PySequence_Size(value); + var size = Runtime.PySequence_Size(value); result = null; if (size < 0) diff --git a/src/runtime/importhook.cs b/src/runtime/importhook.cs index c9943cb43..7e4a208f5 100644 --- a/src/runtime/importhook.cs +++ b/src/runtime/importhook.cs @@ -155,7 +155,7 @@ public static IntPtr __import__(IntPtr self, IntPtr args, IntPtr kw) // hook is saved as this.py_import. This version handles CLR // import and defers to the normal builtin for everything else. - int num_args = Runtime.PyTuple_Size(args); + var num_args = Runtime.PyTuple_Size(args); if (num_args < 1) { return Exceptions.RaiseTypeError("__import__() takes at least 1 argument (0 given)"); diff --git a/src/runtime/indexer.cs b/src/runtime/indexer.cs index 7b6d90ca8..71f7e7aa1 100644 --- a/src/runtime/indexer.cs +++ b/src/runtime/indexer.cs @@ -56,7 +56,7 @@ internal void SetItem(IntPtr inst, IntPtr args) internal bool NeedsDefaultArgs(IntPtr args) { - int pynargs = Runtime.PyTuple_Size(args); + var pynargs = Runtime.PyTuple_Size(args); MethodBase[] methods = SetterBinder.GetMethods(); if (methods.Length == 0) { @@ -72,7 +72,7 @@ internal bool NeedsDefaultArgs(IntPtr args) return false; } - for (int v = pynargs; v < clrnargs; v++) + for (var v = pynargs; v < clrnargs; v++) { if (pi[v].DefaultValue == DBNull.Value) { @@ -95,7 +95,7 @@ internal IntPtr GetDefaultArgs(IntPtr args) { return Runtime.PyTuple_New(0); } - int pynargs = Runtime.PyTuple_Size(args); + var pynargs = Runtime.PyTuple_Size(args); // Get the default arg tuple MethodBase[] methods = SetterBinder.GetMethods(); diff --git a/src/runtime/interfaceobject.cs b/src/runtime/interfaceobject.cs index ce1bc9eb0..616ced6bd 100644 --- a/src/runtime/interfaceobject.cs +++ b/src/runtime/interfaceobject.cs @@ -36,7 +36,7 @@ static InterfaceObject() public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw) { var self = (InterfaceObject)GetManagedObject(tp); - int nargs = Runtime.PyTuple_Size(args); + var nargs = Runtime.PyTuple_Size(args); Type type = self.type; object obj; diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs index 3295ab110..8853c2d5e 100644 --- a/src/runtime/metatype.cs +++ b/src/runtime/metatype.cs @@ -29,7 +29,7 @@ public static IntPtr Initialize() /// public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw) { - int len = Runtime.PyTuple_Size(args); + var len = Runtime.PyTuple_Size(args); if (len < 3) { return Exceptions.RaiseTypeError("invalid argument list"); diff --git a/src/runtime/methodbinder.cs b/src/runtime/methodbinder.cs index eeec8b89d..fac117f5c 100644 --- a/src/runtime/methodbinder.cs +++ b/src/runtime/methodbinder.cs @@ -279,7 +279,7 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth { // loop to find match, return invoker w/ or /wo error MethodBase[] _methods = null; - int pynargs = Runtime.PyTuple_Size(args); + var pynargs = (int)Runtime.PyTuple_Size(args); object arg; var isGeneric = false; ArrayList defaultArgList = null; @@ -301,9 +301,9 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth isGeneric = true; } ParameterInfo[] pi = mi.GetParameters(); - int clrnargs = pi.Length; + var clrnargs = pi.Length; var match = false; - int arrayStart = -1; + var arrayStart = -1; var outs = 0; if (pynargs == clrnargs) @@ -314,7 +314,7 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth { match = true; defaultArgList = new ArrayList(); - for (int v = pynargs; v < clrnargs; v++) + for (var v = pynargs; v < clrnargs; v++) { if (pi[v].DefaultValue == DBNull.Value) { @@ -338,7 +338,7 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth { var margs = new object[clrnargs]; - for (var n = 0; n < clrnargs; n++) + for (int n = 0; n < clrnargs; n++) { IntPtr op; if (n < pynargs) diff --git a/src/runtime/methodbinding.cs b/src/runtime/methodbinding.cs index 3985ed2cb..f402f91f8 100644 --- a/src/runtime/methodbinding.cs +++ b/src/runtime/methodbinding.cs @@ -104,7 +104,7 @@ public static IntPtr tp_call(IntPtr ob, IntPtr args, IntPtr kw) { if (self.info.IsGenericMethod) { - int len = Runtime.PyTuple_Size(args); //FIXME: Never used + var len = Runtime.PyTuple_Size(args); //FIXME: Never used Type[] sigTp = Runtime.PythonArgsToTypeArray(args, true); if (sigTp != null) { @@ -129,7 +129,7 @@ public static IntPtr tp_call(IntPtr ob, IntPtr args, IntPtr kw) if (target == IntPtr.Zero && !self.m.IsStatic()) { - int len = Runtime.PyTuple_Size(args); + var len = Runtime.PyTuple_Size(args); if (len < 1) { Exceptions.SetError(Exceptions.TypeError, "not enough arguments"); diff --git a/src/runtime/pyobject.cs b/src/runtime/pyobject.cs index 0e075824a..3b8c71efa 100644 --- a/src/runtime/pyobject.cs +++ b/src/runtime/pyobject.cs @@ -519,9 +519,9 @@ public virtual void DelItem(int index) /// Returns the length for objects that support the Python sequence /// protocol, or 0 if the object does not support the protocol. /// - public virtual int Length() + public virtual long Length() { - int s = Runtime.PyObject_Size(obj); + var s = Runtime.PyObject_Size(obj); if (s < 0) { Runtime.PyErr_Clear(); diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs index 55b4d1b9d..5938c8a9f 100644 --- a/src/runtime/runtime.cs +++ b/src/runtime/runtime.cs @@ -535,7 +535,7 @@ internal static void CheckExceptionOccurred() internal static IntPtr ExtendTuple(IntPtr t, params IntPtr[] args) { - int size = PyTuple_Size(t); + var size = PyTuple_Size(t); int add = args.Length; IntPtr item; @@ -578,7 +578,7 @@ internal static Type[] PythonArgsToTypeArray(IntPtr arg, bool mangleObjects) free = true; } - int n = PyTuple_Size(args); + var n = PyTuple_Size(args); var types = new Type[n]; Type t = null; @@ -1009,9 +1009,9 @@ internal static int PyObject_Compare(IntPtr value1, IntPtr value2) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern int PyObject_Not(IntPtr pointer); - internal static int PyObject_Size(IntPtr pointer) + internal static long PyObject_Size(IntPtr pointer) { - return (int) _PyObject_Size(pointer); + return (long) _PyObject_Size(pointer); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyObject_Size")] @@ -1245,57 +1245,57 @@ internal static bool PyFloat_Check(IntPtr ob) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern bool PySequence_Check(IntPtr pointer); - internal static IntPtr PySequence_GetItem(IntPtr pointer, int index) + internal static IntPtr PySequence_GetItem(IntPtr pointer, long index) { - return PySequence_GetItem(pointer, (IntPtr) index); + return PySequence_GetItem(pointer, new IntPtr(index)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern IntPtr PySequence_GetItem(IntPtr pointer, IntPtr index); - internal static int PySequence_SetItem(IntPtr pointer, int index, IntPtr value) + internal static int PySequence_SetItem(IntPtr pointer, long index, IntPtr value) { - return PySequence_SetItem(pointer, (IntPtr)index, value); + return PySequence_SetItem(pointer, new IntPtr(index), value); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern int PySequence_SetItem(IntPtr pointer, IntPtr index, IntPtr value); - internal static int PySequence_DelItem(IntPtr pointer, int index) + internal static int PySequence_DelItem(IntPtr pointer, long index) { - return PySequence_DelItem(pointer, (IntPtr)index); + return PySequence_DelItem(pointer, new IntPtr(index)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern int PySequence_DelItem(IntPtr pointer, IntPtr index); - internal static IntPtr PySequence_GetSlice(IntPtr pointer, int i1, int i2) + internal static IntPtr PySequence_GetSlice(IntPtr pointer, long i1, long i2) { - return PySequence_GetSlice(pointer, (IntPtr)i1, (IntPtr)i2); + return PySequence_GetSlice(pointer, new IntPtr(i1), new IntPtr(i2)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern IntPtr PySequence_GetSlice(IntPtr pointer, IntPtr i1, IntPtr i2); - internal static int PySequence_SetSlice(IntPtr pointer, int i1, int i2, IntPtr v) + internal static int PySequence_SetSlice(IntPtr pointer, long i1, long i2, IntPtr v) { - return PySequence_SetSlice(pointer, (IntPtr) i1, (IntPtr) i2, v); + return PySequence_SetSlice(pointer, new IntPtr(i1), new IntPtr(i2), v); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern int PySequence_SetSlice(IntPtr pointer, IntPtr i1, IntPtr i2, IntPtr v); - internal static int PySequence_DelSlice(IntPtr pointer, int i1, int i2) + internal static int PySequence_DelSlice(IntPtr pointer, long i1, long i2) { - return PySequence_DelSlice(pointer, (IntPtr) i1, (IntPtr) i2); + return PySequence_DelSlice(pointer, new IntPtr(i1), new IntPtr(i2)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern int PySequence_DelSlice(IntPtr pointer, IntPtr i1, IntPtr i2); - internal static int PySequence_Size(IntPtr pointer) + internal static long PySequence_Size(IntPtr pointer) { - return (int) _PySequence_Size(pointer); + return (long) _PySequence_Size(pointer); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PySequence_Size")] @@ -1307,9 +1307,9 @@ internal static int PySequence_Size(IntPtr pointer) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PySequence_Concat(IntPtr pointer, IntPtr other); - internal static IntPtr PySequence_Repeat(IntPtr pointer, int count) + internal static IntPtr PySequence_Repeat(IntPtr pointer, long count) { - return PySequence_Repeat(pointer, (IntPtr) count); + return PySequence_Repeat(pointer, new IntPtr(count)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] @@ -1318,9 +1318,9 @@ internal static IntPtr PySequence_Repeat(IntPtr pointer, int count) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern int PySequence_Index(IntPtr pointer, IntPtr item); - internal static int PySequence_Count(IntPtr pointer, IntPtr value) + internal static long PySequence_Count(IntPtr pointer, IntPtr value) { - return (int) _PySequence_Count(pointer, value); + return (long) _PySequence_Count(pointer, value); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PySequence_Count")] @@ -1361,9 +1361,9 @@ internal static IntPtr PyString_FromString(string value) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyBytes_FromString(string op); - internal static int PyBytes_Size(IntPtr op) + internal static long PyBytes_Size(IntPtr op) { - return (int) _PyBytes_Size(op); + return (long) _PyBytes_Size(op); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyBytes_Size")] @@ -1374,9 +1374,9 @@ internal static IntPtr PyBytes_AS_STRING(IntPtr ob) return ob + BytesOffset.ob_sval; } - internal static IntPtr PyString_FromStringAndSize(string value, int size) + internal static IntPtr PyString_FromStringAndSize(string value, long size) { - return _PyString_FromStringAndSize(value, (IntPtr) size); + return _PyString_FromStringAndSize(value, new IntPtr(size)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, @@ -1386,17 +1386,17 @@ internal static extern IntPtr _PyString_FromStringAndSize( IntPtr size ); - internal static IntPtr PyUnicode_FromStringAndSize(IntPtr value, int size) + internal static IntPtr PyUnicode_FromStringAndSize(IntPtr value, long size) { - return PyUnicode_FromStringAndSize(value, (IntPtr) size); + return PyUnicode_FromStringAndSize(value, new IntPtr(size)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern IntPtr PyUnicode_FromStringAndSize(IntPtr value, IntPtr size); #elif PYTHON2 - internal static IntPtr PyString_FromStringAndSize(string value, int size) + internal static IntPtr PyString_FromStringAndSize(string value, long size) { - return PyString_FromStringAndSize(value, (IntPtr) size); + return PyString_FromStringAndSize(value, new IntPtr(size)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] @@ -1421,9 +1421,9 @@ internal static bool PyUnicode_Check(IntPtr ob) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyUnicode_FromEncodedObject(IntPtr ob, IntPtr enc, IntPtr err); - internal static IntPtr PyUnicode_FromKindAndData(int kind, string s, int size) + internal static IntPtr PyUnicode_FromKindAndData(int kind, string s, long size) { - return PyUnicode_FromKindAndData(kind, s, (IntPtr) size); + return PyUnicode_FromKindAndData(kind, s, new IntPtr(size)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] @@ -1433,14 +1433,14 @@ private static extern IntPtr PyUnicode_FromKindAndData( IntPtr size ); - internal static IntPtr PyUnicode_FromUnicode(string s, int size) + internal static IntPtr PyUnicode_FromUnicode(string s, long size) { return PyUnicode_FromKindAndData(_UCS, s, size); } - internal static int PyUnicode_GetSize(IntPtr ob) + internal static long PyUnicode_GetSize(IntPtr ob) { - return (int)_PyUnicode_GetSize(ob); + return (long)_PyUnicode_GetSize(ob); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyUnicode_GetSize")] @@ -1460,9 +1460,9 @@ internal static int PyUnicode_GetSize(IntPtr ob) EntryPoint = PyUnicodeEntryPoint + "FromEncodedObject")] internal static extern IntPtr PyUnicode_FromEncodedObject(IntPtr ob, IntPtr enc, IntPtr err); - internal static IntPtr PyUnicode_FromUnicode(string s, int size) + internal static IntPtr PyUnicode_FromUnicode(string s, long size) { - return PyUnicode_FromUnicode(s, (IntPtr) size); + return PyUnicode_FromUnicode(s, new IntPtr(size)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, @@ -1472,9 +1472,9 @@ private static extern IntPtr PyUnicode_FromUnicode( IntPtr size ); - internal static int PyUnicode_GetSize(IntPtr ob) + internal static long PyUnicode_GetSize(IntPtr ob) { - return (int) _PyUnicode_GetSize(ob); + return (long) _PyUnicode_GetSize(ob); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, @@ -1522,7 +1522,7 @@ internal static string GetManagedString(IntPtr op) if (type == PyUnicodeType) { IntPtr p = PyUnicode_AsUnicode(op); - int length = PyUnicode_GetSize(op); + int length = (int)PyUnicode_GetSize(op); int size = length * _UCS; var buffer = new byte[size]; @@ -1588,9 +1588,9 @@ internal static bool PyDict_Check(IntPtr ob) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern void PyDict_Clear(IntPtr pointer); - internal static int PyDict_Size(IntPtr pointer) + internal static long PyDict_Size(IntPtr pointer) { - return (int) _PyDict_Size(pointer); + return (long) _PyDict_Size(pointer); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyDict_Size")] @@ -1606,9 +1606,9 @@ internal static bool PyList_Check(IntPtr ob) return PyObject_TYPE(ob) == PyListType; } - internal static IntPtr PyList_New(int size) + internal static IntPtr PyList_New(long size) { - return PyList_New((IntPtr) size); + return PyList_New(new IntPtr(size)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] @@ -1617,25 +1617,25 @@ internal static IntPtr PyList_New(int size) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyList_AsTuple(IntPtr pointer); - internal static IntPtr PyList_GetItem(IntPtr pointer, int index) + internal static IntPtr PyList_GetItem(IntPtr pointer, long index) { - return PyList_GetItem(pointer, (IntPtr) index); + return PyList_GetItem(pointer, new IntPtr(index)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern IntPtr PyList_GetItem(IntPtr pointer, IntPtr index); - internal static int PyList_SetItem(IntPtr pointer, int index, IntPtr value) + internal static int PyList_SetItem(IntPtr pointer, long index, IntPtr value) { - return PyList_SetItem(pointer, (IntPtr) index, value); + return PyList_SetItem(pointer, new IntPtr(index), value); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern int PyList_SetItem(IntPtr pointer, IntPtr index, IntPtr value); - internal static int PyList_Insert(IntPtr pointer, int index, IntPtr value) + internal static int PyList_Insert(IntPtr pointer, long index, IntPtr value) { - return PyList_Insert(pointer, (IntPtr)index, value); + return PyList_Insert(pointer, new IntPtr(index), value); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] @@ -1650,25 +1650,25 @@ internal static int PyList_Insert(IntPtr pointer, int index, IntPtr value) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern int PyList_Sort(IntPtr pointer); - internal static IntPtr PyList_GetSlice(IntPtr pointer, int start, int end) + internal static IntPtr PyList_GetSlice(IntPtr pointer, long start, long end) { - return PyList_GetSlice(pointer, (IntPtr) start, (IntPtr) end); + return PyList_GetSlice(pointer, new IntPtr(start), new IntPtr(end)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern IntPtr PyList_GetSlice(IntPtr pointer, IntPtr start, IntPtr end); - internal static int PyList_SetSlice(IntPtr pointer, int start, int end, IntPtr value) + internal static int PyList_SetSlice(IntPtr pointer, long start, long end, IntPtr value) { - return PyList_SetSlice(pointer, (IntPtr) start, (IntPtr) end, value); + return PyList_SetSlice(pointer, new IntPtr(start), new IntPtr(end), value); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern int PyList_SetSlice(IntPtr pointer, IntPtr start, IntPtr end, IntPtr value); - internal static int PyList_Size(IntPtr pointer) + internal static long PyList_Size(IntPtr pointer) { - return (int) _PyList_Size(pointer); + return (long) _PyList_Size(pointer); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyList_Size")] @@ -1683,41 +1683,41 @@ internal static bool PyTuple_Check(IntPtr ob) return PyObject_TYPE(ob) == PyTupleType; } - internal static IntPtr PyTuple_New(int size) + internal static IntPtr PyTuple_New(long size) { - return PyTuple_New((IntPtr) size); + return PyTuple_New(new IntPtr(size)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern IntPtr PyTuple_New(IntPtr size); - internal static IntPtr PyTuple_GetItem(IntPtr pointer, int index) + internal static IntPtr PyTuple_GetItem(IntPtr pointer, long index) { - return PyTuple_GetItem(pointer, (IntPtr) index); + return PyTuple_GetItem(pointer, new IntPtr(index)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern IntPtr PyTuple_GetItem(IntPtr pointer, IntPtr index); - internal static int PyTuple_SetItem(IntPtr pointer, int index, IntPtr value) + internal static int PyTuple_SetItem(IntPtr pointer, long index, IntPtr value) { - return PyTuple_SetItem(pointer, (IntPtr) index, value); + return PyTuple_SetItem(pointer, new IntPtr(index), value); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern int PyTuple_SetItem(IntPtr pointer, IntPtr index, IntPtr value); - internal static IntPtr PyTuple_GetSlice(IntPtr pointer, int start, int end) + internal static IntPtr PyTuple_GetSlice(IntPtr pointer, long start, long end) { - return PyTuple_GetSlice(pointer, (IntPtr)start, (IntPtr)end); + return PyTuple_GetSlice(pointer, new IntPtr(start), new IntPtr(end)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern IntPtr PyTuple_GetSlice(IntPtr pointer, IntPtr start, IntPtr end); - internal static int PyTuple_Size(IntPtr pointer) + internal static long PyTuple_Size(IntPtr pointer) { - return (int) _PyTuple_Size(pointer); + return (long) _PyTuple_Size(pointer); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl, EntryPoint = "PyTuple_Size")] @@ -1827,9 +1827,9 @@ internal static bool PyObject_TypeCheck(IntPtr ob, IntPtr tp) [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr PyType_GenericNew(IntPtr type, IntPtr args, IntPtr kw); - internal static IntPtr PyType_GenericAlloc(IntPtr type, int n) + internal static IntPtr PyType_GenericAlloc(IntPtr type, long n) { - return PyType_GenericAlloc(type, (IntPtr) n); + return PyType_GenericAlloc(type, new IntPtr(n)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] @@ -1867,17 +1867,17 @@ internal static IntPtr PyType_GenericAlloc(IntPtr type, int n) // Python memory API //==================================================================== - internal static IntPtr PyMem_Malloc(int size) + internal static IntPtr PyMem_Malloc(long size) { - return PyMem_Malloc((IntPtr) size); + return PyMem_Malloc(new IntPtr(size)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)] private static extern IntPtr PyMem_Malloc(IntPtr size); - internal static IntPtr PyMem_Realloc(IntPtr ptr, int size) + internal static IntPtr PyMem_Realloc(IntPtr ptr, long size) { - return PyMem_Realloc(ptr, (IntPtr) size); + return PyMem_Realloc(ptr, new IntPtr(size)); } [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]