internal static readonly string/*!*/ IronPythonDisplayName = CurrentVersion.DisplayName;

internal const string/*!*/ IronPythonNames = "IronPython;Python;py";

internal const string/*!*/ IronPythonFileExtensions = ".py";

private static readonly Guid PythonLanguageGuid = new Guid("03ed4b80-d10b-442f-ad9a-47dae85b2051");

private static readonly Guid LanguageVendor_Microsoft = new Guid(-1723120188, -6423, 0x11d2, 0x90, 0x3f, 0, 0xc0, 0x4f, 0xa3, 2, 0xa1);

private readonly Dictionary<string, ModuleGlobalCache>/*!*/ _builtinCache = new Dictionary<string, ModuleGlobalCache>(StringComparer.Ordinal);

#if FEATURE_ASSEMBLY_RESOLVE && FEATURE_FILESYSTEM

private readonly AssemblyResolveHolder _resolveHolder;

private readonly HashSet<Assembly> _loadedAssemblies = new HashSet<Assembly>();

#endif

// conditional variables for silverlight/desktop CLR features

private PythonService _pythonService;

private string _initialExecutable;

// other fields which might only be conditionally used

private string _initialVersionString;

private PythonModule _clrModule;

private PythonFileManager _fileManager;

private Dictionary<string, object> _errorHandlers;

private List<object> _searchFunctions;

private Dictionary<object, object> _moduleState;

/// <summary> stored for copyreg module, used for reduce protocol </summary>

internal BuiltinFunction NewObject;

/// <summary> stored for copyreg module, used for reduce protocol </summary>

internal BuiltinFunction PythonReconstructor;

private Dictionary<Type, object> _genericSiteStorage;

private CallSite<Func<CallSite, CodeContext, object, object>>[] _newUnarySites;

private CallSite<Func<CallSite, CodeContext, object, object, object, object>>[] _newTernarySites;

private CallSite<Func<CallSite, object, object, int>> _compareSite;

private Dictionary<AttrKey, CallSite<Func<CallSite, object, object, object>>> _setAttrSites;

private Dictionary<AttrKey, CallSite<Action<CallSite, object>>> _deleteAttrSites;

private CallSite<Func<CallSite, CodeContext, object, string, PythonTuple, object, object>> _metaClassSite;

private CallSite<Func<CallSite, CodeContext, object, string, object>> _writeSite;

private CallSite<Func<CallSite, object, object, object>> _getIndexSite, _equalSite;

private CallSite<Action<CallSite, object, object>> _delIndexSite;

private CallSite<Func<CallSite, CodeContext, object, object>> _finalizerSite;

private CallSite<Func<CallSite, CodeContext, PythonFunction, object>> _functionCallSite;

private CallSite<Func<CallSite, object, object, bool>> _greaterThanSite, _lessThanSite, _greaterThanEqualSite, _lessThanEqualSite, _containsSite;

private CallSite<Func<CallSite, CodeContext, object, object[], object>> _callSplatSite;

private CallSite<Func<CallSite, CodeContext, object, object[], IDictionary<object, object>, object>> _callDictSite;

private CallSite<Func<CallSite, CodeContext, object, object, object, object>> _callDictSiteLooselyTyped;

private CallSite<Func<CallSite, CodeContext, object, string, PythonDictionary, PythonDictionary, PythonTuple, int, object>> _importSite;

private CallSite<Func<CallSite, object, bool>> _isCallableSite;

private CallSite<Func<CallSite, object, IList<string>>> _getSignaturesSite;

private CallSite<Func<CallSite, object, object, object>> _addSite, _divModSite, _rdivModSite;

private CallSite<Func<CallSite, object, object, object, object>> _setIndexSite, _delSliceSite;

private CallSite<Func<CallSite, object, object, object, object, object>> _setSliceSite;

private CallSite<Func<CallSite, object, string>> _docSite;

// conversion sites

