BadWhileExpression.cs

Go to the documentation of this file.

using System.Text;
 
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 BadWhileExpression : BadExpression
{
    private readonly List<BadExpression> m_Body;
 
    public BadWhileExpression(BadExpression condition, List<BadExpression> block, BadSourcePosition position) : base(
        false,
        position
    )
    {
        Condition = condition;
        m_Body = block;
    }
 
    public IEnumerable<BadExpression> Body => m_Body;
 
    public BadExpression Condition { get; private set; }
 
    public void SetBody(IEnumerable<BadExpression> body)
    {
        m_Body.Clear();
        m_Body.AddRange(body);
    }
 
 
    public override void Optimize()
    {
        Condition = BadConstantFoldingOptimizer.Optimize(Condition);
 
        for (int i = 0; i < m_Body.Count; i++)
        {
            m_Body[i] = BadConstantFoldingOptimizer.Optimize(m_Body[i]);
        }
    }
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        foreach (BadExpression expression in Condition.GetDescendantsAndSelf())
        {
            yield return expression;
        }
 
        foreach (BadExpression descendant in m_Body.SelectMany(expression => expression.GetDescendantsAndSelf()))
        {
            yield return descendant;
        }
    }
 
    public override string ToString()
    {
        StringBuilder sb = new StringBuilder($"while ({Condition})");
        sb.AppendLine();
        sb.AppendLine("{");
 
        foreach (BadExpression expression in m_Body)
        {
            sb.AppendLine($"\t{expression}");
        }
 
        sb.AppendLine("}");
 
        return sb.ToString();
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        BadObject cond = BadObject.Null;
 
        foreach (BadObject o in Condition.Execute(context))
        {
            cond = o;
 
            yield return o;
        }
 
        IBadBoolean bRet = cond.Dereference() as IBadBoolean ??
                           throw new BadRuntimeException("While Condition is not a boolean", Position);
 
        while (bRet.Value)
        {
            using BadExecutionContext loopContext = new BadExecutionContext(
                context.Scope.CreateChild(
                    "WhileLoop",
                    context.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 Condition.Execute(context))
            {
                cond = o;
 
                yield return o;
            }
 
            bRet = cond.Dereference() as IBadBoolean ??
                   throw new BadRuntimeException("While Condition is not a boolean", Position);
        }
 
        yield return BadObject.Null;
    }
}