BadForEachExpression.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Optimizations.Folding;
using BadScript2.Reader.Token;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Native;
 
namespace BadScript2.Parser.Expressions.Block.Loop;
 
public class BadForEachExpression : BadExpression
{
    public readonly BadWordToken LoopVariable;
 
    private readonly List<BadExpression> m_Body;
 
    public BadExpression Target;
 
    public BadForEachExpression(
        BadExpression target,
        BadWordToken loopVariable,
        IEnumerable<BadExpression> body,
        BadSourcePosition position) : base(
        false,
        position
    )
    {
        Target = target;
        LoopVariable = loopVariable;
        m_Body = body.ToList();
    }
 
    public IEnumerable<BadExpression> Body => m_Body;
 
    public void SetBody(IEnumerable<BadExpression> body)
    {
        m_Body.Clear();
        m_Body.AddRange(body);
    }
 
 
    public override void Optimize()
    {
        Target = BadConstantFoldingOptimizer.Optimize(Target);
 
        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 Target.GetDescendantsAndSelf())
        {
            yield return expression;
        }
 
        foreach (BadExpression descendant in m_Body.SelectMany(expression => expression.GetDescendantsAndSelf()))
        {
            yield return descendant;
        }
    }
 
    public static (BadFunction moveNext, BadFunction getCurrent) FindEnumerator(BadObject target, BadExecutionContext context, BadSourcePosition position)
    {
        if (!target.HasProperty("MoveNext", context.Scope))
        {
            throw new BadRuntimeException("Invalid enumerator", position);
        }
 
        if (target.GetProperty("MoveNext", context.Scope).Dereference() is not BadFunction moveNext)
        {
            throw new BadRuntimeException("Invalid enumerator", position);
        }
 
        if (!target.HasProperty("GetCurrent", context.Scope))
        {
            throw new BadRuntimeException("Invalid enumerator", position);
        }
 
        if (target.GetProperty("GetCurrent", context.Scope).Dereference() is BadFunction getCurrent)
        {
            return (moveNext, getCurrent);
        }
 
        throw new BadRuntimeException("Invalid enumerator", position);
    }
public static IEnumerable<BadObject> Enumerate(BadExecutionContext context, BadObject target, BadSourcePosition position, Func<Action, BadExecutionContext, BadObject, IEnumerable<BadObject>> action)
    {
        if (target.HasProperty("GetEnumerator", context.Scope))
        {
            if (target.GetProperty("GetEnumerator", context.Scope).Dereference() is not BadFunction getEnumerator)
            {
                throw new BadRuntimeException("Invalid enumerator", position);
            }
 
            BadObject newTarget = BadObject.Null;
 
            foreach (BadObject o in getEnumerator.Invoke(Array.Empty<BadObject>(), context))
            {
                yield return o;
 
                newTarget = o;
            }
 
 
            if (newTarget == BadObject.Null)
            {
                throw BadRuntimeException.Create(context.Scope, $"Invalid enumerator: {target}", position);
            }
 
            target = newTarget.Dereference();
        }
 
        (BadFunction moveNext, BadFunction getCurrent) = FindEnumerator(target, context, position);
 
 
        BadObject cond = BadObject.Null;
 
        foreach (BadObject o in moveNext.Invoke(Array.Empty<BadObject>(), 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(
                    "ForEachLoop",
                    context.Scope,
                    null,
                    BadScopeFlags.Breakable | BadScopeFlags.Continuable
                )
            );
 
            BadObject current = BadObject.Null;
 
            foreach (BadObject o in getCurrent.Invoke(Array.Empty<BadObject>(), loopContext))
            {
                current = o;
 
                yield return o;
            }
 
 
 
            bool bBreak = false;
            foreach (BadObject? o in action(() => bBreak = true, loopContext, current.Dereference()))
            {
                yield return o;
            }
            
            if (bBreak)
            {
                break;
            }
 
            foreach (BadObject o in moveNext.Invoke(Array.Empty<BadObject>(), loopContext))
            {
                cond = o;
 
                yield return o;
            }
 
 
 
            bRet = cond.Dereference() as IBadBoolean ??
                   throw BadRuntimeException.Create(
                       context.Scope,
                       "Enumerator MoveNext did not return a boolean",
                       position
                   );
        }
    }
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        BadObject target = BadObject.Null;
 
        foreach (BadObject o in Target.Execute(context))
        {
            target = o;
 
            yield return o;
        }
 
 
        target = target.Dereference();
 
        foreach (BadObject? o in Enumerate(context, target, Position, LoopBody))
        {
            yield return o;
        }
    }
    private IEnumerable<BadObject> LoopBody(Action breakLoop, BadExecutionContext loopContext, BadObject current)
    {
        if (m_Body.Count != 0)
        {
            current = current.Dereference();
            loopContext.Scope.DefineVariable(LoopVariable.Text, current);
 
            foreach (BadObject o in loopContext.Execute(m_Body))
            {
                yield return o;
            }
 
            if (loopContext.Scope.IsBreak || loopContext.Scope.ReturnValue != null /*|| loopContext.Scope.IsError*/)
            {
                breakLoop();
            }
        }
    }
}