BadTryCatchExpression.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Optimizations.Folding;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
 
namespace BadScript2.Parser.Expressions.Block;
 
public class BadTryCatchExpression : BadExpression
{
    public readonly string ErrorName;
 
    private readonly BadExpression[] m_CatchExpressions;
 
    private readonly BadExpression[] m_Expressions;
 
    private readonly BadExpression[] m_FinallyExpressions;
 
    public BadTryCatchExpression(
        BadSourcePosition position,
        BadExpression[] expressions,
        BadExpression[] catchExpressions,
        BadExpression[] finallyExpressions,
        string errorName) : base(false, position)
    {
        m_Expressions = expressions;
        m_CatchExpressions = catchExpressions;
        ErrorName = errorName;
        m_FinallyExpressions = finallyExpressions;
    }
 
    public IEnumerable<BadExpression> CatchExpressions => m_CatchExpressions;
 
    public IEnumerable<BadExpression> TryExpressions => m_Expressions;
 
    public IEnumerable<BadExpression> FinallyExpressions => m_FinallyExpressions;
 
    public override void Optimize()
    {
        for (int i = 0; i < m_CatchExpressions.Length; i++)
        {
            m_CatchExpressions[i] = BadConstantFoldingOptimizer.Optimize(m_CatchExpressions[i]);
        }
 
        for (int i = 0; i < m_Expressions.Length; i++)
        {
            m_Expressions[i] = BadConstantFoldingOptimizer.Optimize(m_Expressions[i]);
        }
 
        for (int i = 0; i < m_FinallyExpressions.Length; i++)
        {
            m_FinallyExpressions[i] = BadConstantFoldingOptimizer.Optimize(m_FinallyExpressions[i]);
        }
    }
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        foreach (BadExpression expression in m_Expressions)
        {
            foreach (BadExpression e in expression.GetDescendantsAndSelf())
            {
                yield return e;
            }
        }
 
        foreach (BadExpression expression in m_CatchExpressions)
        {
            foreach (BadExpression e in expression.GetDescendantsAndSelf())
            {
                yield return e;
            }
        }
 
        foreach (BadExpression expression in m_FinallyExpressions)
        {
            foreach (BadExpression e in expression.GetDescendantsAndSelf())
            {
                yield return e;
            }
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        if (m_Expressions.Length != 0) //If the expressions are empty, then we cant possibly throw an error, nor do we need to catch one
        {
            IEnumerable<BadObject>? catchEnumerable = null;
            using (BadExecutionContext tryContext = new BadExecutionContext(
                       context.Scope.CreateChild("TryBlock", context.Scope, null, BadScopeFlags.CaptureThrow)
                   ))
            {
                using IEnumerator<BadObject>? enumerator = tryContext.Execute(m_Expressions).GetEnumerator();
                while (true)
                {
                    BadObject o;
                    
                    try {
                        if (!enumerator.MoveNext())
                            break;
                        o = enumerator.Current ?? BadObject.Null;
                    }
                    catch (Exception e)
                    {
                        if(m_CatchExpressions.Length != 0)
                        {
                            using BadExecutionContext catchContext = new BadExecutionContext(
                                context.Scope.CreateChild("CatchBlock", context.Scope, null)
                            );
                            
                            
                            BadRuntimeError error;
                            if (e is BadRuntimeErrorException bre) error = bre.Error;
                            else error = BadRuntimeError.FromException(e, context.Scope.GetStackTrace());
                            catchContext.Scope.DefineVariable(ErrorName, error);
 
                            catchEnumerable = catchContext.Execute(m_CatchExpressions);
                        }
                        break;
                    }
                    yield return o;
                }
            }
 
            if (catchEnumerable != null)
            {
                foreach (BadObject e in catchEnumerable)
                {
                    yield return e;
                }
            }
        }
 
        if (m_FinallyExpressions.Length != 0)
        {
            using BadExecutionContext finallyContext = new BadExecutionContext(
                context.Scope.CreateChild("FinallyBlock", context.Scope, null)
            );
 
            foreach (BadObject e in finallyContext.Execute(m_FinallyExpressions))
            {
                yield return e;
            }
        }
    }
}