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
{
 
    public BadExpression Value { get; }
    private readonly Dictionary<BadExpression, BadExpression[]> m_Cases;
    private List<BadExpression>? m_DefaultCase;
    public IDictionary<BadExpression, BadExpression[]> Cases => m_Cases;
 
    public IEnumerable<BadExpression>? DefaultCase => 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 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();
 
        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();
                BadObject? result = BadObject.Null;
                foreach (BadObject o in BadEqualityExpression.EqualWithOverride(switchContext, valueResult, keyResult, Position))
                {
                    result = o;
                }
            
            
                result = result.Dereference();
                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);
        }
    }
}