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 ExceptionOperations(LanguageContext context)
{
_context = 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)));
}
