BadRuntime.cs

Go to the documentation of this file.

using BadScript2.Common.Logging;
using BadScript2.Common.Logging.Writer;
using BadScript2.ConsoleAbstraction;
using BadScript2.Debugging;
using BadScript2.IO;
using BadScript2.Optimizations.Folding;
using BadScript2.Optimizations.Substitution;
using BadScript2.Parser;
using BadScript2.Parser.Expressions;
using BadScript2.Runtime;
using BadScript2.Runtime.Interop;
using BadScript2.Runtime.Module;
using BadScript2.Runtime.Module.Handlers;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Settings;
using BadScript2.Runtime.VirtualMachine.Compiler;
using BadScript2.Settings;
 
namespace BadScript2;
 
public class BadRuntime : IDisposable
{
    private readonly List<Action<BadExecutionContext>> m_ConfigureContext = new List<Action<BadExecutionContext>>();
 
    private readonly List<Action<BadExecutionContext, string, BadModuleImporter>> m_ConfigureModuleImporter = new List<Action<BadExecutionContext, string, BadModuleImporter>>();
 
    private readonly List<Action<BadExecutionContextOptions>> m_ConfigureOptions =
        new List<Action<BadExecutionContextOptions>>();
 
    private readonly List<IDisposable> m_Disposables = new List<IDisposable>();
 
    private readonly BadExecutionContextOptions m_Options;
 
    private Func<BadExecutionContext, IEnumerable<BadExpression>, BadObject> m_Executor = Executor;
 
    public BadRuntime(BadExecutionContextOptions options)
    {
        m_Options = options;
 
        if (!BadSettingsProvider.HasRootSettings)
        {
            BadSettingsProvider.SetRootSettings(new BadSettings(string.Empty));
        }
    }
 
    public BadRuntime() : this(new BadExecutionContextOptions()) { }
 
    private BadModuleStore ModuleStore { get; } = new BadModuleStore();
    private BadModuleImporter? Importer { get; set; }
 
    //private BadModuleImporter? Importer { get; set; }
 
    public void Dispose()
    {
        foreach (IDisposable disposable in m_Disposables)
        {
            disposable.Dispose();
        }
    }
 
    public BadRuntime Clone()
    {
        BadRuntime r = new BadRuntime(CreateOptions())
            .UseExecutor(m_Executor);
 
        //Copy the configurators that are not part of the options
        r.m_ConfigureModuleImporter.AddRange(m_ConfigureModuleImporter);
        r.m_ConfigureContext.AddRange(m_ConfigureContext);
 
        return r;
    }
 
    public BadRuntime UseExecutor(Func<BadExecutionContext, IEnumerable<BadExpression>, BadObject> executor)
    {
        m_Executor = executor;
 
        return this;
    }
 
    private static BadObject Executor(BadExecutionContext ctx, IEnumerable<BadExpression> exprs)
    {
        return ctx.ExecuteScript(exprs);
    }
 
    public BadRuntime UseLogMask(params BadLogMask[] mask)
    {
        BadLogWriterSettings.Instance.Mask = BadLogMask.GetMask(mask);
 
        return this;
    }
 
    public BadRuntime UseLogMask(params string[] mask)
    {
        return UseLogMask(mask.Select(x => (BadLogMask)x).ToArray());
    }
 
    public BadRuntime UseConsole(IBadConsole console)
    {
        BadConsole.SetConsole(console);
 
        return this;
    }
 
    public BadRuntime UseLogWriter(BadLogWriter writer)
    {
        writer.Register();
        m_Disposables.Add(writer);
 
        return this;
    }
 
 
    public BadRuntime UseConsoleLogWriter()
    {
        return UseLogWriter(new BadConsoleLogWriter());
    }
 
    public BadRuntime UseFileLogWriter(string path)
    {
        return UseLogWriter(new BadFileLogWriter(path));
    }
 
    public BadRuntime LoadSettings(string settingsFile, IFileSystem? fileSystem = null)
    {
        BadLogger.Log("Loading Settings...", "Settings");
        BadSettingsReader settingsReader = new BadSettingsReader(
            BadSettingsProvider.RootSettings,
            fileSystem ?? BadFileSystem.Instance,
            settingsFile
        );
 
        BadSettingsProvider.SetRootSettings(settingsReader.ReadSettings());
        BadLogger.Log("Settings loaded!", "Settings");
 
        return this;
    }
 
    public BadRuntime UseCompilerApi()
    {
        m_Options.AddApi(new BadCompilerApi());
 
        return this;
    }
 
    public BadRuntime UseDebugger(IBadDebugger debugger)
    {
        if (BadDebugger.IsAttached)
        {
            BadDebugger.Detach();
        }
 
        BadDebugger.Attach(debugger);
 
        return this;
    }
 
    private BadExecutionContextOptions CreateOptions()
    {
        BadExecutionContextOptions opts = m_Options.Clone();
 
        foreach (Action<BadExecutionContextOptions> config in m_ConfigureOptions)
        {
            config(opts);
        }
 
        return opts;
    }
 
    public BadExecutionContext CreateContext(string workingDirectory)
    {
        BadExecutionContext ctx = CreateOptions().Build();
 
        foreach (Action<BadExecutionContext> config in m_ConfigureContext)
        {
            config(ctx);
        }
 
        ctx.Scope.AddSingleton(this);
        BadModuleImporter importer;
        if (Importer == null)
        {
            importer = Importer = new BadModuleImporter(ModuleStore);
        }
        else
        {
            importer = Importer = Importer.Clone();
        }
 
        foreach (Action<BadExecutionContext, string, BadModuleImporter> action in m_ConfigureModuleImporter)
        {
            action(ctx, workingDirectory, importer);
        }
 
        ctx.Scope.AddSingleton(importer);
 
        return ctx;
    }
 
