BadForExpression.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.Loop;
 
public class BadForExpression : BadExpression
{
    private readonly List<BadExpression> m_Body;
 
    public BadForExpression(BadExpression varDef,
                            BadExpression condition,
                            BadExpression varIncrement,
                            IEnumerable<BadExpression> body,
                            BadSourcePosition position) : base(false, position)
    {
        VarDef = varDef;
        Condition = condition;
        VarIncrement = varIncrement;
        m_Body = body.ToList();
    }
 
    public IEnumerable<BadExpression> Body => m_Body;
 
    public BadExpression Condition { get; private set; }
 
    public BadExpression VarDef { get; private set; }
 
    public BadExpression VarIncrement { get; private set; }
 
    public void SetBody(IEnumerable<BadExpression> body)
    {
        m_Body.Clear();
        m_Body.AddRange(body);
    }
 
    public override void Optimize()
    {
        Condition = BadConstantFoldingOptimizer.Optimize(Condition);
        VarDef = BadConstantFoldingOptimizer.Optimize(VarDef);
        VarIncrement = BadConstantFoldingOptimizer.Optimize(VarIncrement);
 
        for (int i = 0; i < m_Body.Count; i++)
        {
            m_Body[i] = BadConstantFoldingOptimizer.Optimize(m_Body[i]);
        }
    }
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        foreach (BadExpression? vDef in VarDef.GetDescendantsAndSelf())
        {
            yield return vDef;
        }
 
        foreach (BadExpression? vInc in VarIncrement.GetDescendantsAndSelf())
        {
            yield return vInc;
        }
 
        foreach (BadExpression? cond in Condition.GetDescendantsAndSelf())
        {
            yield return cond;
        }
 
        foreach (BadExpression descendant in m_Body.SelectMany(expression => expression.GetDescendantsAndSelf()))
        {
            yield return descendant;
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        using BadExecutionContext loopCtx =
            new BadExecutionContext(context.Scope.CreateChild("ForLoop", context.Scope, null));
 
        foreach (BadObject o in VarDef.Execute(loopCtx))
        {
            yield return o;
        }
 
        BadObject cond = BadObject.Null;
 
        foreach (BadObject o in Condition.Execute(loopCtx))
        {
            cond = o;
 
            yield return o;
        }
 
        IBadBoolean bRet = cond.Dereference(Position) as IBadBoolean ??
                           throw new BadRuntimeException("While Condition is not a boolean", Position);
 
        while (bRet.Value)
        {
            using BadExecutionContext loopContext = new BadExecutionContext(loopCtx.Scope.CreateChild("InnerForLoop",
                                                                                 loopCtx.Scope,
                                                                                 null,
                                                                                 BadScopeFlags.Breakable |
                                                                                 BadScopeFlags.Continuable
                                                                                )
                                                                           );
 
            if (m_Body.Count != 0)
            {
                foreach (BadObject o in loopContext.Execute(m_Body))
                {
                    yield return o;
                }
 
                if (loopContext.Scope.IsBreak || loopContext.Scope.ReturnValue != null)
                {
                    break;
                }
            }
 
            foreach (BadObject o in VarIncrement.Execute(loopContext))
            {
                yield return o;
            }
 
            foreach (BadObject o in Condition.Execute(loopContext))
            {
                cond = o;
 
                yield return o;
            }
 
            bRet = cond.Dereference(Position) as IBadBoolean ??
                   throw new BadRuntimeException("While Condition is not a boolean", Position);
        }
 
        yield return BadObject.Null;
    }
}