private CallSite<Func<CallSite, object, int>> _intSite;

private CallSite<Func<CallSite, object, string>> _tryStringSite;

private CallSite<Func<CallSite, object, object>> _tryIntSite;

private CallSite<Func<CallSite, object, IEnumerable>> _tryIEnumerableSite;

private Dictionary<Type, CallSite<Func<CallSite, object, object>>> _implicitConvertSites;

private Dictionary<PythonOperationKind, CallSite<Func<CallSite, object, object, object>>> _binarySites;

private Dictionary<Type, DefaultPythonComparer> _defaultComparer;

private Dictionary<Type, DefaultPythonLtComparer> _defaultLtComparer;

private CallSite<Func<CallSite, CodeContext, object, int, object>> _getItemCallSite;

private CallSite<Func<CallSite, CodeContext, object, object, object>> _propGetSite, _propDelSite;

private CallSite<Func<CallSite, CodeContext, object, object, object, object>> _propSetSite;

private CompiledLoader _compiledLoader;

private bool _importWarningThrows;

private bool _importedEncodings;

private Action<Action> _commandDispatcher; // can be null

private ClrModule.ReferencesList _referencesList;

private CultureInfo _collateCulture, _ctypeCulture, _timeCulture, _monetaryCulture, _numericCulture;

private Dictionary<Type, CallSite<Func<CallSite, object, object, bool>>> _equalSites;

private Dictionary<Type, PythonSiteCache> _systemSiteCache;

internal static readonly object _syntaxErrorNoCaret = new object();

// atomized binders

private PythonInvokeBinder _invokeNoArgs, _invokeOneArg;

private Dictionary<CallSignature, PythonInvokeBinder/*!*/> _invokeBinders;

private Dictionary<string/*!*/, PythonGetMemberBinder/*!*/> _getMemberBinders;

private Dictionary<string/*!*/, PythonGetMemberBinder/*!*/> _tryGetMemberBinders;

private Dictionary<string/*!*/, PythonSetMemberBinder/*!*/> _setMemberBinders;

private Dictionary<string/*!*/, PythonDeleteMemberBinder/*!*/> _deleteMemberBinders;

private Dictionary<string/*!*/, CompatibilityGetMember/*!*/> _compatGetMember;

private Dictionary<string/*!*/, CompatibilityGetMember/*!*/> _compatGetMemberNoThrow;

private Dictionary<PythonOperationKind, PythonOperationBinder/*!*/> _operationBinders;

private Dictionary<ExpressionType, PythonUnaryOperationBinder/*!*/> _unaryBinders;

private PythonBinaryOperationBinder[] _binaryBinders;

private Dictionary<OperationRetTypeKey<ExpressionType>, BinaryRetTypeBinder/*!*/> _binaryRetTypeBinders;

private Dictionary<OperationRetTypeKey<PythonOperationKind>, BinaryRetTypeBinder/*!*/> _operationRetTypeBinders;

private Dictionary<Type/*!*/, PythonConversionBinder/*!*/>[] _conversionBinders;

private Dictionary<Type/*!*/, DynamicMetaObjectBinder/*!*/>[] _convertRetObjectBinders;

private Dictionary<CallSignature, CreateFallback/*!*/> _createBinders;

private Dictionary<CallSignature, CompatibilityInvokeBinder/*!*/> _compatInvokeBinders;

private PythonGetSliceBinder _getSlice;

private PythonSetSliceBinder _setSlice;

private PythonDeleteSliceBinder _deleteSlice;

private PythonGetIndexBinder[] _getIndexBinders;

private PythonSetIndexBinder[] _setIndexBinders;

private PythonDeleteIndexBinder[] _deleteIndexBinders;

private static CultureInfo _CCulture;

private DynamicDelegateCreator _delegateCreator;

// tracing / in-proc debugging support

private DebugContext _debugContext;

private Debugging.TracePipeline _tracePipeline;

