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

// fields used during startup

private readonly IDictionary<object, object>/*!*/ _modulesDict = new PythonDictionary();

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

private readonly Dictionary<Type, string>/*!*/ _builtinModuleNames = new Dictionary<Type, string>();

private readonly PythonOptions/*!*/ _options;

private readonly PythonModule/*!*/ _systemState;

private readonly Dictionary<string, Type>/*!*/ _builtinModulesDict;

private readonly PythonOverloadResolverFactory _sharedOverloadResolverFactory;

private readonly PythonBinder _binder;

private readonly SysModuleDictionaryStorage _sysDict = new SysModuleDictionaryStorage();

#if FEATURE_FILESYSTEM

#if FEATURE_ASSEMBLY_RESOLVE

private readonly AssemblyResolveHolder _resolveHolder;

#endif

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

#endif

private Encoding _defaultEncoding = PythonAsciiEncoding.Instance;

private Hosting.PythonService _pythonService;

private string _initialExecutable, _initialPrefix = GetInitialPrefix();

// other fields which might only be conditionally used

private string _initialVersionString;

private PythonModule _clrModule;

private PythonDictionary _builtinDict;

private PythonModule _builtins;

private PythonFileManager _fileManager;

private Dictionary<string, object> _errorHandlers;

private List<object> _searchFunctions;

private Dictionary<object, object> _moduleState;

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

internal BuiltinFunction NewObject;

/// <summary> stored for copy_reg 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, PythonDictionary, 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, CodeContext, object, string, PythonDictionary, PythonDictionary, PythonTuple, object>> _oldImportSite;

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 CallSite<Func<CallSite, CodeContext, object, object, object, int>> _sharedFunctionCompareSite;

private CallSite<Func<CallSite, CodeContext, PythonFunction, object, object, int>> _sharedPythonFunctionCompareSite;

private CallSite<Func<CallSite, CodeContext, BuiltinFunction, object, object, int>> _sharedBuiltinFunctionCompareSite;

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;

internal bool _importWarningThrows;

private bool _importedEncodings;

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

private ClrModule.ReferencesList _referencesList;

private FloatFormat _floatFormat, _doubleFormat;

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

private CodeContext _defaultContext, _defaultClsContext;

private readonly TopNamespaceTracker _topNamespace;

private readonly IEqualityComparer<object> _equalityComparer;

private readonly IEqualityComparer _equalityComparerNonGeneric;

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

private Dictionary<Type, PythonSiteCache> _systemSiteCache;

internal static 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 DynamicMetaObjectBinder _invokeTwoConvertToInt;

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

_options = new PythonOptions(options);

_builtinModulesDict = CreateBuiltinTable();

PythonDictionary defaultScope = new PythonDictionary();

ModuleContext modContext = new ModuleContext(defaultScope, this);

_defaultContext = modContext.GlobalContext;

PythonDictionary sysDict = new PythonDictionary(_sysDict);

_systemState = new PythonModule(sysDict);

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

_systemState.__dict__["__package__"] = null;

PythonBinder binder = new PythonBinder(this, _defaultContext);

_sharedOverloadResolverFactory = new PythonOverloadResolverFactory(binder, Expression.Constant(_defaultContext));

_binder = binder;

CodeContext defaultClsContext = DefaultContext.CreateDefaultCLSContext(this);

_defaultClsContext = defaultClsContext;

if (DefaultContext._default == null) {

DefaultContext.InitializeDefaults(_defaultContext, defaultClsContext);

}

InitializeBuiltins();

InitializeSystemState();

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

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

new List(new object[] { String.Empty }) :

new List(_options.Arguments)

);

if (_options.WarningFilters.Count > 0) {

_systemState.__dict__["warnoptions"] = new List(_options.WarningFilters);

}

if (_options.Frames) {

var getFrame = BuiltinFunction.MakeFunction(

"_getframe",

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

typeof(SysModule)

);

_systemState.__dict__["_getframe"] = getFrame;

}

if (_options.Tracing) {

EnsureDebugContext();

}

List path = new List(_options.SearchPaths);

#if FEATURE_ASSEMBLY_RESOLVE && FEATURE_FILESYSTEM

_resolveHolder = new AssemblyResolveHolder(this);

try {

string entry = Path.GetDirectoryName(Assembly.GetEntryAssembly()?.Location);

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

// or in self-contained single file scenarios

if (entry != null) {

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

if(Directory.Exists(lib)) {

path.append(lib);

}

string dlls = Path.Combine(entry, "DLLs");

if(Directory.Exists(dlls)) {

// add DLLs directory for user-defined extention modules

path.append(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 dirs = new string[] { "/usr/lib/ironpython2.7", "/usr/share/ironpython2.7/DLLs" };

foreach(var dir in dirs) {

if(Directory.Exists(dir)) {

path.append(dir);

}

}

}

#endif

}

} catch (SecurityException) {

}

#endif

_systemState.__dict__["path"] = path;

RecursionLimit = _options.RecursionLimit;

#if FEATURE_ASSEMBLY_RESOLVE && FEATURE_FILESYSTEM

object asmResolve;

if (options == null ||

!options.TryGetValue("NoAssemblyResolveHook", out 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();

}

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 == Int32.MaxValue) != (value == Int32.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 {

return _topNamespace;

}

}

#if FEATURE_THREAD

/// <summary>

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

/// </summary>

public Thread MainThread {

get {

return _mainThread;

}

set {

_mainThread = value;

}

}

private Thread _mainThread;

#endif

public IEqualityComparer<object>/*!*/ EqualityComparer {

get { return _equalityComparer; }

}

public IEqualityComparer/*!*/ EqualityComparerNonGeneric {

get { return _equalityComparerNonGeneric; }

}

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._defaultContext, x, y);

}

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

return PythonOps.EqualRetBool(Context._defaultContext, 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(this.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 {

get { return 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> 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> 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 {

return _options;

}

}

public override Guid VendorGuid {

get {

return LanguageVendor_Microsoft;

}

}

public override Guid LanguageGuid {

get {

return PythonLanguageGuid;

}

}

public PythonModule/*!*/ SystemState {

get {

return _systemState;

}

}

public PythonModule/*!*/ ClrModule {

get {

if (_clrModule == null) {

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

}

return _clrModule;

}

}

internal bool TryGetSystemPath(out List path) {

object val;

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

path = val as List;

} else {

path = null;

}

return path != null;

}

internal object SystemStandardOut {

get {

return GetSystemStateValue("stdout");

}

}

internal object SystemStandardIn {

get {

return GetSystemStateValue("stdin");

}

}

internal object SystemStandardError {

get {

return GetSystemStateValue("stderr");

}

}

internal IDictionary<object, object> SystemStateModules {

get {

return _modulesDict;

}

}

internal void UpdateExceptionInfo(object type, object value, object traceback) {

_sysDict.UpdateExceptionInfo(type, value, traceback);

}

internal void UpdateExceptionInfo(Exception clrException, object type, object value, List<DynamicStackFrame> traceback) {