using System.Reflection.Emit;

using System;

using System.Diagnostics.Contracts;

using System.Runtime.InteropServices;

using System.Security;

using System.Text;

using System.Threading;

using System.Collections.Generic;

using Python.Runtime.Native;

using Python.Runtime.Platform;

using System.Linq;

using static System.FormattableString;

namespace Python.Runtime

/// <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 unsafe class Runtime

{

public static string PythonDLL

}

static string _PythonDll = GetDefaultDllName();

private static string GetDefaultDllName()

}

private static string GetDefaultDllName(Version version)

}

// set to true when python is finalizing

internal static object IsFinalizingLock = new object();

internal static bool IsFinalizing;

private static bool _isInitialized = false;

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

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

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

internal static Version InteropVersion { get; }

= System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

public static int MainManagedThreadId { get; private set; }

public static ShutdownMode ShutdownMode { get; internal set; }

private static PyReferenceCollection _pyRefs = new PyReferenceCollection();

internal static Version PyVersion

}

/// <summary>

/// Initialize the runtime...

/// </summary>

/// <remarks>Always call this method from the Main thread. After the

/// first call to this method, the main thread has acquired the GIL.</remarks>

internal static void Initialize(bool initSigs = false, ShutdownMode mode = ShutdownMode.Default)

}

private static void InitPyMembers()

}

private static IntPtr Get_PyObject_NextNotImplemented()

}

/// <summary>

/// Tries to downgrade the shutdown mode, if possible.

/// The only possibles downgrades are:

/// Soft -> Normal

/// Reload -> Soft

/// Reload -> Normal

/// </summary>

/// <param name="mode">The desired shutdown mode</param>

/// <returns>The `mode` parameter if the downgrade is supported, the ShutdownMode

/// set at initialization otherwise.</returns>

static ShutdownMode TryDowngradeShutdown(ShutdownMode mode)

}

internal static void Shutdown(ShutdownMode mode)

}

internal static void Shutdown()

}

internal static ShutdownMode GetDefaultShutdownMode()

}

private static void RunExitFuncs()

}

private static void SetPyMember(ref IntPtr obj, IntPtr value, Action onRelease)

}

private static void ResetPyMembers()

{

_pyRefs.Release();

}

private static void ClearClrModules()

}

private static void RemoveClrRootModule()

}

private static void PyDictTryDelItem(BorrowedReference dict, string key)

}

private static void MoveClrInstancesOnwershipToPython()

}

internal static IntPtr PyBaseObjectType;

internal static IntPtr PyModuleType;

internal static IntPtr PyClassType;

internal static IntPtr PyInstanceType;

internal static IntPtr PySuper_Type;

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 Py_NoSiteFlag;

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;

public static PyObject None

}

/// <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()

}

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

}

internal static Type[] PythonArgsToTypeArray(IntPtr arg)

{

return PythonArgsToTypeArray(arg, false);

}

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

}

/// <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)

}

/// <summary>

/// Increase Python's ref counter for the given object, and get the object back.

/// </summary>

internal static IntPtr SelfIncRef(IntPtr op)

}

internal static unsafe void XDecref(IntPtr op)

{

#if !CUSTOM_INCDEC_REF

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.Void_Call_1(new IntPtr(f), op);

}

}

#endif

}

[Pure]

internal static unsafe long Refcount(IntPtr op)

{

#if PYTHON_WITH_PYDEBUG

var p = (void*)(op + TypeOffset.ob_refcnt);

#else

var p = (void*)op;

#endif

if ((void*)0 == p)

{

return 0;

}

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>

internal static void Py_IncRef(IntPtr ob) => Delegates.Py_IncRef(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>

internal static void Py_DecRef(IntPtr ob) => Delegates.Py_DecRef(ob);

internal static void Py_Initialize() => Delegates.Py_Initialize();

internal static void Py_InitializeEx(int initsigs) => Delegates.Py_InitializeEx(initsigs);

internal static int Py_IsInitialized() => Delegates.Py_IsInitialized();

internal static void Py_Finalize() => Delegates.Py_Finalize();

internal static IntPtr Py_NewInterpreter() => Delegates.Py_NewInterpreter();

internal static void Py_EndInterpreter(IntPtr threadState) => Delegates.Py_EndInterpreter(threadState);

internal static IntPtr PyThreadState_New(IntPtr istate) => Delegates.PyThreadState_New(istate);

internal static IntPtr PyThreadState_Get() => Delegates.PyThreadState_Get();

internal static IntPtr _PyThreadState_UncheckedGet() => Delegates._PyThreadState_UncheckedGet();

internal static IntPtr PyThread_get_key_value(IntPtr key) => Delegates.PyThread_get_key_value(key);

internal static int PyThread_get_thread_ident() => Delegates.PyThread_get_thread_ident();

internal static int PyThread_set_key_value(IntPtr key, IntPtr value) => Delegates.PyThread_set_key_value(key, value);

internal static IntPtr PyThreadState_Swap(IntPtr key) => Delegates.PyThreadState_Swap(key);

internal static IntPtr PyGILState_Ensure() => Delegates.PyGILState_Ensure();

internal static void PyGILState_Release(IntPtr gs) => Delegates.PyGILState_Release(gs);

internal static IntPtr PyGILState_GetThisThreadState() => Delegates.PyGILState_GetThisThreadState();

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

{

var marshaler = StrArrayMarshaler.GetInstance(null);

var argvPtr = marshaler.MarshalManagedToNative(argv);

try

{

return Delegates.Py_Main(argc, argvPtr);

}

finally

{

marshaler.CleanUpNativeData(argvPtr);

}

}

internal static void PyEval_InitThreads() => Delegates.PyEval_InitThreads();

internal static int PyEval_ThreadsInitialized() => Delegates.PyEval_ThreadsInitialized();

internal static void PyEval_AcquireLock() => Delegates.PyEval_AcquireLock();

internal static void PyEval_ReleaseLock() => Delegates.PyEval_ReleaseLock();

internal static void PyEval_AcquireThread(IntPtr tstate) => Delegates.PyEval_AcquireThread(tstate);

internal static void PyEval_ReleaseThread(IntPtr tstate) => Delegates.PyEval_ReleaseThread(tstate);

internal static IntPtr PyEval_SaveThread() => Delegates.PyEval_SaveThread();

internal static void PyEval_RestoreThread(IntPtr tstate) => Delegates.PyEval_RestoreThread(tstate);

internal static BorrowedReference PyEval_GetBuiltins() => Delegates.PyEval_GetBuiltins();

internal static BorrowedReference PyEval_GetGlobals() => Delegates.PyEval_GetGlobals();

internal static IntPtr PyEval_GetLocals() => Delegates.PyEval_GetLocals();

internal static IntPtr Py_GetProgramName() => Delegates.Py_GetProgramName();

internal static void Py_SetProgramName(IntPtr name) => Delegates.Py_SetProgramName(name);

internal static IntPtr Py_GetPythonHome() => Delegates.Py_GetPythonHome();

internal static void Py_SetPythonHome(IntPtr home) => Delegates.Py_SetPythonHome(home);

internal static IntPtr Py_GetPath() => Delegates.Py_GetPath();

internal static void Py_SetPath(IntPtr home) => Delegates.Py_SetPath(home);

internal static IntPtr Py_GetVersion() => Delegates.Py_GetVersion();

internal static IntPtr Py_GetPlatform() => Delegates.Py_GetPlatform();

internal static IntPtr Py_GetCopyright() => Delegates.Py_GetCopyright();