private readonly Microsoft.Scripting.Utils.ThreadLocal<PythonTracebackListener> _tracebackListeners = new Microsoft.Scripting.Utils.ThreadLocal<PythonTracebackListener>();

private int _tracebackListenersCount;

internal FunctionCode.CodeList _allCodes;

internal readonly object _codeCleanupLock = new object(), _codeUpdateLock = new object();

internal int _codeCount, _nextCodeCleanup = 200;

private int _recursionLimit;

internal readonly List<FunctionStack> _mainThreadFunctionStack;

private CallSite<Func<CallSite, CodeContext, object, object>> _callSite0LightEh;

private List<WeakReference> _weakExtensionMethodSets;

// store the Python types mapping to each .NET type

private readonly CommonDictionaryStorage _systemPythonTypesWeakRefs = new CommonDictionaryStorage();

#region Generated Python Shared Call Sites Storage

// *** BEGIN GENERATED CODE ***

// generated by function: gen_shared_call_sites_storage from: generate_calls.py

private CallSite<Func<CallSite, CodeContext, object, object>> _callSite0;

private CallSite<Func<CallSite, CodeContext, object, object, object>> _callSite1;

private CallSite<Func<CallSite, CodeContext, object, object, object, object>> _callSite2;

private CallSite<Func<CallSite, CodeContext, object, object, object, object, object>> _callSite3;

private CallSite<Func<CallSite, CodeContext, object, object, object, object, object, object>> _callSite4;

private CallSite<Func<CallSite, CodeContext, object, object, object, object, object, object, object>> _callSite5;

private CallSite<Func<CallSite, CodeContext, object, object, object, object, object, object, object, object>> _callSite6;

// *** END GENERATED CODE ***

#endregion

/// <summary>

/// Creates a new PythonContext not bound to Engine.

/// </summary>

public PythonContext(ScriptDomainManager/*!*/ manager, IDictionary<string, object> options)

: base(manager) {

PythonOptions = new PythonOptions(options);

BuiltinModules = CreateBuiltinTable();

PythonDictionary defaultScope = new PythonDictionary();

ModuleContext modContext = new ModuleContext(defaultScope, this);

SharedContext = modContext.GlobalContext;

ModuleDictionaryStorage sysStorage = new ModuleDictionaryStorage(typeof(SysModule));

PythonDictionary sysDict = new PythonDictionary(sysStorage);

SystemState = new PythonModule(sysDict);

SystemState.__dict__["__name__"] = "sys";

SystemState.__dict__["__package__"] = null;

PythonBinder binder = new PythonBinder(this, SharedContext);

SharedOverloadResolverFactory = new PythonOverloadResolverFactory(binder, Expression.Constant(SharedContext));

Binder = binder;

CodeContext defaultClsContext = DefaultContext.CreateDefaultCLSContext(this);

SharedClsContext = defaultClsContext;

if (DefaultContext._default == null) {

DefaultContext.InitializeDefaults(SharedContext, defaultClsContext);

}

InitializeBuiltins();

InitializeSystemState();

// sys.argv always includes at least one empty string.

SetSystemStateValue("argv", (PythonOptions.Arguments.Count == 0) ?

new PythonList(new object[] { string.Empty }) :

new PythonList(PythonOptions.Arguments)

);

if (PythonOptions.WarningFilters.Count > 0) {

SystemState.__dict__["warnoptions"] = new PythonList(PythonOptions.WarningFilters);

}

if (PythonOptions.Frames) {

var getFrame = BuiltinFunction.MakeFunction(

"_getframe",

ArrayUtils.ConvertAll(typeof(SysModule).GetMember(nameof(SysModule._getframeImpl)), (x) => (MethodBase)x),

typeof(SysModule)

);

SystemState.__dict__["_getframe"] = getFrame;

}

if (PythonOptions.Tracing) {

EnsureDebugContext();

}

PythonList path = new PythonList(PythonOptions.SearchPaths);

#if FEATURE_ASSEMBLY_RESOLVE && FEATURE_FILESYSTEM

_resolveHolder = new AssemblyResolveHolder(this);

try {

Assembly entryAssembly = Assembly.GetEntryAssembly();

// Can be null if called from unmanaged code (VS integration scenario)

if (entryAssembly != null) {

string entry = Path.GetDirectoryName(entryAssembly.Location);

string lib = Path.Combine(entry, "Lib");

path.append(lib);

// add DLLs directory for user-defined extention modules

path.append(Path.Combine(entry, "DLLs"));

#if DEBUG

// For developer use, add Src/StdLib/Lib

string devStdLib = Path.Combine(entry, @"../../../Src/StdLib/Lib");

if (Directory.Exists(devStdLib))

path.append(devStdLib);

#else

if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) {

var dirs = new string[] { "lib", "DLLs" };

var version = CurrentVersion.ReleaseLevel == "final" ? $"{CurrentVersion.Major}.{CurrentVersion.Minor}.{CurrentVersion.Micro}" : $"{CurrentVersion.Major}.{CurrentVersion.Minor}.{CurrentVersion.Micro}-{CurrentVersion.ReleaseLevel}{CurrentVersion.ReleaseSerial}";

foreach (var dir in dirs) {

var p = $"/Library/Frameworks/IronPython.framework/Versions/{version}/{dir}";

if (Directory.Exists(p)) {

path.append(p);

}

}

} else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) {

var version = $"{CurrentVersion.Major}.{CurrentVersion.Minor}";

var dirs = new string[] { $"/usr/lib/ironpython{version}", $"/usr/share/ironpython{version}/DLLs" };

foreach (var dir in dirs) {

if (Directory.Exists(dir)) {

path.append(dir);

}

}

}

#endif

}

} catch (SecurityException) { }

