public static Completion min(IValue @this, IReadOnlyList <IValue> arguments) { double minValue = double.PositiveInfinity; foreach (var arg in arguments) { var xComp = arguments.At(0); if (xComp.IsAbrupt()) { return(xComp); } xComp = xComp.value !.ToNumber(); if (xComp.IsAbrupt()) { return(xComp); } var x = (xComp.value as NumberValue) !.number; if (double.IsNaN(x)) { return(Completion.NormalCompletion(NumberValue.DoubleNaN)); } if (x < minValue) { minValue = x; } } return(Completion.NormalCompletion(new NumberValue(minValue))); }
private static Completion CreatePerIterationEnvironment(IEnumerable <string> perIterationBindings) { if (perIterationBindings.Any()) { var lastIterationEnv = Interpreter.Instance().RunningExecutionContext().LexicalEnvironment; var lastIterationEnvRec = lastIterationEnv.EnvironmentRecord; var outer = lastIterationEnv.Outer; if (outer == null) { throw new InvalidOperationException("Spec 13.7.4.9 step 1d"); } var thisIterationEnv = outer.NewDeclarativeEnvironment(); var thisIterationEnvRec = thisIterationEnv.EnvironmentRecord; foreach (var bn in perIterationBindings) { thisIterationEnvRec.CreateMutableBinding(bn, false); var lastValue = lastIterationEnvRec.GetBindingValue(bn, true); if (lastValue.IsAbrupt()) { return(lastValue); } thisIterationEnvRec.InitializeBinding(bn, lastValue.value !); } Interpreter.Instance().RunningExecutionContext().LexicalEnvironment = thisIterationEnv; } return(Completion.NormalCompletion(UndefinedValue.Instance)); }
public override Completion LabelledEvaluate(Interpreter interpreter, List <string> labels) { IValue V = UndefinedValue.Instance; while (true) { var conditionComp = whileExpression.Evaluate(interpreter); var condition = conditionComp.GetValue(); if (condition.IsAbrupt()) { return(condition); } if (!condition.value !.ToBoolean().boolean) { return(Completion.NormalCompletion(V)); } var stmtResult = doStatement.Evaluate(interpreter); if (!LoopContinues(stmtResult, labels)) { return(stmtResult.UpdateEmpty(V)); } if (stmtResult.value != null) { V = stmtResult.value; } } }
private Completion EvaluateTypeof(Interpreter interpreter) { var valComp = unaryExpression.Evaluate(interpreter); if (valComp.value is ReferenceValue reference) { if (reference.IsUnresolvableReference()) { return(Completion.NormalCompletion(new StringValue("undefined"))); } } var val = valComp.GetValue(); if (val.IsAbrupt()) { return(val); } return(Completion.NormalCompletion(new StringValue(val.value switch { UndefinedValue _ => "undefined", NullValue _ => "object", BooleanValue _ => "boolean", NumberValue _ => "number", StringValue _ => "string", FunctionObject _ => "function", Object _ => "object", _ => throw new InvalidOperationException("OperatorUnaryExpression.EvaluateTypeof: unknown type"), })));
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];
public override Completion Evaluate(Interpreter interpreter) { if (System.Diagnostics.Debugger.IsAttached) { System.Diagnostics.Debugger.Break(); } return(Completion.NormalCompletion()); }
public override Completion Evaluate(Interpreter interpreter) { if (!scriptBody.Any()) { return(Completion.NormalCompletion(UndefinedValue.Instance)); } throw new InvalidOperationException("Evaluate is not defined for scripts with bodies. Use ScriptEvaluate instead."); }
public Completion Evaluate(Interpreter interpreter) { if (statementList == null) { return(Completion.NormalCompletion()); } return(statementList.Evaluate(interpreter)); }
public override Completion Evaluate(Interpreter interpreter) { var comp = variableDeclarations.Evaluate(interpreter); if (comp.IsAbrupt()) { return(comp); } return(Completion.NormalCompletion()); }
public override Completion LabelledEvaluate(Interpreter interpreter, List <string> labelSet) { labelSet.Add(identifier.name); var stmtResult = labelledItem.LabelledEvaluate(interpreter, labelSet); if (stmtResult.completionType == CompletionType.Break && identifier.name == stmtResult.target) { stmtResult = Completion.NormalCompletion(stmtResult.value); } return(stmtResult); }
public override Completion Evaluate(Interpreter interpreter) { foreach (var i in lexicalDeclarationItems) { var completion = i.Evaluate(interpreter); if (completion.IsAbrupt()) { return(completion); } } return(Completion.NormalCompletion()); }
public override Completion LabelledEvaluate(Interpreter interpreter, List <string> labels) { var stmtResult = Evaluate(interpreter); if (stmtResult.completionType == CompletionType.Break && stmtResult.target == null) { if (stmtResult.value == null) { return(Completion.NormalCompletion(UndefinedValue.Instance)); } stmtResult = Completion.NormalCompletion(stmtResult.value); } return(stmtResult); }
public override Completion Evaluate(Interpreter interpreter) { var lhs = unaryExpression.Evaluate(interpreter); if (lhs.IsAbrupt()) { return(lhs); } var lhsValue = lhs.GetValue(); if (lhsValue.IsAbrupt()) { return(lhsValue); } var oldValueComp = lhsValue.value !.ToNumber(); if (oldValueComp.IsAbrupt()) { return(oldValueComp); } var oldValue = oldValueComp.value as NumberValue; if (!(lhs.value is ReferenceValue reference)) { throw new InvalidOperationException("PrefixUpdateExpression.Evaluate: unaryExpression did not return a reference"); } NumberValue newValue; if (updateOperation == UpdateOperator.Decrement) { newValue = new NumberValue(oldValue !.number - 1); } else { newValue = new NumberValue(oldValue !.number + 1); } var putComp = reference.PutValue(newValue); if (putComp.IsAbrupt()) { return(putComp); } return(Completion.NormalCompletion(newValue)); }
public override Completion Evaluate(Interpreter interpreter) { IValue lastValue = UndefinedValue.Instance; foreach (var expression in assignmentExpressions) { var comp = expression.Evaluate(interpreter).GetValue(); if (comp.IsAbrupt()) { return(comp); } lastValue = comp.value !; } return(Completion.NormalCompletion(lastValue)); }
public override Completion Evaluate(Interpreter interpreter) { var obj = Utils.ObjectCreate(interpreter.CurrentRealm().Intrinsics.ObjectPrototype); foreach (var property in propertyDefinitions) { var comp = property.PropertyDefinitionEvaluation(obj, true); if (comp.IsAbrupt()) { return(comp); } } return(Completion.NormalCompletion(obj)); }
protected static Completion ForBodyEvaluation(AbstractExpression?test, AbstractExpression?increment, Statement stmt, IEnumerable <string> perIterationBindings, List <string> labelSet) { IValue V = UndefinedValue.Instance; var comp = CreatePerIterationEnvironment(perIterationBindings); if (comp.IsAbrupt()) { return(comp); } while (true) { if (test != null) { var testComp = test.Evaluate(Interpreter.Instance()); var testValueComp = testComp.GetValue(); if (testValueComp.IsAbrupt()) { return(testValueComp); } if (!testValueComp.value !.ToBoolean().boolean) { return(Completion.NormalCompletion(V)); } } var result = stmt.Evaluate(Interpreter.Instance()); if (!LoopContinues(result, labelSet)) { return(result.UpdateEmpty(V)); } if (result.value != null) { V = result.value; } comp = CreatePerIterationEnvironment(perIterationBindings); if (comp.IsAbrupt()) { return(comp); } if (increment != null) { var inc = increment.Evaluate(Interpreter.Instance()).GetValue(); if (inc.IsAbrupt()) { return(inc); } } } }
public Completion PropertyDefinitionEvaluation(Object @object, bool enumerable) { var valueComp = Evaluate(Interpreter.Instance()).GetValue(); if (valueComp.IsAbrupt()) { return(valueComp); } var value = valueComp.value !; if (Utils.CreateDataPropertyOrThrow(@object, identifier.name, value).IsAbrupt()) { throw new InvalidOperationException("Spec ! 12.2.6.8 IdentifierReference, step 6"); } return(Completion.NormalCompletion()); }
public override Completion Evaluate(Interpreter interpreter) { if (!statementList.Any()) { return(Completion.NormalCompletion()); } var oldEnv = interpreter.RunningExecutionContext().LexicalEnvironment; var blockEnv = oldEnv.NewDeclarativeEnvironment(); BlockDeclarationInstantiation(statementList, blockEnv); interpreter.RunningExecutionContext().LexicalEnvironment = blockEnv; Completion blockValue = statementList.Evaluate(interpreter); interpreter.RunningExecutionContext().LexicalEnvironment = oldEnv; return(blockValue); }
public override Completion Evaluate(Interpreter interpreter) { var left = logicalOrExpression.Evaluate(interpreter).GetValue(); if (left.IsAbrupt()) { return(left); } var leftValue = left.value !; if (leftValue.ToBoolean().boolean) { return(Completion.NormalCompletion(leftValue)); } return(logicalAndExpression.Evaluate(interpreter).GetValue()); }
public override Completion Evaluate(Interpreter interpreter) { var baseValueComp = dotMemberExpression.Evaluate(interpreter).GetValue(); if (baseValueComp.IsAbrupt()) { return(baseValueComp); } var baseValue = baseValueComp.value !; var coercible = baseValue.RequireObjectCoercible(); if (coercible.IsAbrupt()) { return(coercible); } return(Completion.NormalCompletion(new ReferenceValue(baseValue, dotIdentifierName, IsStrictMode))); }
public static Completion log(IValue @this, IReadOnlyList <IValue> arguments) { var xComp = arguments.At(0); if (xComp.IsAbrupt()) { return(xComp); } xComp = xComp.value !.ToNumber(); if (xComp.IsAbrupt()) { return(xComp); } var x = (xComp.value as NumberValue) !.number; return(Completion.NormalCompletion(new NumberValue(System.Math.Log(x)))); }
public Completion BindingInitialization(IValue value, LexicalEnvironment environment) { if (environment != null) { environment.EnvironmentRecord.InitializeBinding(name, value); return(Completion.NormalCompletion(UndefinedValue.Instance)); } var lhsComp = Interpreter.Instance().ResolveBinding(name, IsStrictMode); if (lhsComp.IsAbrupt()) { return(lhsComp); } var lhs = lhsComp.value as ReferenceValue; return(lhs !.PutValue(value)); }
public override Completion Evaluate(Interpreter interpreter) { Completion lastValue = Completion.NormalCompletion(); foreach (var statement in statements) { var val = statement.Evaluate(interpreter); if (val.IsAbrupt()) { return(val); } if (val.value != null) { lastValue = val; } } return(lastValue); }
public override Completion Evaluate(Interpreter interpreter) { if (arrayLiteralItems.Count == 1 && arrayLiteralItems[0] is Elision e) { var array = ArrayObject.ArrayCreate(0); array.Set("length", new NumberValue(e.width), false); return(Completion.NormalCompletion(array)); } else { var array = ArrayObject.ArrayCreate(0); var len = ArrayAccumulate(array, 0); if (len.IsAbrupt()) { return(len); } array.Set("length", len.value !, false); return(Completion.NormalCompletion(array)); } }
public static Completion Calculate(IValue leftValue, IValue rightValue) { var baseComp = leftValue.ToNumber(); if (baseComp.IsAbrupt()) { return(baseComp); } var exponentComp = rightValue.ToNumber(); if (exponentComp.IsAbrupt()) { return(exponentComp); } double @base = (baseComp.value as NumberValue) !.number; double exponent = (exponentComp.value as NumberValue) !.number; return(Completion.NormalCompletion(new NumberValue(Math.Pow(@base, exponent)))); }
public Completion PropertyDefinitionEvaluation(Object @object, bool enumerable) { var valueComp = assignmentExpression.Evaluate(Interpreter.Instance()); if (valueComp.IsAbrupt()) { return(valueComp); } var value = valueComp.value; if (!(value is Object source)) { throw new InvalidOperationException($"ObjectLiteral: tried to initialize an object using a spread on a non-object"); } valueComp = Utils.CopyDataProperties(@object, source, excludedItems: Utils.EmptyList <string>()); if (valueComp.IsAbrupt()) { return(valueComp); } return(Completion.NormalCompletion()); }
public override Completion Evaluate(Interpreter interpreter) { if (hasElse) { var conditionComp = conditionExpression.Evaluate(interpreter).GetValue(); if (conditionComp.IsAbrupt()) { return(conditionComp); } var condition = conditionComp.value !.ToBoolean(); Completion stmtCompletion; if (condition.boolean) { stmtCompletion = trueStatement.Evaluate(interpreter); } else { stmtCompletion = falseStatement !.Evaluate(interpreter); } return(stmtCompletion.UpdateEmpty(UndefinedValue.Instance)); } else { var conditionComp = conditionExpression.Evaluate(interpreter).GetValue(); if (conditionComp.IsAbrupt()) { return(conditionComp); } var condition = conditionComp.value !.ToBoolean(); if (!condition.boolean) { return(Completion.NormalCompletion(UndefinedValue.Instance)); } else { var stmtCompletion = trueStatement.Evaluate(interpreter); return(stmtCompletion.UpdateEmpty(UndefinedValue.Instance)); } } }
private Completion AbstractRelationalComparison(IValue x, IValue y, bool leftFirst = true) { IValue px, py; if (leftFirst) { var xComp = x.ToPrimitive(); if (xComp.IsAbrupt()) { return(xComp); } px = xComp.value !; var yComp = y.ToPrimitive(); if (yComp.IsAbrupt()) { return(yComp); } py = yComp.value !; } else { var yComp = y.ToPrimitive(); if (yComp.IsAbrupt()) { return(yComp); } py = yComp.value !; var xComp = x.ToPrimitive(); if (xComp.IsAbrupt()) { return(xComp); } px = xComp.value !; } if (px is StringValue sx && py is StringValue sy) { return(Completion.NormalCompletion((string.Compare(sx.@string, sy.@string, StringComparison.InvariantCulture) < 0) ? BooleanValue.True : BooleanValue.False)); }
public Completion Evaluate(Interpreter interpreter) { if (assignmentExpression == null) { return(Completion.NormalCompletion()); } var lhsComp = interpreter.ResolveBinding(name, IsStrictMode); if (lhsComp.IsAbrupt()) { return(lhsComp); } if (!(lhsComp.value is ReferenceValue referenceValue)) { throw new InvalidOperationException("ResolveBinding didn't return a reference"); } Completion value; if (assignmentExpression is FunctionExpression functionExpression && functionExpression.isAnonymous) { value = functionExpression.NamedEvaluate(interpreter, name); }
public static Completion MakeSuperPropertyReference(IValue actualThis, string propertyKey, bool strict) { var env = Interpreter.Instance().GetThisEnvironment(); if (!env.HasSuperBinding()) { throw new InvalidOperationException("SuperHelper.MakeSuperPropertyReference: Interpreter.GetThisEnvironment has no super binding"); } var baseValueComp = ((FunctionEnvironmentRecord)env).GetSuperBase(); if (baseValueComp.IsAbrupt()) { return(baseValueComp); } var baseValue = baseValueComp.value !; var coercible = baseValue.RequireObjectCoercible(); if (coercible.IsAbrupt()) { return(coercible); } return(Completion.NormalCompletion(new SuperReferenceValue(baseValue, propertyKey, strict, actualThis))); }