BadSwitchExpression.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Optimizations.Folding;
using BadScript2.Parser.Expressions.Binary.Comparison;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Native;
 
namespace BadScript2.Parser.Expressions.Block;
 
public class BadSwitchExpression : BadExpression
{
    private readonly Dictionary<BadExpression, BadExpression[]> m_Cases;
 
    private List<BadExpression>? m_DefaultCase;
 
    public BadSwitchExpression(BadSourcePosition position,
                               BadExpression value,
                               Dictionary<BadExpression, BadExpression[]> cases,
                               List<BadExpression>? defaultCase) : base(false, position)
    {
        Value = value;
        m_Cases = cases;
        m_DefaultCase = defaultCase;
    }
 
    public BadExpression Value { get; }
 
    public IDictionary<BadExpression, BadExpression[]> Cases => m_Cases;
 
    public IEnumerable<BadExpression>? DefaultCase => m_DefaultCase;
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        yield return Value;
 
        foreach (KeyValuePair<BadExpression, BadExpression[]> branch in m_Cases)
        {
            yield return branch.Key;
 
            foreach (BadExpression valueExpr in branch.Value)
            {
                yield return valueExpr;
            }
        }
 
        if (m_DefaultCase == null)
        {
            yield break;
        }
 
        foreach (BadExpression e in m_DefaultCase)
        {
            yield return e;
        }
    }
 
    public override void Optimize()
    {
        KeyValuePair<BadExpression, BadExpression[]>[] branches = m_Cases.ToArray();
        m_Cases.Clear();
 
        foreach (KeyValuePair<BadExpression, BadExpression[]> branch in branches)
        {
            m_Cases[BadConstantFoldingOptimizer.Optimize(branch.Key)] =
                BadConstantFoldingOptimizer.Optimize(branch.Value)
                                           .ToArray();
        }
 
        if (m_DefaultCase == null)
        {
            return;
        }
 
        for (int i = 0; i < m_DefaultCase.Count; i++)
        {
            m_DefaultCase[i] = BadConstantFoldingOptimizer.Optimize(m_DefaultCase[i]);
        }
    }
 
    public void SetDefaultCase(IEnumerable<BadExpression>? defaultCase)
    {
        if (defaultCase == null)
        {
            m_DefaultCase = null;
        }
        else if (m_DefaultCase != null)
        {
            m_DefaultCase.Clear();
            m_DefaultCase.AddRange(defaultCase);
        }
        else
        {
            m_DefaultCase = new List<BadExpression>(defaultCase);
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        BadObject valueResult = BadObject.Null;
 
        foreach (BadObject o in context.Execute(Value))
        {
            valueResult = o;
        }
 
        valueResult = valueResult.Dereference(Position);
 
        BadExecutionContext? switchContext =
            new BadExecutionContext(context.Scope.CreateChild("SwitchContext",
                                                              context.Scope,
                                                              null,
                                                              BadScopeFlags.Breakable
                                                             )
                                   );
        bool executeNextBlock = false;
 
        foreach (KeyValuePair<BadExpression, BadExpression[]> branch in m_Cases)
        {
            if (!executeNextBlock)
            {
                BadObject keyResult = BadObject.Null;
 
                foreach (BadObject o in switchContext.Execute(branch.Key))
                {
                    keyResult = o;
                }
 
                keyResult = keyResult.Dereference(Position);
                BadObject? result = BadObject.Null;
 
                foreach (BadObject o in BadEqualityExpression.EqualWithOverride(switchContext,
                                                                                valueResult,
                                                                                keyResult,
                                                                                Position
                                                                               ))
                {
                    result = o;
                }
 
                result = result.Dereference(Position);
 
                if (result is not IBadBoolean b)
                {
                    throw new BadRuntimeException("Switch case result must be a boolean", Position);
                }
 
                executeNextBlock = b.Value;
            }
 
            if (executeNextBlock && branch.Value.Length > 0)
            {
                foreach (BadObject o in switchContext.Execute(branch.Value))
                {
                    yield return o;
 
                    if (switchContext.Scope.IsBreak)
                    {
                        yield break;
                    }
                }
 
                throw BadRuntimeException.Create(switchContext.Scope, "Switch Case must break", Position);
            }
        }
 
        if (m_DefaultCase != null)
        {
            foreach (BadObject o in switchContext.Execute(m_DefaultCase))
            {
                yield return o;
 
                if (switchContext.Scope.IsBreak)
                {
                    yield break;
                }
            }
 
            throw BadRuntimeException.Create(switchContext.Scope, "Switch Case must break", Position);
        }
    }
}