public TotemScopeExtension(TotemContext context, Scope scope) : base(scope) { _codeContext = new CodeContext(new TotemDictionary( new ScopeDictionaryStorage(context, scope) ), null, context); }
public OptimizedScriptCode(Scope optimizedScope, DlrMainCallTarget optimizedTarget, SourceUnit sourceUnit) : base(sourceUnit) { ContractUtils.RequiresNotNull(optimizedScope, "optimizedScope"); _optimizedScope = optimizedScope; _optimizedTarget = optimizedTarget; }
public RubyGlobalScope(RubyContext/*!*/ context, Scope/*!*/ scope, object/*!*/ mainObject, bool isHosted) : base(scope) { Assert.NotNull(context, scope, mainObject); _context = context; _mainObject = mainObject; _isHosted = isHosted; }
public ScopeDictionaryStorage(TotemContext/*!*/ context, Scope/*!*/ scope) { Assert.NotNull(context, scope); _scope = scope; _context = context; }
public GlobalScopeExtension(RubyContext/*!*/ context, Scope/*!*/ globalScope, object/*!*/ mainObject, bool isHosted) : base(globalScope) { Assert.NotNull(context, globalScope, mainObject); _context = context; _mainObject = mainObject; _isHosted = isHosted; }
public CodeContext(Scope scope, LanguageContext languageContext, CodeContext parent) { Assert.NotNull(languageContext); _languageContext = languageContext; _scope = scope; _parent = parent; }
protected override object InvokeTarget(LambdaExpression code, Scope scope) { //TODO code is used bizarrly here in this API if (_optimizedScope == null || scope != _optimizedScope) { EnsureCompiled(false); return _code.Run(scope, LanguageContext); } else { return _optimizedCode.Run(); } }
public RubyGlobalScope(RubyContext/*!*/ context, Scope/*!*/ scope, RubyObject/*!*/ mainObject, bool isHosted) : base(scope) { Assert.NotNull(context, scope, mainObject); Debug.Assert(mainObject.ImmediateClass.IsSingletonClass); _context = context; _mainObject = mainObject; _isHosted = isHosted; }
/// <summary> /// Creates a new ModuleContext for the specified module. /// </summary> public ModuleContext(PythonModule/*!*/ module, PythonContext/*!*/ creatingContext) { ContractUtils.RequiresNotNull(module, "module"); ContractUtils.RequiresNotNull(creatingContext, "creatingContext"); _globals = module.__dict__; _pyContext = creatingContext; _globalScope = module.Scope; _globalContext = new CodeContext(_globals, this); _module = module; }
/// <summary> /// Creates a new ModuleContext which is backed by the specified dictionary. /// </summary> public ModuleContext(PythonDictionary/*!*/ globals, PythonContext/*!*/ creatingContext) { ContractUtils.RequiresNotNull(globals, "globals"); ContractUtils.RequiresNotNull(creatingContext, "creatingContext"); _globals = globals; _pyContext = creatingContext; _globalScope = new Scope(globals); _globalContext = new CodeContext(globals, this); _module = new PythonModule(globals, _globalScope); _globalScope.SetExtension(_pyContext.ContextId, new PythonScopeExtension(_pyContext, _module, this)); }
public ScriptDomainManager(DynamicRuntimeHostingProvider hostingProvider, DlrConfiguration configuration) { ContractUtils.RequiresNotNull(hostingProvider, "hostingProvider"); ContractUtils.RequiresNotNull(configuration, "configuration"); configuration.Freeze(); _hostingProvider = hostingProvider; _configuration = configuration; _sharedIO = new SharedIO(); // create the initial default scope _globals = new Scope(); }
protected object InvokeTarget(LambdaExpression code, Scope scope) { if (scope == _optimizedScope) { return _optimizedTarget(scope, LanguageContext); } // new scope, compile unoptimized code and use that. if (_unoptimizedTarget == null) { // TODO: fix generated DLR ASTs - languages should remove their usage // of GlobalVariables and then this can go away. Expression<DlrMainCallTarget> lambda = new GlobalLookupRewriter().RewriteLambda(code); _unoptimizedTarget = lambda.Compile(SourceUnit.EmitDebugSymbols); } return _unoptimizedTarget(scope, LanguageContext); }
private void EnsureCompiled(bool optimized) { //TODO too much duplicated code between these two blocks if (optimized) { if (_optimizedCode != null) return; var rewriter = new LightGlobalRewriter(); var newLambda = rewriter.RewriteLambda(Code, Code.Name, LanguageContext, optimized); _optimizedScope = rewriter.Scope; var compiler = new LightCompiler(); var interpreter = compiler.CompileTop(newLambda); _optimizedCode = new LightLambda(interpreter); } else { if (_code != null) return; var rewriter = new LightGlobalRewriter(); var newLambda = rewriter.RewriteLambda(Code, Code.Name, LanguageContext, optimized); var compiler = new LightCompiler(); var interpreter = compiler.CompileTop(newLambda); _code = new LightLambda(interpreter); } }
/// <summary> /// Creates a new Scope with the provided parent and dictionary. /// </summary> public Scope(Scope parent, IAttributesCollection dictionary) : this(parent, dictionary, true) { }
internal TotemModule(TotemContext context, Scope scope) { _dict = new TotemDictionary(new ScopeDictionaryStorage(context, scope)); _scope = scope; }
public PythonScopeExtension(PythonContext context, Scope scope) : base(scope) { _module = new PythonModule(context, scope); _modContext = new ModuleContext(_module, context); }
// emitted by GlobalRewriter // TODO: Python and JScript should do this public static CodeContext CreateTopLevelCodeContext(Scope scope, LanguageContext context) { context.EnsureScopeExtension(scope.ModuleScope); return new CodeContext(scope, context); }
private Scope CreateScope() { Scope ret = new Scope(new ObjectDictionaryExpando(_dict)); ret.SetExtension(_context.ContextId, new TotemScopeExtension(_context, ret)); return ret; }
private bool RequireFile(string/*!*/ path, Scope scope) { return _context.Loader.LoadFile(scope, null, _context.EncodePath(path), LoadFlags.Require); }
public LambdaExpression RewriteLambda(LambdaExpression lambda, string name, LanguageContext languageContext, bool optimized) { Debug.Assert(_context == null); Debug.Assert(lambda.Parameters.Count == 0); if (optimized) { _wrappers = new Dictionary<GlobalVariableExpression, ModuleGlobalWrapper>(); var customDictionary = new GlobalsDictionary(); this.Scope = new Scope(customDictionary); //context.EnsureScopeExtension(scope.ModuleScope); //return new CodeContext(scope, context); _codeContext = new CodeContext(this.Scope, languageContext); _context = Expression.Constant(_codeContext); var ret = (LambdaExpression)Visit(lambda); //??? customDictionary.SetData(new List<ModuleGlobalWrapper>(_wrappers.Values).ToArray()); return ret; } else { // Fix up the top-level lambda to have a scope and language parameters var scopeParameter = Expression.Parameter(typeof(Scope), "$scope"); var languageParameter = Expression.Parameter(typeof(LanguageContext), "$language"); var contextVariable = Expression.Variable(typeof(CodeContext), "$globalContext"); _context = contextVariable; lambda = (LambdaExpression)Visit(lambda); return Expression.Lambda<DlrMainCallTarget>( AstUtils.AddScopedVariable( lambda.Body, contextVariable, Expression.Call(typeof(ScriptingRuntimeHelpers).GetMethod("CreateTopLevelCodeContext"), scopeParameter, languageParameter) ), name, new[] { scopeParameter, languageParameter } ); } }
public GlobalScopeDictionaryStorage(Scope scope) : base(CodeContext.GetModuleScope(scope)) { }
public object Evaluate(Scope scope) { return this.Value; }
public CodeContext(Scope scope, LanguageContext languageContext) : this(scope, languageContext, null) { }
internal Scope GetLocalsScope() { ScopeData scopeData = CurrentScopeData; Scope scope = scopeData.Scope; if (scope == null) { Debug.Assert(_liftedLocals != null); List<SymbolId> visibleSymbols = new List<SymbolId>(); List<VariableInfo> visibleLocals = new List<VariableInfo>(); // Add parameters for (int i = 0; i < _funcInfo.Variables.Count; i++) { if (_funcInfo.Variables[i].IsParameter && !_funcInfo.Variables[i].Hidden) { visibleSymbols.Add(_funcInfo.Variables[i].Symbol); visibleLocals.Add(_funcInfo.Variables[i]); } } // Add locals foreach (VariableInfo varInfo in LocalsInCurrentScope) { if (!varInfo.Hidden) { visibleSymbols.Add(varInfo.Symbol); visibleLocals.Add(varInfo); } } IRuntimeVariables scopedLocals = new ScopedRuntimeVariables(visibleLocals, _liftedLocals); scope = new Scope(new LocalsDictionary(scopedLocals, visibleSymbols.ToArray())); scopeData.Scope = scope; } return scope; }
/// <summary> /// Creates a new Scope with the provided parent, dictionary and visibility. /// </summary> public Scope(Scope parent, IAttributesCollection dictionary, bool isVisible) { _parent = parent; _dict = dictionary ?? new SymbolDictionary(); _isVisible = isVisible; _extensions = ScopeExtension.EmptyArray; }
public GlobalScopeDictionaryStorage(Scope scope) : base(scope.ModuleScope) { }
public override object Run(Scope scope) { return EnsureTarget(_code)(scope, SourceUnit.LanguageContext); }
public override object Run(Scope scope) { return InvokeTarget(_code, scope); }
protected virtual object InvokeTarget(LambdaExpression code, Scope scope) { return EnsureTarget(code)(scope, LanguageContext); }
/// <summary> /// Creates the methods and optimized Scope's which get associated with each ScriptCode. /// </summary> private Scope CompileOptimizedScope() { DlrMainCallTarget target; IAttributesCollection globals; if (UseLightweightScopes) { CompileWithArrayGlobals(out target, out globals); } else { CompileWithStaticGlobals(out target, out globals); } // Force creation of names used in other script codes into all optimized dictionaries Scope scope = new Scope(globals); ((IModuleDictionaryInitialization)globals).InitializeModuleDictionary(new CodeContext(scope, LanguageContext)); // everything succeeded, commit the results _optimizedTarget = target; _optimizedScope = scope; return scope; }
public ScopeExtension(Scope scope) { ContractUtils.RequiresNotNull(scope, nameof(scope)); Scope = scope; }