BadInequalityExpression.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Runtime;
using BadScript2.Runtime.Objects;
 
namespace BadScript2.Parser.Expressions.Binary.Comparison;
 
public class BadInequalityExpression : BadBinaryExpression
{
    public BadInequalityExpression(BadExpression left, BadExpression right, BadSourcePosition position) : base(left,
                                                                                                               right,
                                                                                                               position
                                                                                                              ) { }
 
    public static BadObject NotEqual(BadObject left, BadObject right)
    {
        return left.Equals(right) ? BadObject.False : BadObject.True;
    }
 
    public static IEnumerable<BadObject> NotEqualWithOverride(BadExecutionContext? caller,
                                                              BadObject left,
                                                              BadObject right,
                                                              BadSourcePosition position)
    {
        if (left.HasProperty(BadStaticKeys.NOT_EQUAL_OPERATOR_NAME, caller?.Scope))
        {
            foreach (BadObject o in ExecuteOperatorOverride(left,
                                                            right,
                                                            caller!,
                                                            BadStaticKeys.NOT_EQUAL_OPERATOR_NAME,
                                                            position
                                                           ))
            {
                yield return o;
            }
        }
        else if (right.HasProperty(BadStaticKeys.NOT_EQUAL_OPERATOR_NAME, caller?.Scope))
        {
            foreach (BadObject o in ExecuteOperatorOverride(right,
                                                            left,
                                                            caller!,
                                                            BadStaticKeys.NOT_EQUAL_OPERATOR_NAME,
                                                            position
                                                           ))
            {
                yield return o;
            }
        }
        else
 
        {
            yield return NotEqual(left, right);
        }
    }
 
    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(Position);
        BadObject right = BadObject.Null;
 
        foreach (BadObject o in Right.Execute(context))
        {
            right = o;
 
            yield return o;
        }
 
        right = right.Dereference(Position);
 
        foreach (BadObject? o in NotEqualWithOverride(context, left, right, Position))
        {
            yield return o;
        }
    }
 
    protected override string GetSymbol()
    {
        return "!=";
    }
}