using System;

using System.Runtime.InteropServices;

using System.Security;

using System.Text;

using System.Threading;

using System.Collections.Generic;

namespace Python.Runtime

{

[SuppressUnmanagedCodeSecurity]

internal static class NativeMethods

{

#if MONO_LINUX || MONO_OSX

#if NETSTANDARD

private static int RTLD_NOW = 0x2;

#if MONO_LINUX

private static int RTLD_GLOBAL = 0x100;

private static IntPtr RTLD_DEFAULT = IntPtr.Zero;

private const string NativeDll = "libdl.so";

public static IntPtr LoadLibrary(string fileName)

{

return dlopen($"lib{fileName}.so", RTLD_NOW | RTLD_GLOBAL);

}

#elif MONO_OSX

private static int RTLD_GLOBAL = 0x8;

private const string NativeDll = "/usr/lib/libSystem.dylib";

private static IntPtr RTLD_DEFAULT = new IntPtr(-2);

public static IntPtr LoadLibrary(string fileName)

{

return dlopen($"lib{fileName}.dylib", RTLD_NOW | RTLD_GLOBAL);

}

#endif

#else

private static int RTLD_NOW = 0x2;

private static int RTLD_SHARED = 0x20;

#if MONO_OSX

private static IntPtr RTLD_DEFAULT = new IntPtr(-2);

private const string NativeDll = "__Internal";

#elif MONO_LINUX

private static IntPtr RTLD_DEFAULT = IntPtr.Zero;

private const string NativeDll = "libdl.so";

#endif

public static IntPtr LoadLibrary(string fileName)

{

return dlopen(fileName, RTLD_NOW | RTLD_SHARED);

}

#endif

public static void FreeLibrary(IntPtr handle)

{

dlclose(handle);

}

public static IntPtr GetProcAddress(IntPtr dllHandle, string name)

{

// look in the exe if dllHandle is NULL

if (dllHandle == IntPtr.Zero)

{

dllHandle = RTLD_DEFAULT;

}

// clear previous errors if any

dlerror();

IntPtr res = dlsym(dllHandle, name);

IntPtr errPtr = dlerror();

if (errPtr != IntPtr.Zero)

{

throw new Exception("dlsym: " + Marshal.PtrToStringAnsi(errPtr));

}

return res;

}

[DllImport(NativeDll, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]

public static extern IntPtr dlopen(String fileName, int flags);

[DllImport(NativeDll, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]

private static extern IntPtr dlsym(IntPtr handle, String symbol);

[DllImport(NativeDll, CallingConvention = CallingConvention.Cdecl)]

private static extern int dlclose(IntPtr handle);

[DllImport(NativeDll, CallingConvention = CallingConvention.Cdecl)]

private static extern IntPtr dlerror();

#else // Windows

private const string NativeDll = "kernel32.dll";

[DllImport(NativeDll)]

public static extern IntPtr LoadLibrary(string dllToLoad);

[DllImport(NativeDll)]

public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);

[DllImport(NativeDll)]

public static extern bool FreeLibrary(IntPtr hModule);

#endif

}

/// <summary>

/// Encapsulates the low-level Python C API. Note that it is

/// the responsibility of the caller to have acquired the GIL

/// before calling any of these methods.

/// </summary>

public class Runtime

{

// C# compiler copies constants to the assemblies that references this library.

// We needs to replace all public constants to static readonly fields to allow

// binary substitution of different Python.Runtime.dll builds in a target application.

public static int UCS => _UCS;

#if UCS4

internal const int _UCS = 4;

/// <summary>

/// EntryPoint to be used in DllImport to map to correct Unicode

/// methods prior to PEP393. Only used for PY27.

/// </summary>

private const string PyUnicodeEntryPoint = "PyUnicodeUCS4_";

#elif UCS2

internal const int _UCS = 2;

/// <summary>

/// EntryPoint to be used in DllImport to map to correct Unicode

/// methods prior to PEP393. Only used for PY27.

/// </summary>

private const string PyUnicodeEntryPoint = "PyUnicodeUCS2_";

#else

#error You must define either UCS2 or UCS4!

#endif

// C# compiler copies constants to the assemblies that references this library.

// We needs to replace all public constants to static readonly fields to allow

// binary substitution of different Python.Runtime.dll builds in a target application.

public static string pyversion => _pyversion;

public static string pyver => _pyver;

#if PYTHON27

internal const string _pyversion = "2.7";

internal const string _pyver = "27";

#elif PYTHON34

internal const string _pyversion = "3.4";

internal const string _pyver = "34";

#elif PYTHON35

internal const string _pyversion = "3.5";

internal const string _pyver = "35";

#elif PYTHON36

internal const string _pyversion = "3.6";

internal const string _pyver = "36";

#elif PYTHON37

internal const string _pyversion = "3.7";

internal const string _pyver = "37";

#else

#error You must define one of PYTHON34 to PYTHON37 or PYTHON27

#endif

#if MONO_LINUX || MONO_OSX // Linux/macOS use dotted version string

internal const string dllBase = "python" + _pyversion;

#else // Windows

internal const string dllBase = "python" + _pyver;

#endif

#if PYTHON_WITH_PYDEBUG

internal const string dllWithPyDebug = "_d";

#else

internal const string dllWithPyDebug = "";

#endif

#if PYTHON_WITH_PYMALLOC

internal const string dllWithPyMalloc = "m";

#else

internal const string dllWithPyMalloc = "";

#endif

// C# compiler copies constants to the assemblies that references this library.

// We needs to replace all public constants to static readonly fields to allow

// binary substitution of different Python.Runtime.dll builds in a target application.

public static readonly string PythonDLL = _PythonDll;

#if PYTHON_WITHOUT_ENABLE_SHARED && !NETSTANDARD

internal const string _PythonDll = "__Internal";

#else

internal const string _PythonDll = dllBase + dllWithPyDebug + dllWithPyMalloc;

#endif

public static readonly int pyversionnumber = Convert.ToInt32(_pyver);

// set to true when python is finalizing

internal static object IsFinalizingLock = new object();

internal static bool IsFinalizing;

internal static bool Is32Bit = IntPtr.Size == 4;

// .NET core: System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Windows)

internal static bool IsWindows = Environment.OSVersion.Platform == PlatformID.Win32NT;

/// <summary>

/// Operating system type as reported by Python.

/// </summary>

public enum OperatingSystemType

{

Windows,

Darwin,

Linux,

Other

}

static readonly Dictionary<string, OperatingSystemType> OperatingSystemTypeMapping = new Dictionary<string, OperatingSystemType>()

{

{ "Windows", OperatingSystemType.Windows },

{ "Darwin", OperatingSystemType.Darwin },

{ "Linux", OperatingSystemType.Linux },

};

/// <summary>

/// Gets the operating system as reported by python's platform.system().

/// </summary>

public static OperatingSystemType OperatingSystem { get; private set; }

/// <summary>

/// Gets the operating system as reported by python's platform.system().

/// </summary>

public static string OperatingSystemName { get; private set; }

public enum MachineType

{

i386,

x86_64,

Other

};

/// <summary>

/// Map lower-case version of the python machine name to the processor

/// type. There are aliases, e.g. x86_64 and amd64 are two names for

/// the same thing. Make sure to lower-case the search string, because

/// capitalization can differ.

/// </summary>

static readonly Dictionary<string, MachineType> MachineTypeMapping = new Dictionary<string, MachineType>()

{

["i386"] = MachineType.i386,

["i686"] = MachineType.i386,

["x86"] = MachineType.i386,

["x86_64"] = MachineType.x86_64,

["amd64"] = MachineType.x86_64,

["x64"] = MachineType.x86_64,

["em64t"] = MachineType.x86_64,

};

/// <summary>

/// Gets the machine architecture as reported by python's platform.machine().

/// </summary>

public static MachineType Machine { get; private set; }/* set in Initialize using python's platform.machine */

/// <summary>

/// Gets the machine architecture as reported by python's platform.machine().

/// </summary>

public static string MachineName { get; private set; }

internal static bool IsPython2 = pyversionnumber < 30;

internal static bool IsPython3 = pyversionnumber >= 30;

public static int MainManagedThreadId { get; private set; }

/// <summary>

/// Encoding to use to convert Unicode to/from Managed to Native

/// </summary>

internal static readonly Encoding PyEncoding = _UCS == 2 ? Encoding.Unicode : Encoding.UTF32;

/// <summary>

/// Initialize the runtime...

/// </summary>

internal static void Initialize(bool initSigs = false)

{

if (Py_IsInitialized() == 0)

{

Py_InitializeEx(initSigs ? 1 : 0);

MainManagedThreadId = Thread.CurrentThread.ManagedThreadId;

}

if (PyEval_ThreadsInitialized() == 0)

{

PyEval_InitThreads();

}

IsFinalizing = false;

CLRModule.Reset();

GenericUtil.Reset();

PyScopeManager.Reset();

ClassManager.Reset();

ClassDerivedObject.Reset();

TypeManager.Reset();

IntPtr op;

IntPtr dict;

if (IsPython3)

{

op = PyImport_ImportModule("builtins");

dict = PyObject_GetAttrString(op, "__dict__");

}

else // Python2

{

dict = PyImport_GetModuleDict();

op = PyDict_GetItemString(dict, "__builtin__");

}

PyNotImplemented = PyObject_GetAttrString(op, "NotImplemented");

TypeManager.AddRawType(PyNotImplemented);

PyBaseObjectType = PyObject_GetAttrString(op, "object");

TypeManager.AddRawType(PyBaseObjectType);

PyModuleType = PyObject_Type(op);

PyNone = PyObject_GetAttrString(op, "None");

TypeManager.AddRawType(PyNone);

PyTrue = PyObject_GetAttrString(op, "True");

TypeManager.AddRawType(PyTrue);

PyFalse = PyObject_GetAttrString(op, "False");

TypeManager.AddRawType(PyFalse);

PyBoolType = PyObject_Type(PyTrue);

TypeManager.AddRawType(PyBoolType);

PyNoneType = PyObject_Type(PyNone);

TypeManager.AddRawType(PyNoneType);

PyTypeType = PyObject_Type(PyNoneType);

TypeManager.AddRawType(PyTypeType);

op = PyObject_GetAttrString(dict, "keys");

PyMethodType = PyObject_Type(op);

TypeManager.AddRawType(PyMethodType);

XDecref(op);

// For some arcane reason, builtins.__dict__.__setitem__ is *not*

// a wrapper_descriptor, even though dict.__setitem__ is.

//

// object.__init__ seems safe, though.

op = PyObject_GetAttrString(PyBaseObjectType, "__init__");

PyWrapperDescriptorType = PyObject_Type(op);

XDecref(op);

#if PYTHON3

XDecref(dict);

#endif

op = PyString_FromString("string");

PyStringType = PyObject_Type(op);

TypeManager.AddRawType(PyStringType);

XDecref(op);

op = PyUnicode_FromString("unicode");

PyUnicodeType = PyObject_Type(op);

TypeManager.AddRawType(PyUnicodeType);

XDecref(op);

#if PYTHON3

op = PyBytes_FromString("bytes");

PyBytesType = PyObject_Type(op);

TypeManager.AddRawType(PyBytesType);

XDecref(op);

#endif

op = PyTuple_New(0);

PyTupleType = PyObject_Type(op);

TypeManager.AddRawType(PyTupleType);

XDecref(op);

op = PyList_New(0);

PyListType = PyObject_Type(op);

TypeManager.AddRawType(PyListType);

XDecref(op);

op = PyDict_New();

PyDictType = PyObject_Type(op);

TypeManager.AddRawType(PyDictType);

XDecref(op);

op = PyInt_FromInt32(0);

PyIntType = PyObject_Type(op);

TypeManager.AddRawType(PyIntType);

XDecref(op);

op = PyLong_FromLong(0);

PyLongType = PyObject_Type(op);

TypeManager.AddRawType(PyLongType);

XDecref(op);

op = PyFloat_FromDouble(0);

PyFloatType = PyObject_Type(op);

TypeManager.AddRawType(PyFloatType);

XDecref(op);

#if PYTHON3

PyClassType = IntPtr.Zero;

PyInstanceType = IntPtr.Zero;

#elif PYTHON2

IntPtr s = PyString_FromString("_temp");

IntPtr d = PyDict_New();

IntPtr c = PyClass_New(IntPtr.Zero, d, s);

PyClassType = PyObject_Type(c);

TypeManager.AddRawType(PyClassType);

IntPtr i = PyInstance_New(c, IntPtr.Zero, IntPtr.Zero);

PyInstanceType = PyObject_Type(i);

TypeManager.AddRawType(PyInstanceType);

XDecref(s);

XDecref(i);

XDecref(c);

XDecref(d);

#endif

Error = new IntPtr(-1);

IntPtr dllLocal = IntPtr.Zero;

if (_PythonDll != "__Internal")

{

dllLocal = NativeMethods.LoadLibrary(_PythonDll);

}

_PyObject_NextNotImplemented = NativeMethods.GetProcAddress(dllLocal, "_PyObject_NextNotImplemented");

#if !(MONO_LINUX || MONO_OSX)

if (dllLocal != IntPtr.Zero)

{

NativeMethods.FreeLibrary(dllLocal);

}

#endif

// Initialize data about the platform we're running on. We need

// this for the type manager and potentially other details. Must

// happen after caching the python types, above.

InitializePlatformData();

// Initialize modules that depend on the runtime class.

AssemblyManager.Initialize();

PyCLRMetaType = MetaType.Initialize();

TypeManager.AddRawType(PyCLRMetaType);

Exceptions.Initialize();

ImportHook.Initialize();

// Need to add the runtime directory to sys.path so that we

// can find built-in assemblies like System.Data, et. al.

string rtdir = RuntimeEnvironment.GetRuntimeDirectory();

IntPtr path = PySys_GetObject("path");

IntPtr item = PyString_FromString(rtdir);

PyList_Append(path, item);

XDecref(item);

AssemblyManager.UpdatePath();

}

/// <summary>

/// Initializes the data about platforms.

///

/// This must be the last step when initializing the runtime:

/// GetManagedString needs to have the cached values for types.

/// But it must run before initializing anything outside the runtime

/// because those rely on the platform data.

/// </summary>

private static void InitializePlatformData()

{

IntPtr op;

IntPtr fn;

IntPtr platformModule = PyImport_ImportModule("platform");

IntPtr emptyTuple = PyTuple_New(0);

fn = PyObject_GetAttrString(platformModule, "system");

op = PyObject_Call(fn, emptyTuple, IntPtr.Zero);

OperatingSystemName = GetManagedString(op);

XDecref(op);

XDecref(fn);

fn = PyObject_GetAttrString(platformModule, "machine");

op = PyObject_Call(fn, emptyTuple, IntPtr.Zero);

MachineName = GetManagedString(op);

XDecref(op);

XDecref(fn);

XDecref(emptyTuple);

XDecref(platformModule);

// Now convert the strings into enum values so we can do switch

// statements rather than constant parsing.

OperatingSystemType OSType;

if (!OperatingSystemTypeMapping.TryGetValue(OperatingSystemName, out OSType))

{

OSType = OperatingSystemType.Other;

}

OperatingSystem = OSType;

MachineType MType;

if (!MachineTypeMapping.TryGetValue(MachineName.ToLower(), out MType))

{

MType = MachineType.Other;

}

Machine = MType;

}

internal static void Shutdown()

{

AssemblyManager.Shutdown();

Exceptions.Shutdown();

ImportHook.Shutdown();

TypeManager.Shutdown();

ClassManager.Shutdown();

Finalizer.Shutdown();

Py_Finalize();

}

// called *without* the GIL acquired by clr._AtExit

internal static int AtExit()

{

lock (IsFinalizingLock)

{

IsFinalizing = true;

}

return 0;

}

internal static IntPtr Py_single_input = (IntPtr)256;

internal static IntPtr Py_file_input = (IntPtr)257;

internal static IntPtr Py_eval_input = (IntPtr)258;

internal static IntPtr PyBaseObjectType;

internal static IntPtr PyModuleType;

internal static IntPtr PyClassType;

internal static IntPtr PyInstanceType;

internal static IntPtr PyCLRMetaType;

internal static IntPtr PyMethodType;

internal static IntPtr PyWrapperDescriptorType;

internal static IntPtr PyUnicodeType;

internal static IntPtr PyStringType;

internal static IntPtr PyTupleType;

internal static IntPtr PyListType;

internal static IntPtr PyDictType;

internal static IntPtr PyIntType;

internal static IntPtr PyLongType;

internal static IntPtr PyFloatType;

internal static IntPtr PyBoolType;

internal static IntPtr PyNoneType;

internal static IntPtr PyTypeType;

#if PYTHON3

internal static IntPtr PyBytesType;

#endif

internal static IntPtr _PyObject_NextNotImplemented;

internal static IntPtr PyNotImplemented;

internal const int Py_LT = 0;

internal const int Py_LE = 1;

internal const int Py_EQ = 2;

internal const int Py_NE = 3;

internal const int Py_GT = 4;

internal const int Py_GE = 5;

internal static IntPtr PyTrue;

internal static IntPtr PyFalse;

internal static IntPtr PyNone;

internal static IntPtr Error;

/// <summary>

/// Check if any Python Exceptions occurred.

/// If any exist throw new PythonException.

/// </summary>

/// <remarks>

/// Can be used instead of `obj == IntPtr.Zero` for example.

/// </remarks>

internal static void CheckExceptionOccurred()

{

if (PyErr_Occurred() != IntPtr.Zero)

{

throw new PythonException();

}

}

internal static IntPtr ExtendTuple(IntPtr t, params IntPtr[] args)

{

var size = PyTuple_Size(t);

int add = args.Length;

IntPtr item;

IntPtr items = PyTuple_New(size + add);

for (var i = 0; i < size; i++)

{

item = PyTuple_GetItem(t, i);

XIncref(item);

PyTuple_SetItem(items, i, item);

}

for (var n = 0; n < add; n++)

{

item = args[n];

XIncref(item);

PyTuple_SetItem(items, size + n, item);

}

return items;

}

internal static Type[] PythonArgsToTypeArray(IntPtr arg)

{

return PythonArgsToTypeArray(arg, false);

}

internal static Type[] PythonArgsToTypeArray(IntPtr arg, bool mangleObjects)

{

// Given a PyObject * that is either a single type object or a

// tuple of (managed or unmanaged) type objects, return a Type[]

// containing the CLR Type objects that map to those types.

IntPtr args = arg;

var free = false;

if (!PyTuple_Check(arg))

{

args = PyTuple_New(1);

XIncref(arg);

PyTuple_SetItem(args, 0, arg);

free = true;

}

var n = PyTuple_Size(args);

var types = new Type[n];

Type t = null;

for (var i = 0; i < n; i++)

{

IntPtr op = PyTuple_GetItem(args, i);

if (mangleObjects && (!PyType_Check(op)))

{

op = PyObject_TYPE(op);

}

ManagedType mt = ManagedType.GetManagedObject(op);

if (mt is ClassBase)

{

t = ((ClassBase)mt).type;

}

else if (mt is CLRObject)

{

object inst = ((CLRObject)mt).inst;

if (inst is Type)

{

t = inst as Type;

}

}

else

{

t = Converter.GetTypeByAlias(op);

}

if (t == null)

{

types = null;

break;

}

types[i] = t;

}

if (free)

{

XDecref(args);

}

return types;

}

/// <summary>

/// Managed exports of the Python C API. Where appropriate, we do

/// some optimization to avoid managed &lt;--&gt; unmanaged transitions

/// (mostly for heavily used methods).

/// </summary>

internal static unsafe void XIncref(IntPtr op)

{

#if PYTHON_WITH_PYDEBUG || NETSTANDARD

Py_IncRef(op);

return;

#else

var p = (void*)op;

if ((void*)0 != p)

{

if (Is32Bit)

{

(*(int*)p)++;

}

else

{

(*(long*)p)++;

}

}

#endif

}

internal static unsafe void XDecref(IntPtr op)

{

#if PYTHON_WITH_PYDEBUG || NETSTANDARD

Py_DecRef(op);

return;

#else

var p = (void*)op;

if ((void*)0 != p)

{

if (Is32Bit)

{

--(*(int*)p);

}

else

{

--(*(long*)p);

}

if ((*(int*)p) == 0)

{

// PyObject_HEAD: struct _typeobject *ob_type

void* t = Is32Bit

? (void*)(*((uint*)p + 1))

: (void*)(*((ulong*)p + 1));

// PyTypeObject: destructor tp_dealloc

void* f = Is32Bit

? (void*)(*((uint*)t + 6))

: (void*)(*((ulong*)t + 6));

if ((void*)0 == f)

{

return;

}

NativeCall.Impl.Void_Call_1(new IntPtr(f), op);

}

}

#endif

}

internal static unsafe long Refcount(IntPtr op)

{

var p = (void*)op;

if ((void*)0 == p)

{

return 0;

}

p = (byte*)p + TypeOffset.ob_refcnt;

return Is32Bit ? (*(int*)p) : (*(long*)p);

}

/// <summary>

/// Export of Macro Py_XIncRef. Use XIncref instead.

/// Limit this function usage for Testing and Py_Debug builds

/// </summary>

/// <param name="ob">PyObject Ptr</param>

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void Py_IncRef(IntPtr ob);

/// <summary>

/// Export of Macro Py_XDecRef. Use XDecref instead.

/// Limit this function usage for Testing and Py_Debug builds

/// </summary>

/// <param name="ob">PyObject Ptr</param>

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void Py_DecRef(IntPtr ob);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void Py_Initialize();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void Py_InitializeEx(int initsigs);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int Py_IsInitialized();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void Py_Finalize();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_NewInterpreter();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void Py_EndInterpreter(IntPtr threadState);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyThreadState_New(IntPtr istate);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyThreadState_Get();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyThread_get_key_value(IntPtr key);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int PyThread_get_thread_ident();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int PyThread_set_key_value(IntPtr key, IntPtr value);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyThreadState_Swap(IntPtr key);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern long PyGC_Collect();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyGILState_Ensure();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void PyGILState_Release(IntPtr gs);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyGILState_GetThisThreadState();

#if PYTHON3

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

public static extern int Py_Main(

int argc,

[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StrArrayMarshaler))] string[] argv

);

#elif PYTHON2

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

public static extern int Py_Main(int argc, string[] argv);

#endif

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void PyEval_InitThreads();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int PyEval_ThreadsInitialized();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void PyEval_AcquireLock();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void PyEval_ReleaseLock();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void PyEval_AcquireThread(IntPtr tstate);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void PyEval_ReleaseThread(IntPtr tstate);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyEval_SaveThread();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void PyEval_RestoreThread(IntPtr tstate);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyEval_GetBuiltins();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyEval_GetGlobals();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyEval_GetLocals();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_GetProgramName();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void Py_SetProgramName(IntPtr name);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_GetPythonHome();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void Py_SetPythonHome(IntPtr home);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_GetPath();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern void Py_SetPath(IntPtr home);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_GetVersion();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_GetPlatform();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_GetCopyright();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_GetCompiler();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_GetBuildInfo();

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int PyRun_SimpleString(string code);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyRun_String(string code, IntPtr st, IntPtr globals, IntPtr locals);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyEval_EvalCode(IntPtr co, IntPtr globals, IntPtr locals);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr Py_CompileString(string code, string file, IntPtr tok);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyImport_ExecCodeModule(string name, IntPtr code);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyCFunction_NewEx(IntPtr ml, IntPtr self, IntPtr mod);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyCFunction_Call(IntPtr func, IntPtr args, IntPtr kw);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyClass_New(IntPtr bases, IntPtr dict, IntPtr name);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyInstance_New(IntPtr cls, IntPtr args, IntPtr kw);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyInstance_NewRaw(IntPtr cls, IntPtr dict);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyMethod_New(IntPtr func, IntPtr self, IntPtr cls);

//====================================================================

// Python abstract object API

//====================================================================

/// <summary>

/// A macro-like method to get the type of a Python object. This is

/// designed to be lean and mean in IL &amp; avoid managed &lt;-&gt; unmanaged

/// transitions. Note that this does not incref the type object.

/// </summary>

internal static unsafe IntPtr PyObject_TYPE(IntPtr op)

{

var p = (void*)op;

if ((void*)0 == p)

{

return IntPtr.Zero;

}

#if PYTHON_WITH_PYDEBUG

var n = 3;

#else

var n = 1;

#endif

return Is32Bit

? new IntPtr((void*)(*((uint*)p + n)))

: new IntPtr((void*)(*((ulong*)p + n)));

}

/// <summary>

/// Managed version of the standard Python C API PyObject_Type call.

/// This version avoids a managed &lt;-&gt; unmanaged transition.

/// This one does incref the returned type object.

/// </summary>

internal static IntPtr PyObject_Type(IntPtr op)

{

IntPtr tp = PyObject_TYPE(op);

XIncref(tp);

return tp;

}

internal static string PyObject_GetTypeName(IntPtr op)

{

IntPtr pyType = Marshal.ReadIntPtr(op, ObjectOffset.ob_type);

IntPtr ppName = Marshal.ReadIntPtr(pyType, TypeOffset.tp_name);

return Marshal.PtrToStringAnsi(ppName);

}

/// <summary>

/// Test whether the Python object is an iterable.

/// </summary>

internal static bool PyObject_IsIterable(IntPtr pointer)

{

var ob_type = Marshal.ReadIntPtr(pointer, ObjectOffset.ob_type);

#if PYTHON2

long tp_flags = Util.ReadCLong(ob_type, TypeOffset.tp_flags);

if ((tp_flags & TypeFlags.HaveIter) == 0)

return false;

#endif

IntPtr tp_iter = Marshal.ReadIntPtr(ob_type, TypeOffset.tp_iter);

return tp_iter != IntPtr.Zero;

}

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int PyObject_HasAttrString(IntPtr pointer, string name);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyObject_GetAttrString(IntPtr pointer, string name);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int PyObject_SetAttrString(IntPtr pointer, string name, IntPtr value);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int PyObject_HasAttr(IntPtr pointer, IntPtr name);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern IntPtr PyObject_GetAttr(IntPtr pointer, IntPtr name);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]

internal static extern int PyObject_SetAttr(IntPtr pointer, IntPtr name, IntPtr value);

[DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]