internal BuiltinClassInfo MakeGenericType(Type clrType, params Type[] clrIndexTypes) { var genType = clrType.MakeGenericType(clrIndexTypes); var pyType = ClrModule.GetPythonType(genType); return(GetCached(pyType, () => new BuiltinClassInfo(pyType, this))); }
public BuiltinEventInfo(ReflectedEvent value, ProjectState projectState) : base(ClrModule.GetPythonType(value.Info.EventHandlerType), projectState) { _value = value; _doc = null; _type = ClrModule.GetPythonType(value.Info.EventHandlerType); }
public BuiltinFieldInfo(ReflectedField value, ProjectState projectState) : base(new LazyDotNetDict(ClrModule.GetPythonType(value.FieldType), projectState, true)) { _value = value; _doc = null; _type = ClrModule.GetPythonType(value.FieldType); }
public BuiltinFunctionInfo(BuiltinFunction function, ProjectState projectState) : base(ClrModule.GetPythonType(typeof(BuiltinFunction)), projectState) { // TODO: get return information, parameters, members _function = function; _returnTypes = Utils.GetReturnTypes(function, projectState); _doc = null; }
public static void InjectType(this ScriptScope scope, Type t) { string name = t.Name; if (t.IsGenericTypeDefinition) { name = name.Substring(0, name.IndexOf('`')); } scope.SetVariable(name, ClrModule.GetPythonType(t)); }
public static void AddExtensionType(this ModuleContext mc, Type type) { System.Type ExtensionMethodSet = typeof(PythonContext).Assembly.GetType("IronPython.Runtime.ExtensionMethodSet"); var extsetProp = typeof(ModuleContext).GetProperty("ExtensionMethods", BindingFlags.NonPublic | BindingFlags.Instance); object existingExt = extsetProp.GetValue(mc, null); var args = new object[] { mc.Context, existingExt, ClrModule.GetPythonType(type) }; object newExt = ExtensionMethodSet.GetMethod("AddType").Invoke(null, args); extsetProp.SetValue(mc, newExt, null); }
public BuiltinMethodInfo(BuiltinMethodDescriptor method, ProjectState projectState) : base(ClrModule.GetPythonType(typeof(BuiltinMethodDescriptor)), projectState) { // TODO: get return information, parameters, members _method = method; var function = PythonOps.GetBuiltinMethodDescriptorTemplate(method); _returnTypes = Utils.GetReturnTypes(function, projectState); _doc = null; }
internal static ParameterResult GetParameterResultFromParameterInfo(ParameterInfo param) { // TODO: Get parameter documentation var pyType = ClrModule.GetPythonType(param.ParameterType); string name = param.Name; string typeName = PythonType.Get__name__(pyType); if (param.IsDefined(typeof(ParamArrayAttribute), false)) { name = "*" + name; if (param.ParameterType.IsArray) { var elemType = param.ParameterType.GetElementType(); if (elemType == typeof(object)) { typeName = "sequence"; } else { typeName = PythonType.Get__name__(DynamicHelpers.GetPythonTypeFromType(elemType)) + " sequence"; } } } else if (param.IsDefined(typeof(ParamDictionaryAttribute), false)) { name = "**" + name; typeName = "object"; } bool isOptional = false; if (param.DefaultValue != DBNull.Value && !(param.DefaultValue is Missing)) { name = name + " = " + PythonOps.Repr(DefaultContext.Default, param.DefaultValue); } else if (param.IsOptional) { object missing = CompilerHelpers.GetMissingValue(param.ParameterType); if (missing != Missing.Value) { name = name + " = " + PythonOps.Repr(DefaultContext.Default, missing); } else { isOptional = true; } } return(new ParameterResult(name, "", typeName, isOptional)); }
public override ISet <Namespace> GetMember(Node node, AnalysisUnit unit, string name) { if (name == "get") { if (_getMethod == null) { var getter = ProjectState.GetMember <BuiltinMethodDescriptor>(ClrModule.GetPythonType(typeof(PythonDictionary)), "get"); _getMethod = new DictionaryGetMethod(getter, ProjectState, this).SelfSet; } return(_getMethod); } return(base.GetMember(node, unit, name)); }
internal static ISet <Namespace> GetReturnTypes(BuiltinFunction func, ProjectState projectState) { var result = new HashSet <Namespace>(); var found = new HashSet <Type>(); foreach (var target in func.Overloads.Targets) { var targetInfo = (target as System.Reflection.MethodInfo); if (targetInfo != null && !found.Contains(targetInfo.ReturnType)) { var pyType = ClrModule.GetPythonType(targetInfo.ReturnType); result.Add(((BuiltinClassInfo)projectState.GetNamespaceFromObjects(pyType)).Instance); found.Add(targetInfo.ReturnType); } } return(result); }
private void FillCommandsFromScriptSource(ScriptSource script) { CompiledCode code; try { code = script.Compile(); } catch (SyntaxErrorException e) { throw new SyntaxErrorExceptionPrettyWrapper(string.Format("Error compiling '{0}", _fileFullName), e); } ScriptScope scope = _engine.CreateScope(); scope.SetVariable("IIronPythonCommand", ClrModule.GetPythonType(typeof(IIronPythonCommand))); scope.SetVariable("BaseIronPythonCommand", ClrModule.GetPythonType(typeof(BaseIronPythonCommand))); scope.SetVariable("UserContext", UserContext.Instance); scope.SetVariable("WindowUtility", WindowUtility.Instance); scope.SetVariable("clr", _engine.GetClrModule()); try { code.Execute(scope); } catch (UnboundNameException e) { throw new PythonException(string.Format("Error compiling '{0}'", _fileFullName), e); } var pluginClasses = scope.GetItems() .Where(kvp => kvp.Value is IronPython.Runtime.Types.PythonType) .Where( kvp => typeof(IIronPythonCommand).IsAssignableFrom(((IronPython.Runtime.Types.PythonType)kvp.Value).__clrtype__())) .Where(kvp => kvp.Key != "BaseIronPythonCommand" && kvp.Key != "IIronPythonCommand"); var pluginMethods = scope.GetItems() .Where(kvp => _engine.Operations.IsCallable(kvp.Value) && kvp.Value is PythonFunction) .Where(kvp => !kvp.Key.StartsWith("_")); foreach (var nameAndClass in pluginClasses) { var plugin = (IIronPythonCommand)_engine.Operations.Invoke(nameAndClass.Value, new object[] { }); var commandName = CamelToSpaced(nameAndClass.Key); var description = _engine.Operations.GetDocumentation(nameAndClass.Value); if (plugin as BaseIronPythonCommand != null) { // retrieving the class name from the python time is a bit trickier without access to the engine // so we pass this here ((BaseIronPythonCommand)plugin).SetDefaultName(commandName); } var command = new IronPythonPluginCommand(_fileFullName, plugin, description); _localCommands.Add(command); } foreach (var pluginMethod in pluginMethods) { var commandName = CamelToSpaced(pluginMethod.Key); var method = pluginMethod.Value; var commandFromMethod = new IronPythonCommandFromMethod(commandName, arguments => _engine.Operations.Invoke(method, arguments).ToString()); var description = _engine.Operations.GetDocumentation(pluginMethod.Value); if (!string.IsNullOrEmpty(description)) { commandFromMethod.SetDescription(description); } var ironPythonPluginCommand = new IronPythonPluginCommand(_fileFullName, commandFromMethod, description); _localCommands.Add(ironPythonPluginCommand); } }
internal BuiltinClassInfo GetBuiltinType(Type type) { return(GetBuiltinType(ClrModule.GetPythonType(type))); }
internal BuiltinInstanceInfo GetInstance(Type type) { return(GetInstance(ClrModule.GetPythonType(type))); }
public ProjectState(ScriptEngine pythonEngine) { _pythonEngine = pythonEngine; _projectEntries = new List <ProjectEntry>(); _modules = new Dictionary <string, ModuleReference>(); _modulesByFilename = new Dictionary <string, ModuleInfo>(StringComparer.OrdinalIgnoreCase); _itemCache = new Dictionary <object, object>(); var pythonContext = HostingHelpers.GetLanguageContext(_pythonEngine) as PythonContext; _codeContextCls = new ModuleContext(new PythonDictionary(), pythonContext).GlobalContext; _codeContextCls.ModuleContext.ShowCls = true; _codeContext = new ModuleContext( new PythonDictionary(), HostingHelpers.GetLanguageContext(_pythonEngine) as PythonContext ).GlobalContext; InitializeBuiltinModules(); // TODO: Use reflection-only! _references = new List <KeyValuePair <Assembly, TopNamespaceTracker> >(); AddAssembly(LoadAssemblyInfo(typeof(string).Assembly)); AddAssembly(LoadAssemblyInfo(typeof(Debug).Assembly)); // cached for quick checks to see if we're a call to clr.AddReference SpecializeFunction("clr", "AddReference", (n, unit, args) => AddReference(n, null)); SpecializeFunction("clr", "AddReferenceByPartialName", (n, unit, args) => AddReference(n, ClrModule.LoadAssemblyByPartialName)); SpecializeFunction("clr", "AddReferenceByName", (n, unit, args) => AddReference(n, null)); SpecializeFunction("clr", "AddReferenceToFile", (n, unit, args) => AddReference(n, (s) => ClrModule.LoadAssemblyFromFile(_codeContext, s))); SpecializeFunction("clr", "AddReferenceToFileAndPath", (n, unit, args) => AddReference(n, (s) => ClrModule.LoadAssemblyFromFileWithPath(_codeContext, s))); try { SpecializeFunction("wpf", "LoadComponent", LoadComponent); } catch (KeyNotFoundException) { // IronPython.Wpf.dll isn't available... } SpecializeFunction("__builtin__", "range", (n, unit, args) => unit.DeclaringModule.GetOrMakeNodeVariable(n, (nn) => new RangeInfo(ClrModule.GetPythonType(typeof(List)), unit.ProjectState).SelfSet)); SpecializeFunction("__builtin__", "min", ReturnUnionOfInputs); SpecializeFunction("__builtin__", "max", ReturnUnionOfInputs); _builtinModule = (BuiltinModule)Modules["__builtin__"].Module; _propertyObj = GetBuiltin("property"); _classmethodObj = GetBuiltin("classmethod"); _staticmethodObj = GetBuiltin("staticmethod"); _typeObj = GetBuiltin("type"); _intType = GetBuiltin("int"); _stringType = (BuiltinClassInfo)GetBuiltin("str"); _objectSet = new HashSet <Namespace>(new[] { GetBuiltin("object") }); _setType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.Set); _rangeFunc = GetBuiltin("range"); _frozensetType = GetBuiltin("frozenset"); _functionType = GetNamespaceFromObjects(TypeCache.Function); _generatorType = (BuiltinClassInfo)GetNamespaceFromObjects(DynamicHelpers.GetPythonTypeFromType(typeof(PythonGenerator))); _dictType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.Dict); _boolType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.Boolean); _noneInst = (ConstantInfo)GetNamespaceFromObjects(new object[] { null }); _listType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.List); _tupleType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.PythonTuple); _queue = new Queue <AnalysisUnit>(); _docProvider = CodeContext.LanguageContext.GetService <DocumentationProvider>(); }