BadIfExpression.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;
using BadScript2.Runtime.Objects.Native;
 
namespace BadScript2.Parser.Expressions.Block;
 
public class BadIfExpression : BadExpression
{
    private readonly Dictionary<BadExpression, BadExpression[]> m_ConditionalBranches;
 
    private List<BadExpression>? m_ElseBranch;
 
    public BadIfExpression(Dictionary<BadExpression, BadExpression[]> branches,
                           IEnumerable<BadExpression>? elseBranch,
                           BadSourcePosition position) : base(false, position)
    {
        m_ConditionalBranches = branches;
        m_ElseBranch = elseBranch?.ToList();
    }
 
    public IDictionary<BadExpression, BadExpression[]> ConditionalBranches => m_ConditionalBranches;
 
    public IEnumerable<BadExpression>? ElseBranch => m_ElseBranch;
 
    public void SetElseBranch(IEnumerable<BadExpression>? branch)
    {
        if (branch == null)
        {
            m_ElseBranch = null;
        }
        else if (m_ElseBranch != null)
        {
            m_ElseBranch.Clear();
            m_ElseBranch.AddRange(branch);
        }
        else
        {
            m_ElseBranch = new List<BadExpression>(branch);
        }
    }
 
    public override void Optimize()
    {
        KeyValuePair<BadExpression, BadExpression[]>[] branches = m_ConditionalBranches.ToArray();
        m_ConditionalBranches.Clear();
 
        foreach (KeyValuePair<BadExpression, BadExpression[]> branch in branches)
        {
            m_ConditionalBranches[BadConstantFoldingOptimizer.Optimize(branch.Key)] =
                BadConstantFoldingOptimizer.Optimize(branch.Value)
                                           .ToArray();
        }
 
        if (m_ElseBranch == null)
        {
            return;
        }
 
        for (int i = 0; i < m_ElseBranch.Count; i++)
        {
            m_ElseBranch[i] = BadConstantFoldingOptimizer.Optimize(m_ElseBranch[i]);
        }
    }
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        foreach (KeyValuePair<BadExpression, BadExpression[]> branch in m_ConditionalBranches)
        {
            foreach (BadExpression keyExpr in branch.Key.GetDescendantsAndSelf())
            {
                yield return keyExpr;
            }
 
            foreach (BadExpression valueExpr in branch.Value)
            {
                foreach (BadExpression expr in valueExpr.GetDescendantsAndSelf())
                {
                    yield return expr;
                }
            }
        }
 
        if (m_ElseBranch == null)
        {
            yield break;
        }
 
        foreach (BadExpression e in m_ElseBranch.SelectMany(expr => expr.GetDescendantsAndSelf()))
        {
            yield return e;
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        foreach (KeyValuePair<BadExpression, BadExpression[]> keyValuePair in m_ConditionalBranches)
        {
            BadObject conditionResult = BadObject.Null;
 
            foreach (BadObject o in keyValuePair.Key.Execute(context))
            {
                conditionResult = o;
 
                yield return o;
            }
 
            conditionResult = conditionResult.Dereference(Position);
 
            if (conditionResult is not IBadBoolean cBool)
            {
                throw new BadRuntimeException("Condition must be a boolean", Position);
            }
 
            if (!cBool.Value)
            {
                continue;
            }
 
            if (keyValuePair.Value.Length == 0)
            {
                yield break;
            }
 
            using BadExecutionContext branchContext = new BadExecutionContext(context.Scope.CreateChild("IfBranch",
                                                                                   context.Scope,
                                                                                   null
                                                                                  )
                                                                             );
 
            foreach (BadObject o in branchContext.Execute(keyValuePair.Value))
            {
                yield return o;
            }
 
            yield break;
        }
 
        if (m_ElseBranch is null)
        {
            yield break;
        }
 
        using BadExecutionContext elseContext = new BadExecutionContext(context.Scope.CreateChild("IfBranch",
                                                                             context.Scope,
                                                                             null
                                                                            )
                                                                       );
 
        foreach (BadObject o in elseContext.Execute(m_ElseBranch))
        {
            yield return o;
        }
    }
}