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;
            }
        }
    }
}