Nor.cs

using System;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Operators.Dual
{
    public class Nor : BinaryDualBoolDoubleOperator 
    {
        public Nor(ScriptNode Left, ScriptNode Right, int Start, int Length, Expression Expression)
            : base(Left, Right, Start, Length, Expression)
        {
        }
 
        public override IElement EvaluateOptimizedResult(bool Left)
        {
            if (Left)
                return BooleanValue.False;
            else
                return null;
        }
 
        public override IElement Evaluate(bool Left, bool Right)
        {
            if (!(Left || Right))
                return BooleanValue.True;
            else
                return BooleanValue.False;
        }
 
        public override IElement Evaluate(double Left, double Right)
        {
            ulong L, R;
            bool LSigned;
            bool RSigned;
 
            if (Left != Math.Floor(Left) || Right != Math.Floor(Right))
                throw new OperandNonIntegerScriptException(this);
 
            if (Left < 0)
            {
                LSigned = true;
                if (Left < long.MinValue)
                    throw new OperandOutOfBoundsScriptException(this);
 
                L = (ulong)((long)Left);
            }
            else
            {
                LSigned = false;
                if (Left > ulong.MaxValue)
                    throw new OperandOutOfBoundsScriptException(this);
 
                L = (ulong)Left;
            }
 
            if (Right < 0)
            {
                RSigned = true;
                if (Right < long.MinValue)
                    throw new OperandOutOfBoundsScriptException(this);
 
                R = (ulong)((long)Right);
            }
            else
            {
                RSigned = false;
                if (Right > ulong.MaxValue)
                    throw new OperandOutOfBoundsScriptException(this);
 
                R = (ulong)Right;
            }
 
            L = ~(L | R);
 
            if (LSigned && RSigned)
                return new DoubleNumber((long)L);
            else
                return new DoubleNumber(L);
        }
    }
}