#endif

SystemState.__dict__["path"] = path;

RecursionLimit = PythonOptions.RecursionLimit;

#if FEATURE_ASSEMBLY_RESOLVE && FEATURE_FILESYSTEM

if (options == null ||

!options.TryGetValue("NoAssemblyResolveHook", out object asmResolve) ||

!System.Convert.ToBoolean(asmResolve)) {

try {

HookAssemblyResolve();

} catch (System.Security.SecurityException) {

// We may not have SecurityPermissionFlag.ControlAppDomain.

// If so, we will not look up sys.path for module loads

}

}

#endif

EqualityComparer = new PythonEqualityComparer(this);

EqualityComparerNonGeneric = (IEqualityComparer)EqualityComparer;

InitialHasher = InitialHasherImpl;

IntHasher = IntHasherImpl;

DoubleHasher = DoubleHasherImpl;

StringHasher = StringHasherImpl;

FallbackHasher = FallbackHasherImpl;

TopNamespace = new TopNamespaceTracker(manager);

foreach (Assembly asm in manager.GetLoadedAssemblyList()) {

TopNamespace.LoadAssembly(asm);

}

manager.AssemblyLoaded += new EventHandler<AssemblyLoadedEventArgs>(ManagerAssemblyLoaded);

_mainThreadFunctionStack = PythonOps.GetFunctionStack();

// bootstrap importlib

try {

var sourceUnit = CreateSourceUnit(new BootstrapStreamContentProvider(), null, DefaultEncoding, SourceCodeKind.File);

var moduleOptions = ModuleOptions.Initialize | ModuleOptions.Optimized;

var scriptCode = GetScriptCode(sourceUnit, "_frozen_importlib", moduleOptions);

var scope = scriptCode.CreateScope();

var _frozen_importlib = InitializeModule(null, ((PythonScopeExtension)scope.GetExtension(ContextId)).ModuleContext, scriptCode, moduleOptions);

PythonOps.Invoke(SharedClsContext, _frozen_importlib, "_install", SystemState, GetBuiltinModule("_imp"));

} catch { }

}

