using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;
using System.Threading;
using System.Collections.Generic;
using Python.Runtime.Platform;
namespace Python.Runtime
{
///
/// 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.
///
public static partial 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.
// set to true when python is finalizing
internal static object IsFinalizingLock = new object();
internal static bool IsFinalizing;
internal static bool Is32Bit = IntPtr.Size == 4;
internal static bool IsWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
#if PYTHON2
internal static bool IsPython2 = true;
#else
internal static bool IsPython2 = false;
#endif
internal static bool IsPython3 = !IsPython2;
public static int MainManagedThreadId { get; private set; }
#if UCS2 && PYTHON2
static int _UCS = 2;
#else
static int _UCS = 4;
#endif
///
/// Encoding to use to convert Unicode to/from Managed to Native
///
internal static readonly Encoding PyEncoding = _UCS == 2 ? Encoding.Unicode : Encoding.UTF32;
///
/// Initialize the runtime...
///
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");
PyBaseObjectType = PyObject_GetAttrString(op, "object");
PyNone = PyObject_GetAttrString(op, "None");
PyTrue = PyObject_GetAttrString(op, "True");
PyFalse = PyObject_GetAttrString(op, "False");
PyBoolType = PyObject_Type(PyTrue);
PyNoneType = PyObject_Type(PyNone);
PyTypeType = PyObject_Type(PyNoneType);
op = PyObject_GetAttrString(dict, "keys");
PyMethodType = PyObject_Type(op);
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 !PYTHON2
XDecref(dict);
#endif
op = PyString_FromString("string");
PyStringType = PyObject_Type(op);
XDecref(op);
op = PyUnicode_FromString("unicode");
PyUnicodeType = PyObject_Type(op);
XDecref(op);
#if !PYTHON2
op = PyBytes_FromString("bytes");
PyBytesType = PyObject_Type(op);
XDecref(op);
#endif
op = PyTuple_New(0);
PyTupleType = PyObject_Type(op);
XDecref(op);
op = PyList_New(0);
PyListType = PyObject_Type(op);
XDecref(op);
op = PyDict_New();
PyDictType = PyObject_Type(op);
XDecref(op);
op = PyInt_FromInt32(0);
PyIntType = PyObject_Type(op);
XDecref(op);
op = PyLong_FromLong(0);
PyLongType = PyObject_Type(op);
XDecref(op);
op = PyFloat_FromDouble(0);
PyFloatType = PyObject_Type(op);
XDecref(op);
PyClassType = IntPtr.Zero;
PyInstanceType = IntPtr.Zero;
#if PYTHON2
IntPtr s = PyString_FromString("_temp");
IntPtr d = PyDict_New();
IntPtr c = PyClass_New(IntPtr.Zero, d, s);
PyClassType = PyObject_Type(c);
IntPtr i = PyInstance_New(c, IntPtr.Zero, IntPtr.Zero);
PyInstanceType = PyObject_Type(i);
XDecref(s);
XDecref(i);
XDecref(c);
XDecref(d);
#endif
Error = new IntPtr(-1);
IntPtr dllLocal = IntPtr.Zero;
var loader = LibraryLoader.Instance;
_PyObject_NextNotImplemented = loader.GetFunction(dllLocal, "_PyObject_NextNotImplemented");
PyModuleType = loader.GetFunction(dllLocal, "PyModule_Type");
// Initialize modules that depend on the runtime class.
AssemblyManager.Initialize();
PyCLRMetaType = MetaType.Initialize();
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();
}
internal static void Shutdown()
{
AssemblyManager.Shutdown();
Exceptions.Shutdown();
ImportHook.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;
internal static IntPtr PyBytesType;
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;
///
/// Check if any Python Exceptions occurred.
/// If any exist throw new PythonException.
///
///
/// Can be used instead of `obj == IntPtr.Zero` for example.
///
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;
}
///
/// Managed exports of the Python C API. Where appropriate, we do
/// some optimization to avoid managed <--> unmanaged transitions
/// (mostly for heavily used methods).
///
internal static unsafe void XIncref(IntPtr op)
{
Py_IncRef(op);
return;
}
internal static unsafe void XDecref(IntPtr op)
{
Py_DecRef(op);
return;
}
internal static unsafe long Refcount(IntPtr op)
{
var p = (void*)op;
if ((void*)0 == p)
{
return 0;
}
return Is32Bit ? (*(int*)p) : (*(long*)p);
}
//====================================================================
// Python abstract object API
//====================================================================
///
/// A macro-like method to get the type of a Python object. This is
/// designed to be lean and mean in IL & avoid managed <-> unmanaged
/// transitions. Note that this does not incref the type object.
///
internal static unsafe IntPtr PyObject_TYPE(IntPtr op)
{
var p = (void*)op;
if ((void*)0 == p)
{
return IntPtr.Zero;
}
#if PYTHON_WITH_PYDEBUG // TODO: Only for Python