From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- .../PerformanceTests/ARES-6/Babylon/basic-blob.js | 273 +++++++++++++++++++++ 1 file changed, 273 insertions(+) create mode 100644 third_party/webkit/PerformanceTests/ARES-6/Babylon/basic-blob.js (limited to 'third_party/webkit/PerformanceTests/ARES-6/Babylon/basic-blob.js') diff --git a/third_party/webkit/PerformanceTests/ARES-6/Babylon/basic-blob.js b/third_party/webkit/PerformanceTests/ARES-6/Babylon/basic-blob.js new file mode 100644 index 0000000000..bebd9f6359 --- /dev/null +++ b/third_party/webkit/PerformanceTests/ARES-6/Babylon/basic-blob.js @@ -0,0 +1,273 @@ +/* + * Copyright (C) 2016-2017 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +"use strict"; + +const Basic = {}; + +Basic.NumberApply = function(state) +{ + // I'd call this arguments but we're in strict mode. + let parameters = this.parameters.map(value => value.evaluate(state)); + + return state.getValue(this.name, parameters.length).apply(state, parameters); +}; + +Basic.Variable = function(state) +{ + let parameters = this.parameters.map(value => value.evaluate(state)); + + return state.getValue(this.name, parameters.length).leftApply(state, parameters); +} + +Basic.Const = function(state) +{ + return this.value; +} + +Basic.NumberPow = function(state) +{ + return Math.pow(this.left.evaluate(state), this.right.evaluate(state)); +} + +Basic.NumberMul = function(state) +{ + return this.left.evaluate(state) * this.right.evaluate(state); +} + +Basic.NumberDiv = function(state) +{ + return this.left.evaluate(state) / this.right.evaluate(state); +} + +Basic.NumberNeg = function(state) +{ + return -this.term.evaluate(state); +} + +Basic.NumberAdd = function(state) +{ + return this.left.evaluate(state) + this.right.evaluate(state); +} + +Basic.NumberSub = function(state) +{ + return this.left.evaluate(state) - this.right.evaluate(state); +} + +Basic.StringVar = function(state) +{ + let value = state.stringValues.get(this.name); + if (value == null) + state.abort("Could not find string variable " + this.name); + return value; +} + +Basic.Equals = function(state) +{ + return this.left.evaluate(state) == this.right.evaluate(state); +} + +Basic.NotEquals = function(state) +{ + return this.left.evaluate(state) != this.right.evaluate(state); +} + +Basic.LessThan = function(state) +{ + return this.left.evaluate(state) < this.right.evaluate(state); +} + +Basic.GreaterThan = function(state) +{ + return this.left.evaluate(state) > this.right.evaluate(state); +} + +Basic.LessEqual = function(state) +{ + return this.left.evaluate(state) <= this.right.evaluate(state); +} + +Basic.GreaterEqual = function(state) +{ + return this.left.evaluate(state) >= this.right.evaluate(state); +} + +Basic.GoTo = function*(state) +{ + state.nextLineNumber = this.target; +} + +Basic.GoSub = function*(state) +{ + state.subStack.push(state.nextLineNumber); + state.nextLineNumber = this.target; +} + +Basic.Def = function*(state) +{ + state.validate(!state.values.has(this.name), "Cannot redefine function"); + state.values.set(this.name, new NumberFunction(this.parameters, this.expression)); +} + +Basic.Let = function*(state) +{ + this.variable.evaluate(state).assign(this.expression.evaluate(state)); +} + +Basic.If = function*(state) +{ + if (this.condition.evaluate(state)) + state.nextLineNumber = this.target; +} + +Basic.Return = function*(state) +{ + this.validate(state.subStack.length, "Not in a subroutine"); + this.nextLineNumber = state.subStack.pop(); +} + +Basic.Stop = function*(state) +{ + state.nextLineNumber = null; +} + +Basic.On = function*(state) +{ + let index = this.expression.evaluate(state); + if (!(index >= 1) || !(index <= this.targets.length)) + state.abort("Index out of bounds: " + index); + this.nextLineNumber = this.targets[Math.floor(index)]; +} + +Basic.For = function*(state) +{ + let sideState = state.getSideState(this); + sideState.variable = state.getValue(this.variable, 0).leftApply(state, []); + sideState.initialValue = this.initial.evaluate(state); + sideState.limitValue = this.limit.evaluate(state); + sideState.stepValue = this.step.evaluate(state); + sideState.variable.assign(sideState.initialValue); + sideState.shouldStop = function() { + return (sideState.variable.value - sideState.limitValue) * Math.sign(sideState.stepValue) > 0; + }; + if (sideState.shouldStop()) + this.nextLineNumber = this.target.lineNumber + 1; +} + +Basic.Next = function*(state) +{ + let sideState = state.getSideState(this.target); + sideState.variable.assign(sideState.variable.value + sideState.stepValue); + if (sideState.shouldStop()) + return; + state.nextLineNumber = this.target.lineNumber + 1; +} + +Basic.Next.isBlockEnd = true; + +Basic.Print = function*(state) +{ + let string = ""; + for (let item of this.items) { + switch (item.kind) { + case "comma": + while (string.length % 14) + string += " "; + break; + case "tab": { + let value = item.value.evaluate(state); + value = Math.max(Math.round(value), 1); + while (string.length % value) + string += " "; + break; + } + case "string": + case "number": + string += item.value.evaluate(state); + break; + default: + throw new Error("Bad item kind: " + item.kind); + } + } + + yield {kind: "output", string}; +} + +Basic.Input = function*(state) +{ + let results = yield {kind: "input", numItems: this.items.length}; + state.validate(results != null && results.length == this.items.length, "Input did not get the right number of items"); + for (let i = 0; i < results.length; ++i) + this.items[i].evaluate(state).assign(results[i]); +} + +Basic.Read = function*(state) +{ + for (let item of this.items) { + state.validate(state.dataIndex < state.program.data.length, "Attempting to read past the end of data"); + item.assign(state.program.data[state.dataIndex++]); + } +} + +Basic.Restore = function*(state) +{ + state.dataIndex = 0; +} + +Basic.Dim = function*(state) +{ + for (let item of this.items) { + state.validate(!state.values.has(item.name), "Variable " + item.name + " already exists"); + state.validate(item.bounds.length, "Dim statement is for arrays"); + state.values.set(item.name, new NumberArray(item.bounds.map(bound => bound + 1))); + } +} + +Basic.Randomize = function*(state) +{ + state.rng = createRNGWithRandomSeed(); +} + +Basic.End = function*(state) +{ + state.nextLineNumber = null; +} + +Basic.End.isBlockEnd = true; + +Basic.Program = function* programGenerator(state) +{ + state.validate(state.program == this, "State must match program"); + let maxLineNumber = Math.max(...this.statements.keys()); + while (state.nextLineNumber != null) { + state.validate(state.nextLineNumber <= maxLineNumber, "Went out of bounds of the program"); + let statement = this.statements.get(state.nextLineNumber++); + if (statement == null || statement.process == null) + continue; + state.statement = statement; + yield* statement.process(state); + } +} + -- cgit v1.2.3