Ejemplo n.º 1
0
        public override Completion Evaluate(Interpreter interpreter)
        {
            var @ref     = memberExpression.Evaluate(interpreter);
            var funcComp = @ref.GetValue();

            if (funcComp.IsAbrupt())
            {
                return(funcComp);
            }
            var func = funcComp.value !;

            if (func == UndefinedValue.Instance && @ref.value is ReferenceValue r)
            {
                return(Completion.ThrowReferenceError($"Cannot call undefined method {r.referencedName } on a {r.baseValue.GetType().Name}"));
            }

            if (@ref.value is ReferenceValue referenceValue && !referenceValue.baseValue.IsPrimitive() && referenceValue.referencedName == "eval")
            {
                if (func == interpreter.CurrentRealm().Intrinsics.Eval)
                {
                    var argList = arguments.ArgumentListEvaluation();
                    if (argList.IsAbrupt())
                    {
                        return(argList);
                    }
                    if (!argList.Other.Any())
                    {
                        return(Completion.NormalCompletion(UndefinedValue.Instance));
                    }
                    var evalText  = argList.Other ![0];
Ejemplo n.º 2
0
        private BooleanCompletion EvaluateDelete(Interpreter interpreter)
        {
            var refComp = unaryExpression.Evaluate(interpreter);

            if (refComp.IsAbrupt())
            {
                return(refComp.WithEmptyBool());
            }
            var @ref = refComp.value;

            if (!(@ref is ReferenceValue reference))
            {
                return(true);
            }
            if (reference.IsUnresolvableReference())
            {
                if (reference.strict)
                {
                    throw new InvalidOperationException("OperatorUnaryExpression.EvaluateDelete: cannot delete an unresolved member in strict mode");
                }
                return(true);
            }
            if (reference.IsPropertyReference())
            {
                if (reference is SuperReferenceValue)
                {
                    return(Completion.ThrowReferenceError("OperatorUnaryExpression.EvaluateDelete: cannot delete from super").WithEmptyBool());
                }
                var baseObj      = ((IValue)reference.baseValue).ToObject().value as Object;
                var deleteStatus = baseObj !.InternalDelete(reference.referencedName);
                if (deleteStatus.IsAbrupt())
                {
                    return(deleteStatus);
                }
                var success = deleteStatus.Other;
                if (success == false && reference.strict)
                {
                    return(Completion.ThrowTypeError("OperatorUnaryExpression.EvaluateDelete: delete failed in strict mode").WithEmptyBool());
                }
                return(success);
            }
            if (!(reference.baseValue is EnvironmentRecord envRec))
            {
                throw new InvalidOperationException("OperatorUnaryExpression.EvaluateDelete: unrecognized IReferenceable");
            }
            return(envRec.DeleteBinding(reference.referencedName));
        }