private sealed class BootstrapStreamContentProvider : StreamContentProvider {

public override Stream GetStream() {

return typeof(PythonContext).Assembly.GetManifestResourceStream("IronPython.Modules._bootstrap.py");

}

}

private void ManagerAssemblyLoaded(object sender, AssemblyLoadedEventArgs e) {

TopNamespace.LoadAssembly(e.Assembly);

}

/// <summary>

/// Gets or sets the maximum depth of function calls. Equivalent to sys.getrecursionlimit

/// and sys.setrecursionlimit.

/// </summary>

public int RecursionLimit {

get {

return _recursionLimit;

}

set {

if (value < 0) {

throw PythonOps.ValueError("recursion limit must be positive");

}

lock (_codeUpdateLock) {

_recursionLimit = value;

if ((_recursionLimit == int.MaxValue) != (value == int.MaxValue)) {

// recursion setting has changed, we need to update all of our

// function codes to enforce or un-enforce recursion.

FunctionCode.UpdateAllCode(this);

}

}

}

}

internal bool EnableTracing {

get {

return PythonOptions.Tracing || _tracebackListenersCount > 0;

}

}

internal TopNamespaceTracker TopNamespace { get; }

#if FEATURE_THREAD

/// <summary>

/// Gets or sets the main thread which should be interupted by thread.interrupt_main

/// </summary>

public Thread MainThread { get; set; }

#endif

public IEqualityComparer<object>/*!*/ EqualityComparer { get; }

public IEqualityComparer/*!*/ EqualityComparerNonGeneric { get; }

internal sealed class PythonEqualityComparer : IEqualityComparer, IEqualityComparer<object> {

public readonly PythonContext/*!*/ Context;

public PythonEqualityComparer(PythonContext/*!*/ context) {

Assert.NotNull(context);

Context = context;

}

bool IEqualityComparer.Equals(object x, object y) {

return PythonOps.EqualRetBool(Context.SharedContext, x, y);

}

bool IEqualityComparer<object>.Equals(object x, object y) {

return PythonOps.EqualRetBool(Context.SharedContext, x, y);

}

int IEqualityComparer.GetHashCode(object obj) {

return PythonContext.Hash(obj);

}

int IEqualityComparer<object>.GetHashCode(object obj) {

return PythonContext.Hash(obj);

}

}

#region Specialized Hashers

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]

internal readonly HashDelegate InitialHasher;

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]

internal readonly HashDelegate IntHasher;

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]

internal readonly HashDelegate DoubleHasher;

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]

internal readonly HashDelegate StringHasher;

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]

internal readonly HashDelegate FallbackHasher;

private int InitialHasherImpl(object o, ref HashDelegate dlg) {

if (o == null) {

return NoneTypeOps.NoneHashCode;

}

switch (o.GetType().GetTypeCode()) {

case TypeCode.String:

dlg = StringHasher;

return StringHasher(o, ref dlg);

case TypeCode.Int32:

dlg = IntHasher;

return IntHasher(o, ref dlg);

case TypeCode.Double:

dlg = DoubleHasher;

return DoubleHasher(o, ref dlg);

default:

if (o is IPythonObject) {

dlg = new OptimizedUserHasher(this, ((IPythonObject)o).PythonType).Hasher;

} else {

dlg = new OptimizedBuiltinHasher(this, o.GetType()).Hasher;

}

return dlg(o, ref dlg);

}

}

private int IntHasherImpl(object o, ref HashDelegate dlg) {

if (o != null && o.GetType() == typeof(int)) {

return o.GetHashCode();

}

dlg = FallbackHasher;

return FallbackHasher(o, ref dlg);

}

private int DoubleHasherImpl(object o, ref HashDelegate dlg) {

if (o != null && o.GetType() == typeof(double)) {

return DoubleOps.__hash__((double)o);

}

dlg = FallbackHasher;

return FallbackHasher(o, ref dlg);

}

