public LanguageBoundTextContentProvider(LanguageContext context, StreamContentProvider streamProvider, Encoding defaultEncoding, string path) { Assert.NotNull(context, streamProvider, defaultEncoding); _context = context; _streamProvider = streamProvider; _defaultEncoding = defaultEncoding; _path = path; }
public CodeContext(Scope scope, LanguageContext languageContext, CodeContext parent) { Assert.NotNull(languageContext); _languageContext = languageContext; _scope = scope; _parent = parent; }
internal DelegateInfo(LanguageContext context, Type returnType, ParameterInfo[] parameters) { Assert.NotNull(returnType); Assert.NotNullItems(parameters); _returnType = returnType; _parameters = parameters; PerfTrack.NoteEvent(PerfTrack.Categories.DelegateCreate, ToString()); if (_returnType != typeof(void)) { _convertBinder = context.CreateConvertBinder(_returnType, true); } _invokeBinder = context.CreateInvokeBinder(new CallInfo(_parameters.Length)); Type[] delegateParams = new Type[_parameters.Length]; for (int i = 0; i < _parameters.Length; i++) { delegateParams[i] = _parameters[i].ParameterType; } // Create the method with a special name so the langauge compiler knows that method's stack frame is not visible DynamicILGen cg = Snippets.Shared.CreateDynamicMethod("_Scripting_", _returnType, ArrayUtils.Insert(typeof(object[]), delegateParams), false); // Emit the stub _constants = EmitClrCallStub(cg); _method = cg.Finish(); }
internal DelegateSignatureInfo(LanguageContext context, Type returnType, ParameterInfo[] parameters) { Assert.NotNull(context, returnType); Assert.NotNullItems(parameters); _context = context; _parameters = parameters; _returnType = returnType; }
public CompletionProviderOriginal(IBackendContext backendContext, LanguageContext languageContext) { _languageContext = languageContext; _backendContext = backendContext; _powershell = PowerShell.Create(); _powershell.Runspace = RunspaceFactory.CreateRunspace(); _powershell.Runspace.ThreadOptions = PSThreadOptions.UseNewThread; _powershell.Runspace.Open(); Keywords = new List<ICompletionEntry>(); Runbooks = new List<ICompletionEntry>(); }
internal DelegateSignatureInfo(LanguageContext context, Type returnType, ParameterInfo[] parameters) { Assert.NotNull(context, returnType); Assert.NotNullItems(parameters); _context = context; _parameters = parameters; _returnType = returnType; if (_returnType != typeof(void)) { _convert = _context.CreateConvertBinder(_returnType, true); } _invoke = _context.CreateInvokeBinder(new CallInfo(_parameters.Length)); }
public SourceUnit GenerateCode(CodeMemberMethod codeDom, LanguageContext context, string path, SourceCodeKind kind) { ContractUtils.RequiresNotNull(codeDom, "codeDom"); ContractUtils.RequiresNotNull(context, "context"); ContractUtils.Requires(path == null || path.Length > 0, "path"); // Convert the CodeDom to source code if (_writer != null) { _writer.Close(); } _writer = new PositionTrackingWriter(); WriteFunctionDefinition(codeDom); return CreateSourceUnit(context, path, kind); }
internal DelegateSignatureInfo(LanguageContext context, Type returnType, ParameterInfo[] parameters) { Assert.NotNull(context, returnType); Assert.NotNullItems(parameters); _context = context; _parameters = parameters; _returnType = returnType; if (_returnType != typeof(void)) { _convert = _context.CreateConvertBinder(_returnType, true); } ArgumentInfo[] args = new ArgumentInfo[_parameters.Length]; for (int i = 0; i < args.Length; i++) { args[i] = Expression.PositionalArg(i); } _invoke = _context.CreateInvokeBinder(args); }
public DelegateInfo(LanguageContext context, Type returnType, Type[] parameters) { Assert.NotNull(returnType); Assert.NotNullItems(parameters); _returnType = returnType; _parameterTypes = parameters; PerfTrack.NoteEvent(PerfTrack.Categories.DelegateCreate, ToString()); if (_returnType != typeof(void)) { _convertBinder = context.CreateConvertBinder(_returnType, true); } _invokeBinder = context.CreateInvokeBinder(new CallInfo(_parameterTypes.Length)); Type[] delegateParams = new Type[1 + _parameterTypes.Length]; delegateParams[0] = typeof(object[]); for (int i = 0; i < _parameterTypes.Length; i++) { delegateParams[1 + i] = _parameterTypes[i]; } EmitClrCallStub(returnType, delegateParams, out _method); }
protected abstract IAttributesCollection CreateLanguageDictionary(LanguageContext context, ScopeAllocator allocator);
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods")] // TODO: fix public IEnumerable<SymbolId> GetKeys(LanguageContext context) { foreach (SymbolId si in _dict.SymbolAttributes.Keys) { yield return si; } }
public bool TryGetLanguageByFileExtension(string fileExtension, out LanguageContext language) { ContractUtils.RequiresNotEmpty(fileExtension, "fileExtension"); return _configuration.TryLoadLanguage(this, DlrConfiguration.NormalizeExtension(fileExtension), true, out language); }
public System.Linq.Expressions.Expression ResolveForDelete(string name) { return(System.Linq.Expressions.Expression.Dynamic(LanguageContext.CreateDeleteMemberBinder(name, false, true), typeof(object), Context)); }
public DynamicDelegateCreator(LanguageContext languageContext) { ContractUtils.RequiresNotNull(languageContext, "languageContext"); _languageContext = languageContext; }
internal static Delegate /*!*/ CompileLambda(LambdaExpression /*!*/ lambda, LanguageContext /*!*/ context) { return(CompileLambda(lambda, context.DomainManager.Configuration.DebugMode, context.Options.NoAdaptiveCompilation, context.Options.CompilationThreshold)); }
public System.Linq.Expressions.Expression Register(System.Linq.Expressions.Expression registeredTo) { return(Ast.Dynamic(LanguageContext.CreateSetMemberBinder(Name, false, true, true), typeof(object), registeredTo, TransformFunction(registeredTo) )); }
public void AddHandler(object target, object handler, LanguageContext language) { ContractUtils.RequiresNotNull(handler, "handler"); ContractUtils.RequiresNotNull(language, "language"); Delegate delegateHandler; HandlerList stubs; // we can add event directly (signature does match): if (_eventInfo.EventHandlerType.IsAssignableFrom(handler.GetType())) { delegateHandler = (Delegate)handler; stubs = null; } else { // create signature converting stub: delegateHandler = language.GetDelegate(handler, _eventInfo.EventHandlerType); stubs = GetHandlerList(target); } GetCallableAddMethod().Invoke(target, new object[] { delegateHandler }); if (stubs != null) { // remember the stub so that we could search for it on removal: stubs.AddHandler(handler, delegateHandler); } }
internal DelegateInfo GenerateDelegateStub(LanguageContext context) { return new DelegateInfo(context, _returnType, _parameters); }
public IronSchemeScriptEngine(LanguageProvider lp, EngineOptions eo, LanguageContext lc) : base(lp, eo, lc) { ((IronSchemeLanguageContext)LanguageContext).se = this; }
protected ScriptEngine(LanguageProvider provider, EngineOptions engineOptions, LanguageContext languageContext) { Contract.RequiresNotNull(provider, "provider"); Contract.RequiresNotNull(engineOptions, "engineOptions"); Contract.RequiresNotNull(languageContext, "languageContext"); #if !SILVERLIGHT // SecurityPermission if (engineOptions.ClrDebuggingEnabled) { // Currently, AssemblyBuilder.DefineDynamicModule requires high trust for emitting debug information. new System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode).Demand(); } #endif _provider = provider; _options = engineOptions; _languageContext = languageContext; }
private SourceUnit CreateSourceUnit(LanguageContext context, string path, SourceCodeKind kind) { string code = _writer.ToString(); SourceUnit src = context.CreateSnippet(code, path, kind); src.SetLineMapping(_writer.GetLineMap()); return src; }
public Ast Register(Ast registeredTo) { return(Ast.Dynamic(LanguageContext.CreateSetMemberBinder(Name, false, true, true), typeof(object), registeredTo, TransformFunction(registeredTo) )); }
private object _lastInputLine; // TODO: per method scope and top level scope, not block scope // top scope: protected RubyClosureScope(LanguageContext /*!*/ language, IAttributesCollection /*!*/ frame) : base(language, frame) { }
protected static CodeContext /*!*/ CreateTopLevelCodeContext(PythonDictionary /*!*/ dict, LanguageContext /*!*/ context) { ModuleContext modContext = new ModuleContext(dict, (PythonContext)context); return(modContext.GlobalContext); }
public override System.Linq.Expressions.Expression TransformGetProperty() { return(System.Linq.Expressions.Expression.Dynamic(LanguageContext.CreateGetIndexBinder(new CallInfo(2), true), typeof(object), Target.TransformRead(), Member.TransformRead())); }
public FragmentTagHelper(LanguageContext db) { _db = db; }
public override System.Linq.Expressions.Expression TransformDelete() { return(System.Linq.Expressions.Expression.Dynamic(LanguageContext.CreateDeleteMemberBinder(MemberName, false, true), typeof(object), TargetExpression)); }
/// <summary> /// Gets engine for the specified language. /// </summary> internal ScriptEngine GetEngine(LanguageContext language) { Assert.NotNull(language); ScriptEngine engine; bool freshEngineCreated; lock (_engines) { engine = GetEngineNoLockNoNotification(language, out freshEngineCreated); } if (freshEngineCreated && !ReferenceEquals(language, _invariantContext)) { _host.EngineCreated(engine); } return engine; }
public override System.Linq.Expressions.Expression TransformSetProperty(System.Linq.Expressions.Expression value) { return(System.Linq.Expressions.Expression.Dynamic(LanguageContext.CreateSetMemberBinder(MemberName, false, true, true), typeof(object), TargetExpression, value)); }
// top scope: protected RubyScope(LanguageContext /*!*/ language, IAttributesCollection /*!*/ frame) : base(null, language, null) { _frame = frame; _top = (RubyTopLevelScope)this; }
public override System.Linq.Expressions.Expression TransformWrite(System.Linq.Expressions.Expression value) { return(System.Linq.Expressions.Expression.Dynamic(LanguageContext.CreateSetIndexBinder(new CallInfo(3), false), typeof(object), Target.TransformRead(), Member.TransformRead(), value)); }
public System.Linq.Expressions.Expression DeclareVariable(string name, System.Linq.Expressions.Expression value) { return(System.Linq.Expressions.Expression.Dynamic(LanguageContext.CreateSetMemberBinder(name, false, true, true), typeof(object), Context, value)); }
/// <summary> /// Creates a new ScriptScope using the default storage container /// </summary> public ScriptScope CreateScope() { return(new ScriptScope(this, LanguageContext.CreateScope())); }
public object GetClientData(object data, ref BitSet flag, LanguageContext languageContext) { return(data); }
/// <summary> /// Creates a new ScriptScope whose storage contains the provided dictionary of objects /// /// Accesses to the ScriptScope will turn into get,set, and delete members against this dictionary /// </summary> public ScriptScope CreateScope(IDictionary <string, object> dictionary) { ContractUtils.RequiresNotNull(dictionary, nameof(dictionary)); return(new ScriptScope(this, LanguageContext.CreateScope(dictionary))); }
/// <summary> /// Attempts to lookup the provided name in this scope or any outer scope. /// If the name is not defined the language defined MissingName exception is thrown. /// </summary> public object LookupName(LanguageContext context, SymbolId name) { object res; if (!TryLookupName(name, out res)) { throw context.MissingName(name); } return res; }
/// <summary> /// Creates a new ScriptScope whose storage is an arbitrary object. /// /// Accesses to the ScriptScope will turn into get, set, and delete members against the object. /// </summary> public ScriptScope CreateScope(IDynamicMetaObjectProvider storage) { ContractUtils.RequiresNotNull(storage, nameof(storage)); return(new ScriptScope(this, LanguageContext.CreateScope(storage))); }
public bool TryGetLanguage(string languageName, out LanguageContext language) { ContractUtils.RequiresNotNull(languageName, "languageName"); return _configuration.TryLoadLanguage(this, languageName, false, out language); }
internal ExceptionOperations(LanguageContext context) { _context = context; }
/// <summary> /// Method that allows the object to initialize itself. Passes the property map down /// the object hierarchy so that other objects may configure themselves as well.. /// sample config string /// /// backing-source /// ( /// read-thru /// ( /// assembly='Diyatech.Sample'; /// class='mySync.DB.Reader' /// ); /// write-thru /// ( /// assembly='Diyatech.Sample'; /// class='mySync.DB.Writer' /// ) /// ) /// </summary> /// <param name="properties">properties collection for this cache.</param> private void Initialize(IDictionary properties) { Assembly asm = null; if (properties == null) { throw new ArgumentNullException("properties"); } try { if (!properties.Contains("assembly-name")) { throw new ConfigurationException("Missing assembly name for write-thru option"); } if (!properties.Contains("class-name")) { throw new ConfigurationException("Missing class name for write-thru option"); } string assembly = Convert.ToString(properties["assembly-name"]); string classname = Convert.ToString(properties["class-name"]); IDictionary startupparams = properties["parameters"] as IDictionary; //This is added to load the .exe and .dll providers //to keep previous provider running this bad chunk of code is written //later on you can directly provide the provider name read from config. string extension = ".dll"; if (properties.Contains("full-name")) { extension = Path.GetExtension(Convert.ToString(properties["full-name"])); } if (startupparams == null) { startupparams = new Hashtable(); } try { if (extension.Equals(".dll") || extension.Equals(".exe")) { AuthenticateFeature.Authenticate(LanguageContext.DOTNET); _languageContext = LanguageContext.DOTNET; if (classname.Contains("Alachisoft.NCache.Web.ClientCache.ClientCacheWriteThru") && InternalProviderFactory.Instance != null) { _dsWriter = InternalProviderFactory.Instance.CreateWriteThruProvider(); } else { string path = AppUtil.DeployedAssemblyDir + _cacheName + GetWriteThruAssemblyPath(assembly) + extension; if (DatasourceMgr.AssemblyCache.ContainsKey(assembly)) { asm = DatasourceMgr.AssemblyCache[assembly]; } else { try { asm = Assembly.LoadFrom(path); } catch (Exception e) { try { asm = Assembly.Load(assembly); } catch (Exception) { try { string version = Assembly.GetExecutingAssembly().ImageRuntimeVersion; path = Path.Combine(AppUtil.InstallDir, "bin"); path = Path.Combine(path, "assembly"); if (version.Contains("v4")) { path = Path.Combine(path, "4.0") + GetWriteThruAssemblyPath(assembly) + extension; } else { path = Path.Combine(path, "2.0") + GetWriteThruAssemblyPath(assembly) + extension; } asm = Assembly.LoadFrom(path); } catch (Exception) { string message = string.Format("Could not load assembly \"" + assembly + "\". {0}", e.Message); throw new Exception(message); } } } } if (asm != null) { _dsWriter = (IWriteThruProvider)asm.CreateInstance(classname); } if (_dsWriter == null) { throw new Exception("Unable to instantiate " + classname); } if (asm != null) { DatasourceMgr.AssemblyCache[assembly] = asm; } } _dsWriter.Init(startupparams, _cacheName); } } catch (InvalidCastException) { throw new ConfigurationException("The class specified in write-thru does not implement IDatasourceWriter"); } catch (Exception e) { throw new ConfigurationException(e.Message, e); } } catch (ConfigurationException) { throw; } catch (Exception e) { throw new ConfigurationException("Configuration Error: " + e.ToString(), e); } }
public WordsSerialiser(string dataStoraPath, LanguageContext context) : base(dataStoraPath) { _languageContext = context; }
internal bool TryLoadLanguage(ScriptDomainManager manager, string str, bool isExtension, out LanguageContext language) { Assert.NotNull(manager, str); var dict = (isExtension) ? _languageExtensions : _languageNames; LanguageConfiguration config; if (dict.TryGetValue(str, out config)) { language = LoadLanguageContext(manager, config); return true; } language = null; return false; }
public static ScriptCode Load(DlrMainCallTarget method, LanguageContext language, string path) { SourceUnit su = new SourceUnit(language, NullTextContentProvider.Null, path, SourceCodeKind.File); return new LegacyScriptCode(null, method, su); }
public string[] GetFileExtensions(LanguageContext context) { var result = new List<string>(); foreach (var entry in _languageExtensions) { if (entry.Value.LanguageContext == context) { result.Add(entry.Key); } } return result.ToArray(); }
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 override System.Linq.Expressions.Expression TransformRead() { var args = TransformTargetAndArguments(); return(System.Linq.Expressions.Expression.Dynamic(LanguageContext.CreateInvokeBinder(args.Item2), typeof(object), args.Item1)); }
/// <summary> /// Looks up the engine for the specified language. It the engine hasn't been created in this Runtime, it is instantiated here. /// The method doesn't lock nor send notifications to the host. /// </summary> private ScriptEngine GetEngineNoLockNoNotification(LanguageContext language, out bool freshEngineCreated) { Debug.Assert(_engines != null, "Invalid ScriptRuntime initialiation order"); ScriptEngine engine; if (freshEngineCreated = !_engines.TryGetValue(language, out engine)) { engine = new ScriptEngine(this, language); Thread.MemoryBarrier(); _engines.Add(language, engine); } return engine; }
public System.Linq.Expressions.Expression ResolveForWrite(string name, System.Linq.Expressions.Expression value, bool direct) { return(System.Linq.Expressions.Expression.Dynamic(LanguageContext.CreateSetMemberBinder(name, false, false, direct), typeof(object), Context, value)); }
public CompilerOptions GetCompilerOptions() { return(LanguageContext.GetCompilerOptions()); }
internal static bool RequireFile(LanguageContext/*!*/ context, string/*!*/ path) { var rc = (RubyContext)context; return rc.Loader.LoadFile(rc.DefaultGlobalScope, null, MutableString.Create(path), LoadFlags.LoadOnce | LoadFlags.AppendExtensions); }
// 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); }
public CompilerOptions GetCompilerOptions(ScriptScope scope) { return(LanguageContext.GetCompilerOptions(scope.Scope)); }
internal bool TryLoadLanguage(ScriptDomainManager manager, AssemblyQualifiedTypeName providerName, out LanguageContext language) { Assert.NotNull(manager); LanguageConfiguration config; if (_languageConfigurations.TryGetValue(providerName, out config)) { language = LoadLanguageContext(manager, config); return true; } language = null; return false; }
public ICollection <string> GetSearchPaths() { return(LanguageContext.GetSearchPaths()); }
public string[] GetLanguageNames(LanguageContext context) { ContractUtils.RequiresNotNull(context, "context"); List<string> result = new List<string>(); foreach (var entry in _languageNames) { if (entry.Value.LanguageContext == context) { result.Add(entry.Key); } } return result.ToArray(); }
public CodeContext(Scope scope, LanguageContext languageContext) : this(scope, languageContext, null) { }
internal LanguageConfiguration GetLanguageConfig(LanguageContext context) { foreach (var config in _languageConfigurations.Values) { if (config.LanguageContext == context) { return config; } } return null; }
public MSAst.Expression Register(MSAst.Expression registeredTo) { return(MSAst.Expression.Dynamic(LanguageContext.CreateSetMemberBinder(Name, false, true, true), typeof(object), registeredTo, TransformProperty(registeredTo))); }