BadInteractiveConsole.cs

Go to the documentation of this file.

using BadScript2.ConsoleAbstraction;
using BadScript2.Interop.Common.Task;
using BadScript2.IO;
using BadScript2.Optimizations.Folding;
using BadScript2.Optimizations.Substitution;
using BadScript2.Parser;
using BadScript2.Parser.Expressions;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Settings;
 
 
namespace BadScript2.Interactive;
 
public class BadInteractiveConsole
{
    private readonly BadInteractiveConsoleApi m_Api;
 
    private readonly BadTaskRunner m_Runner;
 
    private readonly BadRuntime m_Runtime;
 
    private BadExecutionContext? m_Context;
 
    public BadInteractiveConsole(BadRuntime runtime, BadTaskRunner runner, IEnumerable<string> files)
    {
        m_Runner = runner;
        m_Api = new BadInteractiveConsoleApi(this);
        m_Runtime = runtime;
        Reset();
 
        foreach (string file in files)
        {
            LoadIsolated(file);
        }
    }
 
    public BadScope? CurrentScope => m_Context?.Scope;
 
    public bool CatchErrors { get; set; }
 
    public bool PreParse { get; set; }
 
    private BadExecutionContext CreateContext()
    {
        BadExecutionContext ctx = m_Runtime.CreateContext(BadFileSystem.Instance.GetCurrentDirectory());
        BadTable apiTable = new BadTable();
        m_Api.Load(ctx, apiTable);
 
        ctx.Scope.DefineVariable(m_Api.Name, apiTable);
 
        return ctx;
    }
 
 
    public void Reset()
    {
        m_Context = CreateContext();
    }
 
    public BadObject LoadIsolated(string file)
    {
        if (m_Context == null)
        {
            throw new BadRuntimeException("Context is not initialized");
        }
 
        Reset();
        BadExecutionContext current = m_Context;
        BadSourceParser parser = BadSourceParser.Create(file, BadFileSystem.ReadAllText(file));
        Run(parser.Parse());
 
        Reset();
 
        return current.Scope.ReturnValue ?? current.Scope.GetTable();
    }
 
    public void Load(string file)
    {
        BadSourceParser parser = BadSourceParser.Create(file, BadFileSystem.ReadAllText(file));
        Run(parser.Parse());
    }
 
    private IEnumerable<object?> RunRoutine(IEnumerable<BadExpression> expressions)
    {
        IEnumerable<BadExpression> exprs = expressions;
 
        if (PreParse)
        {
            exprs = exprs.ToArray();
        }
 
        if (BadNativeOptimizationSettings.Instance.UseConstantFoldingOptimization)
        {
            exprs = BadConstantFoldingOptimizer.Optimize(exprs);
        }
 
        if (BadNativeOptimizationSettings.Instance.UseConstantSubstitutionOptimization)
        {
            exprs = BadConstantSubstitutionOptimizer.Optimize(exprs);
        }
 
        if (m_Context == null)
        {
            throw new BadRuntimeException("Context is not initialized");
        }
 
        m_Runner.AddTask(new BadTask(BadRunnable.Create(m_Context.Execute(exprs)), "Main"), true);
 
        while (!m_Runner.IsIdle)
        {
            m_Runner.RunStep();
 
            yield return null;
        }
    }
 
    private void Run(IEnumerable<BadExpression> expressions)
    {
        IEnumerable<BadExpression> exprs = expressions;
 
        if (PreParse)
        {
            exprs = exprs.ToArray();
        }
 
        if (BadNativeOptimizationSettings.Instance.UseConstantFoldingOptimization)
        {
            exprs = BadConstantFoldingOptimizer.Optimize(exprs);
        }
 
        if (m_Context == null)
        {
            throw new BadRuntimeException("Context is not initialized");
        }
 
        m_Runner.AddTask(new BadTask(BadRunnable.Create(m_Context.Execute(exprs)), "Main"), true);
 
        if (CatchErrors)
        {
            try
            {
                while (!m_Runner.IsIdle)
                {
                    m_Runner.RunStep();
                }
            }
            catch (Exception e)
            {
                BadConsole.WriteLine(e.Message);
            }
        }
        else
        {
            while (!m_Runner.IsIdle)
            {
                m_Runner.RunStep();
            }
        }
    }
 
    public IEnumerable<object?> RunIsolatedRoutine(string code)
    {
        if (m_Context == null)
        {
            throw new BadRuntimeException("Context is not initialized");
        }
 
        BadExecutionContext ctx = m_Context;
        Reset();
        BadSourceParser parser = BadSourceParser.Create("<stdin>", code);
 
        foreach (object? o in RunRoutine(parser.Parse()))
        {
            yield return o;
        }
 
        m_Context = ctx;
    }
 
    public BadObject RunIsolated(string code)
    {
        if (m_Context == null)
        {
            throw new BadRuntimeException("Context is not initialized");
        }
 
        BadExecutionContext ctx = m_Context;
        Reset();
        BadExecutionContext current = m_Context;
        BadSourceParser parser = BadSourceParser.Create("<stdin>", code);
        Run(parser.Parse());
        m_Context = ctx;
 
        return current.Scope.ReturnValue ?? current.Scope.GetTable();
    }
 
    public void Run(string code)
    {
        BadSourceParser parser = BadSourceParser.Create("<stdin>", code);
        Run(parser.Parse());
    }
}