    public BadRuntimeExecutionResult Execute(IEnumerable<BadExpression> expressions, string workingDirectory)
    {
        BadExecutionContext ctx = CreateContext(workingDirectory);
 
        BadObject? result = m_Executor(ctx, expressions);
        BadObject exports = ctx.Scope.GetExports();
 
        return new BadRuntimeExecutionResult(result, exports);
    }
 
 
    public BadRuntimeExecutionResult Execute(string source)
    {
        return Execute(Parse(source), BadFileSystem.Instance.GetCurrentDirectory());
    }
 
    public BadRuntimeExecutionResult Execute(string source, string file)
    {
        return Execute(Parse(source, file), Path.GetDirectoryName(BadFileSystem.Instance.GetFullPath(file)) ?? BadFileSystem.Instance.GetCurrentDirectory());
    }
 
    public BadRuntimeExecutionResult ExecuteFile(string file, IFileSystem? fileSystem = null)
    {
        var fs = fileSystem ?? BadFileSystem.Instance;
        return Execute(ParseFile(file, fs), fs.GetFullPath(Path.GetDirectoryName(fs.GetFullPath(file)) ?? fs.GetCurrentDirectory()));
    }
 
    public static IEnumerable<BadExpression> Parse(string source)
    {
        return Parse(source, "<memory>");
    }
 
    public static IEnumerable<BadExpression> Parse(string source, string file)
    {
        BadSourceParser parser = BadSourceParser.Create(file, source);
 
        IEnumerable<BadExpression> result = parser.Parse();
 
        if (BadNativeOptimizationSettings.Instance.UseConstantFoldingOptimization)
        {
            result = BadConstantFoldingOptimizer.Optimize(result);
        }
 
        if (BadNativeOptimizationSettings.Instance.UseConstantSubstitutionOptimization)
        {
            result = BadConstantSubstitutionOptimizer.Optimize(result);
        }
 
        return result;
    }
 
    public static IEnumerable<BadExpression> ParseFile(string file, IFileSystem? fileSystem = null)
    {
        var fs = fileSystem ?? BadFileSystem.Instance;
        return Parse(fs.ReadAllText(file), file);
    }
 
 
    public BadRuntime UseLocalModules(IFileSystem? fs = null)
    {
        return UseImportHandler((workingDir, _) => new BadLocalPathImportHandler(this, workingDir, fs ?? BadFileSystem.Instance));
    }
 
    public BadRuntime ConfigureContextOptions(params Action<BadExecutionContextOptions>[] action)
    {
        m_ConfigureOptions.AddRange(action);
 
        return this;
    }
 
    public BadRuntime UseApi(BadInteropApi api, bool replace = false)
    {
        if (replace)
        {
            return ConfigureContextOptions(opt => opt.AddOrReplaceApi(api));
        }
 
        return ConfigureContextOptions(opt => opt.AddApi(api));
    }
 
 
    public BadRuntime UseApis(IEnumerable<BadInteropApi> apis, bool replace = false)
    {
        if (replace)
        {
            return ConfigureContextOptions(opt => opt.AddOrReplaceApis(apis));
        }
 
        return ConfigureContextOptions(opt => opt.AddApis(apis));
    }
 
 
    public BadRuntime UseExtension<T>() where T : BadInteropExtension, new()
    {
        return ConfigureContextOptions(opts => opts.AddExtension<T>());
    }
 
 
    public BadRuntime UseImportHandler(Func<BadExecutionContext, string, BadModuleImporter, BadImportHandler> f)
    {
        return ConfigureModuleImporter((ctx, workingDir, importer) => importer.AddHandler(f(ctx, workingDir, importer)));
    }
 
    public BadRuntime UseImportHandler(Func<BadExecutionContext, BadModuleImporter, BadImportHandler> f)
    {
        return ConfigureModuleImporter((ctx, importer) => importer.AddHandler(f(ctx, importer)));
    }
 
    public BadRuntime UseImportHandler(Func<BadModuleImporter, BadImportHandler> f)
    {
        return ConfigureModuleImporter(importer => importer.AddHandler(f(importer)));
    }
 
    public BadRuntime UseImportHandler(Func<string, BadModuleImporter, BadImportHandler> f)
    {
        return ConfigureModuleImporter((workingDir, importer) => importer.AddHandler(f(workingDir, importer)));
    }
 
    public BadRuntime UseImportHandler(BadImportHandler handler)
    {
        return ConfigureModuleImporter(importer => importer.AddHandler(handler));
    }
 
 
    public BadRuntime ConfigureModuleImporter(Action<BadExecutionContext, string, BadModuleImporter> action)
    {
        m_ConfigureModuleImporter.Add(action);
 
        return this;
    }
 
    public BadRuntime ConfigureModuleImporter(Action<BadExecutionContext, BadModuleImporter> action)
    {
        return ConfigureModuleImporter((ctx, _, importer) => action(ctx, importer));
    }
 
    public BadRuntime ConfigureModuleImporter(Action<BadModuleImporter> action)
    {
        return ConfigureModuleImporter((_, _, importer) => action(importer));
    }
 
    public BadRuntime ConfigureModuleImporter(Action<string, BadModuleImporter> action)
    {
        return ConfigureModuleImporter((_, workingDir, importer) => action(workingDir, importer));
    }
 
    public BadRuntime UseSingleton<T>(T obj) where T : class
    {
        return ConfigureContext(ctx => ctx.Scope.AddSingleton(obj));
    }
 
    public BadRuntime ConfigureContext(params Action<BadExecutionContext>[] action)
    {
        m_ConfigureContext.AddRange(action);
 
        return this;
    }
}