private int StringHasherImpl(object o, ref HashDelegate dlg) {

if (o != null && o.GetType() == typeof(string)) {

return o.GetHashCode();

}

dlg = FallbackHasher;

return FallbackHasher(o, ref dlg);

}

private int FallbackHasherImpl(object o, ref HashDelegate dlg) {

return PythonOps.Hash(SharedContext, o);

}

private sealed class OptimizedUserHasher {

private readonly PythonContext _context;

private readonly PythonType _pt;

public OptimizedUserHasher(PythonContext context, PythonType pt) {

_context = context;

_pt = pt;

}

public int Hasher(object o, ref HashDelegate dlg) {

if (o is IPythonObject ipo && ipo.PythonType == _pt) {

return _pt.Hash(o);

}

dlg = _context.FallbackHasher;

return _context.FallbackHasher(o, ref dlg);

}

}

private sealed class OptimizedBuiltinHasher {

private readonly PythonContext _context;

private readonly Type _type;

private readonly PythonType _pt;

public OptimizedBuiltinHasher(PythonContext context, Type type) {

_context = context;

_type = type;

_pt = DynamicHelpers.GetPythonTypeFromType(type);

}

public int Hasher(object o, ref HashDelegate dlg) {

if (o != null && o.GetType() == _type) {

return _pt.Hash(o);

}

dlg = _context.FallbackHasher;

return _context.FallbackHasher(o, ref dlg);

}

}

#endregion

public override LanguageOptions/*!*/ Options => PythonOptions;

/// <summary>

/// Checks to see if module state has the current value stored already.

/// </summary>

public bool HasModuleState(object key) {

EnsureModuleState();

lock (_moduleState) {

return _moduleState.ContainsKey(key);

}

}

private void EnsureModuleState() {

if (_moduleState == null) {

Interlocked.CompareExchange(ref _moduleState, new Dictionary<object, object>(), null);

}

}

/// <summary>

/// Gets per-runtime state used by a module. The module should have a unique key for

/// each piece of state it needs to store.

/// </summary>

public object GetModuleState(object key) {

EnsureModuleState();

lock (_moduleState) {

Debug.Assert(_moduleState.ContainsKey(key));

return _moduleState[key];

}

}

/// <summary>

/// Sets per-runtime state used by a module. The module should have a unique key for

/// each piece of state it needs to store.

/// </summary>

public void SetModuleState(object key, object value) {

EnsureModuleState();

lock (_moduleState) {

_moduleState[key] = value;

}

}

/// <summary>

/// Sets per-runtime state used by a module and returns the previous value. The module

/// should have a unique key for each piece of state it needs to store.

/// </summary>

public object GetSetModuleState(object key, object value) {

EnsureModuleState();

lock (_moduleState) {

object result;

_moduleState.TryGetValue(key, out result);

_moduleState[key] = value;

return result;

}

}

/// <summary>

/// Sets per-runtime state used by a module and returns the previous value. The module

/// should have a unique key for each piece of state it needs to store.

/// </summary>

public T GetOrCreateModuleState<T>(object key, Func<T> value) where T : class {

EnsureModuleState();

lock (_moduleState) {

object result;

if (!_moduleState.TryGetValue(key, out result)) {

_moduleState[key] = result = value();

}

return (result as T);

}

}

public PythonType EnsureModuleException(object key, PythonDictionary dict, string name, string module) {

return (PythonType)(dict[name] = GetOrCreateModuleState(

key,

() => PythonExceptions.CreateSubType(this, PythonExceptions.Exception, name, module, null, PythonType.DefaultMakeException)

));

}

public PythonType EnsureModuleException(object key, PythonType baseType, PythonDictionary dict, string name, string module) {

return (PythonType)(dict[name] = GetOrCreateModuleState(

key,

() => PythonExceptions.CreateSubType(this, baseType, name, module, null, PythonType.DefaultMakeException)

));

}

