BadArrayAccessReverseExpression.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.Functions;
 
namespace BadScript2.Parser.Expressions.Access;
 
public class BadArrayAccessReverseExpression : BadExpression, IBadAccessExpression
{
    private readonly BadExpression[] m_Arguments;
 
    public BadArrayAccessReverseExpression(
        BadExpression left,
        BadExpression[] args,
        BadSourcePosition position,
        bool nullChecked = false) : base(
        false,
        position
    )
    {
        Left = left;
        m_Arguments = args;
        NullChecked = nullChecked;
    }
 
    public IEnumerable<BadExpression> Arguments => m_Arguments;
 
    public int ArgumentCount => m_Arguments.Length;
 
    public BadExpression Left { get; set; }
 
    public bool NullChecked { get; }
 
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        foreach (BadExpression expression in Left.GetDescendantsAndSelf())
        {
            yield return expression;
        }
 
        foreach (BadExpression expression in m_Arguments)
        {
            foreach (BadExpression descendant in expression.GetDescendantsAndSelf())
            {
                yield return descendant;
            }
        }
    }
 
 
    public override void Optimize()
    {
        Left = BadConstantFoldingOptimizer.Optimize(Left);
 
        for (int i = 0; i < m_Arguments.Length; i++)
        {
            m_Arguments[i] = BadConstantFoldingOptimizer.Optimize(m_Arguments[i]);
        }
    }
 
    public static IEnumerable<BadObject> Access(
        BadExecutionContext context,
        BadObject left,
        IEnumerable<BadObject> args,
        BadSourcePosition position)
    {
        //Can be null when evaluated as an optimization step
        // ReSharper disable once ConditionalAccessQualifierIsNonNullableAccordingToAPIContract
        if (left.HasProperty(BadStaticKeys.ARRAY_ACCESS_REVERSE_OPERATOR_NAME, context?.Scope))
        {
            if (left.GetProperty(BadStaticKeys.ARRAY_ACCESS_REVERSE_OPERATOR_NAME, context?.Scope)
                    .Dereference() is not BadFunction func)
            {
                throw new BadRuntimeException("Array access reverse operator is not a function", position);
            }
 
            BadObject r = BadObject.Null;
 
            foreach (BadObject o in func.Invoke(args.ToArray(), context!))
            {
                yield return o;
 
                r = o;
            }
 
            yield return r;
        }
        else
        {
            throw new BadRuntimeException("Array access reverse operator is not defined", position);
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        BadObject left = BadObject.Null;
 
        foreach (BadObject o in Left.Execute(context))
        {
            left = o;
 
            yield return o;
        }
 
        left = left.Dereference();
 
        if (NullChecked && left == BadObject.Null)
        {
            yield return left;
 
            yield break;
        }
 
        List<BadObject> args = new List<BadObject>();
 
        foreach (BadExpression argExpr in m_Arguments)
        {
            BadObject argObj = BadObject.Null;
 
            foreach (BadObject arg in argExpr.Execute(context))
            {
                argObj = arg;
 
                yield return arg;
            }
 
            args.Add(argObj.Dereference());
        }
 
        foreach (BadObject o in Access(context, left, args.ToArray(), Position))
        {
            yield return o;
        }
    }
}