BadPostDecrementExpression.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Native;
 
namespace BadScript2.Parser.Expressions.Binary.Math.Atomic;
 
public class BadPostDecrementExpression : BadExpression
{
    public readonly BadExpression Left;
 
    public BadPostDecrementExpression(BadExpression left, BadSourcePosition position) : base(left.IsConstant,
                                                                                             position
                                                                                            )
    {
        Left = left;
    }
 
 
    public override IEnumerable<BadExpression> GetDescendants()
    {
        return Left.GetDescendantsAndSelf();
    }
 
 
    public static BadObject Decrement(BadObjectReference reference, BadSourcePosition position)
    {
        BadObject value = reference.Dereference(position);
 
        if (value is not IBadNumber leftNumber)
        {
            throw new BadRuntimeException("Left side of -- must be a number", position);
        }
 
        reference.Set(leftNumber.Value - 1, position);
 
        return value;
    }
 
    public static IEnumerable<BadObject> DecrementWithOverride(BadExecutionContext? context,
                                                               BadObjectReference leftRef,
                                                               BadSourcePosition position)
    {
        BadObject left = leftRef.Dereference(position);
 
        if (left.HasProperty(BadStaticKeys.POST_DECREMENT_OPERATOR_NAME, context?.Scope))
        {
            foreach (BadObject o in ExecuteOperatorOverride(left,
                                                            context!,
                                                            BadStaticKeys.POST_DECREMENT_OPERATOR_NAME,
                                                            position
                                                           ))
            {
                yield return o;
            }
        }
        else
        {
            yield return Decrement(leftRef, position);
        }
    }
 
    protected override IEnumerable<BadObject> InnerExecute(BadExecutionContext context)
    {
        BadObject left = BadObject.Null;
 
        foreach (BadObject o in Left.Execute(context))
        {
            left = o;
 
            yield return o;
        }
 
        if (left is not BadObjectReference leftRef)
        {
            throw new BadRuntimeException("Left side of -- must be a reference", Position);
        }
 
        foreach (BadObject o in DecrementWithOverride(context, leftRef, Position))
        {
            yield return o;
        }
    }
}