public PythonType EnsureModuleException(object key, PythonType baseType, Type underlyingType, PythonDictionary dict, string name, string module, Func<string, Exception, Exception> exceptionMaker) {

return (PythonType)(dict[name] = GetOrCreateModuleState(

key,

() => PythonExceptions.CreateSubType(this, baseType, underlyingType, name, module, null, exceptionMaker)

));

}

public PythonType EnsureModuleException(object key, PythonType baseType, Type underlyingType, PythonDictionary dict, string name, string module, string documentation, Func<string, Exception, Exception> exceptionMaker) {

return (PythonType)(dict[name] = GetOrCreateModuleState(

key,

() => PythonExceptions.CreateSubType(this, baseType, underlyingType, name, module, documentation, exceptionMaker)

));

}

public PythonType EnsureModuleException(object key, PythonType[] baseTypes, Type underlyingType, PythonDictionary dict, string name, string module) {

return (PythonType)(dict[name] = GetOrCreateModuleState(

key,

() => PythonExceptions.CreateSubType(this, baseTypes, underlyingType, name, module, null, PythonType.DefaultMakeException)

));

}

internal PythonOptions/*!*/ PythonOptions { get; }

public override Guid VendorGuid => LanguageVendor_Microsoft;

public override Guid LanguageGuid => PythonLanguageGuid;

public PythonModule/*!*/ SystemState { get; }

public PythonModule/*!*/ ClrModule {

get {

if (_clrModule == null) {

Interlocked.CompareExchange(ref _clrModule, CreateBuiltinModule("clr"), null);

}

return _clrModule;

}

}

internal bool TryGetSystemPath(out PythonList path) {

if (SystemState.__dict__.TryGetValue("path", out object val)) {

path = val as PythonList;

} else {

path = null;

}

return path != null;

}

internal object SystemStandardOut => GetSystemStateValue("stdout");

internal object SystemStandardIn => GetSystemStateValue("stdin");

internal object SystemStandardError => GetSystemStateValue("stderr");

internal IDictionary<object, object>/*!*/ SystemStateModules { get; } = new PythonDictionary();

internal PythonModule GetModuleByName(string/*!*/ name) {

Assert.NotNull(name);

if (SystemStateModules.TryGetValue(name, out object scopeObj) && scopeObj is PythonModule module) {

return module;

}

return null;

}

internal PythonModule GetModuleByPath(string/*!*/ path) {

Assert.NotNull(path);

foreach (object moduleObj in SystemStateModules.Values) {

if (moduleObj is PythonModule module) {

if (DomainManager.Platform.PathComparer.Compare(module.GetFile(), path) == 0) {

return module;

}

}

}

return null;

}

public override Version LanguageVersion => GetPythonVersion();

internal static Version GetPythonVersion()

=> new AssemblyName(typeof(PythonContext).Assembly.FullName).Version;

internal FloatFormat FloatFormat { get; set; }

internal FloatFormat DoubleFormat { get; set; }

/// <summary>

/// Initializes the sys module on startup. Called both to load and reload sys

/// </summary>

private void InitializeSystemState() {

// These fields do not get reset on "reload(sys)", we populate them once on startup

SetSystemStateValue("argv", PythonList.FromArrayNoCopy(new object[] { string.Empty }));

SetSystemStateValue("modules", SystemStateModules);

InitializeSysFlags();

SystemStateModules["sys"] = SystemState;

SetSystemStateValue("path", new PythonList(3));

SetStandardIO();

SysModule.PerformModuleReload(this, SystemState.__dict__);

}

internal bool EmitDebugSymbols(SourceUnit sourceUnit) {

return sourceUnit.EmitDebugSymbols && (PythonOptions.NoDebug == null || !PythonOptions.NoDebug.IsMatch(sourceUnit.Path));

}

private void InitializeSysFlags() {

// sys.flags