/// <summary> /// Gets a reference to a module. /// </summary> /// <param name="name">The full import name of the module.</param> /// <param name="res">The module reference object.</param> /// <returns> /// True if the module is available. This means that <c>res.Module</c> /// is not null. If this function returns false, <paramref name="res"/> /// may be valid and should not be replaced, but it is an unresolved /// reference. /// </returns> public async Task <ModuleReference> TryImportAsync(string name) { ModuleReference res; bool firstImport = false; if (!_modules.TryGetValue(name, out res) || res == null) { var mod = await Task.Run(() => _interpreter.ImportModule(name)); _modules[name] = res = new ModuleReference(GetBuiltinModule(mod)); firstImport = true; } if (res != null && res.Module == null) { var mod = await Task.Run(() => _interpreter.ImportModule(name)); res.Module = GetBuiltinModule(mod); } if (firstImport && res != null && res.Module != null) { await Task.Run(() => _analyzer.DoDelayedSpecialization(name)); } if (res != null && res.Module == null) { return(null); } return(res); }
private IEnumerable <IAnalysisItemView> CalculateChildren() { if (_module == null) { _module = _interpreter.ImportModule(Name); } if (File.Exists(_idbPath)) { yield return(RawView.FromFile(_idbPath)); } var cpm = _module as Interpreter.LegacyDB.CPythonModule; if (cpm != null) { cpm.EnsureLoaded(); } if (cpm != null && cpm._hiddenMembers != null) { foreach (var keyValue in cpm._hiddenMembers) { yield return(MemberView.Make(_context, keyValue.Key, keyValue.Value)); } } foreach (var memberName in _module.GetMemberNames(_context)) { yield return(MemberView.Make(_context, _module, memberName)); } }
private IPythonModule GetModule() { var mod = Volatile.Read(ref _module); if (mod != null) { return(mod); } foreach (var n in _importNames) { mod = _interpreter.ImportModule(n); if (mod != null) { Debug.Assert(!(mod is AstNestedPythonModule), "ImportModule should not return nested module"); break; } } if (mod == null) { mod = new SentinelModule(_importNames.FirstOrDefault() ?? "<unknown>", false); } return(Interlocked.CompareExchange(ref _module, mod, null) ?? mod); }
/// <summary> /// Gets a reference to a module. /// </summary> /// <param name="name">The full import name of the module.</param> /// <param name="res">The module reference object.</param> /// <returns> /// True if the module is available. This means that <c>res.Module</c> /// is not null. If this function returns false, <paramref name="res"/> /// may be valid and should not be replaced, but it is an unresolved /// reference. /// </returns> public bool TryImport(string name, out ModuleReference res) { bool firstImport = false; if (!_modules.TryGetValue(name, out res) || res == null) { _modules[name] = res = new ModuleReference(GetBuiltinModule(_interpreter.ImportModule(name))); firstImport = true; } if (res != null && res.Module == null) { res.Module = GetBuiltinModule(_interpreter.ImportModule(name)); } if (firstImport && res != null && res.Module != null) { _analyzer.DoDelayedSpecialization(name); } return(res != null && res.Module != null); }
private void InitializeBuiltinModules() { var names = _interpreter.GetModuleNames(); foreach (string modName in names) { var mod = _interpreter.ImportModule(modName); if (mod != null) { ModuleReference modRef; if (Modules.TryGetValue(modName, out modRef)) { var existingBuiltin = modRef.Module as BuiltinModule; if (existingBuiltin != null && existingBuiltin._type == mod) { // don't replace existing module which is the same continue; } } Modules[modName] = new ModuleReference(new BuiltinModule(mod, this)); } } }
/// <summary> /// Gets a reference to a module. /// </summary> /// <param name="name">The full import name of the module.</param> /// <param name="moduleReference">The module reference object.</param> /// <returns> /// True if the module is available. This means that <c>moduleReference.Module</c> /// is not null. If this function returns false, <paramref name="moduleReference"/> /// may be valid and should not be replaced, but it is an unresolved /// reference. /// </returns> public bool TryImport(string name, out ModuleReference moduleReference) { var firstImport = false; if (!_modules.TryGetValue(name, out moduleReference) || moduleReference == null) { var pythonModule = _interpreter.ImportModule(name); moduleReference = SetModule(name, GetBuiltinModule(pythonModule)); firstImport = true; } if (moduleReference.Module == null) { moduleReference.Module = GetBuiltinModule(_interpreter.ImportModule(name)); } if (firstImport && moduleReference.Module != null) { _analyzer.DoDelayedSpecialization(name); } return(moduleReference.Module != null); }
public IPythonModule ImportModule(string name) { if (string.IsNullOrWhiteSpace(name)) { return(null); } if (name == _builtinModule?.Name) { return(_builtinModule); } if (_modules.TryGetValue(name, out var mod)) { return(mod); } var handle = Remote.LookupNamespace(name); if (!handle.IsNull) { mod = MakeObject(handle) as IPythonModule; if (mod != null) { return(_modules.GetOrAdd(name, mod)); } } var pythonModule = _pythonInterpreter.ImportModule(name); if (pythonModule != null) { _modules.GetOrAdd(name, pythonModule); return(pythonModule); } var nameParts = name.Split('.'); if (nameParts.Length > 1 && (mod = ImportModule(nameParts[0])) != null) { for (var i = 1; i < nameParts.Length && mod != null; ++i) { mod = mod.GetMember(IronPythonModuleContext.ShowClrInstance, nameParts[i]) as IPythonModule; } } return(_modules.GetOrAdd(name, mod)); }
private IPythonModule GetModule() { var module = Volatile.Read(ref _module); if (module != null) { return(module); } module = _interpreter.ImportModule(Name); if (module != null) { Debug.Assert(!(module is AstNestedPythonModule), "ImportModule should not return nested module"); } if (module == null) { module = new SentinelModule(Name, false); } return(Interlocked.CompareExchange(ref _module, module, null) ?? module); }