Esempio n. 1
0
        public override Completion Evaluate(Interpreter interpreter)
        {
            var left = shiftExpression.Evaluate(interpreter).GetValue();

            if (left.IsAbrupt())
            {
                return(left);
            }
            var leftValue = left.value !;

            var right = additiveExpression.Evaluate(interpreter).GetValue();

            if (right.IsAbrupt())
            {
                return(right);
            }
            var rightValue = right.value !;

            return(Calculate(leftValue, shiftOperator, rightValue));
        }
Esempio n. 2
0
        public override Completion Evaluate(Interpreter interpreter)
        {
            var leftValueComp = relationalExpression.Evaluate(interpreter).GetValue();

            if (leftValueComp.IsAbrupt())
            {
                return(leftValueComp);
            }
            var leftValue      = leftValueComp.value !;
            var rightValueComp = shiftExpression.Evaluate(interpreter).GetValue();

            if (rightValueComp.IsAbrupt())
            {
                return(rightValueComp);
            }
            var rightValue = rightValueComp.value !;

            Completion r;

            switch (relationalOperator)
            {
            case RelationalOperator.LessThan:
                r = AbstractRelationalComparison(leftValue, rightValue);
                if (r.IsAbrupt())
                {
                    return(r);
                }
                if (r.value == UndefinedValue.Instance)
                {
                    return(Completion.NormalCompletion(BooleanValue.False));
                }
                return(r);

            case RelationalOperator.GreaterThan:
                r = AbstractRelationalComparison(rightValue, leftValue, false);
                if (r.IsAbrupt())
                {
                    return(r);
                }
                if (r.value == UndefinedValue.Instance)
                {
                    return(Completion.NormalCompletion(BooleanValue.False));
                }
                return(r);

            case RelationalOperator.LessThanOrEqual:
                r = AbstractRelationalComparison(rightValue, leftValue, false);
                if (r.IsAbrupt())
                {
                    return(r);
                }
                if (r.value == UndefinedValue.Instance || r.value == BooleanValue.True)
                {
                    return(Completion.NormalCompletion(BooleanValue.False));
                }
                return(Completion.NormalCompletion(BooleanValue.True));

            case RelationalOperator.GreaterThanOrEqual:
                r = AbstractRelationalComparison(leftValue, rightValue);
                if (r.IsAbrupt())
                {
                    return(r);
                }
                if (r.value == UndefinedValue.Instance || r.value == BooleanValue.True)
                {
                    return(Completion.NormalCompletion(BooleanValue.False));
                }
                return(Completion.NormalCompletion(BooleanValue.True));

            case RelationalOperator.Instanceof:
                return(InstanceOf(leftValue, rightValue));

            case RelationalOperator.In:
                if (!(rightValue is Object o))
                {
                    return(Completion.ThrowTypeError("in operator applied to non-object"));
                }
                var propertyKey = leftValue.ToPropertyKey();
                if (propertyKey.IsAbrupt())
                {
                    return(propertyKey);
                }
                return(o.HasProperty(propertyKey.Other !));

            default:
                throw new InvalidOperationException($"RelationalExpression.Evaluate: unknown RelationalOperator enum value {(int)relationalOperator}");
            }
        }