[oden] Grab my incomplete QuickJS wrapper

oden-js-sys/quickjs/tests/bench-v8/Makefile

@@ -0,0 +1,10 @@
+all: combined.js
+
+FILES=base.js richards.js deltablue.js crypto.js raytrace.js earley-boyer.js regexp.js splay.js navier-stokes.js run_harness.js
+#FILES=base.js richards.js deltablue.js crypto.js raytrace.js earley-boyer.js splay.js navier-stokes.js run_harness.js
+
+combined.js: $(FILES)
+	cat $(FILES) >$@
+
+clean:
+	rm -f combined.js

oden-js-sys/quickjs/tests/bench-v8/README.txt

@@ -0,0 +1,86 @@
+V8 Benchmark Suite
+==================
+
+This is the V8 benchmark suite: A collection of pure JavaScript
+benchmarks that we have used to tune V8. The licenses for the
+individual benchmarks are included in the JavaScript files.
+
+In addition to the benchmarks, the suite consists of the benchmark
+framework (base.js), which must be loaded before any of the individual
+benchmark files, and two benchmark runners: An HTML version (run.html)
+and a standalone JavaScript version (run.js).
+
+
+Changes From Version 1 To Version 2
+===================================
+
+For version 2 the crypto benchmark was fixed.  Previously, the
+decryption stage was given plaintext as input, which resulted in an
+error.  Now, the decryption stage is given the output of the
+encryption stage as input.  The result is checked against the original
+plaintext.  For this to give the correct results the crypto objects
+are reset for each iteration of the benchmark.  In addition, the size
+of the plain text has been increased a little and the use of
+Math.random() and new Date() to build an RNG pool has been removed.
+
+Other benchmarks were fixed to do elementary verification of the
+results of their calculations.  This is to avoid accidentally
+obtaining scores that are the result of an incorrect JavaScript engine
+optimization.
+
+
+Changes From Version 2 To Version 3
+===================================
+
+Version 3 adds a new benchmark, RegExp.  The RegExp benchmark is
+generated by loading 50 of the most popular pages on the web and
+logging all regexp operations performed.  Each operation is given a
+weight that is calculated from an estimate of the popularity of the
+pages where it occurs and the number of times it is executed while
+loading each page.  Finally the literal letters in the data are
+encoded using ROT13 in a way that does not affect how the regexps
+match their input.
+
+
+Changes from Version 3 to Version 4
+===================================
+
+The Splay benchmark is a newcomer in version 4.  It manipulates a
+splay tree by adding and removing data nodes, thus exercising the
+memory management subsystem of the JavaScript engine.
+
+Furthermore, all the unused parts of the Prototype library were
+removed from the RayTrace benchmark. This does not affect the running
+of the benchmark.
+
+
+Changes from Version 4 to Version 5
+===================================
+
+Removed duplicate line in random seed code, and changed the name of
+the Object.prototype.inherits function in the DeltaBlue benchmark to
+inheritsFrom to avoid name clashes when running in Chromium with
+extensions enabled.
+
+
+Changes from Version 5 to Version 6
+===================================
+
+Removed dead code from the RayTrace benchmark and fixed a couple of
+typos in the DeltaBlue implementation. Changed the Splay benchmark to
+avoid converting the same numeric key to a string over and over again
+and to avoid inserting and removing the same element repeatedly thus
+increasing pressure on the memory subsystem. Changed the RegExp
+benchmark to exercise the regular expression engine on different
+input strings.
+
+Furthermore, the benchmark runner was changed to run the benchmarks
+for at least a few times to stabilize the reported numbers on slower
+machines.
+
+
+Changes from Version 6 to Version 7
+===================================
+
+Added the Navier-Stokes benchmark, a 2D differential equation solver
+that stresses arithmetic computations on double arrays.

oden-js-sys/quickjs/tests/bench-v8/base.js

@@ -0,0 +1,285 @@
+"use strict";
+"use strip";
+// Copyright 2012 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * 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.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "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 THE COPYRIGHT
+// OWNER 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.
+
+// Simple framework for running the benchmark suites and
+// computing a score based on the timing measurements.
+
+
+// A benchmark has a name (string) and a function that will be run to
+// do the performance measurement. The optional setup and tearDown
+// arguments are functions that will be invoked before and after
+// running the benchmark, but the running time of these functions will
+// not be accounted for in the benchmark score.
+function Benchmark(name, run, setup, tearDown) {
+  this.name = name;
+  this.run = run;
+  this.Setup = setup ? setup : function() { };
+  this.TearDown = tearDown ? tearDown : function() { };
+}
+
+
+// Benchmark results hold the benchmark and the measured time used to
+// run the benchmark. The benchmark score is computed later once a
+// full benchmark suite has run to completion.
+function BenchmarkResult(benchmark, time) {
+  this.benchmark = benchmark;
+  this.time = time;
+}
+
+
+// Automatically convert results to numbers. Used by the geometric
+// mean computation.
+BenchmarkResult.prototype.valueOf = function() {
+  return this.time;
+};
+
+
+// Suites of benchmarks consist of a name and the set of benchmarks in
+// addition to the reference timing that the final score will be based
+// on. This way, all scores are relative to a reference run and higher
+// scores implies better performance.
+function BenchmarkSuite(name, reference, benchmarks) {
+  this.name = name;
+  this.reference = reference;
+  this.benchmarks = benchmarks;
+  BenchmarkSuite.suites.push(this);
+}
+
+
+// Keep track of all declared benchmark suites.
+BenchmarkSuite.suites = [];
+
+
+// Scores are not comparable across versions. Bump the version if
+// you're making changes that will affect that scores, e.g. if you add
+// a new benchmark or change an existing one.
+BenchmarkSuite.version = '7';
+
+
+// To make the benchmark results predictable, we replace Math.random
+// with a 100% deterministic alternative.
+Math.random = (function() {
+  var seed = 49734321;
+  return function() {
+    // Robert Jenkins' 32 bit integer hash function.
+    seed = ((seed + 0x7ed55d16) + (seed << 12))  & 0xffffffff;
+    seed = ((seed ^ 0xc761c23c) ^ (seed >>> 19)) & 0xffffffff;
+    seed = ((seed + 0x165667b1) + (seed << 5))   & 0xffffffff;
+    seed = ((seed + 0xd3a2646c) ^ (seed << 9))   & 0xffffffff;
+    seed = ((seed + 0xfd7046c5) + (seed << 3))   & 0xffffffff;
+    seed = ((seed ^ 0xb55a4f09) ^ (seed >>> 16)) & 0xffffffff;
+    return (seed & 0xfffffff) / 0x10000000;
+  };
+})();
+
+
+// Runs all registered benchmark suites and optionally yields between
+// each individual benchmark to avoid running for too long in the
+// context of browsers. Once done, the final score is reported to the
+// runner.
+BenchmarkSuite.RunSuites = function(runner) {
+  var continuation = null;
+  var suites = BenchmarkSuite.suites;
+  var length = suites.length;
+  BenchmarkSuite.scores = [];
+  var index = 0;
+  function RunStep() {
+    while (continuation || index < length) {
+      if (continuation) {
+        continuation = continuation();
+      } else {
+        var suite = suites[index++];
+        if (runner.NotifyStart) runner.NotifyStart(suite.name);
+        continuation = suite.RunStep(runner);
+      }
+      if (continuation && typeof window != 'undefined' && window.setTimeout) {
+        window.setTimeout(RunStep, 25);
+        return;
+      }
+    }
+    if (runner.NotifyScore) {
+      var score = BenchmarkSuite.GeometricMean(BenchmarkSuite.scores);
+      var formatted = BenchmarkSuite.FormatScore(100 * score);
+      runner.NotifyScore(formatted);
+    }
+  }
+  RunStep();
+};
+
+
+// Counts the total number of registered benchmarks. Useful for
+// showing progress as a percentage.
+BenchmarkSuite.CountBenchmarks = function() {
+  var result = 0;
+  var suites = BenchmarkSuite.suites;
+  for (var i = 0; i < suites.length; i++) {
+    result += suites[i].benchmarks.length;
+  }
+  return result;
+};
+
+
+// Computes the geometric mean of a set of numbers.
+BenchmarkSuite.GeometricMean = function(numbers) {
+  var log = 0;
+  for (var i = 0; i < numbers.length; i++) {
+    log += Math.log(numbers[i]);
+  }
+  return Math.pow(Math.E, log / numbers.length);
+};
+
+
+// Converts a score value to a string with at least three significant
+// digits.
+BenchmarkSuite.FormatScore = function(value) {
+  if (value > 100) {
+    return value.toFixed(0);
+  } else {
+    return value.toPrecision(3);
+  }
+};
+
+// Notifies the runner that we're done running a single benchmark in
+// the benchmark suite. This can be useful to report progress.
+BenchmarkSuite.prototype.NotifyStep = function(result) {
+  this.results.push(result);
+  if (this.runner.NotifyStep) this.runner.NotifyStep(result.benchmark.name);
+};
+
+
+// Notifies the runner that we're done with running a suite and that
+// we have a result which can be reported to the user if needed.
+BenchmarkSuite.prototype.NotifyResult = function() {
+  var mean = BenchmarkSuite.GeometricMean(this.results);
+  var score = this.reference / mean;
+  BenchmarkSuite.scores.push(score);
+  if (this.runner.NotifyResult) {
+    var formatted = BenchmarkSuite.FormatScore(100 * score);
+    this.runner.NotifyResult(this.name, formatted);
+  }
+};
+
+
+// Notifies the runner that running a benchmark resulted in an error.
+BenchmarkSuite.prototype.NotifyError = function(error) {
+  if (this.runner.NotifyError) {
+    this.runner.NotifyError(this.name, error);
+  }
+  if (this.runner.NotifyStep) {
+    this.runner.NotifyStep(this.name);
+  }
+};
+
+
+// Runs a single benchmark for at least a second and computes the
+// average time it takes to run a single iteration.
+BenchmarkSuite.prototype.RunSingleBenchmark = function(benchmark, data) {
+  function Measure(data) {
+    var elapsed = 0;
+    var start = new Date();
+    for (var n = 0; elapsed < 1000; n++) {
+      benchmark.run();
+      elapsed = new Date() - start;
+    }
+    if (data != null) {
+      data.runs += n;
+      data.elapsed += elapsed;
+    }
+  }
+
+  if (data == null) {
+    // Measure the benchmark once for warm up and throw the result
+    // away. Return a fresh data object.
+    Measure(null);
+    return { runs: 0, elapsed: 0 };
+  } else {
+    Measure(data);
+    // If we've run too few iterations, we continue for another second.
+    if (data.runs < 32) return data;
+    var usec = (data.elapsed * 1000) / data.runs;
+    this.NotifyStep(new BenchmarkResult(benchmark, usec));
+    return null;
+  }
+};
+
+
+// This function starts running a suite, but stops between each
+// individual benchmark in the suite and returns a continuation
+// function which can be invoked to run the next benchmark. Once the
+// last benchmark has been executed, null is returned.
+BenchmarkSuite.prototype.RunStep = function(runner) {
+  this.results = [];
+  this.runner = runner;
+  var length = this.benchmarks.length;
+  var index = 0;
+  var suite = this;
+  var data;
+
+  // Run the setup, the actual benchmark, and the tear down in three
+  // separate steps to allow the framework to yield between any of the
+  // steps.
+
+  function RunNextSetup() {
+    if (index < length) {
+      try {
+        suite.benchmarks[index].Setup();
+      } catch (e) {
+        suite.NotifyError(e);
+        return null;
+      }
+      return RunNextBenchmark;
+    }
+    suite.NotifyResult();
+    return null;
+  }
+
+  function RunNextBenchmark() {
+    try {
+      data = suite.RunSingleBenchmark(suite.benchmarks[index], data);
+    } catch (e) {
+      suite.NotifyError(e);
+      return null;
+    }
+    // If data is null, we're done with this benchmark.
+    return (data == null) ? RunNextTearDown : RunNextBenchmark();
+  }
+
+  function RunNextTearDown() {
+    try {
+      suite.benchmarks[index++].TearDown();
+    } catch (e) {
+      suite.NotifyError(e);
+      return null;
+    }
+    return RunNextSetup;
+  }
+
+  // Start out running the setup.
+  return RunNextSetup();
+};

oden-js-sys/quickjs/tests/bench-v8/deltablue.js

@@ -0,0 +1,879 @@
+// Copyright 2008 the V8 project authors. All rights reserved.
+// Copyright 1996 John Maloney and Mario Wolczko.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+// This implementation of the DeltaBlue benchmark is derived
+// from the Smalltalk implementation by John Maloney and Mario
+// Wolczko. Some parts have been translated directly, whereas
+// others have been modified more aggresively to make it feel
+// more like a JavaScript program.
+
+
+/**
+ * A JavaScript implementation of the DeltaBlue constraint-solving
+ * algorithm, as described in:
+ *
+ * "The DeltaBlue Algorithm: An Incremental Constraint Hierarchy Solver"
+ *   Bjorn N. Freeman-Benson and John Maloney
+ *   January 1990 Communications of the ACM,
+ *   also available as University of Washington TR 89-08-06.
+ *
+ * Beware: this benchmark is written in a grotesque style where
+ * the constraint model is built by side-effects from constructors.
+ * I've kept it this way to avoid deviating too much from the original
+ * implementation.
+ */
+
+
+/* --- O b j e c t   M o d e l --- */
+
+Object.prototype.inheritsFrom = function (shuper) {
+  function Inheriter() { }
+  Inheriter.prototype = shuper.prototype;
+  this.prototype = new Inheriter();
+  this.superConstructor = shuper;
+};
+
+function OrderedCollection() {
+  this.elms = new Array();
+}
+
+OrderedCollection.prototype.add = function (elm) {
+  this.elms.push(elm);
+};
+
+OrderedCollection.prototype.at = function (index) {
+  return this.elms[index];
+};
+
+OrderedCollection.prototype.size = function () {
+  return this.elms.length;
+};
+
+OrderedCollection.prototype.removeFirst = function () {
+  return this.elms.pop();
+};
+
+OrderedCollection.prototype.remove = function (elm) {
+  var index = 0, skipped = 0;
+  for (var i = 0; i < this.elms.length; i++) {
+    var value = this.elms[i];
+    if (value != elm) {
+      this.elms[index] = value;
+      index++;
+    } else {
+      skipped++;
+    }
+  }
+  for (var i = 0; i < skipped; i++)
+    this.elms.pop();
+};
+
+/* --- *
+ * S t r e n g t h
+ * --- */
+
+/**
+ * Strengths are used to measure the relative importance of constraints.
+ * New strengths may be inserted in the strength hierarchy without
+ * disrupting current constraints.  Strengths cannot be created outside
+ * this class, so pointer comparison can be used for value comparison.
+ */
+function Strength(strengthValue, name) {
+  this.strengthValue = strengthValue;
+  this.name = name;
+}
+
+Strength.stronger = function (s1, s2) {
+  return s1.strengthValue < s2.strengthValue;
+};
+
+Strength.weaker = function (s1, s2) {
+  return s1.strengthValue > s2.strengthValue;
+};
+
+Strength.weakestOf = function (s1, s2) {
+  return this.weaker(s1, s2) ? s1 : s2;
+};
+
+Strength.strongest = function (s1, s2) {
+  return this.stronger(s1, s2) ? s1 : s2;
+};
+
+Strength.prototype.nextWeaker = function () {
+  switch (this.strengthValue) {
+    case 0: return Strength.STRONG_PREFERRED;
+    case 1: return Strength.PREFERRED;
+    case 2: return Strength.STRONG_DEFAULT;
+    case 3: return Strength.NORMAL;
+    case 4: return Strength.WEAK_DEFAULT;
+    case 5: return Strength.WEAKEST;
+  }
+};
+
+// Strength constants.
+Strength.REQUIRED         = new Strength(0, "required");
+Strength.STRONG_PREFERRED = new Strength(1, "strongPreferred");
+Strength.PREFERRED        = new Strength(2, "preferred");
+Strength.STRONG_DEFAULT   = new Strength(3, "strongDefault");
+Strength.NORMAL           = new Strength(4, "normal");
+Strength.WEAK_DEFAULT     = new Strength(5, "weakDefault");
+Strength.WEAKEST          = new Strength(6, "weakest");
+
+/* --- *
+ * C o n s t r a i n t
+ * --- */
+
+/**
+ * An abstract class representing a system-maintainable relationship
+ * (or "constraint") between a set of variables. A constraint supplies
+ * a strength instance variable; concrete subclasses provide a means
+ * of storing the constrained variables and other information required
+ * to represent a constraint.
+ */
+function Constraint(strength) {
+  this.strength = strength;
+}
+
+/**
+ * Activate this constraint and attempt to satisfy it.
+ */
+Constraint.prototype.addConstraint = function () {
+  this.addToGraph();
+  planner.incrementalAdd(this);
+};
+
+/**
+ * Attempt to find a way to enforce this constraint. If successful,
+ * record the solution, perhaps modifying the current dataflow
+ * graph. Answer the constraint that this constraint overrides, if
+ * there is one, or nil, if there isn't.
+ * Assume: I am not already satisfied.
+ */
+Constraint.prototype.satisfy = function (mark) {
+  this.chooseMethod(mark);
+  if (!this.isSatisfied()) {
+    if (this.strength == Strength.REQUIRED)
+      alert("Could not satisfy a required constraint!");
+    return null;
+  }
+  this.markInputs(mark);
+  var out = this.output();
+  var overridden = out.determinedBy;
+  if (overridden != null) overridden.markUnsatisfied();
+  out.determinedBy = this;
+  if (!planner.addPropagate(this, mark))
+    alert("Cycle encountered");
+  out.mark = mark;
+  return overridden;
+};
+
+Constraint.prototype.destroyConstraint = function () {
+  if (this.isSatisfied()) planner.incrementalRemove(this);
+  else this.removeFromGraph();
+};
+
+/**
+ * Normal constraints are not input constraints.  An input constraint
+ * is one that depends on external state, such as the mouse, the
+ * keybord, a clock, or some arbitraty piece of imperative code.
+ */
+Constraint.prototype.isInput = function () {
+  return false;
+};
+
+/* --- *
+ * U n a r y   C o n s t r a i n t
+ * --- */
+
+/**
+ * Abstract superclass for constraints having a single possible output
+ * variable.
+ */
+function UnaryConstraint(v, strength) {
+  UnaryConstraint.superConstructor.call(this, strength);
+  this.myOutput = v;
+  this.satisfied = false;
+  this.addConstraint();
+}
+
+UnaryConstraint.inheritsFrom(Constraint);
+
+/**
+ * Adds this constraint to the constraint graph
+ */
+UnaryConstraint.prototype.addToGraph = function () {
+  this.myOutput.addConstraint(this);
+  this.satisfied = false;
+};
+
+/**
+ * Decides if this constraint can be satisfied and records that
+ * decision.
+ */
+UnaryConstraint.prototype.chooseMethod = function (mark) {
+  this.satisfied = (this.myOutput.mark != mark)
+    && Strength.stronger(this.strength, this.myOutput.walkStrength);
+};
+
+/**
+ * Returns true if this constraint is satisfied in the current solution.
+ */
+UnaryConstraint.prototype.isSatisfied = function () {
+  return this.satisfied;
+};
+
+UnaryConstraint.prototype.markInputs = function (mark) {
+  // has no inputs
+};
+
+/**
+ * Returns the current output variable.
+ */
+UnaryConstraint.prototype.output = function () {
+  return this.myOutput;
+};
+
+/**
+ * Calculate the walkabout strength, the stay flag, and, if it is
+ * 'stay', the value for the current output of this constraint. Assume
+ * this constraint is satisfied.
+ */
+UnaryConstraint.prototype.recalculate = function () {
+  this.myOutput.walkStrength = this.strength;
+  this.myOutput.stay = !this.isInput();
+  if (this.myOutput.stay) this.execute(); // Stay optimization
+};
+
+/**
+ * Records that this constraint is unsatisfied
+ */
+UnaryConstraint.prototype.markUnsatisfied = function () {
+  this.satisfied = false;
+};
+
+UnaryConstraint.prototype.inputsKnown = function () {
+  return true;
+};
+
+UnaryConstraint.prototype.removeFromGraph = function () {
+  if (this.myOutput != null) this.myOutput.removeConstraint(this);
+  this.satisfied = false;
+};
+
+/* --- *
+ * S t a y   C o n s t r a i n t
+ * --- */
+
+/**
+ * Variables that should, with some level of preference, stay the same.
+ * Planners may exploit the fact that instances, if satisfied, will not
+ * change their output during plan execution.  This is called "stay
+ * optimization".
+ */
+function StayConstraint(v, str) {
+  StayConstraint.superConstructor.call(this, v, str);
+}
+
+StayConstraint.inheritsFrom(UnaryConstraint);
+
+StayConstraint.prototype.execute = function () {
+  // Stay constraints do nothing
+};
+
+/* --- *
+ * E d i t   C o n s t r a i n t
+ * --- */
+
+/**
+ * A unary input constraint used to mark a variable that the client
+ * wishes to change.
+ */
+function EditConstraint(v, str) {
+  EditConstraint.superConstructor.call(this, v, str);
+}
+
+EditConstraint.inheritsFrom(UnaryConstraint);
+
+/**
+ * Edits indicate that a variable is to be changed by imperative code.
+ */
+EditConstraint.prototype.isInput = function () {
+  return true;
+};
+
+EditConstraint.prototype.execute = function () {
+  // Edit constraints do nothing
+};
+
+/* --- *
+ * B i n a r y   C o n s t r a i n t
+ * --- */
+
+var Direction = new Object();
+Direction.NONE     = 0;
+Direction.FORWARD  = 1;
+Direction.BACKWARD = -1;
+
+/**
+ * Abstract superclass for constraints having two possible output
+ * variables.
+ */
+function BinaryConstraint(var1, var2, strength) {
+  BinaryConstraint.superConstructor.call(this, strength);
+  this.v1 = var1;
+  this.v2 = var2;
+  this.direction = Direction.NONE;
+  this.addConstraint();
+}
+
+BinaryConstraint.inheritsFrom(Constraint);
+
+/**
+ * Decides if this constraint can be satisfied and which way it
+ * should flow based on the relative strength of the variables related,
+ * and record that decision.
+ */
+BinaryConstraint.prototype.chooseMethod = function (mark) {
+  if (this.v1.mark == mark) {
+    this.direction = (this.v2.mark != mark && Strength.stronger(this.strength, this.v2.walkStrength))
+      ? Direction.FORWARD
+      : Direction.NONE;
+  }
+  if (this.v2.mark == mark) {
+    this.direction = (this.v1.mark != mark && Strength.stronger(this.strength, this.v1.walkStrength))
+      ? Direction.BACKWARD
+      : Direction.NONE;
+  }
+  if (Strength.weaker(this.v1.walkStrength, this.v2.walkStrength)) {
+    this.direction = Strength.stronger(this.strength, this.v1.walkStrength)
+      ? Direction.BACKWARD
+      : Direction.NONE;
+  } else {
+    this.direction = Strength.stronger(this.strength, this.v2.walkStrength)
+      ? Direction.FORWARD
+      : Direction.BACKWARD
+  }
+};
+
+/**
+ * Add this constraint to the constraint graph
+ */
+BinaryConstraint.prototype.addToGraph = function () {
+  this.v1.addConstraint(this);
+  this.v2.addConstraint(this);
+  this.direction = Direction.NONE;
+};
+
+/**
+ * Answer true if this constraint is satisfied in the current solution.
+ */
+BinaryConstraint.prototype.isSatisfied = function () {
+  return this.direction != Direction.NONE;
+};
+
+/**
+ * Mark the input variable with the given mark.
+ */
+BinaryConstraint.prototype.markInputs = function (mark) {
+  this.input().mark = mark;
+};
+
+/**
+ * Returns the current input variable
+ */
+BinaryConstraint.prototype.input = function () {
+  return (this.direction == Direction.FORWARD) ? this.v1 : this.v2;
+};
+
+/**
+ * Returns the current output variable
+ */
+BinaryConstraint.prototype.output = function () {
+  return (this.direction == Direction.FORWARD) ? this.v2 : this.v1;
+};
+
+/**
+ * Calculate the walkabout strength, the stay flag, and, if it is
+ * 'stay', the value for the current output of this
+ * constraint. Assume this constraint is satisfied.
+ */
+BinaryConstraint.prototype.recalculate = function () {
+  var ihn = this.input(), out = this.output();
+  out.walkStrength = Strength.weakestOf(this.strength, ihn.walkStrength);
+  out.stay = ihn.stay;
+  if (out.stay) this.execute();
+};
+
+/**
+ * Record the fact that this constraint is unsatisfied.
+ */
+BinaryConstraint.prototype.markUnsatisfied = function () {
+  this.direction = Direction.NONE;
+};
+
+BinaryConstraint.prototype.inputsKnown = function (mark) {
+  var i = this.input();
+  return i.mark == mark || i.stay || i.determinedBy == null;
+};
+
+BinaryConstraint.prototype.removeFromGraph = function () {
+  if (this.v1 != null) this.v1.removeConstraint(this);
+  if (this.v2 != null) this.v2.removeConstraint(this);
+  this.direction = Direction.NONE;
+};
+
+/* --- *
+ * S c a l e   C o n s t r a i n t
+ * --- */
+
+/**
+ * Relates two variables by the linear scaling relationship: "v2 =
+ * (v1 * scale) + offset". Either v1 or v2 may be changed to maintain
+ * this relationship but the scale factor and offset are considered
+ * read-only.
+ */
+function ScaleConstraint(src, scale, offset, dest, strength) {
+  this.direction = Direction.NONE;
+  this.scale = scale;
+  this.offset = offset;
+  ScaleConstraint.superConstructor.call(this, src, dest, strength);
+};
+
+ScaleConstraint.inheritsFrom(BinaryConstraint);
+
+/**
+ * Adds this constraint to the constraint graph.
+ */
+ScaleConstraint.prototype.addToGraph = function () {
+  ScaleConstraint.superConstructor.prototype.addToGraph.call(this);
+  this.scale.addConstraint(this);
+  this.offset.addConstraint(this);
+};
+
+ScaleConstraint.prototype.removeFromGraph = function () {
+  ScaleConstraint.superConstructor.prototype.removeFromGraph.call(this);
+  if (this.scale != null) this.scale.removeConstraint(this);
+  if (this.offset != null) this.offset.removeConstraint(this);
+};
+
+ScaleConstraint.prototype.markInputs = function (mark) {
+  ScaleConstraint.superConstructor.prototype.markInputs.call(this, mark);
+  this.scale.mark = this.offset.mark = mark;
+};
+
+/**
+ * Enforce this constraint. Assume that it is satisfied.
+ */
+ScaleConstraint.prototype.execute = function () {
+  if (this.direction == Direction.FORWARD) {
+    this.v2.value = this.v1.value * this.scale.value + this.offset.value;
+  } else {
+    this.v1.value = (this.v2.value - this.offset.value) / this.scale.value;
+  }
+}
+
+/**
+ * Calculate the walkabout strength, the stay flag, and, if it is
+ * 'stay', the value for the current output of this constraint. Assume
+ * this constraint is satisfied.
+ */
+ScaleConstraint.prototype.recalculate = function () {
+  var ihn = this.input(), out = this.output();
+  out.walkStrength = Strength.weakestOf(this.strength, ihn.walkStrength);
+  out.stay = ihn.stay && this.scale.stay && this.offset.stay;
+  if (out.stay) this.execute();
+}
+
+/* --- *
+ * E q u a l i t  y   C o n s t r a i n t
+ * --- */
+
+/**
+ * Constrains two variables to have the same value.
+ */
+function EqualityConstraint(var1, var2, strength) {
+  EqualityConstraint.superConstructor.call(this, var1, var2, strength);
+}
+
+EqualityConstraint.inheritsFrom(BinaryConstraint);
+
+/**
+ * Enforce this constraint. Assume that it is satisfied.
+ */
+EqualityConstraint.prototype.execute = function () {
+  this.output().value = this.input().value;
+}
+
+/* --- *
+ * V a r i a b l e
+ * --- */
+
+/**
+ * A constrained variable. In addition to its value, it maintain the
+ * structure of the constraint graph, the current dataflow graph, and
+ * various parameters of interest to the DeltaBlue incremental
+ * constraint solver.
+ **/
+function Variable(name, initialValue) {
+  this.value = initialValue || 0;
+  this.constraints = new OrderedCollection();
+  this.determinedBy = null;
+  this.mark = 0;
+  this.walkStrength = Strength.WEAKEST;
+  this.stay = true;
+  this.name = name;
+}
+
+/**
+ * Add the given constraint to the set of all constraints that refer
+ * this variable.
+ */
+Variable.prototype.addConstraint = function (c) {
+  this.constraints.add(c);
+}
+
+/**
+ * Removes all traces of c from this variable.
+ */
+Variable.prototype.removeConstraint = function (c) {
+  this.constraints.remove(c);
+  if (this.determinedBy == c) this.determinedBy = null;
+}
+
+/* --- *
+ * P l a n n e r
+ * --- */
+
+/**
+ * The DeltaBlue planner
+ */
+function Planner() {
+  this.currentMark = 0;
+}
+
+/**
+ * Attempt to satisfy the given constraint and, if successful,
+ * incrementally update the dataflow graph.  Details: If satifying
+ * the constraint is successful, it may override a weaker constraint
+ * on its output. The algorithm attempts to resatisfy that
+ * constraint using some other method. This process is repeated
+ * until either a) it reaches a variable that was not previously
+ * determined by any constraint or b) it reaches a constraint that
+ * is too weak to be satisfied using any of its methods. The
+ * variables of constraints that have been processed are marked with
+ * a unique mark value so that we know where we've been. This allows
+ * the algorithm to avoid getting into an infinite loop even if the
+ * constraint graph has an inadvertent cycle.
+ */
+Planner.prototype.incrementalAdd = function (c) {
+  var mark = this.newMark();
+  var overridden = c.satisfy(mark);
+  while (overridden != null)
+    overridden = overridden.satisfy(mark);
+}
+
+/**
+ * Entry point for retracting a constraint. Remove the given
+ * constraint and incrementally update the dataflow graph.
+ * Details: Retracting the given constraint may allow some currently
+ * unsatisfiable downstream constraint to be satisfied. We therefore collect
+ * a list of unsatisfied downstream constraints and attempt to
+ * satisfy each one in turn. This list is traversed by constraint
+ * strength, strongest first, as a heuristic for avoiding
+ * unnecessarily adding and then overriding weak constraints.
+ * Assume: c is satisfied.
+ */
+Planner.prototype.incrementalRemove = function (c) {
+  var out = c.output();
+  c.markUnsatisfied();
+  c.removeFromGraph();
+  var unsatisfied = this.removePropagateFrom(out);
+  var strength = Strength.REQUIRED;
+  do {
+    for (var i = 0; i < unsatisfied.size(); i++) {
+      var u = unsatisfied.at(i);
+      if (u.strength == strength)
+        this.incrementalAdd(u);
+    }
+    strength = strength.nextWeaker();
+  } while (strength != Strength.WEAKEST);
+}
+
+/**
+ * Select a previously unused mark value.
+ */
+Planner.prototype.newMark = function () {
+  return ++this.currentMark;
+}
+
+/**
+ * Extract a plan for resatisfaction starting from the given source
+ * constraints, usually a set of input constraints. This method
+ * assumes that stay optimization is desired; the plan will contain
+ * only constraints whose output variables are not stay. Constraints
+ * that do no computation, such as stay and edit constraints, are
+ * not included in the plan.
+ * Details: The outputs of a constraint are marked when it is added
+ * to the plan under construction. A constraint may be appended to
+ * the plan when all its input variables are known. A variable is
+ * known if either a) the variable is marked (indicating that has
+ * been computed by a constraint appearing earlier in the plan), b)
+ * the variable is 'stay' (i.e. it is a constant at plan execution
+ * time), or c) the variable is not determined by any
+ * constraint. The last provision is for past states of history
+ * variables, which are not stay but which are also not computed by
+ * any constraint.
+ * Assume: sources are all satisfied.
+ */
+Planner.prototype.makePlan = function (sources) {
+  var mark = this.newMark();
+  var plan = new Plan();
+  var todo = sources;
+  while (todo.size() > 0) {
+    var c = todo.removeFirst();
+    if (c.output().mark != mark && c.inputsKnown(mark)) {
+      plan.addConstraint(c);
+      c.output().mark = mark;
+      this.addConstraintsConsumingTo(c.output(), todo);
+    }
+  }
+  return plan;
+}
+
+/**
+ * Extract a plan for resatisfying starting from the output of the
+ * given constraints, usually a set of input constraints.
+ */
+Planner.prototype.extractPlanFromConstraints = function (constraints) {
+  var sources = new OrderedCollection();
+  for (var i = 0; i < constraints.size(); i++) {
+    var c = constraints.at(i);
+    if (c.isInput() && c.isSatisfied())
+      // not in plan already and eligible for inclusion
+      sources.add(c);
+  }
+  return this.makePlan(sources);
+}
+
+/**
+ * Recompute the walkabout strengths and stay flags of all variables
+ * downstream of the given constraint and recompute the actual
+ * values of all variables whose stay flag is true. If a cycle is
+ * detected, remove the given constraint and answer
+ * false. Otherwise, answer true.
+ * Details: Cycles are detected when a marked variable is
+ * encountered downstream of the given constraint. The sender is
+ * assumed to have marked the inputs of the given constraint with
+ * the given mark. Thus, encountering a marked node downstream of
+ * the output constraint means that there is a path from the
+ * constraint's output to one of its inputs.
+ */
+Planner.prototype.addPropagate = function (c, mark) {
+  var todo = new OrderedCollection();
+  todo.add(c);
+  while (todo.size() > 0) {
+    var d = todo.removeFirst();
+    if (d.output().mark == mark) {
+      this.incrementalRemove(c);
+      return false;
+    }
+    d.recalculate();
+    this.addConstraintsConsumingTo(d.output(), todo);
+  }
+  return true;
+}
+
+
+/**
+ * Update the walkabout strengths and stay flags of all variables
+ * downstream of the given constraint. Answer a collection of
+ * unsatisfied constraints sorted in order of decreasing strength.
+ */
+Planner.prototype.removePropagateFrom = function (out) {
+  out.determinedBy = null;
+  out.walkStrength = Strength.WEAKEST;
+  out.stay = true;
+  var unsatisfied = new OrderedCollection();
+  var todo = new OrderedCollection();
+  todo.add(out);
+  while (todo.size() > 0) {
+    var v = todo.removeFirst();
+    for (var i = 0; i < v.constraints.size(); i++) {
+      var c = v.constraints.at(i);
+      if (!c.isSatisfied())
+        unsatisfied.add(c);
+    }
+    var determining = v.determinedBy;
+    for (var i = 0; i < v.constraints.size(); i++) {
+      var next = v.constraints.at(i);
+      if (next != determining && next.isSatisfied()) {
+        next.recalculate();
+        todo.add(next.output());
+      }
+    }
+  }
+  return unsatisfied;
+}
+
+Planner.prototype.addConstraintsConsumingTo = function (v, coll) {
+  var determining = v.determinedBy;
+  var cc = v.constraints;
+  for (var i = 0; i < cc.size(); i++) {
+    var c = cc.at(i);
+    if (c != determining && c.isSatisfied())
+      coll.add(c);
+  }
+}
+
+/* --- *
+ * P l a n
+ * --- */
+
+/**
+ * A Plan is an ordered list of constraints to be executed in sequence
+ * to resatisfy all currently satisfiable constraints in the face of
+ * one or more changing inputs.
+ */
+function Plan() {
+  this.v = new OrderedCollection();
+}
+
+Plan.prototype.addConstraint = function (c) {
+  this.v.add(c);
+}
+
+Plan.prototype.size = function () {
+  return this.v.size();
+}
+
+Plan.prototype.constraintAt = function (index) {
+  return this.v.at(index);
+}
+
+Plan.prototype.execute = function () {
+  for (var i = 0; i < this.size(); i++) {
+    var c = this.constraintAt(i);
+    c.execute();
+  }
+}
+
+/* --- *
+ * M a i n
+ * --- */
+
+/**
+ * This is the standard DeltaBlue benchmark. A long chain of equality
+ * constraints is constructed with a stay constraint on one end. An
+ * edit constraint is then added to the opposite end and the time is
+ * measured for adding and removing this constraint, and extracting
+ * and executing a constraint satisfaction plan. There are two cases.
+ * In case 1, the added constraint is stronger than the stay
+ * constraint and values must propagate down the entire length of the
+ * chain. In case 2, the added constraint is weaker than the stay
+ * constraint so it cannot be accomodated. The cost in this case is,
+ * of course, very low. Typical situations lie somewhere between these
+ * two extremes.
+ */
+function chainTest(n) {
+  planner = new Planner();
+  var prev = null, first = null, last = null;
+
+  // Build chain of n equality constraints
+  for (var i = 0; i <= n; i++) {
+    var name = "v" + i;
+    var v = new Variable(name);
+    if (prev != null)
+      new EqualityConstraint(prev, v, Strength.REQUIRED);
+    if (i == 0) first = v;
+    if (i == n) last = v;
+    prev = v;
+  }
+
+  new StayConstraint(last, Strength.STRONG_DEFAULT);
+  var edit = new EditConstraint(first, Strength.PREFERRED);
+  var edits = new OrderedCollection();
+  edits.add(edit);
+  var plan = planner.extractPlanFromConstraints(edits);
+  for (var i = 0; i < 100; i++) {
+    first.value = i;
+    plan.execute();
+    if (last.value != i)
+      alert("Chain test failed.");
+  }
+}
+
+/**
+ * This test constructs a two sets of variables related to each
+ * other by a simple linear transformation (scale and offset). The
+ * time is measured to change a variable on either side of the
+ * mapping and to change the scale and offset factors.
+ */
+function projectionTest(n) {
+  planner = new Planner();
+  var scale = new Variable("scale", 10);
+  var offset = new Variable("offset", 1000);
+  var src = null, dst = null;
+
+  var dests = new OrderedCollection();
+  for (var i = 0; i < n; i++) {
+    src = new Variable("src" + i, i);
+    dst = new Variable("dst" + i, i);
+    dests.add(dst);
+    new StayConstraint(src, Strength.NORMAL);
+    new ScaleConstraint(src, scale, offset, dst, Strength.REQUIRED);
+  }
+
+  change(src, 17);
+  if (dst.value != 1170) alert("Projection 1 failed");
+  change(dst, 1050);
+  if (src.value != 5) alert("Projection 2 failed");
+  change(scale, 5);
+  for (var i = 0; i < n - 1; i++) {
+    if (dests.at(i).value != i * 5 + 1000)
+      alert("Projection 3 failed");
+  }
+  change(offset, 2000);
+  for (var i = 0; i < n - 1; i++) {
+    if (dests.at(i).value != i * 5 + 2000)
+      alert("Projection 4 failed");
+  }
+}
+
+function change(v, newValue) {
+  var edit = new EditConstraint(v, Strength.PREFERRED);
+  var edits = new OrderedCollection();
+  edits.add(edit);
+  var plan = planner.extractPlanFromConstraints(edits);
+  for (var i = 0; i < 10; i++) {
+    v.value = newValue;
+    plan.execute();
+  }
+  edit.destroyConstraint();
+}
+
+// Global variable holding the current planner.
+var planner = null;
+
+function deltaBlue() {
+  chainTest(100);
+  projectionTest(100);
+}
+
+var DeltaBlue = new BenchmarkSuite('DeltaBlue', 66118, [
+  new Benchmark('DeltaBlue', deltaBlue)
+]);

oden-js-sys/quickjs/tests/bench-v8/navier-stokes.js

@@ -0,0 +1,388 @@
+/**
+ * Copyright 2012 the V8 project authors. All rights reserved.
+ * Copyright 2009 Oliver Hunt <http://nerget.com>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+var solver = null;
+
+function runNavierStokes()
+{
+    solver.update();
+}
+
+function setupNavierStokes()
+{
+    solver = new FluidField(null);
+    solver.setResolution(128, 128);
+    solver.setIterations(20);
+    solver.setDisplayFunction(function(){});
+    solver.setUICallback(prepareFrame);
+    solver.reset();
+}
+
+function tearDownNavierStokes()
+{
+    solver = null;
+}
+
+function addPoints(field) {
+    var n = 64;
+    for (var i = 1; i <= n; i++) {
+        field.setVelocity(i, i, n, n);
+        field.setDensity(i, i, 5);
+        field.setVelocity(i, n - i, -n, -n);
+        field.setDensity(i, n - i, 20);
+        field.setVelocity(128 - i, n + i, -n, -n);
+        field.setDensity(128 - i, n + i, 30);
+    }
+}
+
+var framesTillAddingPoints = 0;
+var framesBetweenAddingPoints = 5;
+
+function prepareFrame(field)
+{
+    if (framesTillAddingPoints == 0) {
+        addPoints(field);
+        framesTillAddingPoints = framesBetweenAddingPoints;
+        framesBetweenAddingPoints++;
+    } else {
+        framesTillAddingPoints--;
+    }
+}
+
+// Code from Oliver Hunt (http://nerget.com/fluidSim/pressure.js) starts here.
+function FluidField(canvas) {
+    function addFields(x, s, dt)
+    {
+        for (var i=0; i<size ; i++ ) x[i] += dt*s[i];
+    }
+
+    function set_bnd(b, x)
+    {
+        if (b===1) {
+            for (var i = 1; i <= width; i++) {
+                x[i] =  x[i + rowSize];
+                x[i + (height+1) *rowSize] = x[i + height * rowSize];
+            }
+
+            for (var j = 1; i <= height; i++) {
+                x[j * rowSize] = -x[1 + j * rowSize];
+                x[(width + 1) + j * rowSize] = -x[width + j * rowSize];
+            }
+        } else if (b === 2) {
+            for (var i = 1; i <= width; i++) {
+                x[i] = -x[i + rowSize];
+                x[i + (height + 1) * rowSize] = -x[i + height * rowSize];
+            }
+
+            for (var j = 1; j <= height; j++) {
+                x[j * rowSize] =  x[1 + j * rowSize];
+                x[(width + 1) + j * rowSize] =  x[width + j * rowSize];
+            }
+        } else {
+            for (var i = 1; i <= width; i++) {
+                x[i] =  x[i + rowSize];
+                x[i + (height + 1) * rowSize] = x[i + height * rowSize];
+            }
+
+            for (var j = 1; j <= height; j++) {
+                x[j * rowSize] =  x[1 + j * rowSize];
+                x[(width + 1) + j * rowSize] =  x[width + j * rowSize];
+            }
+        }
+        var maxEdge = (height + 1) * rowSize;
+        x[0]                 = 0.5 * (x[1] + x[rowSize]);
+        x[maxEdge]           = 0.5 * (x[1 + maxEdge] + x[height * rowSize]);
+        x[(width+1)]         = 0.5 * (x[width] + x[(width + 1) + rowSize]);
+        x[(width+1)+maxEdge] = 0.5 * (x[width + maxEdge] + x[(width + 1) + height * rowSize]);
+    }
+
+    function lin_solve(b, x, x0, a, c)
+    {
+        if (a === 0 && c === 1) {
+            for (var j=1 ; j<=height; j++) {
+                var currentRow = j * rowSize;
+                ++currentRow;
+                for (var i = 0; i < width; i++) {
+                    x[currentRow] = x0[currentRow];
+                    ++currentRow;
+                }
+            }
+            set_bnd(b, x);
+        } else {
+            var invC = 1 / c;
+            for (var k=0 ; k<iterations; k++) {
+                for (var j=1 ; j<=height; j++) {
+                    var lastRow = (j - 1) * rowSize;
+                    var currentRow = j * rowSize;
+                    var nextRow = (j + 1) * rowSize;
+                    var lastX = x[currentRow];
+                    ++currentRow;
+                    for (var i=1; i<=width; i++)
+                        lastX = x[currentRow] = (x0[currentRow] + a*(lastX+x[++currentRow]+x[++lastRow]+x[++nextRow])) * invC;
+                }
+                set_bnd(b, x);
+            }
+        }
+    }
+
+    function diffuse(b, x, x0, dt)
+    {
+        var a = 0;
+        lin_solve(b, x, x0, a, 1 + 4*a);
+    }
+
+    function lin_solve2(x, x0, y, y0, a, c)
+    {
+        if (a === 0 && c === 1) {
+            for (var j=1 ; j <= height; j++) {
+                var currentRow = j * rowSize;
+                ++currentRow;
+                for (var i = 0; i < width; i++) {
+                    x[currentRow] = x0[currentRow];
+                    y[currentRow] = y0[currentRow];
+                    ++currentRow;
+                }
+            }
+            set_bnd(1, x);
+            set_bnd(2, y);
+        } else {
+            var invC = 1/c;
+            for (var k=0 ; k<iterations; k++) {
+                for (var j=1 ; j <= height; j++) {
+                    var lastRow = (j - 1) * rowSize;
+                    var currentRow = j * rowSize;
+                    var nextRow = (j + 1) * rowSize;
+                    var lastX = x[currentRow];
+                    var lastY = y[currentRow];
+                    ++currentRow;
+                    for (var i = 1; i <= width; i++) {
+                        lastX = x[currentRow] = (x0[currentRow] + a * (lastX + x[currentRow] + x[lastRow] + x[nextRow])) * invC;
+                        lastY = y[currentRow] = (y0[currentRow] + a * (lastY + y[++currentRow] + y[++lastRow] + y[++nextRow])) * invC;
+                    }
+                }
+                set_bnd(1, x);
+                set_bnd(2, y);
+            }
+        }
+    }
+
+    function diffuse2(x, x0, y, y0, dt)
+    {
+        var a = 0;
+        lin_solve2(x, x0, y, y0, a, 1 + 4 * a);
+    }
+
+    function advect(b, d, d0, u, v, dt)
+    {
+        var Wdt0 = dt * width;
+        var Hdt0 = dt * height;
+        var Wp5 = width + 0.5;
+        var Hp5 = height + 0.5;
+        for (var j = 1; j<= height; j++) {
+            var pos = j * rowSize;
+            for (var i = 1; i <= width; i++) {
+                var x = i - Wdt0 * u[++pos];
+                var y = j - Hdt0 * v[pos];
+                if (x < 0.5)
+                    x = 0.5;
+                else if (x > Wp5)
+                    x = Wp5;
+                var i0 = x | 0;
+                var i1 = i0 + 1;
+                if (y < 0.5)
+                    y = 0.5;
+                else if (y > Hp5)
+                    y = Hp5;
+                var j0 = y | 0;
+                var j1 = j0 + 1;
+                var s1 = x - i0;
+                var s0 = 1 - s1;
+                var t1 = y - j0;
+                var t0 = 1 - t1;
+                var row1 = j0 * rowSize;
+                var row2 = j1 * rowSize;
+                d[pos] = s0 * (t0 * d0[i0 + row1] + t1 * d0[i0 + row2]) + s1 * (t0 * d0[i1 + row1] + t1 * d0[i1 + row2]);
+            }
+        }
+        set_bnd(b, d);
+    }
+
+    function project(u, v, p, div)
+    {
+        var h = -0.5 / Math.sqrt(width * height);
+        for (var j = 1 ; j <= height; j++ ) {
+            var row = j * rowSize;
+            var previousRow = (j - 1) * rowSize;
+            var prevValue = row - 1;
+            var currentRow = row;
+            var nextValue = row + 1;
+            var nextRow = (j + 1) * rowSize;
+            for (var i = 1; i <= width; i++ ) {
+                div[++currentRow] = h * (u[++nextValue] - u[++prevValue] + v[++nextRow] - v[++previousRow]);
+                p[currentRow] = 0;
+            }
+        }
+        set_bnd(0, div);
+        set_bnd(0, p);
+
+        lin_solve(0, p, div, 1, 4 );
+        var wScale = 0.5 * width;
+        var hScale = 0.5 * height;
+        for (var j = 1; j<= height; j++ ) {
+            var prevPos = j * rowSize - 1;
+            var currentPos = j * rowSize;
+            var nextPos = j * rowSize + 1;
+            var prevRow = (j - 1) * rowSize;
+            var currentRow = j * rowSize;
+            var nextRow = (j + 1) * rowSize;
+
+            for (var i = 1; i<= width; i++) {
+                u[++currentPos] -= wScale * (p[++nextPos] - p[++prevPos]);
+                v[currentPos]   -= hScale * (p[++nextRow] - p[++prevRow]);
+            }
+        }
+        set_bnd(1, u);
+        set_bnd(2, v);
+    }
+
+    function dens_step(x, x0, u, v, dt)
+    {
+        addFields(x, x0, dt);
+        diffuse(0, x0, x, dt );
+        advect(0, x, x0, u, v, dt );
+    }
+
+    function vel_step(u, v, u0, v0, dt)
+    {
+        addFields(u, u0, dt );
+        addFields(v, v0, dt );
+        var temp = u0; u0 = u; u = temp;
+        var temp = v0; v0 = v; v = temp;
+        diffuse2(u,u0,v,v0, dt);
+        project(u, v, u0, v0);
+        var temp = u0; u0 = u; u = temp;
+        var temp = v0; v0 = v; v = temp;
+        advect(1, u, u0, u0, v0, dt);
+        advect(2, v, v0, u0, v0, dt);
+        project(u, v, u0, v0 );
+    }
+    var uiCallback = function(d,u,v) {};
+
+    function Field(dens, u, v) {
+        // Just exposing the fields here rather than using accessors is a measurable win during display (maybe 5%)
+        // but makes the code ugly.
+        this.setDensity = function(x, y, d) {
+             dens[(x + 1) + (y + 1) * rowSize] = d;
+        }
+        this.getDensity = function(x, y) {
+             return dens[(x + 1) + (y + 1) * rowSize];
+        }
+        this.setVelocity = function(x, y, xv, yv) {
+             u[(x + 1) + (y + 1) * rowSize] = xv;
+             v[(x + 1) + (y + 1) * rowSize] = yv;
+        }
+        this.getXVelocity = function(x, y) {
+             return u[(x + 1) + (y + 1) * rowSize];
+        }
+        this.getYVelocity = function(x, y) {
+             return v[(x + 1) + (y + 1) * rowSize];
+        }
+        this.width = function() { return width; }
+        this.height = function() { return height; }
+    }
+    function queryUI(d, u, v)
+    {
+        for (var i = 0; i < size; i++)
+            u[i] = v[i] = d[i] = 0.0;
+        uiCallback(new Field(d, u, v));
+    }
+
+    this.update = function () {
+        queryUI(dens_prev, u_prev, v_prev);
+        vel_step(u, v, u_prev, v_prev, dt);
+        dens_step(dens, dens_prev, u, v, dt);
+        displayFunc(new Field(dens, u, v));
+    }
+    this.setDisplayFunction = function(func) {
+        displayFunc = func;
+    }
+
+    this.iterations = function() { return iterations; }
+    this.setIterations = function(iters) {
+        if (iters > 0 && iters <= 100)
+           iterations = iters;
+    }
+    this.setUICallback = function(callback) {
+        uiCallback = callback;
+    }
+    var iterations = 10;
+    var visc = 0.5;
+    var dt = 0.1;
+    var dens;
+    var dens_prev;
+    var u;
+    var u_prev;
+    var v;
+    var v_prev;
+    var width;
+    var height;
+    var rowSize;
+    var size;
+    var displayFunc;
+    function reset()
+    {
+        rowSize = width + 2;
+        size = (width+2)*(height+2);
+        dens = new Array(size);
+        dens_prev = new Array(size);
+        u = new Array(size);
+        u_prev = new Array(size);
+        v = new Array(size);
+        v_prev = new Array(size);
+        for (var i = 0; i < size; i++)
+            dens_prev[i] = u_prev[i] = v_prev[i] = dens[i] = u[i] = v[i] = 0;
+    }
+    this.reset = reset;
+    this.setResolution = function (hRes, wRes)
+    {
+        var res = wRes * hRes;
+        if (res > 0 && res < 1000000 && (wRes != width || hRes != height)) {
+            width = wRes;
+            height = hRes;
+            reset();
+            return true;
+        }
+        return false;
+    }
+    this.setResolution(64, 64);
+}
+
+var NavierStokes = new BenchmarkSuite('NavierStokes', 1484000,
+                                      [new Benchmark('NavierStokes',
+                                                     runNavierStokes,
+                                                     setupNavierStokes,
+                                                     tearDownNavierStokes)]);
+

oden-js-sys/quickjs/tests/bench-v8/raytrace.js

@@ -0,0 +1,904 @@
+// The ray tracer code in this file is written by Adam Burmister. It
+// is available in its original form from:
+//
+//   http://labs.flog.nz.co/raytracer/
+//
+// It has been modified slightly by Google to work as a standalone
+// benchmark, but the all the computational code remains
+// untouched. This file also contains a copy of parts of the Prototype
+// JavaScript framework which is used by the ray tracer.
+
+// Variable used to hold a number that can be used to verify that
+// the scene was ray traced correctly.
+var checkNumber;
+
+
+// ------------------------------------------------------------------------
+// ------------------------------------------------------------------------
+
+// The following is a copy of parts of the Prototype JavaScript library:
+
+// Prototype JavaScript framework, version 1.5.0
+// (c) 2005-2007 Sam Stephenson
+//
+// Prototype is freely distributable under the terms of an MIT-style license.
+// For details, see the Prototype web site: http://prototype.conio.net/
+
+var Class = {
+  create: function() {
+    return function() {
+      this.initialize.apply(this, arguments);
+    }
+  }
+};
+
+
+Object.extend = function(destination, source) {
+  for (var property in source) {
+    destination[property] = source[property];
+  }
+  return destination;
+};
+
+
+// ------------------------------------------------------------------------
+// ------------------------------------------------------------------------
+
+// The rest of this file is the actual ray tracer written by Adam
+// Burmister. It's a concatenation of the following files:
+//
+//   flog/color.js
+//   flog/light.js
+//   flog/vector.js
+//   flog/ray.js
+//   flog/scene.js
+//   flog/material/basematerial.js
+//   flog/material/solid.js
+//   flog/material/chessboard.js
+//   flog/shape/baseshape.js
+//   flog/shape/sphere.js
+//   flog/shape/plane.js
+//   flog/intersectioninfo.js
+//   flog/camera.js
+//   flog/background.js
+//   flog/engine.js
+
+
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Color = Class.create();
+
+Flog.RayTracer.Color.prototype = {
+    red : 0.0,
+    green : 0.0,
+    blue : 0.0,
+
+    initialize : function(r, g, b) {
+        if(!r) r = 0.0;
+        if(!g) g = 0.0;
+        if(!b) b = 0.0;
+
+        this.red = r;
+        this.green = g;
+        this.blue = b;
+    },
+
+    add : function(c1, c2){
+        var result = new Flog.RayTracer.Color(0,0,0);
+
+        result.red = c1.red + c2.red;
+        result.green = c1.green + c2.green;
+        result.blue = c1.blue + c2.blue;
+
+        return result;
+    },
+
+    addScalar: function(c1, s){
+        var result = new Flog.RayTracer.Color(0,0,0);
+
+        result.red = c1.red + s;
+        result.green = c1.green + s;
+        result.blue = c1.blue + s;
+
+        result.limit();
+
+        return result;
+    },
+
+    subtract: function(c1, c2){
+        var result = new Flog.RayTracer.Color(0,0,0);
+
+        result.red = c1.red - c2.red;
+        result.green = c1.green - c2.green;
+        result.blue = c1.blue - c2.blue;
+
+        return result;
+    },
+
+    multiply : function(c1, c2) {
+        var result = new Flog.RayTracer.Color(0,0,0);
+
+        result.red = c1.red * c2.red;
+        result.green = c1.green * c2.green;
+        result.blue = c1.blue * c2.blue;
+
+        return result;
+    },
+
+    multiplyScalar : function(c1, f) {
+        var result = new Flog.RayTracer.Color(0,0,0);
+
+        result.red = c1.red * f;
+        result.green = c1.green * f;
+        result.blue = c1.blue * f;
+
+        return result;
+    },
+
+    divideFactor : function(c1, f) {
+        var result = new Flog.RayTracer.Color(0,0,0);
+
+        result.red = c1.red / f;
+        result.green = c1.green / f;
+        result.blue = c1.blue / f;
+
+        return result;
+    },
+
+    limit: function(){
+        this.red = (this.red > 0.0) ? ( (this.red > 1.0) ? 1.0 : this.red ) : 0.0;
+        this.green = (this.green > 0.0) ? ( (this.green > 1.0) ? 1.0 : this.green ) : 0.0;
+        this.blue = (this.blue > 0.0) ? ( (this.blue > 1.0) ? 1.0 : this.blue ) : 0.0;
+    },
+
+    distance : function(color) {
+        var d = Math.abs(this.red - color.red) + Math.abs(this.green - color.green) + Math.abs(this.blue - color.blue);
+        return d;
+    },
+
+    blend: function(c1, c2, w){
+        var result = new Flog.RayTracer.Color(0,0,0);
+        result = Flog.RayTracer.Color.prototype.add(
+                    Flog.RayTracer.Color.prototype.multiplyScalar(c1, 1 - w),
+                    Flog.RayTracer.Color.prototype.multiplyScalar(c2, w)
+                  );
+        return result;
+    },
+
+    brightness : function() {
+        var r = Math.floor(this.red*255);
+        var g = Math.floor(this.green*255);
+        var b = Math.floor(this.blue*255);
+        return (r * 77 + g * 150 + b * 29) >> 8;
+    },
+
+    toString : function () {
+        var r = Math.floor(this.red*255);
+        var g = Math.floor(this.green*255);
+        var b = Math.floor(this.blue*255);
+
+        return "rgb("+ r +","+ g +","+ b +")";
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Light = Class.create();
+
+Flog.RayTracer.Light.prototype = {
+    position: null,
+    color: null,
+    intensity: 10.0,
+
+    initialize : function(pos, color, intensity) {
+        this.position = pos;
+        this.color = color;
+        this.intensity = (intensity ? intensity : 10.0);
+    },
+
+    toString : function () {
+        return 'Light [' + this.position.x + ',' + this.position.y + ',' + this.position.z + ']';
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Vector = Class.create();
+
+Flog.RayTracer.Vector.prototype = {
+    x : 0.0,
+    y : 0.0,
+    z : 0.0,
+
+    initialize : function(x, y, z) {
+        this.x = (x ? x : 0);
+        this.y = (y ? y : 0);
+        this.z = (z ? z : 0);
+    },
+
+    copy: function(vector){
+        this.x = vector.x;
+        this.y = vector.y;
+        this.z = vector.z;
+    },
+
+    normalize : function() {
+        var m = this.magnitude();
+        return new Flog.RayTracer.Vector(this.x / m, this.y / m, this.z / m);
+    },
+
+    magnitude : function() {
+        return Math.sqrt((this.x * this.x) + (this.y * this.y) + (this.z * this.z));
+    },
+
+    cross : function(w) {
+        return new Flog.RayTracer.Vector(
+                                            -this.z * w.y + this.y * w.z,
+                                           this.z * w.x - this.x * w.z,
+                                          -this.y * w.x + this.x * w.y);
+    },
+
+    dot : function(w) {
+        return this.x * w.x + this.y * w.y + this.z * w.z;
+    },
+
+    add : function(v, w) {
+        return new Flog.RayTracer.Vector(w.x + v.x, w.y + v.y, w.z + v.z);
+    },
+
+    subtract : function(v, w) {
+        if(!w || !v) throw 'Vectors must be defined [' + v + ',' + w + ']';
+        return new Flog.RayTracer.Vector(v.x - w.x, v.y - w.y, v.z - w.z);
+    },
+
+    multiplyVector : function(v, w) {
+        return new Flog.RayTracer.Vector(v.x * w.x, v.y * w.y, v.z * w.z);
+    },
+
+    multiplyScalar : function(v, w) {
+        return new Flog.RayTracer.Vector(v.x * w, v.y * w, v.z * w);
+    },
+
+    toString : function () {
+        return 'Vector [' + this.x + ',' + this.y + ',' + this.z + ']';
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Ray = Class.create();
+
+Flog.RayTracer.Ray.prototype = {
+    position : null,
+    direction : null,
+    initialize : function(pos, dir) {
+        this.position = pos;
+        this.direction = dir;
+    },
+
+    toString : function () {
+        return 'Ray [' + this.position + ',' + this.direction + ']';
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Scene = Class.create();
+
+Flog.RayTracer.Scene.prototype = {
+    camera : null,
+    shapes : [],
+    lights : [],
+    background : null,
+
+    initialize : function() {
+        this.camera = new Flog.RayTracer.Camera(
+            new Flog.RayTracer.Vector(0,0,-5),
+            new Flog.RayTracer.Vector(0,0,1),
+            new Flog.RayTracer.Vector(0,1,0)
+        );
+        this.shapes = new Array();
+        this.lights = new Array();
+        this.background = new Flog.RayTracer.Background(new Flog.RayTracer.Color(0,0,0.5), 0.2);
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+if(typeof(Flog.RayTracer.Material) == 'undefined') Flog.RayTracer.Material = {};
+
+Flog.RayTracer.Material.BaseMaterial = Class.create();
+
+Flog.RayTracer.Material.BaseMaterial.prototype = {
+
+    gloss: 2.0,             // [0...infinity] 0 = matt
+    transparency: 0.0,      // 0=opaque
+    reflection: 0.0,        // [0...infinity] 0 = no reflection
+    refraction: 0.50,
+    hasTexture: false,
+
+    initialize : function() {
+
+    },
+
+    getColor: function(u, v){
+
+    },
+
+    wrapUp: function(t){
+        t = t % 2.0;
+        if(t < -1) t += 2.0;
+        if(t >= 1) t -= 2.0;
+        return t;
+    },
+
+    toString : function () {
+        return 'Material [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Material.Solid = Class.create();
+
+Flog.RayTracer.Material.Solid.prototype = Object.extend(
+    new Flog.RayTracer.Material.BaseMaterial(), {
+        initialize : function(color, reflection, refraction, transparency, gloss) {
+            this.color = color;
+            this.reflection = reflection;
+            this.transparency = transparency;
+            this.gloss = gloss;
+            this.hasTexture = false;
+        },
+
+        getColor: function(u, v){
+            return this.color;
+        },
+
+        toString : function () {
+            return 'SolidMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';
+        }
+    }
+);
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Material.Chessboard = Class.create();
+
+Flog.RayTracer.Material.Chessboard.prototype = Object.extend(
+    new Flog.RayTracer.Material.BaseMaterial(), {
+        colorEven: null,
+        colorOdd: null,
+        density: 0.5,
+
+        initialize : function(colorEven, colorOdd, reflection, transparency, gloss, density) {
+            this.colorEven = colorEven;
+            this.colorOdd = colorOdd;
+            this.reflection = reflection;
+            this.transparency = transparency;
+            this.gloss = gloss;
+            this.density = density;
+            this.hasTexture = true;
+        },
+
+        getColor: function(u, v){
+            var t = this.wrapUp(u * this.density) * this.wrapUp(v * this.density);
+
+            if(t < 0.0)
+                return this.colorEven;
+            else
+                return this.colorOdd;
+        },
+
+        toString : function () {
+            return 'ChessMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';
+        }
+    }
+);
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+if(typeof(Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};
+
+Flog.RayTracer.Shape.Sphere = Class.create();
+
+Flog.RayTracer.Shape.Sphere.prototype = {
+    initialize : function(pos, radius, material) {
+        this.radius = radius;
+        this.position = pos;
+        this.material = material;
+    },
+
+    intersect: function(ray){
+        var info = new Flog.RayTracer.IntersectionInfo();
+        info.shape = this;
+
+        var dst = Flog.RayTracer.Vector.prototype.subtract(ray.position, this.position);
+
+        var B = dst.dot(ray.direction);
+        var C = dst.dot(dst) - (this.radius * this.radius);
+        var D = (B * B) - C;
+
+        if(D > 0){ // intersection!
+            info.isHit = true;
+            info.distance = (-B) - Math.sqrt(D);
+            info.position = Flog.RayTracer.Vector.prototype.add(
+                                                ray.position,
+                                                Flog.RayTracer.Vector.prototype.multiplyScalar(
+                                                    ray.direction,
+                                                    info.distance
+                                                )
+                                            );
+            info.normal = Flog.RayTracer.Vector.prototype.subtract(
+                                            info.position,
+                                            this.position
+                                        ).normalize();
+
+            info.color = this.material.getColor(0,0);
+        } else {
+            info.isHit = false;
+        }
+        return info;
+    },
+
+    toString : function () {
+        return 'Sphere [position=' + this.position + ', radius=' + this.radius + ']';
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+if(typeof(Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};
+
+Flog.RayTracer.Shape.Plane = Class.create();
+
+Flog.RayTracer.Shape.Plane.prototype = {
+    d: 0.0,
+
+    initialize : function(pos, d, material) {
+        this.position = pos;
+        this.d = d;
+        this.material = material;
+    },
+
+    intersect: function(ray){
+        var info = new Flog.RayTracer.IntersectionInfo();
+
+        var Vd = this.position.dot(ray.direction);
+        if(Vd == 0) return info; // no intersection
+
+        var t = -(this.position.dot(ray.position) + this.d) / Vd;
+        if(t <= 0) return info;
+
+        info.shape = this;
+        info.isHit = true;
+        info.position = Flog.RayTracer.Vector.prototype.add(
+                                            ray.position,
+                                            Flog.RayTracer.Vector.prototype.multiplyScalar(
+                                                ray.direction,
+                                                t
+                                            )
+                                        );
+        info.normal = this.position;
+        info.distance = t;
+
+        if(this.material.hasTexture){
+            var vU = new Flog.RayTracer.Vector(this.position.y, this.position.z, -this.position.x);
+            var vV = vU.cross(this.position);
+            var u = info.position.dot(vU);
+            var v = info.position.dot(vV);
+            info.color = this.material.getColor(u,v);
+        } else {
+            info.color = this.material.getColor(0,0);
+        }
+
+        return info;
+    },
+
+    toString : function () {
+        return 'Plane [' + this.position + ', d=' + this.d + ']';
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.IntersectionInfo = Class.create();
+
+Flog.RayTracer.IntersectionInfo.prototype = {
+    isHit: false,
+    hitCount: 0,
+    shape: null,
+    position: null,
+    normal: null,
+    color: null,
+    distance: null,
+
+    initialize : function() {
+        this.color = new Flog.RayTracer.Color(0,0,0);
+    },
+
+    toString : function () {
+        return 'Intersection [' + this.position + ']';
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Camera = Class.create();
+
+Flog.RayTracer.Camera.prototype = {
+    position: null,
+    lookAt: null,
+    equator: null,
+    up: null,
+    screen: null,
+
+    initialize : function(pos, lookAt, up) {
+        this.position = pos;
+        this.lookAt = lookAt;
+        this.up = up;
+        this.equator = lookAt.normalize().cross(this.up);
+        this.screen = Flog.RayTracer.Vector.prototype.add(this.position, this.lookAt);
+    },
+
+    getRay: function(vx, vy){
+        var pos = Flog.RayTracer.Vector.prototype.subtract(
+            this.screen,
+            Flog.RayTracer.Vector.prototype.subtract(
+                Flog.RayTracer.Vector.prototype.multiplyScalar(this.equator, vx),
+                Flog.RayTracer.Vector.prototype.multiplyScalar(this.up, vy)
+            )
+        );
+        pos.y = pos.y * -1;
+        var dir = Flog.RayTracer.Vector.prototype.subtract(
+            pos,
+            this.position
+        );
+
+        var ray = new Flog.RayTracer.Ray(pos, dir.normalize());
+
+        return ray;
+    },
+
+    toString : function () {
+        return 'Ray []';
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Background = Class.create();
+
+Flog.RayTracer.Background.prototype = {
+    color : null,
+    ambience : 0.0,
+
+    initialize : function(color, ambience) {
+        this.color = color;
+        this.ambience = ambience;
+    }
+}
+/* Fake a Flog.* namespace */
+if(typeof(Flog) == 'undefined') var Flog = {};
+if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
+
+Flog.RayTracer.Engine = Class.create();
+
+Flog.RayTracer.Engine.prototype = {
+    canvas: null, /* 2d context we can render to */
+
+    initialize: function(options){
+        this.options = Object.extend({
+                canvasHeight: 100,
+                canvasWidth: 100,
+                pixelWidth: 2,
+                pixelHeight: 2,
+                renderDiffuse: false,
+                renderShadows: false,
+                renderHighlights: false,
+                renderReflections: false,
+                rayDepth: 2
+            }, options || {});
+
+        this.options.canvasHeight /= this.options.pixelHeight;
+        this.options.canvasWidth /= this.options.pixelWidth;
+
+        /* TODO: dynamically include other scripts */
+    },
+
+    setPixel: function(x, y, color){
+        var pxW, pxH;
+        pxW = this.options.pixelWidth;
+        pxH = this.options.pixelHeight;
+
+        if (this.canvas) {
+          this.canvas.fillStyle = color.toString();
+          this.canvas.fillRect (x * pxW, y * pxH, pxW, pxH);
+        } else {
+          if (x ===  y) {
+            checkNumber += color.brightness();
+          }
+          // print(x * pxW, y * pxH, pxW, pxH);
+        }
+    },
+
+    renderScene: function(scene, canvas){
+        checkNumber = 0;
+        /* Get canvas */
+        if (canvas) {
+          this.canvas = canvas.getContext("2d");
+        } else {
+          this.canvas = null;
+        }
+
+        var canvasHeight = this.options.canvasHeight;
+        var canvasWidth = this.options.canvasWidth;
+
+        for(var y=0; y < canvasHeight; y++){
+            for(var x=0; x < canvasWidth; x++){
+                var yp = y * 1.0 / canvasHeight * 2 - 1;
+          		var xp = x * 1.0 / canvasWidth * 2 - 1;
+
+          		var ray = scene.camera.getRay(xp, yp);
+
+          		var color = this.getPixelColor(ray, scene);
+
+            	this.setPixel(x, y, color);
+            }
+        }
+        if (checkNumber !== 2321) {
+          throw new Error("Scene rendered incorrectly");
+        }
+    },
+
+    getPixelColor: function(ray, scene){
+        var info = this.testIntersection(ray, scene, null);
+        if(info.isHit){
+            var color = this.rayTrace(info, ray, scene, 0);
+            return color;
+        }
+        return scene.background.color;
+    },
+
+    testIntersection: function(ray, scene, exclude){
+        var hits = 0;
+        var best = new Flog.RayTracer.IntersectionInfo();
+        best.distance = 2000;
+
+        for(var i=0; i<scene.shapes.length; i++){
+            var shape = scene.shapes[i];
+
+            if(shape != exclude){
+                var info = shape.intersect(ray);
+                if(info.isHit && info.distance >= 0 && info.distance < best.distance){
+                    best = info;
+                    hits++;
+                }
+            }
+        }
+        best.hitCount = hits;
+        return best;
+    },
+
+    getReflectionRay: function(P,N,V){
+        var c1 = -N.dot(V);
+        var R1 = Flog.RayTracer.Vector.prototype.add(
+            Flog.RayTracer.Vector.prototype.multiplyScalar(N, 2*c1),
+            V
+        );
+        return new Flog.RayTracer.Ray(P, R1);
+    },
+
+    rayTrace: function(info, ray, scene, depth){
+        // Calc ambient
+        var color = Flog.RayTracer.Color.prototype.multiplyScalar(info.color, scene.background.ambience);
+        var oldColor = color;
+        var shininess = Math.pow(10, info.shape.material.gloss + 1);
+
+        for(var i=0; i<scene.lights.length; i++){
+            var light = scene.lights[i];
+
+            // Calc diffuse lighting
+            var v = Flog.RayTracer.Vector.prototype.subtract(
+                                light.position,
+                                info.position
+                            ).normalize();
+
+            if(this.options.renderDiffuse){
+                var L = v.dot(info.normal);
+                if(L > 0.0){
+                    color = Flog.RayTracer.Color.prototype.add(
+                                        color,
+                                        Flog.RayTracer.Color.prototype.multiply(
+                                            info.color,
+                                            Flog.RayTracer.Color.prototype.multiplyScalar(
+                                                light.color,
+                                                L
+                                            )
+                                        )
+                                    );
+                }
+            }
+
+            // The greater the depth the more accurate the colours, but
+            // this is exponentially (!) expensive
+            if(depth <= this.options.rayDepth){
+          // calculate reflection ray
+          if(this.options.renderReflections && info.shape.material.reflection > 0)
+          {
+              var reflectionRay = this.getReflectionRay(info.position, info.normal, ray.direction);
+              var refl = this.testIntersection(reflectionRay, scene, info.shape);
+
+              if (refl.isHit && refl.distance > 0){
+                  refl.color = this.rayTrace(refl, reflectionRay, scene, depth + 1);
+              } else {
+                  refl.color = scene.background.color;
+                        }
+
+                  color = Flog.RayTracer.Color.prototype.blend(
+                    color,
+                    refl.color,
+                    info.shape.material.reflection
+                  );
+          }
+
+                // Refraction
+                /* TODO */
+            }
+
+            /* Render shadows and highlights */
+
+            var shadowInfo = new Flog.RayTracer.IntersectionInfo();
+
+            if(this.options.renderShadows){
+                var shadowRay = new Flog.RayTracer.Ray(info.position, v);
+
+                shadowInfo = this.testIntersection(shadowRay, scene, info.shape);
+                if(shadowInfo.isHit && shadowInfo.shape != info.shape /*&& shadowInfo.shape.type != 'PLANE'*/){
+                    var vA = Flog.RayTracer.Color.prototype.multiplyScalar(color, 0.5);
+                    var dB = (0.5 * Math.pow(shadowInfo.shape.material.transparency, 0.5));
+                    color = Flog.RayTracer.Color.prototype.addScalar(vA,dB);
+                }
+            }
+
+      // Phong specular highlights
+      if(this.options.renderHighlights && !shadowInfo.isHit && info.shape.material.gloss > 0){
+        var Lv = Flog.RayTracer.Vector.prototype.subtract(
+                            info.shape.position,
+                            light.position
+                        ).normalize();
+
+        var E = Flog.RayTracer.Vector.prototype.subtract(
+                            scene.camera.position,
+                            info.shape.position
+                        ).normalize();
+
+        var H = Flog.RayTracer.Vector.prototype.subtract(
+                            E,
+                            Lv
+                        ).normalize();
+
+        var glossWeight = Math.pow(Math.max(info.normal.dot(H), 0), shininess);
+        color = Flog.RayTracer.Color.prototype.add(
+                            Flog.RayTracer.Color.prototype.multiplyScalar(light.color, glossWeight),
+                            color
+                        );
+      }
+        }
+        color.limit();
+        return color;
+    }
+};
+
+
+function renderScene(){
+    var scene = new Flog.RayTracer.Scene();
+
+    scene.camera = new Flog.RayTracer.Camera(
+                        new Flog.RayTracer.Vector(0, 0, -15),
+                        new Flog.RayTracer.Vector(-0.2, 0, 5),
+                        new Flog.RayTracer.Vector(0, 1, 0)
+                    );
+
+    scene.background = new Flog.RayTracer.Background(
+                                new Flog.RayTracer.Color(0.5, 0.5, 0.5),
+                                0.4
+                            );
+
+    var sphere = new Flog.RayTracer.Shape.Sphere(
+        new Flog.RayTracer.Vector(-1.5, 1.5, 2),
+        1.5,
+        new Flog.RayTracer.Material.Solid(
+            new Flog.RayTracer.Color(0,0.5,0.5),
+            0.3,
+            0.0,
+            0.0,
+            2.0
+        )
+    );
+
+    var sphere1 = new Flog.RayTracer.Shape.Sphere(
+        new Flog.RayTracer.Vector(1, 0.25, 1),
+        0.5,
+        new Flog.RayTracer.Material.Solid(
+            new Flog.RayTracer.Color(0.9,0.9,0.9),
+            0.1,
+            0.0,
+            0.0,
+            1.5
+        )
+    );
+
+    var plane = new Flog.RayTracer.Shape.Plane(
+                                new Flog.RayTracer.Vector(0.1, 0.9, -0.5).normalize(),
+                                1.2,
+                                new Flog.RayTracer.Material.Chessboard(
+                                    new Flog.RayTracer.Color(1,1,1),
+                                    new Flog.RayTracer.Color(0,0,0),
+                                    0.2,
+                                    0.0,
+                                    1.0,
+                                    0.7
+                                )
+                            );
+
+    scene.shapes.push(plane);
+    scene.shapes.push(sphere);
+    scene.shapes.push(sphere1);
+
+    var light = new Flog.RayTracer.Light(
+        new Flog.RayTracer.Vector(5, 10, -1),
+        new Flog.RayTracer.Color(0.8, 0.8, 0.8)
+    );
+
+    var light1 = new Flog.RayTracer.Light(
+        new Flog.RayTracer.Vector(-3, 5, -15),
+        new Flog.RayTracer.Color(0.8, 0.8, 0.8),
+        100
+    );
+
+    scene.lights.push(light);
+    scene.lights.push(light1);
+
+    var imageWidth = 100; // $F('imageWidth');
+    var imageHeight = 100; // $F('imageHeight');
+    var pixelSize = "5,5".split(','); //  $F('pixelSize').split(',');
+    var renderDiffuse = true; // $F('renderDiffuse');
+    var renderShadows = true; // $F('renderShadows');
+    var renderHighlights = true; // $F('renderHighlights');
+    var renderReflections = true; // $F('renderReflections');
+    var rayDepth = 2;//$F('rayDepth');
+
+    var raytracer = new Flog.RayTracer.Engine(
+        {
+            canvasWidth: imageWidth,
+            canvasHeight: imageHeight,
+            pixelWidth: pixelSize[0],
+            pixelHeight: pixelSize[1],
+            "renderDiffuse": renderDiffuse,
+            "renderHighlights": renderHighlights,
+            "renderShadows": renderShadows,
+            "renderReflections": renderReflections,
+            "rayDepth": rayDepth
+        }
+    );
+
+    raytracer.renderScene(scene, null, 0);
+}
+
+var RayTrace = new BenchmarkSuite('RayTrace', 739989, [
+  new Benchmark('RayTrace', renderScene)
+]);
+
+

oden-js-sys/quickjs/tests/bench-v8/revisions.html

@@ -0,0 +1,104 @@
+<html>
+<head>
+<title>V8 Benchmark Suite Revisions</title>
+<link type="text/css" rel="stylesheet" href="style.css" />
+</head>
+<body>
+<div>
+  <div class="title"><h1>V8 Benchmark Suite Revisions</h1></div>
+  <table>
+    <tr>
+      <td class="contents">
+
+<p>
+
+The V8 benchmark suite is changed from time to time as we fix bugs or
+expand the scope of the benchmarks.  Here is a list of revisions, with
+a description of the changes made.  Note that benchmark results are
+not comparable unless both results are run with the same revision of
+the benchmark suite.
+
+</p>
+<div class="subtitle"><h3>Version 7 (<a href="http://v8.googlecode.com/svn/data/benchmarks/v7/run.html">link</a>)</h3></div>
+
+<p>This version includes the new Navier-Stokes benchmark, a 2D differential
+ equation solver that stresses arithmetic computations on double arrays.</p>
+
+<div class="subtitle"><h3>Version 6 (<a href="http://v8.googlecode.com/svn/data/benchmarks/v6/run.html">link</a>)</h3></div>
+
+<p>Removed dead code from the RayTrace benchmark and fixed a couple of
+typos in the DeltaBlue implementation. Changed the Splay benchmark to
+avoid converting the same numeric key to a string over and over again
+and to avoid inserting and removing the same element repeatedly thus
+increasing pressure on the memory subsystem. Changed the RegExp
+benchmark to exercise the regular expression engine on different input
+strings.</p>
+
+<p>Furthermore, the benchmark runner was changed to run the benchmarks
+for at least a few times to stabilize the reported numbers on slower
+machines.</p>
+
+<div class="subtitle"><h3>Version 5 (<a href="http://v8.googlecode.com/svn/data/benchmarks/v5/run.html">link</a>)</h3></div>
+
+<p>Removed duplicate line in random seed code, and changed the name of
+the Object.prototype.inherits function in the DeltaBlue benchmark to
+inheritsFrom to avoid name clashes when running in Chromium with
+extensions enabled.
+</p>
+
+<div class="subtitle"><h3>Version 4 (<a href="http://v8.googlecode.com/svn/data/benchmarks/v4/run.html">link</a>)</h3></div>
+
+<p>The <i>Splay</i> benchmark is a newcomer in version 4.  It
+manipulates a splay tree by adding and removing data nodes, thus
+exercising the memory management subsystem of the JavaScript engine.
+</p>
+
+<p>
+Furthermore, all the unused parts of the Prototype library were
+removed from the RayTrace benchmark. This does not affect the running
+of the benchmark.
+</p>
+
+
+<div class="subtitle"><h3>Version 3 (<a href="http://v8.googlecode.com/svn/data/benchmarks/v3/run.html">link</a>)</h3></div>
+
+<p>Version 3 adds a new benchmark, <i>RegExp</i>.  The RegExp
+benchmark is generated by loading 50 of the most popular pages on the
+web and logging all regexp operations performed.  Each operation is
+given a weight that is calculated from an estimate of the popularity
+of the pages where it occurs and the number of times it is executed
+while loading each page.  Finally the literal letters in the data are
+encoded using ROT13 in a way that does not affect how the regexps
+match their input.
+</p>
+
+
+<div class="subtitle"><h3>Version 2 (<a href="http://v8.googlecode.com/svn/data/benchmarks/v2/run.html">link</a>)</h3></div>
+
+<p>For version 2 the Crypto benchmark was fixed.  Previously, the
+decryption stage was given plaintext as input, which resulted in an
+error.  Now, the decryption stage is given the output of the
+encryption stage as input.  The result is checked against the original
+plaintext.  For this to give the correct results the crypto objects
+are reset for each iteration of the benchmark.  In addition, the size
+of the plain text has been increased a little and the use of
+Math.random() and new Date() to build an RNG pool has been
+removed. </p>
+
+<p>Other benchmarks were fixed to do elementary verification of the
+results of their calculations.  This is to avoid accidentally
+obtaining scores that are the result of an incorrect JavaScript engine
+optimization.</p>
+
+
+<div class="subtitle"><h3>Version 1 (<a href="http://v8.googlecode.com/svn/data/benchmarks/v1/run.html">link</a>)</h3></div>
+
+<p>Initial release.</p>
+
+</td><td style="text-align: center">
+</td></tr></table>
+
+</div>
+
+</body>
+</html>

oden-js-sys/quickjs/tests/bench-v8/richards.js

@@ -0,0 +1,539 @@
+// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * 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.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "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 THE COPYRIGHT
+// OWNER 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.
+
+
+// This is a JavaScript implementation of the Richards
+// benchmark from:
+//
+//    http://www.cl.cam.ac.uk/~mr10/Bench.html
+//
+// The benchmark was originally implemented in BCPL by
+// Martin Richards.
+
+
+/**
+ * The Richards benchmark simulates the task dispatcher of an
+ * operating system.
+ **/
+function runRichards() {
+  var scheduler = new Scheduler();
+  scheduler.addIdleTask(ID_IDLE, 0, null, COUNT);
+
+  var queue = new Packet(null, ID_WORKER, KIND_WORK);
+  queue = new Packet(queue,  ID_WORKER, KIND_WORK);
+  scheduler.addWorkerTask(ID_WORKER, 1000, queue);
+
+  queue = new Packet(null, ID_DEVICE_A, KIND_DEVICE);
+  queue = new Packet(queue,  ID_DEVICE_A, KIND_DEVICE);
+  queue = new Packet(queue,  ID_DEVICE_A, KIND_DEVICE);
+  scheduler.addHandlerTask(ID_HANDLER_A, 2000, queue);
+
+  queue = new Packet(null, ID_DEVICE_B, KIND_DEVICE);
+  queue = new Packet(queue,  ID_DEVICE_B, KIND_DEVICE);
+  queue = new Packet(queue,  ID_DEVICE_B, KIND_DEVICE);
+  scheduler.addHandlerTask(ID_HANDLER_B, 3000, queue);
+
+  scheduler.addDeviceTask(ID_DEVICE_A, 4000, null);
+
+  scheduler.addDeviceTask(ID_DEVICE_B, 5000, null);
+
+  scheduler.schedule();
+
+  if (scheduler.queueCount != EXPECTED_QUEUE_COUNT ||
+      scheduler.holdCount != EXPECTED_HOLD_COUNT) {
+    var msg =
+        "Error during execution: queueCount = " + scheduler.queueCount +
+        ", holdCount = " + scheduler.holdCount + ".";
+    throw new Error(msg);
+  }
+}
+
+var COUNT = 1000;
+
+/**
+ * These two constants specify how many times a packet is queued and
+ * how many times a task is put on hold in a correct run of richards.
+ * They don't have any meaning a such but are characteristic of a
+ * correct run so if the actual queue or hold count is different from
+ * the expected there must be a bug in the implementation.
+ **/
+var EXPECTED_QUEUE_COUNT = 2322;
+var EXPECTED_HOLD_COUNT = 928;
+
+
+/**
+ * A scheduler can be used to schedule a set of tasks based on their relative
+ * priorities.  Scheduling is done by maintaining a list of task control blocks
+ * which holds tasks and the data queue they are processing.
+ * @constructor
+ */
+function Scheduler() {
+  this.queueCount = 0;
+  this.holdCount = 0;
+  this.blocks = new Array(NUMBER_OF_IDS);
+  this.list = null;
+  this.currentTcb = null;
+  this.currentId = null;
+}
+
+var ID_IDLE       = 0;
+var ID_WORKER     = 1;
+var ID_HANDLER_A  = 2;
+var ID_HANDLER_B  = 3;
+var ID_DEVICE_A   = 4;
+var ID_DEVICE_B   = 5;
+var NUMBER_OF_IDS = 6;
+
+var KIND_DEVICE   = 0;
+var KIND_WORK     = 1;
+
+/**
+ * Add an idle task to this scheduler.
+ * @param {int} id the identity of the task
+ * @param {int} priority the task's priority
+ * @param {Packet} queue the queue of work to be processed by the task
+ * @param {int} count the number of times to schedule the task
+ */
+Scheduler.prototype.addIdleTask = function (id, priority, queue, count) {
+  this.addRunningTask(id, priority, queue, new IdleTask(this, 1, count));
+};
+
+/**
+ * Add a work task to this scheduler.
+ * @param {int} id the identity of the task
+ * @param {int} priority the task's priority
+ * @param {Packet} queue the queue of work to be processed by the task
+ */
+Scheduler.prototype.addWorkerTask = function (id, priority, queue) {
+  this.addTask(id, priority, queue, new WorkerTask(this, ID_HANDLER_A, 0));
+};
+
+/**
+ * Add a handler task to this scheduler.
+ * @param {int} id the identity of the task
+ * @param {int} priority the task's priority
+ * @param {Packet} queue the queue of work to be processed by the task
+ */
+Scheduler.prototype.addHandlerTask = function (id, priority, queue) {
+  this.addTask(id, priority, queue, new HandlerTask(this));
+};
+
+/**
+ * Add a handler task to this scheduler.
+ * @param {int} id the identity of the task
+ * @param {int} priority the task's priority
+ * @param {Packet} queue the queue of work to be processed by the task
+ */
+Scheduler.prototype.addDeviceTask = function (id, priority, queue) {
+  this.addTask(id, priority, queue, new DeviceTask(this));
+};
+
+/**
+ * Add the specified task and mark it as running.
+ * @param {int} id the identity of the task
+ * @param {int} priority the task's priority
+ * @param {Packet} queue the queue of work to be processed by the task
+ * @param {Task} task the task to add
+ */
+Scheduler.prototype.addRunningTask = function (id, priority, queue, task) {
+  this.addTask(id, priority, queue, task);
+  this.currentTcb.setRunning();
+};
+
+/**
+ * Add the specified task to this scheduler.
+ * @param {int} id the identity of the task
+ * @param {int} priority the task's priority
+ * @param {Packet} queue the queue of work to be processed by the task
+ * @param {Task} task the task to add
+ */
+Scheduler.prototype.addTask = function (id, priority, queue, task) {
+  this.currentTcb = new TaskControlBlock(this.list, id, priority, queue, task);
+  this.list = this.currentTcb;
+  this.blocks[id] = this.currentTcb;
+};
+
+/**
+ * Execute the tasks managed by this scheduler.
+ */
+Scheduler.prototype.schedule = function () {
+  this.currentTcb = this.list;
+  while (this.currentTcb != null) {
+    if (this.currentTcb.isHeldOrSuspended()) {
+      this.currentTcb = this.currentTcb.link;
+    } else {
+      this.currentId = this.currentTcb.id;
+      this.currentTcb = this.currentTcb.run();
+    }
+  }
+};
+
+/**
+ * Release a task that is currently blocked and return the next block to run.
+ * @param {int} id the id of the task to suspend
+ */
+Scheduler.prototype.release = function (id) {
+  var tcb = this.blocks[id];
+  if (tcb == null) return tcb;
+  tcb.markAsNotHeld();
+  if (tcb.priority > this.currentTcb.priority) {
+    return tcb;
+  } else {
+    return this.currentTcb;
+  }
+};
+
+/**
+ * Block the currently executing task and return the next task control block
+ * to run.  The blocked task will not be made runnable until it is explicitly
+ * released, even if new work is added to it.
+ */
+Scheduler.prototype.holdCurrent = function () {
+  this.holdCount++;
+  this.currentTcb.markAsHeld();
+  return this.currentTcb.link;
+};
+
+/**
+ * Suspend the currently executing task and return the next task control block
+ * to run.  If new work is added to the suspended task it will be made runnable.
+ */
+Scheduler.prototype.suspendCurrent = function () {
+  this.currentTcb.markAsSuspended();
+  return this.currentTcb;
+};
+
+/**
+ * Add the specified packet to the end of the worklist used by the task
+ * associated with the packet and make the task runnable if it is currently
+ * suspended.
+ * @param {Packet} packet the packet to add
+ */
+Scheduler.prototype.queue = function (packet) {
+  var t = this.blocks[packet.id];
+  if (t == null) return t;
+  this.queueCount++;
+  packet.link = null;
+  packet.id = this.currentId;
+  return t.checkPriorityAdd(this.currentTcb, packet);
+};
+
+/**
+ * A task control block manages a task and the queue of work packages associated
+ * with it.
+ * @param {TaskControlBlock} link the preceding block in the linked block list
+ * @param {int} id the id of this block
+ * @param {int} priority the priority of this block
+ * @param {Packet} queue the queue of packages to be processed by the task
+ * @param {Task} task the task
+ * @constructor
+ */
+function TaskControlBlock(link, id, priority, queue, task) {
+  this.link = link;
+  this.id = id;
+  this.priority = priority;
+  this.queue = queue;
+  this.task = task;
+  if (queue == null) {
+    this.state = STATE_SUSPENDED;
+  } else {
+    this.state = STATE_SUSPENDED_RUNNABLE;
+  }
+}
+
+/**
+ * The task is running and is currently scheduled.
+ */
+var STATE_RUNNING = 0;
+
+/**
+ * The task has packets left to process.
+ */
+var STATE_RUNNABLE = 1;
+
+/**
+ * The task is not currently running.  The task is not blocked as such and may
+* be started by the scheduler.
+ */
+var STATE_SUSPENDED = 2;
+
+/**
+ * The task is blocked and cannot be run until it is explicitly released.
+ */
+var STATE_HELD = 4;
+
+var STATE_SUSPENDED_RUNNABLE = STATE_SUSPENDED | STATE_RUNNABLE;
+var STATE_NOT_HELD = ~STATE_HELD;
+
+TaskControlBlock.prototype.setRunning = function () {
+  this.state = STATE_RUNNING;
+};
+
+TaskControlBlock.prototype.markAsNotHeld = function () {
+  this.state = this.state & STATE_NOT_HELD;
+};
+
+TaskControlBlock.prototype.markAsHeld = function () {
+  this.state = this.state | STATE_HELD;
+};
+
+TaskControlBlock.prototype.isHeldOrSuspended = function () {
+  return (this.state & STATE_HELD) != 0 || (this.state == STATE_SUSPENDED);
+};
+
+TaskControlBlock.prototype.markAsSuspended = function () {
+  this.state = this.state | STATE_SUSPENDED;
+};
+
+TaskControlBlock.prototype.markAsRunnable = function () {
+  this.state = this.state | STATE_RUNNABLE;
+};
+
+/**
+ * Runs this task, if it is ready to be run, and returns the next task to run.
+ */
+TaskControlBlock.prototype.run = function () {
+  var packet;
+  if (this.state == STATE_SUSPENDED_RUNNABLE) {
+    packet = this.queue;
+    this.queue = packet.link;
+    if (this.queue == null) {
+      this.state = STATE_RUNNING;
+    } else {
+      this.state = STATE_RUNNABLE;
+    }
+  } else {
+    packet = null;
+  }
+  return this.task.run(packet);
+};
+
+/**
+ * Adds a packet to the worklist of this block's task, marks this as runnable if
+ * necessary, and returns the next runnable object to run (the one
+ * with the highest priority).
+ */
+TaskControlBlock.prototype.checkPriorityAdd = function (task, packet) {
+  if (this.queue == null) {
+    this.queue = packet;
+    this.markAsRunnable();
+    if (this.priority > task.priority) return this;
+  } else {
+    this.queue = packet.addTo(this.queue);
+  }
+  return task;
+};
+
+TaskControlBlock.prototype.toString = function () {
+  return "tcb { " + this.task + "@" + this.state + " }";
+};
+
+/**
+ * An idle task doesn't do any work itself but cycles control between the two
+ * device tasks.
+ * @param {Scheduler} scheduler the scheduler that manages this task
+ * @param {int} v1 a seed value that controls how the device tasks are scheduled
+ * @param {int} count the number of times this task should be scheduled
+ * @constructor
+ */
+function IdleTask(scheduler, v1, count) {
+  this.scheduler = scheduler;
+  this.v1 = v1;
+  this.count = count;
+}
+
+IdleTask.prototype.run = function (packet) {
+  this.count--;
+  if (this.count == 0) return this.scheduler.holdCurrent();
+  if ((this.v1 & 1) == 0) {
+    this.v1 = this.v1 >> 1;
+    return this.scheduler.release(ID_DEVICE_A);
+  } else {
+    this.v1 = (this.v1 >> 1) ^ 0xD008;
+    return this.scheduler.release(ID_DEVICE_B);
+  }
+};
+
+IdleTask.prototype.toString = function () {
+  return "IdleTask";
+};
+
+/**
+ * A task that suspends itself after each time it has been run to simulate
+ * waiting for data from an external device.
+ * @param {Scheduler} scheduler the scheduler that manages this task
+ * @constructor
+ */
+function DeviceTask(scheduler) {
+  this.scheduler = scheduler;
+  this.v1 = null;
+}
+
+DeviceTask.prototype.run = function (packet) {
+  if (packet == null) {
+    if (this.v1 == null) return this.scheduler.suspendCurrent();
+    var v = this.v1;
+    this.v1 = null;
+    return this.scheduler.queue(v);
+  } else {
+    this.v1 = packet;
+    return this.scheduler.holdCurrent();
+  }
+};
+
+DeviceTask.prototype.toString = function () {
+  return "DeviceTask";
+};
+
+/**
+ * A task that manipulates work packets.
+ * @param {Scheduler} scheduler the scheduler that manages this task
+ * @param {int} v1 a seed used to specify how work packets are manipulated
+ * @param {int} v2 another seed used to specify how work packets are manipulated
+ * @constructor
+ */
+function WorkerTask(scheduler, v1, v2) {
+  this.scheduler = scheduler;
+  this.v1 = v1;
+  this.v2 = v2;
+}
+
+WorkerTask.prototype.run = function (packet) {
+  if (packet == null) {
+    return this.scheduler.suspendCurrent();
+  } else {
+    if (this.v1 == ID_HANDLER_A) {
+      this.v1 = ID_HANDLER_B;
+    } else {
+      this.v1 = ID_HANDLER_A;
+    }
+    packet.id = this.v1;
+    packet.a1 = 0;
+    for (var i = 0; i < DATA_SIZE; i++) {
+      this.v2++;
+      if (this.v2 > 26) this.v2 = 1;
+      packet.a2[i] = this.v2;
+    }
+    return this.scheduler.queue(packet);
+  }
+};
+
+WorkerTask.prototype.toString = function () {
+  return "WorkerTask";
+};
+
+/**
+ * A task that manipulates work packets and then suspends itself.
+ * @param {Scheduler} scheduler the scheduler that manages this task
+ * @constructor
+ */
+function HandlerTask(scheduler) {
+  this.scheduler = scheduler;
+  this.v1 = null;
+  this.v2 = null;
+}
+
+HandlerTask.prototype.run = function (packet) {
+  if (packet != null) {
+    if (packet.kind == KIND_WORK) {
+      this.v1 = packet.addTo(this.v1);
+    } else {
+      this.v2 = packet.addTo(this.v2);
+    }
+  }
+  if (this.v1 != null) {
+    var count = this.v1.a1;
+    var v;
+    if (count < DATA_SIZE) {
+      if (this.v2 != null) {
+        v = this.v2;
+        this.v2 = this.v2.link;
+        v.a1 = this.v1.a2[count];
+        this.v1.a1 = count + 1;
+        return this.scheduler.queue(v);
+      }
+    } else {
+      v = this.v1;
+      this.v1 = this.v1.link;
+      return this.scheduler.queue(v);
+    }
+  }
+  return this.scheduler.suspendCurrent();
+};
+
+HandlerTask.prototype.toString = function () {
+  return "HandlerTask";
+};
+
+/* --- *
+ * P a c k e t
+ * --- */
+
+var DATA_SIZE = 4;
+
+/**
+ * A simple package of data that is manipulated by the tasks.  The exact layout
+ * of the payload data carried by a packet is not importaint, and neither is the
+ * nature of the work performed on packets by the tasks.
+ *
+ * Besides carrying data, packets form linked lists and are hence used both as
+ * data and worklists.
+ * @param {Packet} link the tail of the linked list of packets
+ * @param {int} id an ID for this packet
+ * @param {int} kind the type of this packet
+ * @constructor
+ */
+function Packet(link, id, kind) {
+  this.link = link;
+  this.id = id;
+  this.kind = kind;
+  this.a1 = 0;
+  this.a2 = new Array(DATA_SIZE);
+}
+
+/**
+ * Add this packet to the end of a worklist, and return the worklist.
+ * @param {Packet} queue the worklist to add this packet to
+ */
+Packet.prototype.addTo = function (queue) {
+  this.link = null;
+  if (queue == null) return this;
+  var peek, next = queue;
+  while ((peek = next.link) != null)
+    next = peek;
+  next.link = this;
+  return queue;
+};
+
+Packet.prototype.toString = function () {
+  return "Packet";
+};
+
+var Richards = new BenchmarkSuite('Richards', 35302, [
+  new Benchmark("Richards", runRichards)
+]);
+

oden-js-sys/quickjs/tests/bench-v8/run_harness.js

@@ -0,0 +1,42 @@
+/* run_harness.js */
+var print = console.log;
+
+function Run() {
+  BenchmarkSuite.RunSuites({ NotifyStep: ShowProgress,
+                             NotifyError: AddError,
+                             NotifyResult: AddResult,
+                             NotifyScore: AddScore });
+}
+
+var harnessErrorCount = 0;
+
+function ShowProgress(name) {
+  print('PROGRESS', name);
+}
+
+function AddError(name, error) {
+  print('ERROR', name, error);
+  print(error.stack);
+  harnessErrorCount++;
+}
+
+function AddResult(name, result) {
+  print('RESULT', name, result);
+}
+
+function AddScore(score) {
+  print('SCORE', score);
+}
+
+try {
+  Run();
+} catch (e) {
+  print('*** Run() failed');
+  print(e.stack || e);
+}
+
+if (harnessErrorCount > 0) {
+  // Throw an error so that 'duk' has a non-zero exit code which helps
+  // automatic testing.
+  throw new Error('Benchmark had ' + harnessErrorCount + ' errors');
+}

oden-js-sys/quickjs/tests/bench-v8/splay.js

@@ -0,0 +1,393 @@
+// Copyright 2009 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * 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.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "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 THE COPYRIGHT
+// OWNER 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.
+
+// This benchmark is based on a JavaScript log processing module used
+// by the V8 profiler to generate execution time profiles for runs of
+// JavaScript applications, and it effectively measures how fast the
+// JavaScript engine is at allocating nodes and reclaiming the memory
+// used for old nodes. Because of the way splay trees work, the engine
+// also has to deal with a lot of changes to the large tree object
+// graph.
+
+// Configuration.
+var kSplayTreeSize = 8000;
+var kSplayTreeModifications = 80;
+var kSplayTreePayloadDepth = 5;
+
+var splayTree = null;
+
+
+function GeneratePayloadTree(depth, tag) {
+  if (depth == 0) {
+    return {
+      array  : [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ],
+      string : 'String for key ' + tag + ' in leaf node'
+    };
+  } else {
+    return {
+      left:  GeneratePayloadTree(depth - 1, tag),
+      right: GeneratePayloadTree(depth - 1, tag)
+    };
+  }
+}
+
+
+function GenerateKey() {
+  // The benchmark framework guarantees that Math.random is
+  // deterministic; see base.js.
+  return Math.random();
+}
+
+
+function InsertNewNode() {
+  // Insert new node with a unique key.
+  var key;
+  do {
+    key = GenerateKey();
+  } while (splayTree.find(key) != null);
+  var payload = GeneratePayloadTree(kSplayTreePayloadDepth, String(key));
+  splayTree.insert(key, payload);
+  return key;
+}
+
+
+
+function SplaySetup() {
+  splayTree = new SplayTree();
+  for (var i = 0; i < kSplayTreeSize; i++) InsertNewNode();
+}
+
+
+function SplayTearDown() {
+  // Allow the garbage collector to reclaim the memory
+  // used by the splay tree no matter how we exit the
+  // tear down function.
+  var keys = splayTree.exportKeys();
+  splayTree = null;
+
+  // Verify that the splay tree has the right size.
+  var length = keys.length;
+  if (length != kSplayTreeSize) {
+    throw new Error("Splay tree has wrong size");
+  }
+
+  // Verify that the splay tree has sorted, unique keys.
+  for (var i = 0; i < length - 1; i++) {
+    if (keys[i] >= keys[i + 1]) {
+      throw new Error("Splay tree not sorted");
+    }
+  }
+}
+
+
+function SplayRun() {
+  // Replace a few nodes in the splay tree.
+  for (var i = 0; i < kSplayTreeModifications; i++) {
+    var key = InsertNewNode();
+    var greatest = splayTree.findGreatestLessThan(key);
+    if (greatest == null) splayTree.remove(key);
+    else splayTree.remove(greatest.key);
+  }
+}
+
+
+/**
+ * Constructs a Splay tree.  A splay tree is a self-balancing binary
+ * search tree with the additional property that recently accessed
+ * elements are quick to access again. It performs basic operations
+ * such as insertion, look-up and removal in O(log(n)) amortized time.
+ *
+ * @constructor
+ */
+function SplayTree() {
+};
+
+
+/**
+ * Pointer to the root node of the tree.
+ *
+ * @type {SplayTree.Node}
+ * @private
+ */
+SplayTree.prototype.root_ = null;
+
+
+/**
+ * @return {boolean} Whether the tree is empty.
+ */
+SplayTree.prototype.isEmpty = function() {
+  return !this.root_;
+};
+
+
+/**
+ * Inserts a node into the tree with the specified key and value if
+ * the tree does not already contain a node with the specified key. If
+ * the value is inserted, it becomes the root of the tree.
+ *
+ * @param {number} key Key to insert into the tree.
+ * @param {*} value Value to insert into the tree.
+ */
+SplayTree.prototype.insert = function(key, value) {
+  if (this.isEmpty()) {
+    this.root_ = new SplayTree.Node(key, value);
+    return;
+  }
+  // Splay on the key to move the last node on the search path for
+  // the key to the root of the tree.
+  this.splay_(key);
+  if (this.root_.key == key) {
+    return;
+  }
+  var node = new SplayTree.Node(key, value);
+  if (key > this.root_.key) {
+    node.left = this.root_;
+    node.right = this.root_.right;
+    this.root_.right = null;
+  } else {
+    node.right = this.root_;
+    node.left = this.root_.left;
+    this.root_.left = null;
+  }
+  this.root_ = node;
+};
+
+
+/**
+ * Removes a node with the specified key from the tree if the tree
+ * contains a node with this key. The removed node is returned. If the
+ * key is not found, an exception is thrown.
+ *
+ * @param {number} key Key to find and remove from the tree.
+ * @return {SplayTree.Node} The removed node.
+ */
+SplayTree.prototype.remove = function(key) {
+  if (this.isEmpty()) {
+    throw Error('Key not found: ' + key);
+  }
+  this.splay_(key);
+  if (this.root_.key != key) {
+    throw Error('Key not found: ' + key);
+  }
+  var removed = this.root_;
+  if (!this.root_.left) {
+    this.root_ = this.root_.right;
+  } else {
+    var right = this.root_.right;
+    this.root_ = this.root_.left;
+    // Splay to make sure that the new root has an empty right child.
+    this.splay_(key);
+    // Insert the original right child as the right child of the new
+    // root.
+    this.root_.right = right;
+  }
+  return removed;
+};
+
+
+/**
+ * Returns the node having the specified key or null if the tree doesn't contain
+ * a node with the specified key.
+ *
+ * @param {number} key Key to find in the tree.
+ * @return {SplayTree.Node} Node having the specified key.
+ */
+SplayTree.prototype.find = function(key) {
+  if (this.isEmpty()) {
+    return null;
+  }
+  this.splay_(key);
+  return this.root_.key == key ? this.root_ : null;
+};
+
+
+/**
+ * @return {SplayTree.Node} Node having the maximum key value.
+ */
+SplayTree.prototype.findMax = function(opt_startNode) {
+  if (this.isEmpty()) {
+    return null;
+  }
+  var current = opt_startNode || this.root_;
+  while (current.right) {
+    current = current.right;
+  }
+  return current;
+};
+
+
+/**
+ * @return {SplayTree.Node} Node having the maximum key value that
+ *     is less than the specified key value.
+ */
+SplayTree.prototype.findGreatestLessThan = function(key) {
+  if (this.isEmpty()) {
+    return null;
+  }
+  // Splay on the key to move the node with the given key or the last
+  // node on the search path to the top of the tree.
+  this.splay_(key);
+  // Now the result is either the root node or the greatest node in
+  // the left subtree.
+  if (this.root_.key < key) {
+    return this.root_;
+  } else if (this.root_.left) {
+    return this.findMax(this.root_.left);
+  } else {
+    return null;
+  }
+};
+
+
+/**
+ * @return {Array<*>} An array containing all the keys of tree's nodes.
+ */
+SplayTree.prototype.exportKeys = function() {
+  var result = [];
+  if (!this.isEmpty()) {
+    this.root_.traverse_(function(node) { result.push(node.key); });
+  }
+  return result;
+};
+
+
+/**
+ * Perform the splay operation for the given key. Moves the node with
+ * the given key to the top of the tree.  If no node has the given
+ * key, the last node on the search path is moved to the top of the
+ * tree. This is the simplified top-down splaying algorithm from:
+ * "Self-adjusting Binary Search Trees" by Sleator and Tarjan
+ *
+ * @param {number} key Key to splay the tree on.
+ * @private
+ */
+SplayTree.prototype.splay_ = function(key) {
+  if (this.isEmpty()) {
+    return;
+  }
+  // Create a dummy node.  The use of the dummy node is a bit
+  // counter-intuitive: The right child of the dummy node will hold
+  // the L tree of the algorithm.  The left child of the dummy node
+  // will hold the R tree of the algorithm.  Using a dummy node, left
+  // and right will always be nodes and we avoid special cases.
+  var dummy, left, right;
+  dummy = left = right = new SplayTree.Node(null, null);
+  var current = this.root_;
+  while (true) {
+    if (key < current.key) {
+      if (!current.left) {
+        break;
+      }
+      if (key < current.left.key) {
+        // Rotate right.
+        var tmp = current.left;
+        current.left = tmp.right;
+        tmp.right = current;
+        current = tmp;
+        if (!current.left) {
+          break;
+        }
+      }
+      // Link right.
+      right.left = current;
+      right = current;
+      current = current.left;
+    } else if (key > current.key) {
+      if (!current.right) {
+        break;
+      }
+      if (key > current.right.key) {
+        // Rotate left.
+        var tmp = current.right;
+        current.right = tmp.left;
+        tmp.left = current;
+        current = tmp;
+        if (!current.right) {
+          break;
+        }
+      }
+      // Link left.
+      left.right = current;
+      left = current;
+      current = current.right;
+    } else {
+      break;
+    }
+  }
+  // Assemble.
+  left.right = current.left;
+  right.left = current.right;
+  current.left = dummy.right;
+  current.right = dummy.left;
+  this.root_ = current;
+};
+
+
+/**
+ * Constructs a Splay tree node.
+ *
+ * @param {number} key Key.
+ * @param {*} value Value.
+ */
+SplayTree.Node = function(key, value) {
+  this.key = key;
+  this.value = value;
+};
+
+
+/**
+ * @type {SplayTree.Node}
+ */
+SplayTree.Node.prototype.left = null;
+
+
+/**
+ * @type {SplayTree.Node}
+ */
+SplayTree.Node.prototype.right = null;
+
+
+/**
+ * Performs an ordered traversal of the subtree starting at
+ * this SplayTree.Node.
+ *
+ * @param {function(SplayTree.Node)} f Visitor function.
+ * @private
+ */
+SplayTree.Node.prototype.traverse_ = function(f) {
+  var current = this;
+  while (current) {
+    var left = current.left;
+    if (left) left.traverse_(f);
+    f(current);
+    current = current.right;
+  }
+};
+
+var Splay = new BenchmarkSuite('Splay', 81491, [
+  new Benchmark("Splay", SplayRun, SplaySetup, SplayTearDown)
+]);

oden-js-sys/quickjs/tests/bjson.c

@@ -0,0 +1,96 @@
+/*
+ * QuickJS: binary JSON module (test only)
+ * 
+ * Copyright (c) 2017-2019 Fabrice Bellard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include "../quickjs-libc.h"
+#include "../cutils.h"
+
+static JSValue js_bjson_read(JSContext *ctx, JSValueConst this_val,
+                             int argc, JSValueConst *argv)
+{
+    uint8_t *buf;
+    uint64_t pos, len;
+    JSValue obj;
+    size_t size;
+    int flags;
+    
+    if (JS_ToIndex(ctx, &pos, argv[1]))
+        return JS_EXCEPTION;
+    if (JS_ToIndex(ctx, &len, argv[2]))
+        return JS_EXCEPTION;
+    buf = JS_GetArrayBuffer(ctx, &size, argv[0]);
+    if (!buf)
+        return JS_EXCEPTION;
+    if (pos + len > size)
+        return JS_ThrowRangeError(ctx, "array buffer overflow");
+    flags = 0;
+    if (JS_ToBool(ctx, argv[3]))
+        flags |= JS_READ_OBJ_REFERENCE;
+    obj = JS_ReadObject(ctx, buf + pos, len, flags);
+    return obj;
+}
+
+static JSValue js_bjson_write(JSContext *ctx, JSValueConst this_val,
+                              int argc, JSValueConst *argv)
+{
+    size_t len;
+    uint8_t *buf;
+    JSValue array;
+    int flags;
+    
+    flags = 0;
+    if (JS_ToBool(ctx, argv[1]))
+        flags |= JS_WRITE_OBJ_REFERENCE;
+    buf = JS_WriteObject(ctx, &len, argv[0], flags);
+    if (!buf)
+        return JS_EXCEPTION;
+    array = JS_NewArrayBufferCopy(ctx, buf, len);
+    js_free(ctx, buf);
+    return array;
+}
+
+static const JSCFunctionListEntry js_bjson_funcs[] = {
+    JS_CFUNC_DEF("read", 4, js_bjson_read ),
+    JS_CFUNC_DEF("write", 2, js_bjson_write ),
+};
+
+static int js_bjson_init(JSContext *ctx, JSModuleDef *m)
+{
+    return JS_SetModuleExportList(ctx, m, js_bjson_funcs,
+                                  countof(js_bjson_funcs));
+}
+
+#ifdef JS_SHARED_LIBRARY
+#define JS_INIT_MODULE js_init_module
+#else
+#define JS_INIT_MODULE js_init_module_bjson
+#endif
+
+JSModuleDef *JS_INIT_MODULE(JSContext *ctx, const char *module_name)
+{
+    JSModuleDef *m;
+    m = JS_NewCModule(ctx, module_name, js_bjson_init);
+    if (!m)
+        return NULL;
+    JS_AddModuleExportList(ctx, m, js_bjson_funcs, countof(js_bjson_funcs));
+    return m;
+}

oden-js-sys/quickjs/tests/test262.patch

@@ -0,0 +1,71 @@
+diff --git a/harness/atomicsHelper.js b/harness/atomicsHelper.js
+index 9c1217351e..3c24755558 100644
+--- a/harness/atomicsHelper.js
++++ b/harness/atomicsHelper.js
+@@ -227,10 +227,14 @@ $262.agent.waitUntil = function(typedArray, index, expected) {
+  *   }
+  */
+ $262.agent.timeouts = {
+-  yield: 100,
+-  small: 200,
+-  long: 1000,
+-  huge: 10000,
++//  yield: 100,
++//  small: 200,
++//  long: 1000,
++//  huge: 10000,
++  yield: 20,
++  small: 20,
++  long: 100,
++  huge: 1000,
+ };
+ 
+ /**
+diff --git a/harness/regExpUtils.js b/harness/regExpUtils.js
+index be7039fda0..7b38abf8df 100644
+--- a/harness/regExpUtils.js
++++ b/harness/regExpUtils.js
+@@ -6,24 +6,27 @@ description: |
+ defines: [buildString, testPropertyEscapes, matchValidator]
+ ---*/
+ 
++if ($262 && typeof $262.codePointRange === "function") {
++    /* use C function to build the codePointRange (much faster with
++       slow JS engines) */
++    codePointRange = $262.codePointRange;
++} else {
++    codePointRange = function codePointRange(start, end) {
++        const codePoints = [];
++        let length = 0;
++        for (codePoint = start; codePoint < end; codePoint++) {
++            codePoints[length++] = codePoint;
++        }
++        return String.fromCodePoint.apply(null, codePoints);
++    }
++}
++
+ function buildString({ loneCodePoints, ranges }) {
+-  const CHUNK_SIZE = 10000;
+-  let result = Reflect.apply(String.fromCodePoint, null, loneCodePoints);
+-  for (let i = 0; i < ranges.length; i++) {
+-    const range = ranges[i];
+-    const start = range[0];
+-    const end = range[1];
+-    const codePoints = [];
+-    for (let length = 0, codePoint = start; codePoint <= end; codePoint++) {
+-      codePoints[length++] = codePoint;
+-      if (length === CHUNK_SIZE) {
+-        result += Reflect.apply(String.fromCodePoint, null, codePoints);
+-        codePoints.length = length = 0;
+-      }
++    let result = String.fromCodePoint.apply(null, loneCodePoints);
++    for (const [start, end] of ranges) {
++        result += codePointRange(start, end + 1);
+     }
+-    result += Reflect.apply(String.fromCodePoint, null, codePoints);
+-  }
+-  return result;
++    return result;
+ }
+ 
+ function testPropertyEscapes(regex, string, expression) {

oden-js-sys/quickjs/tests/test_bignum.js

@@ -0,0 +1,326 @@
+"use strict";
+
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+function assertThrows(err, func)
+{
+    var ex;
+    ex = false;
+    try {
+        func();
+    } catch(e) {
+        ex = true;
+        assert(e instanceof err);
+    }
+    assert(ex, true, "exception expected");
+}
+
+// load more elaborate version of assert if available
+try { __loadScript("test_assert.js"); } catch(e) {}
+
+/*----------------*/
+
+function bigint_pow(a, n)
+{
+    var r, i;
+    r = 1n;
+    for(i = 0n; i < n; i++)
+        r *= a;
+    return r;
+}
+
+/* a must be < b */
+function test_less(a, b)
+{
+    assert(a < b);
+    assert(!(b < a));
+    assert(a <= b);
+    assert(!(b <= a));
+    assert(b > a);
+    assert(!(a > b));
+    assert(b >= a);
+    assert(!(a >= b));
+    assert(a != b);
+    assert(!(a == b));
+}
+
+/* a must be numerically equal to b */
+function test_eq(a, b)
+{
+    assert(a == b);
+    assert(b == a);
+    assert(!(a != b));
+    assert(!(b != a));
+    assert(a <= b);
+    assert(b <= a);
+    assert(!(a < b));
+    assert(a >= b);
+    assert(b >= a);
+    assert(!(a > b));
+}
+
+function test_bigint1()
+{
+    var a, r;
+
+    test_less(2n, 3n);
+    test_eq(3n, 3n);
+
+    test_less(2, 3n);
+    test_eq(3, 3n);
+
+    test_less(2.1, 3n);
+    test_eq(Math.sqrt(4), 2n);
+
+    a = bigint_pow(3n, 100n);
+    assert((a - 1n) != a);
+    assert(a == 515377520732011331036461129765621272702107522001n);
+    assert(a == 0x5a4653ca673768565b41f775d6947d55cf3813d1n);
+
+    r = 1n << 31n;
+    assert(r, 2147483648n, "1 << 31n === 2147483648n");
+    
+    r = 1n << 32n;
+    assert(r, 4294967296n, "1 << 32n === 4294967296n");
+}
+
+function test_bigint2()
+{
+    assert(BigInt(""), 0n);
+    assert(BigInt("  123"), 123n);
+    assert(BigInt("  123   "), 123n);
+    assertThrows(SyntaxError, () => { BigInt("+") } );
+    assertThrows(SyntaxError, () => { BigInt("-") } );
+    assertThrows(SyntaxError, () => { BigInt("\x00a") } );
+    assertThrows(SyntaxError, () => { BigInt("  123  r") } );
+}
+
+function test_divrem(div1, a, b, q)
+{
+    var div, divrem, t;
+    div = BigInt[div1];
+    divrem = BigInt[div1 + "rem"];
+    assert(div(a, b) == q);
+    t = divrem(a, b);
+    assert(t[0] == q);
+    assert(a == b * q + t[1]);
+}
+
+function test_idiv1(div, a, b, r)
+{
+    test_divrem(div, a, b, r[0]);
+    test_divrem(div, -a, b, r[1]);
+    test_divrem(div, a, -b, r[2]);
+    test_divrem(div, -a, -b, r[3]);
+}
+
+/* QuickJS BigInt extensions */
+function test_bigint_ext()
+{
+    var r;
+    assert(BigInt.floorLog2(0n) === -1n);
+    assert(BigInt.floorLog2(7n) === 2n);
+
+    assert(BigInt.sqrt(0xffffffc000000000000000n) === 17592185913343n);
+    r = BigInt.sqrtrem(0xffffffc000000000000000n);
+    assert(r[0] === 17592185913343n);
+    assert(r[1] === 35167191957503n);
+
+    test_idiv1("tdiv", 3n, 2n, [1n, -1n, -1n, 1n]);
+    test_idiv1("fdiv", 3n, 2n, [1n, -2n, -2n, 1n]);
+    test_idiv1("cdiv", 3n, 2n, [2n, -1n, -1n, 2n]);
+    test_idiv1("ediv", 3n, 2n, [1n, -2n, -1n, 2n]);
+}
+
+function test_bigfloat()
+{
+    var e, a, b, sqrt2;
+    
+    assert(typeof 1n === "bigint");
+    assert(typeof 1l === "bigfloat");
+    assert(1 == 1.0l);
+    assert(1 !== 1.0l);
+
+    test_less(2l, 3l);
+    test_eq(3l, 3l);
+
+    test_less(2, 3l);
+    test_eq(3, 3l);
+
+    test_less(2.1, 3l);
+    test_eq(Math.sqrt(9), 3l);
+    
+    test_less(2n, 3l);
+    test_eq(3n, 3l);
+
+    e = new BigFloatEnv(128);
+    assert(e.prec == 128);
+    a = BigFloat.sqrt(2l, e);
+    assert(a === BigFloat.parseFloat("0x1.6a09e667f3bcc908b2fb1366ea957d3e", 0, e));
+    assert(e.inexact === true);
+    assert(BigFloat.fpRound(a) == 0x1.6a09e667f3bcc908b2fb1366ea95l);
+    
+    b = BigFloatEnv.setPrec(BigFloat.sqrt.bind(null, 2), 128);
+    assert(a === b);
+
+    assert(BigFloat.isNaN(BigFloat(NaN)));
+    assert(BigFloat.isFinite(1l));
+    assert(!BigFloat.isFinite(1l/0l));
+
+    assert(BigFloat.abs(-3l) === 3l);
+    assert(BigFloat.sign(-3l) === -1l);
+
+    assert(BigFloat.exp(0.2l) === 1.2214027581601698339210719946396742l);
+    assert(BigFloat.log(3l) === 1.0986122886681096913952452369225256l);
+    assert(BigFloat.pow(2.1l, 1.6l) === 3.277561666451861947162828744873745l);
+    
+    assert(BigFloat.sin(-1l) === -0.841470984807896506652502321630299l);
+    assert(BigFloat.cos(1l) === 0.5403023058681397174009366074429766l);
+    assert(BigFloat.tan(0.1l) === 0.10033467208545054505808004578111154l);
+
+    assert(BigFloat.asin(0.3l) === 0.30469265401539750797200296122752915l);
+    assert(BigFloat.acos(0.4l) === 1.1592794807274085998465837940224159l);
+    assert(BigFloat.atan(0.7l) === 0.610725964389208616543758876490236l);
+    assert(BigFloat.atan2(7.1l, -5.1l) === 2.1937053809751415549388104628759813l);
+
+    assert(BigFloat.floor(2.5l) === 2l);
+    assert(BigFloat.ceil(2.5l) === 3l);
+    assert(BigFloat.trunc(-2.5l) === -2l);
+    assert(BigFloat.round(2.5l) === 3l);
+
+    assert(BigFloat.fmod(3l,2l) === 1l);
+    assert(BigFloat.remainder(3l,2l) === -1l);
+
+    /* string conversion */
+    assert((1234.125l).toString(), "1234.125");
+    assert((1234.125l).toFixed(2), "1234.13");
+    assert((1234.125l).toFixed(2, "down"), "1234.12");
+    assert((1234.125l).toExponential(), "1.234125e+3");
+    assert((1234.125l).toExponential(5), "1.23413e+3");
+    assert((1234.125l).toExponential(5, BigFloatEnv.RNDZ), "1.23412e+3");
+    assert((1234.125l).toPrecision(6), "1234.13");
+    assert((1234.125l).toPrecision(6, BigFloatEnv.RNDZ), "1234.12");
+
+    /* string conversion with binary base */
+    assert((0x123.438l).toString(16), "123.438");
+    assert((0x323.438l).toString(16), "323.438");
+    assert((0x723.438l).toString(16), "723.438");
+    assert((0xf23.438l).toString(16), "f23.438");
+    assert((0x123.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "123.44");
+    assert((0x323.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "323.44");
+    assert((0x723.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "723.44");
+    assert((0xf23.438l).toFixed(2, BigFloatEnv.RNDNA, 16), "f23.44");
+    assert((0x0.0000438l).toFixed(6, BigFloatEnv.RNDNA, 16), "0.000044");
+    assert((0x1230000000l).toFixed(1, BigFloatEnv.RNDNA, 16), "1230000000.0");
+    assert((0x123.438l).toPrecision(5, BigFloatEnv.RNDNA, 16), "123.44");
+    assert((0x123.438l).toPrecision(5, BigFloatEnv.RNDZ, 16), "123.43");
+    assert((0x323.438l).toPrecision(5, BigFloatEnv.RNDNA, 16), "323.44");
+    assert((0x723.438l).toPrecision(5, BigFloatEnv.RNDNA, 16), "723.44");
+    assert((-0xf23.438l).toPrecision(5, BigFloatEnv.RNDD, 16), "-f23.44");
+    assert((0x123.438l).toExponential(4, BigFloatEnv.RNDNA, 16), "1.2344p+8");
+}
+
+function test_bigdecimal()
+{
+    assert(1m === 1m);
+    assert(1m !== 2m);
+    test_less(1m, 2m);
+    test_eq(2m, 2m);
+    
+    test_less(1, 2m);
+    test_eq(2, 2m);
+
+    test_less(1.1, 2m);
+    test_eq(Math.sqrt(4), 2m);
+    
+    test_less(2n, 3m);
+    test_eq(3n, 3m);
+    
+    assert(BigDecimal("1234.1") === 1234.1m);
+    assert(BigDecimal("    1234.1") === 1234.1m);
+    assert(BigDecimal("    1234.1  ") === 1234.1m);
+
+    assert(BigDecimal(0.1) === 0.1m);
+    assert(BigDecimal(123) === 123m);
+    assert(BigDecimal(true) === 1m);
+
+    assert(123m + 1m === 124m);
+    assert(123m - 1m === 122m);
+
+    assert(3.2m * 3m === 9.6m);
+    assert(10m / 2m === 5m);
+    assertThrows(RangeError, () => { 10m / 3m } );
+
+    assert(10m % 3m === 1m);
+    assert(-10m % 3m === -1m);
+
+    assert(1234.5m ** 3m === 1881365963.625m);
+    assertThrows(RangeError, () => { 2m ** 3.1m } );
+    assertThrows(RangeError, () => { 2m ** -3m } );
+    
+    assert(BigDecimal.sqrt(2m,
+                       { roundingMode: "half-even",
+                         maximumSignificantDigits: 4 }) === 1.414m);
+    assert(BigDecimal.sqrt(101m,
+                       { roundingMode: "half-even",
+                         maximumFractionDigits: 3 }) === 10.050m);
+    assert(BigDecimal.sqrt(0.002m,
+                       { roundingMode: "half-even",
+                         maximumFractionDigits: 3 }) === 0.045m);
+    
+    assert(BigDecimal.round(3.14159m,
+                       { roundingMode: "half-even",
+                         maximumFractionDigits: 3 }) === 3.142m);
+
+    assert(BigDecimal.add(3.14159m, 0.31212m,
+                          { roundingMode: "half-even",
+                            maximumFractionDigits: 2 }) === 3.45m);
+    assert(BigDecimal.sub(3.14159m, 0.31212m,
+                          { roundingMode: "down",
+                            maximumFractionDigits: 2 }) === 2.82m);
+    assert(BigDecimal.mul(3.14159m, 0.31212m,
+                          { roundingMode: "half-even",
+                            maximumFractionDigits: 3 }) === 0.981m);
+    assert(BigDecimal.mod(3.14159m, 0.31211m,
+                          { roundingMode: "half-even",
+                            maximumFractionDigits: 4 }) === 0.0205m);
+    assert(BigDecimal.div(20m, 3m,
+                       { roundingMode: "half-even",
+                         maximumSignificantDigits: 3 }) === 6.67m);
+    assert(BigDecimal.div(20m, 3m,
+                       { roundingMode: "half-even",
+                         maximumFractionDigits: 50 }) ===
+           6.66666666666666666666666666666666666666666666666667m);
+
+    /* string conversion */
+    assert((1234.125m).toString(), "1234.125");
+    assert((1234.125m).toFixed(2), "1234.13");
+    assert((1234.125m).toFixed(2, "down"), "1234.12");
+    assert((1234.125m).toExponential(), "1.234125e+3");
+    assert((1234.125m).toExponential(5), "1.23413e+3");
+    assert((1234.125m).toExponential(5, "down"), "1.23412e+3");
+    assert((1234.125m).toPrecision(6), "1234.13");
+    assert((1234.125m).toPrecision(6, "down"), "1234.12");
+    assert((-1234.125m).toPrecision(6, "floor"), "-1234.13");
+}
+
+test_bigint1();
+test_bigint2();
+test_bigint_ext();
+test_bigfloat();
+test_bigdecimal();

oden-js-sys/quickjs/tests/test_bjson.js

@@ -0,0 +1,191 @@
+import * as bjson from "./bjson.so";
+
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+function toHex(a)
+{
+    var i, s = "", tab, v;
+    tab = new Uint8Array(a);
+    for(i = 0; i < tab.length; i++) {
+        v = tab[i].toString(16);
+        if (v.length < 2)
+            v = "0" + v;
+        if (i !== 0)
+            s += " ";
+        s += v;
+    }
+    return s;
+}
+
+function isArrayLike(a)
+{
+    return Array.isArray(a) || 
+        (a instanceof Uint8ClampedArray) ||
+        (a instanceof Uint8Array) ||
+        (a instanceof Uint16Array) ||
+        (a instanceof Uint32Array) ||
+        (a instanceof Int8Array) ||
+        (a instanceof Int16Array) ||
+        (a instanceof Int32Array) ||
+        (a instanceof Float32Array) ||
+        (a instanceof Float64Array);
+}
+
+function toStr(a)
+{
+    var s, i, props, prop;
+
+    switch(typeof(a)) {
+    case "object":
+        if (a === null)
+            return "null";
+        if (a instanceof Date) {
+            s = "Date(" + toStr(a.valueOf()) + ")";
+        } else if (a instanceof Number) {
+            s = "Number(" + toStr(a.valueOf()) + ")";
+        } else if (a instanceof String) {
+            s = "String(" + toStr(a.valueOf()) + ")";
+        } else if (a instanceof Boolean) {
+            s = "Boolean(" + toStr(a.valueOf()) + ")";
+        } else if (isArrayLike(a)) {
+            s = "[";
+            for(i = 0; i < a.length; i++) {
+                if (i != 0)
+                    s += ",";
+                s += toStr(a[i]);
+            }
+            s += "]";
+        } else {
+            props = Object.keys(a);
+            s = "{";
+            for(i = 0; i < props.length; i++) {
+                if (i != 0)
+                    s += ",";
+                prop = props[i];
+                s += prop + ":" + toStr(a[prop]);
+            }
+            s += "}";
+        }
+        return s;
+    case "undefined":
+        return "undefined";
+    case "string":
+        return a.__quote();
+    case "number":
+    case "bigfloat":
+        if (a == 0 && 1 / a < 0)
+            return "-0";
+        else
+            return a.toString();
+        break;
+    default:
+        return a.toString();
+    }
+}
+
+function bjson_test(a)
+{
+    var buf, r, a_str, r_str;
+    a_str = toStr(a);
+    buf = bjson.write(a);
+    if (0) {
+        print(a_str, "->", toHex(buf));
+    }
+    r = bjson.read(buf, 0, buf.byteLength);
+    r_str = toStr(r);
+    if (a_str != r_str) {
+        print(a_str);
+        print(r_str);
+        assert(false);
+    }
+}
+
+/* test multiple references to an object including circular
+   references */
+function bjson_test_reference()
+{
+    var array, buf, i, n, array_buffer;
+    n = 16;
+    array = [];
+    for(i = 0; i < n; i++)
+        array[i] = {};
+    array_buffer = new ArrayBuffer(n);
+    for(i = 0; i < n; i++) {
+        array[i].next = array[(i + 1) % n];
+        array[i].idx = i;
+        array[i].typed_array = new Uint8Array(array_buffer, i, 1);
+    }
+    buf = bjson.write(array, true);
+
+    array = bjson.read(buf, 0, buf.byteLength, true);
+
+    /* check the result */
+    for(i = 0; i < n; i++) {
+        assert(array[i].next, array[(i + 1) % n]);
+        assert(array[i].idx, i);
+        assert(array[i].typed_array.buffer, array_buffer);
+        assert(array[i].typed_array.length, 1);
+        assert(array[i].typed_array.byteOffset, i);
+    }
+}
+
+function bjson_test_all()
+{
+    var obj;
+    
+    bjson_test({x:1, y:2, if:3});
+    bjson_test([1, 2, 3]);
+    bjson_test([1.0, "aa", true, false, undefined, null, NaN, -Infinity, -0.0]);
+    if (typeof BigInt !== "undefined") {
+        bjson_test([BigInt("1"), -BigInt("0x123456789"),
+               BigInt("0x123456789abcdef123456789abcdef")]);
+    }
+    if (typeof BigFloat !== "undefined") {
+        BigFloatEnv.setPrec(function () {
+            bjson_test([BigFloat("0.1"), BigFloat("-1e30"), BigFloat("0"),
+                   BigFloat("-0"), BigFloat("Infinity"), BigFloat("-Infinity"),
+                   0.0 / BigFloat("0"), BigFloat.MAX_VALUE,
+                   BigFloat.MIN_VALUE]);
+        }, 113, 15);
+    }
+    if (typeof BigDecimal !== "undefined") {
+        bjson_test([BigDecimal("0"),
+                    BigDecimal("0.8"), BigDecimal("123321312321321e100"),
+                    BigDecimal("-1233213123213214332333223332e100"),
+                    BigDecimal("1.233e-1000")]);
+    }
+
+    bjson_test([new Date(1234), new String("abc"), new Number(-12.1), new Boolean(true)]);
+
+    bjson_test(new Int32Array([123123, 222111, -32222]));
+    bjson_test(new Float64Array([123123, 222111.5]));
+    
+    /* tested with a circular reference */
+    obj = {};
+    obj.x = obj;
+    try {
+        bjson.write(obj);
+        assert(false);
+    } catch(e) {
+        assert(e instanceof TypeError);
+    }
+
+    bjson_test_reference();
+}
+
+bjson_test_all();

oden-js-sys/quickjs/tests/test_builtin.js

@@ -0,0 +1,685 @@
+"use strict";
+
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+function assert_throws(expected_error, func)
+{
+    var err = false;
+    try {
+        func();
+    } catch(e) {
+        err = true;
+        if (!(e instanceof expected_error)) {
+            throw Error("unexpected exception type");
+        }
+    }
+    if (!err) {
+        throw Error("expected exception");
+    }
+}
+
+// load more elaborate version of assert if available
+try { __loadScript("test_assert.js"); } catch(e) {}
+
+/*----------------*/
+
+function my_func(a, b)
+{
+    return a + b;
+}
+
+function test_function()
+{
+    function f(a, b) {
+        var i, tab = [];
+        tab.push(this);
+        for(i = 0; i < arguments.length; i++)
+            tab.push(arguments[i]);
+        return tab;
+    }
+    function constructor1(a) {
+        this.x = a;
+    }
+
+    var r, g;
+    
+    r = my_func.call(null, 1, 2);
+    assert(r, 3, "call");
+
+    r = my_func.apply(null, [1, 2]);
+    assert(r, 3, "apply");
+
+    r = (function () { return 1; }).apply(null, undefined);
+    assert(r, 1);
+
+    assert_throws(TypeError, (function() {
+        Reflect.apply((function () { return 1; }), null, undefined);
+    }));
+    
+    r = new Function("a", "b", "return a + b;");
+    assert(r(2,3), 5, "function");
+    
+    g = f.bind(1, 2);
+    assert(g.length, 1);
+    assert(g.name, "bound f");
+    assert(g(3), [1,2,3]);
+
+    g = constructor1.bind(null, 1);
+    r = new g();
+    assert(r.x, 1);
+}
+
+function test()
+{
+    var r, a, b, c, err;
+
+    r = Error("hello");
+    assert(r.message, "hello", "Error");
+
+    a = new Object();
+    a.x = 1;
+    assert(a.x, 1, "Object");
+
+    assert(Object.getPrototypeOf(a), Object.prototype, "getPrototypeOf");
+    Object.defineProperty(a, "y", { value: 3, writable: true, configurable: true, enumerable: true });
+    assert(a.y, 3, "defineProperty");
+
+    Object.defineProperty(a, "z", { get: function () { return 4; }, set: function(val) { this.z_val = val; }, configurable: true, enumerable: true });
+    assert(a.z, 4, "get");
+    a.z = 5;
+    assert(a.z_val, 5, "set");
+    
+    a = { get z() { return 4; }, set z(val) { this.z_val = val; } };
+    assert(a.z, 4, "get");
+    a.z = 5;
+    assert(a.z_val, 5, "set");
+
+    b = Object.create(a);
+    assert(Object.getPrototypeOf(b), a, "create");
+    c = {u:2};
+    /* XXX: refcount bug in 'b' instead of 'a' */
+    Object.setPrototypeOf(a, c);
+    assert(Object.getPrototypeOf(a), c, "setPrototypeOf");
+
+    a = {};
+    assert(a.toString(), "[object Object]", "toString");
+
+    a = {x:1};
+    assert(Object.isExtensible(a), true, "extensible");
+    Object.preventExtensions(a);
+
+    err = false;
+    try {
+        a.y = 2;
+    } catch(e) {
+        err = true;
+    }
+    assert(Object.isExtensible(a), false, "extensible");
+    assert(typeof a.y, "undefined", "extensible");
+    assert(err, true, "extensible");
+}
+
+function test_enum()
+{
+    var a, tab;
+    a = {x:1,
+         "18014398509481984": 1,
+         "9007199254740992": 1,
+         "9007199254740991": 1,
+         "4294967296": 1,
+         "4294967295": 1,
+         y:1,
+         "4294967294": 1,
+         "1": 2};
+    tab = Object.keys(a);
+//    console.log("tab=" + tab.toString());
+    assert(tab, ["1","4294967294","x","18014398509481984","9007199254740992","9007199254740991","4294967296","4294967295","y"], "keys");
+}
+
+function test_array()
+{
+    var a, err;
+
+    a = [1, 2, 3];
+    assert(a.length, 3, "array");
+    assert(a[2], 3, "array1");
+
+    a = new Array(10);
+    assert(a.length, 10, "array2");
+
+    a = new Array(1, 2);
+    assert(a.length === 2 && a[0] === 1 && a[1] === 2, true, "array3");
+
+    a = [1, 2, 3];
+    a.length = 2;
+    assert(a.length === 2 && a[0] === 1 && a[1] === 2, true, "array4");
+
+    a = [];
+    a[1] = 10;
+    a[4] = 3;
+    assert(a.length, 5);
+
+    a = [1,2];
+    a.length = 5;
+    a[4] = 1;
+    a.length = 4;
+    assert(a[4] !== 1, true, "array5");
+
+    a = [1,2];
+    a.push(3,4);
+    assert(a.join(), "1,2,3,4", "join");
+
+    a = [1,2,3,4,5];
+    Object.defineProperty(a, "3", { configurable: false });
+    err = false;
+    try {
+        a.length = 2;
+    } catch(e) {
+        err = true;
+    }
+    assert(err && a.toString() === "1,2,3,4");
+}
+
+function test_string()
+{
+    var a;
+    a = String("abc");
+    assert(a.length, 3, "string");
+    assert(a[1], "b", "string");
+    assert(a.charCodeAt(1), 0x62, "string");
+    assert(String.fromCharCode(65), "A", "string");
+    assert(String.fromCharCode.apply(null, [65, 66, 67]), "ABC", "string");
+    assert(a.charAt(1), "b");
+    assert(a.charAt(-1), "");
+    assert(a.charAt(3), "");
+    
+    a = "abcd";
+    assert(a.substring(1, 3), "bc", "substring");
+    a = String.fromCharCode(0x20ac);
+    assert(a.charCodeAt(0), 0x20ac, "unicode");
+    assert(a, "€", "unicode");
+    assert(a, "\u20ac", "unicode");
+    assert(a, "\u{20ac}", "unicode");
+    assert("a", "\x61", "unicode");
+        
+    a = "\u{10ffff}";
+    assert(a.length, 2, "unicode");
+    assert(a, "\u{dbff}\u{dfff}", "unicode");
+    assert(a.codePointAt(0), 0x10ffff);
+    assert(String.fromCodePoint(0x10ffff), a);
+
+    assert("a".concat("b", "c"), "abc");
+
+    assert("abcabc".indexOf("cab"), 2);
+    assert("abcabc".indexOf("cab2"), -1);
+    assert("abc".indexOf("c"), 2);
+
+    assert("aaa".indexOf("a"), 0);
+    assert("aaa".indexOf("a", NaN), 0);
+    assert("aaa".indexOf("a", -Infinity), 0);
+    assert("aaa".indexOf("a", -1), 0);
+    assert("aaa".indexOf("a", -0), 0);
+    assert("aaa".indexOf("a", 0), 0);
+    assert("aaa".indexOf("a", 1), 1);
+    assert("aaa".indexOf("a", 2), 2);
+    assert("aaa".indexOf("a", 3), -1);
+    assert("aaa".indexOf("a", 4), -1);
+    assert("aaa".indexOf("a", Infinity), -1);
+
+    assert("aaa".indexOf(""), 0);
+    assert("aaa".indexOf("", NaN), 0);
+    assert("aaa".indexOf("", -Infinity), 0);
+    assert("aaa".indexOf("", -1), 0);
+    assert("aaa".indexOf("", -0), 0);
+    assert("aaa".indexOf("", 0), 0);
+    assert("aaa".indexOf("", 1), 1);
+    assert("aaa".indexOf("", 2), 2);
+    assert("aaa".indexOf("", 3), 3);
+    assert("aaa".indexOf("", 4), 3);
+    assert("aaa".indexOf("", Infinity), 3);
+
+    assert("aaa".lastIndexOf("a"), 2);
+    assert("aaa".lastIndexOf("a", NaN), 2);
+    assert("aaa".lastIndexOf("a", -Infinity), 0);
+    assert("aaa".lastIndexOf("a", -1), 0);
+    assert("aaa".lastIndexOf("a", -0), 0);
+    assert("aaa".lastIndexOf("a", 0), 0);
+    assert("aaa".lastIndexOf("a", 1), 1);
+    assert("aaa".lastIndexOf("a", 2), 2);
+    assert("aaa".lastIndexOf("a", 3), 2);
+    assert("aaa".lastIndexOf("a", 4), 2);
+    assert("aaa".lastIndexOf("a", Infinity), 2);
+
+    assert("aaa".lastIndexOf(""), 3);
+    assert("aaa".lastIndexOf("", NaN), 3);
+    assert("aaa".lastIndexOf("", -Infinity), 0);
+    assert("aaa".lastIndexOf("", -1), 0);
+    assert("aaa".lastIndexOf("", -0), 0);
+    assert("aaa".lastIndexOf("", 0), 0);
+    assert("aaa".lastIndexOf("", 1), 1);
+    assert("aaa".lastIndexOf("", 2), 2);
+    assert("aaa".lastIndexOf("", 3), 3);
+    assert("aaa".lastIndexOf("", 4), 3);
+    assert("aaa".lastIndexOf("", Infinity), 3);
+
+    assert("a,b,c".split(","), ["a","b","c"]);
+    assert(",b,c".split(","), ["","b","c"]);
+    assert("a,b,".split(","), ["a","b",""]);
+
+    assert("aaaa".split(), [ "aaaa" ]);
+    assert("aaaa".split(undefined, 0), [ ]);
+    assert("aaaa".split(""), [ "a", "a", "a", "a" ]);
+    assert("aaaa".split("", 0), [ ]);
+    assert("aaaa".split("", 1), [ "a" ]);
+    assert("aaaa".split("", 2), [ "a", "a" ]);
+    assert("aaaa".split("a"), [ "", "", "", "", "" ]);
+    assert("aaaa".split("a", 2), [ "", "" ]);
+    assert("aaaa".split("aa"), [ "", "", "" ]);
+    assert("aaaa".split("aa", 0), [ ]);
+    assert("aaaa".split("aa", 1), [ "" ]);
+    assert("aaaa".split("aa", 2), [ "", "" ]);
+    assert("aaaa".split("aaa"), [ "", "a" ]);
+    assert("aaaa".split("aaaa"), [ "", "" ]);
+    assert("aaaa".split("aaaaa"), [ "aaaa" ]);
+    assert("aaaa".split("aaaaa", 0), [  ]);
+    assert("aaaa".split("aaaaa", 1), [ "aaaa" ]);
+
+    assert(eval('"\0"'), "\0");
+
+    assert("abc".padStart(Infinity, ""), "abc");
+}
+
+function test_math()
+{
+    var a;
+    a = 1.4;
+    assert(Math.floor(a), 1);
+    assert(Math.ceil(a), 2);
+    assert(Math.imul(0x12345678, 123), -1088058456);
+    assert(Math.fround(0.1), 0.10000000149011612);
+    assert(Math.hypot() == 0);
+    assert(Math.hypot(-2) == 2);
+    assert(Math.hypot(3, 4) == 5);
+    assert(Math.abs(Math.hypot(3, 4, 5) - 7.0710678118654755) <= 1e-15);
+}
+
+function test_number()
+{
+    assert(parseInt("123"), 123);
+    assert(parseInt("  123r"), 123);
+    assert(parseInt("0x123"), 0x123);
+    assert(parseInt("0o123"), 0);
+    assert(+"  123   ", 123);
+    assert(+"0b111", 7);
+    assert(+"0o123", 83);
+    assert(parseFloat("0x1234"), 0);
+    assert(parseFloat("Infinity"), Infinity);
+    assert(parseFloat("-Infinity"), -Infinity);
+    assert(parseFloat("123.2"), 123.2);
+    assert(parseFloat("123.2e3"), 123200);
+    assert(Number.isNaN(Number("+")));
+    assert(Number.isNaN(Number("-")));
+    assert(Number.isNaN(Number("\x00a")));
+
+    assert((25).toExponential(0), "3e+1");
+    assert((-25).toExponential(0), "-3e+1");
+    assert((2.5).toPrecision(1), "3");
+    assert((-2.5).toPrecision(1), "-3");
+    assert((1.125).toFixed(2), "1.13");
+    assert((-1.125).toFixed(2), "-1.13");
+}
+
+function test_eval2()
+{
+    var g_call_count = 0;
+    /* force non strict mode for f1 and f2 */
+    var f1 = new Function("eval", "eval(1, 2)");
+    var f2 = new Function("eval", "eval(...[1, 2])");
+    function g(a, b) {
+        assert(a, 1);
+        assert(b, 2);
+        g_call_count++;
+    }
+    f1(g);
+    f2(g);
+    assert(g_call_count, 2);
+}
+
+function test_eval()
+{
+    function f(b) {
+        var x = 1;
+        return eval(b);
+    }
+    var r, a;
+
+    r = eval("1+1;");
+    assert(r, 2, "eval");
+
+    r = eval("var my_var=2; my_var;");
+    assert(r, 2, "eval");
+    assert(typeof my_var, "undefined");
+
+    assert(eval("if (1) 2; else 3;"), 2);
+    assert(eval("if (0) 2; else 3;"), 3);
+
+    assert(f.call(1, "this"), 1);
+    
+    a = 2;
+    assert(eval("a"), 2);
+
+    eval("a = 3");
+    assert(a, 3);
+
+    assert(f("arguments.length", 1), 2);
+    assert(f("arguments[1]", 1), 1);
+
+    a = 4;
+    assert(f("a"), 4);
+    f("a=3");
+    assert(a, 3);
+
+    test_eval2();
+}
+
+function test_typed_array()
+{
+    var buffer, a, i, str;
+
+    a = new Uint8Array(4);
+    assert(a.length, 4);
+    for(i = 0; i < a.length; i++)
+        a[i] = i;
+    assert(a.join(","), "0,1,2,3");
+    a[0] = -1;
+    assert(a[0], 255);
+
+    a = new Int8Array(3);
+    a[0] = 255;
+    assert(a[0], -1);
+
+    a = new Int32Array(3);
+    a[0] = Math.pow(2, 32) - 1;
+    assert(a[0], -1);
+    assert(a.BYTES_PER_ELEMENT, 4);
+
+    a = new Uint8ClampedArray(4);
+    a[0] = -100;
+    a[1] = 1.5;
+    a[2] = 0.5;
+    a[3] = 1233.5;
+    assert(a.toString(), "0,2,0,255");
+    
+    buffer = new ArrayBuffer(16);
+    assert(buffer.byteLength, 16);
+    a = new Uint32Array(buffer, 12, 1);
+    assert(a.length, 1);
+    a[0] = -1;
+
+    a = new Uint16Array(buffer, 2);
+    a[0] = -1;
+
+    a = new Float32Array(buffer, 8, 1);
+    a[0] = 1;
+    
+    a = new Uint8Array(buffer);
+
+    str = a.toString();
+    /* test little and big endian cases */
+    if (str !== "0,0,255,255,0,0,0,0,0,0,128,63,255,255,255,255" &&
+        str !== "0,0,255,255,0,0,0,0,63,128,0,0,255,255,255,255") {
+        assert(false);
+    }
+
+    assert(a.buffer, buffer);
+
+    a = new Uint8Array([1, 2, 3, 4]);
+    assert(a.toString(), "1,2,3,4");
+    a.set([10, 11], 2);
+    assert(a.toString(), "1,2,10,11");
+}
+
+function test_json()
+{
+    var a, s;
+    s = '{"x":1,"y":true,"z":null,"a":[1,2,3],"s":"str"}';
+    a = JSON.parse(s);
+    assert(a.x, 1);
+    assert(a.y, true);
+    assert(a.z, null);
+    assert(JSON.stringify(a), s);
+
+    /* indentation test */
+    assert(JSON.stringify([[{x:1,y:{},z:[]},2,3]],undefined,1),
+`[
+ [
+  {
+   "x": 1,
+   "y": {},
+   "z": []
+  },
+  2,
+  3
+ ]
+]`);
+}
+
+function test_date()
+{
+    var d = new Date(1506098258091), a, s;
+    assert(d.toISOString(), "2017-09-22T16:37:38.091Z");
+    d.setUTCHours(18, 10, 11);
+    assert(d.toISOString(), "2017-09-22T18:10:11.091Z");
+    a = Date.parse(d.toISOString());
+    assert((new Date(a)).toISOString(), d.toISOString());
+    s = new Date("2020-01-01T01:01:01.1Z").toISOString();
+    assert(s ==  "2020-01-01T01:01:01.100Z");
+    s = new Date("2020-01-01T01:01:01.12Z").toISOString();
+    assert(s ==  "2020-01-01T01:01:01.120Z");
+    s = new Date("2020-01-01T01:01:01.123Z").toISOString();
+    assert(s ==  "2020-01-01T01:01:01.123Z");
+    s = new Date("2020-01-01T01:01:01.1234Z").toISOString();
+    assert(s ==  "2020-01-01T01:01:01.123Z");
+    s = new Date("2020-01-01T01:01:01.12345Z").toISOString();
+    assert(s ==  "2020-01-01T01:01:01.123Z");
+    s = new Date("2020-01-01T01:01:01.1235Z").toISOString();
+    assert(s ==  "2020-01-01T01:01:01.124Z");
+    s = new Date("2020-01-01T01:01:01.9999Z").toISOString();
+    assert(s ==  "2020-01-01T01:01:02.000Z");
+}
+
+function test_regexp()
+{
+    var a, str;
+    str = "abbbbbc";
+    a = /(b+)c/.exec(str);
+    assert(a[0], "bbbbbc");
+    assert(a[1], "bbbbb");
+    assert(a.index, 1);
+    assert(a.input, str);
+    a = /(b+)c/.test(str);
+    assert(a, true);
+    assert(/\x61/.exec("a")[0], "a");
+    assert(/\u0061/.exec("a")[0], "a");
+    assert(/\ca/.exec("\x01")[0], "\x01");
+    assert(/\\a/.exec("\\a")[0], "\\a");
+    assert(/\c0/.exec("\\c0")[0], "\\c0");
+
+    a = /(\.(?=com|org)|\/)/.exec("ah.com");
+    assert(a.index === 2 && a[0] === ".");
+
+    a = /(\.(?!com|org)|\/)/.exec("ah.com");
+    assert(a, null);
+    
+    a = /(?=(a+))/.exec("baaabac");
+    assert(a.index === 1 && a[0] === "" && a[1] === "aaa");
+
+    a = /(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac");
+    assert(a, ["zaacbbbcac","z","ac","a",,"c"]);
+
+    a = eval("/\0a/");
+    assert(a.toString(), "/\0a/");
+    assert(a.exec("\0a")[0], "\0a");
+
+    assert(/{1a}/.toString(), "/{1a}/");
+    a = /a{1+/.exec("a{11");
+    assert(a, ["a{11"] );
+}
+
+function test_symbol()
+{
+    var a, b, obj, c;
+    a = Symbol("abc");
+    obj = {};
+    obj[a] = 2;
+    assert(obj[a], 2);
+    assert(typeof obj["abc"], "undefined");
+    assert(String(a), "Symbol(abc)");
+    b = Symbol("abc");
+    assert(a == a);
+    assert(a === a);
+    assert(a != b);
+    assert(a !== b);
+
+    b = Symbol.for("abc");
+    c = Symbol.for("abc");
+    assert(b === c);
+    assert(b !== a);
+
+    assert(Symbol.keyFor(b), "abc");
+    assert(Symbol.keyFor(a), undefined);
+
+    a = Symbol("aaa");
+    assert(a.valueOf(), a);
+    assert(a.toString(), "Symbol(aaa)");
+
+    b = Object(a);
+    assert(b.valueOf(), a);
+    assert(b.toString(), "Symbol(aaa)");
+}
+
+function test_map()
+{
+    var a, i, n, tab, o, v;
+    n = 1000;
+    a = new Map();
+    tab = [];
+    for(i = 0; i < n; i++) {
+        v = { };
+        o = { id: i };
+        tab[i] = [o, v];
+        a.set(o, v);
+    }
+
+    assert(a.size, n);
+    for(i = 0; i < n; i++) {
+        assert(a.get(tab[i][0]), tab[i][1]);
+    }
+
+    i = 0;
+    a.forEach(function (v, o) { 
+        assert(o, tab[i++][0]);
+        assert(a.has(o));
+        assert(a.delete(o));
+        assert(!a.has(o));
+    });
+
+    assert(a.size, 0);
+}
+
+function test_weak_map()
+{
+    var a, i, n, tab, o, v, n2;
+    a = new WeakMap();
+    n = 10;
+    tab = [];
+    for(i = 0; i < n; i++) {
+        v = { };
+        o = { id: i };
+        tab[i] = [o, v];
+        a.set(o, v);
+    }
+    o = null;
+    
+    n2 = n >> 1;
+    for(i = 0; i < n2; i++) {
+        a.delete(tab[i][0]);
+    }
+    for(i = n2; i < n; i++) {
+        tab[i][0] = null; /* should remove the object from the WeakMap too */
+    }
+    /* the WeakMap should be empty here */
+}
+
+function test_generator()
+{
+    function *f() {
+        var ret;
+        yield 1;
+        ret = yield 2;
+        assert(ret, "next_arg");
+        return 3;
+    }
+    function *f2() {
+        yield 1;
+        yield 2;
+        return "ret_val";
+    }
+    function *f1() {
+        var ret = yield *f2();
+        assert(ret, "ret_val");
+        return 3;
+    }
+    var g, v;
+    g = f();
+    v = g.next();
+    assert(v.value === 1 && v.done === false);
+    v = g.next();
+    assert(v.value === 2 && v.done === false);
+    v = g.next("next_arg");
+    assert(v.value === 3 && v.done === true);
+    v = g.next();
+    assert(v.value === undefined && v.done === true);
+
+    g = f1();
+    v = g.next();
+    assert(v.value === 1 && v.done === false);
+    v = g.next();
+    assert(v.value === 2 && v.done === false);
+    v = g.next();
+    assert(v.value === 3 && v.done === true);
+    v = g.next();
+    assert(v.value === undefined && v.done === true);
+}
+
+test();
+test_function();
+test_enum();
+test_array();
+test_string();
+test_math();
+test_number();
+test_eval();
+test_typed_array();
+test_json();
+test_date();
+test_regexp();
+test_symbol();
+test_map();
+test_weak_map();
+test_generator();

oden-js-sys/quickjs/tests/test_closure.js

@@ -0,0 +1,221 @@
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+// load more elaborate version of assert if available
+try { __loadScript("test_assert.js"); } catch(e) {}
+
+/*----------------*/
+
+var log_str = "";
+
+function log(str)
+{
+    log_str += str + ",";
+}
+
+function f(a, b, c)
+{
+    var x = 10;
+    log("a="+a);
+    function g(d) {
+        function h() {
+            log("d=" + d);
+            log("x=" + x);
+        }
+        log("b=" + b);
+        log("c=" + c);
+        h();
+    }
+    g(4);
+    return g;
+}
+
+var g1 = f(1, 2, 3);
+g1(5);
+
+assert(log_str, "a=1,b=2,c=3,d=4,x=10,b=2,c=3,d=5,x=10,", "closure1");
+
+function test_closure1()
+{
+    function f2()
+    {
+        var val = 1;
+        
+        function set(a) {
+            val = a;
+        }
+        function get(a) {
+            return val;
+        }
+        return { "set": set, "get": get };
+    }
+    
+    var obj = f2();
+    obj.set(10);
+    var r;
+    r = obj.get();
+    assert(r, 10, "closure2");
+}
+
+function test_closure2()
+{
+    var expr_func = function myfunc1(n) {
+        function myfunc2(n) {
+            return myfunc1(n - 1);
+        }
+        if (n == 0)
+            return 0;
+        else
+            return myfunc2(n);
+    };
+    var r;
+    r = expr_func(1);
+    assert(r, 0, "expr_func");
+}
+
+function test_closure3()
+{
+    function fib(n)
+    {
+        if (n <= 0)
+            return 0;
+        else if (n == 1)
+            return 1;
+        else
+            return fib(n - 1) + fib(n - 2);
+    }
+
+    var fib_func = function fib1(n)
+    {
+        if (n <= 0)
+            return 0;
+        else if (n == 1)
+            return 1;
+        else
+            return fib1(n - 1) + fib1(n - 2);
+    };
+
+    assert(fib(6), 8, "fib");
+    assert(fib_func(6), 8, "fib_func");
+}
+
+function test_arrow_function()
+{
+    "use strict";
+
+    function f1() {
+        return (() => arguments)();
+    }
+    function f2() {
+        return (() => this)();
+    }
+    function f3() {
+        return (() => eval("this"))();
+    }
+    function f4() {
+        return (() => eval("new.target"))();
+    }
+    var a;
+
+    a = f1(1, 2);
+    assert(a.length, 2);
+    assert(a[0] === 1 && a[1] === 2);
+
+    assert(f2.call("this_val") === "this_val");
+    assert(f3.call("this_val") === "this_val");
+    assert(new f4() === f4);
+
+    var o1 = { f() { return this; } };
+    var o2 = { f() {
+        return (() => eval("super.f()"))();
+    } };
+    o2.__proto__ = o1;
+
+    assert(o2.f() === o2);
+}
+
+function test_with()
+{
+    var o1 = { x: "o1", y: "o1" };
+    var x = "local";
+    eval('var z="var_obj";');
+    assert(z === "var_obj");
+    with (o1) {
+        assert(x === "o1");
+        assert(eval("x") === "o1");
+        var f = function () {
+            o2 = { x: "o2" };
+            with (o2) {
+                assert(x === "o2");
+                assert(y === "o1");
+                assert(z === "var_obj");
+                assert(eval("x") === "o2");
+                assert(eval("y") === "o1");
+                assert(eval("z") === "var_obj");
+                assert(eval('eval("x")') === "o2");
+            }
+        };
+        f();
+    }
+}
+
+function test_eval_closure()
+{
+    var tab;
+
+    tab = [];
+    for(let i = 0; i < 3; i++) {
+        eval("tab.push(function g1() { return i; })");
+    }
+    for(let i = 0; i < 3; i++) {
+        assert(tab[i]() === i);
+    }
+
+    tab = [];
+    for(let i = 0; i < 3; i++) {
+        let f = function f() {
+            eval("tab.push(function g2() { return i; })");
+        };
+        f();
+    }
+    for(let i = 0; i < 3; i++) {
+        assert(tab[i]() === i);
+    }
+}
+
+function test_eval_const()
+{
+    const a = 1;
+    var success = false;
+    var f = function () {
+        eval("a = 1");
+    };
+    try {
+        f();
+    } catch(e) {
+        success = (e instanceof TypeError);
+    }
+    assert(success);
+}
+
+test_closure1();
+test_closure2();
+test_closure3();
+test_arrow_function();
+test_with();
+test_eval_closure();
+test_eval_const();

oden-js-sys/quickjs/tests/test_language.js

@@ -0,0 +1,547 @@
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+function assert_throws(expected_error, func)
+{
+    var err = false;
+    try {
+        func();
+    } catch(e) {
+        err = true;
+        if (!(e instanceof expected_error)) {
+            throw Error("unexpected exception type");
+        }
+    }
+    if (!err) {
+        throw Error("expected exception");
+    }
+}
+
+// load more elaborate version of assert if available
+try { __loadScript("test_assert.js"); } catch(e) {}
+
+/*----------------*/
+
+function test_op1()
+{
+    var r, a;
+    r = 1 + 2;
+    assert(r, 3, "1 + 2 === 3");
+
+    r = 1 - 2;
+    assert(r, -1, "1 - 2 === -1");
+
+    r = -1;
+    assert(r, -1, "-1 === -1");
+
+    r = +2;
+    assert(r, 2, "+2 === 2");
+
+    r = 2 * 3;
+    assert(r, 6, "2 * 3 === 6");
+
+    r = 4 / 2;
+    assert(r, 2, "4 / 2 === 2");
+
+    r = 4 % 3;
+    assert(r, 1, "4 % 3 === 3");
+
+    r = 4 << 2;
+    assert(r, 16, "4 << 2 === 16");
+
+    r = 1 << 0;
+    assert(r, 1, "1 << 0 === 1");
+
+    r = 1 << 31;
+    assert(r, -2147483648, "1 << 31 === -2147483648");
+    
+    r = 1 << 32;
+    assert(r, 1, "1 << 32 === 1");
+    
+    r = (1 << 31) < 0;
+    assert(r, true, "(1 << 31) < 0 === true");
+
+    r = -4 >> 1;
+    assert(r, -2, "-4 >> 1 === -2");
+
+    r = -4 >>> 1;
+    assert(r, 0x7ffffffe, "-4 >>> 1 === 0x7ffffffe");
+
+    r = 1 & 1;
+    assert(r, 1, "1 & 1 === 1");
+
+    r = 0 | 1;
+    assert(r, 1, "0 | 1 === 1");
+
+    r = 1 ^ 1;
+    assert(r, 0, "1 ^ 1 === 0");
+
+    r = ~1;
+    assert(r, -2, "~1 === -2");
+
+    r = !1;
+    assert(r, false, "!1 === false");
+
+    assert((1 < 2), true, "(1 < 2) === true");
+
+    assert((2 > 1), true, "(2 > 1) === true");
+
+    assert(('b' > 'a'), true, "('b' > 'a') === true");
+
+    assert(2 ** 8, 256, "2 ** 8 === 256");
+}
+
+function test_cvt()
+{
+    assert((NaN | 0) === 0);
+    assert((Infinity | 0) === 0);
+    assert(((-Infinity) | 0) === 0);
+    assert(("12345" | 0) === 12345);
+    assert(("0x12345" | 0) === 0x12345);
+    assert(((4294967296 * 3 - 4) | 0) === -4);
+    
+    assert(("12345" >>> 0) === 12345);
+    assert(("0x12345" >>> 0) === 0x12345);
+    assert((NaN >>> 0) === 0);
+    assert((Infinity >>> 0) === 0);
+    assert(((-Infinity) >>> 0) === 0);
+    assert(((4294967296 * 3 - 4) >>> 0) === (4294967296 - 4));
+}
+
+function test_eq()
+{
+    assert(null == undefined);
+    assert(undefined == null);
+    assert(true == 1);
+    assert(0 == false);
+    assert("" == 0);
+    assert("123" == 123);
+    assert("122" != 123);
+    assert((new Number(1)) == 1);
+    assert(2 == (new Number(2)));
+    assert((new String("abc")) == "abc");
+    assert({} != "abc");
+}
+
+function test_inc_dec()
+{
+    var a, r;
+    
+    a = 1;
+    r = a++;
+    assert(r === 1 && a === 2, true, "++");
+
+    a = 1;
+    r = ++a;
+    assert(r === 2 && a === 2, true, "++");
+
+    a = 1;
+    r = a--;
+    assert(r === 1 && a === 0, true, "--");
+
+    a = 1;
+    r = --a;
+    assert(r === 0 && a === 0, true, "--");
+
+    a = {x:true};
+    a.x++;
+    assert(a.x, 2, "++");
+
+    a = {x:true};
+    a.x--;
+    assert(a.x, 0, "--");
+
+    a = [true];
+    a[0]++;
+    assert(a[0], 2, "++");
+    
+    a = {x:true};
+    r = a.x++;
+    assert(r === 1 && a.x === 2, true, "++");
+    
+    a = {x:true};
+    r = a.x--;
+    assert(r === 1 && a.x === 0, true, "--");
+    
+    a = [true];
+    r = a[0]++;
+    assert(r === 1 && a[0] === 2, true, "++");
+    
+    a = [true];
+    r = a[0]--;
+    assert(r === 1 && a[0] === 0, true, "--");
+}
+
+function F(x)
+{
+    this.x = x;
+}
+
+function test_op2()
+{
+    var a, b;
+    a = new Object;
+    a.x = 1;
+    assert(a.x, 1, "new");
+    b = new F(2);
+    assert(b.x, 2, "new");
+
+    a = {x : 2};
+    assert(("x" in a), true, "in");
+    assert(("y" in a), false, "in");
+
+    a = {};
+    assert((a instanceof Object), true, "instanceof");
+    assert((a instanceof String), false, "instanceof");
+
+    assert((typeof 1), "number", "typeof");
+    assert((typeof Object), "function", "typeof");
+    assert((typeof null), "object", "typeof");
+    assert((typeof unknown_var), "undefined", "typeof");
+    
+    a = {x: 1, if: 2, async: 3};
+    assert(a.if === 2);
+    assert(a.async === 3);
+}
+
+function test_delete()
+{
+    var a, err;
+
+    a = {x: 1, y: 1};
+    assert((delete a.x), true, "delete");
+    assert(("x" in a), false, "delete");
+    
+    /* the following are not tested by test262 */
+    assert(delete "abc"[100], true);
+
+    err = false;
+    try {
+        delete null.a;
+    } catch(e) {
+        err = (e instanceof TypeError);
+    }
+    assert(err, true, "delete");
+
+    err = false;
+    try {
+        a = { f() { delete super.a; } };
+        a.f();
+    } catch(e) {
+        err = (e instanceof ReferenceError);
+    }
+    assert(err, true, "delete");
+}
+
+function test_prototype()
+{
+    var f = function f() { };
+    assert(f.prototype.constructor, f, "prototype");
+
+    var g = function g() { };
+    /* QuickJS bug */
+    Object.defineProperty(g, "prototype", { writable: false });
+    assert(g.prototype.constructor, g, "prototype");
+}
+
+function test_arguments()
+{
+    function f2() {
+        assert(arguments.length, 2, "arguments");
+        assert(arguments[0], 1, "arguments");
+        assert(arguments[1], 3, "arguments");
+    }
+    f2(1, 3);
+}
+
+function test_class()
+{
+    var o;
+    class C {
+        constructor() {
+            this.x = 10;
+        }
+        f() {
+            return 1;
+        }
+        static F() {
+            return -1;
+        }
+        get y() {
+            return 12;
+        }
+    };
+    class D extends C {
+        constructor() {
+            super();
+            this.z = 20;
+        }
+        g() {
+            return 2;
+        }
+        static G() {
+            return -2;
+        }
+        h() {
+            return super.f();
+        }
+        static H() {
+            return super["F"]();
+        }
+    }
+
+    assert(C.F() === -1);
+    assert(Object.getOwnPropertyDescriptor(C.prototype, "y").get.name === "get y");
+
+    o = new C();
+    assert(o.f() === 1);
+    assert(o.x === 10);
+    
+    assert(D.F() === -1);
+    assert(D.G() === -2);
+    assert(D.H() === -1);
+
+    o = new D();
+    assert(o.f() === 1);
+    assert(o.g() === 2);
+    assert(o.x === 10);
+    assert(o.z === 20);
+    assert(o.h() === 1);
+
+    /* test class name scope */
+    var E1 = class E { static F() { return E; } };
+    assert(E1 === E1.F());
+};
+
+function test_template()
+{
+    var a, b;
+    b = 123;
+    a = `abc${b}d`;
+    assert(a, "abc123d");
+
+    a = String.raw `abc${b}d`;
+    assert(a, "abc123d");
+
+    a = "aaa";
+    b = "bbb";
+    assert(`aaa${a, b}ccc`, "aaabbbccc");
+}
+
+function test_template_skip()
+{
+    var a = "Bar";
+    var { b = `${a + `a${a}` }baz` } = {};
+    assert(b, "BaraBarbaz");
+}
+
+function test_object_literal()
+{
+    var x = 0, get = 1, set = 2; async = 3;
+    a = { get: 2, set: 3, async: 4 };
+    assert(JSON.stringify(a), '{"get":2,"set":3,"async":4}');
+
+    a = { x, get, set, async };
+    assert(JSON.stringify(a), '{"x":0,"get":1,"set":2,"async":3}');
+}
+
+function test_regexp_skip()
+{
+    var a, b;
+    [a, b = /abc\(/] = [1];
+    assert(a === 1);
+    
+    [a, b =/abc\(/] = [2];
+    assert(a === 2);
+}
+
+function test_labels()
+{
+    do x: { break x; } while(0);
+    if (1)
+        x: { break x; }
+    else
+        x: { break x; }
+    with ({}) x: { break x; };
+    while (0) x: { break x; };
+}
+
+function test_destructuring()
+{
+    function * g () { return 0; };
+    var [x] = g();
+    assert(x, void 0);
+}
+
+function test_spread()
+{
+    var x;
+    x = [1, 2, ...[3, 4]];
+    assert(x.toString(), "1,2,3,4");
+
+    x = [ ...[ , ] ];
+    assert(Object.getOwnPropertyNames(x).toString(), "0,length");
+}
+
+function test_function_length()
+{
+    assert( ((a, b = 1, c) => {}).length, 1);
+    assert( (([a,b]) => {}).length, 1);
+    assert( (({a,b}) => {}).length, 1);
+    assert( ((c, [a,b] = 1, d) => {}).length, 1);
+}
+
+function test_argument_scope()
+{
+    var f;
+    var c = "global";
+    
+    f = function(a = eval("var arguments")) {};
+    assert_throws(SyntaxError, f);
+
+    f = function(a = eval("1"), b = arguments[0]) { return b; };
+    assert(f(12), 12);
+
+    f = function(a, b = arguments[0]) { return b; };
+    assert(f(12), 12);
+
+    f = function(a, b = () => arguments) { return b; };
+    assert(f(12)()[0], 12);
+
+    f = function(a = eval("1"), b = () => arguments) { return b; };
+    assert(f(12)()[0], 12);
+
+    (function() {
+        "use strict";
+        f = function(a = this) { return a; };
+        assert(f.call(123), 123);
+
+        f = function f(a = f) { return a; };
+        assert(f(), f);
+
+        f = function f(a = eval("f")) { return a; };
+        assert(f(), f);
+    })();
+
+    f = (a = eval("var c = 1"), probe = () => c) => {
+        var c = 2;
+        assert(c, 2);
+        assert(probe(), 1);
+    }
+    f();
+
+    f = (a = eval("var arguments = 1"), probe = () => arguments) => {
+        var arguments = 2;
+        assert(arguments, 2);
+        assert(probe(), 1);
+    }
+    f();
+
+    f = function f(a = eval("var c = 1"), b = c, probe = () => c) {
+        assert(b, 1);
+        assert(c, 1);
+        assert(probe(), 1)
+    }
+    f();
+
+    assert(c, "global");
+    f = function f(a, b = c, probe = () => c) {
+        eval("var c = 1");
+        assert(c, 1);
+        assert(b, "global");
+        assert(probe(), "global")
+    }
+    f();
+    assert(c, "global");
+
+    f = function f(a = eval("var c = 1"), probe = (d = eval("c")) => d) {
+        assert(probe(), 1)
+    }
+    f();
+}
+
+function test_function_expr_name()
+{
+    var f;
+
+    /* non strict mode test : assignment to the function name silently
+       fails */
+    
+    f = function myfunc() {
+        myfunc = 1;
+        return myfunc;
+    };
+    assert(f(), f);
+
+    f = function myfunc() {
+        myfunc = 1;
+        (() => {
+            myfunc = 1;
+        })();
+        return myfunc;
+    };
+    assert(f(), f);
+
+    f = function myfunc() {
+        eval("myfunc = 1");
+        return myfunc;
+    };
+    assert(f(), f);
+    
+    /* strict mode test : assignment to the function name raises a
+       TypeError exception */
+
+    f = function myfunc() {
+        "use strict";
+        myfunc = 1;
+    };
+    assert_throws(TypeError, f);
+
+    f = function myfunc() {
+        "use strict";
+        (() => {
+            myfunc = 1;
+        })();
+    };
+    assert_throws(TypeError, f);
+
+    f = function myfunc() {
+        "use strict";
+        eval("myfunc = 1");
+    };
+    assert_throws(TypeError, f);
+}
+
+test_op1();
+test_cvt();
+test_eq();
+test_inc_dec();
+test_op2();
+test_delete();
+test_prototype();
+test_arguments();
+test_class();
+test_template();
+test_template_skip();
+test_object_literal();
+test_regexp_skip();
+test_labels();
+test_destructuring();
+test_spread();
+test_function_length();
+test_argument_scope();
+test_function_expr_name();

oden-js-sys/quickjs/tests/test_loop.js

@@ -0,0 +1,368 @@
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+// load more elaborate version of assert if available
+try { __loadScript("test_assert.js"); } catch(e) {}
+
+/*----------------*/
+
+function test_while()
+{
+    var i, c;
+    i = 0;
+    c = 0;
+    while (i < 3) {
+        c++;
+        i++;
+    }
+    assert(c === 3);
+}
+
+function test_while_break()
+{
+    var i, c;
+    i = 0;
+    c = 0;
+    while (i < 3) {
+        c++;
+        if (i == 1)
+            break;
+        i++;
+    }
+    assert(c === 2 && i === 1);
+}
+
+function test_do_while()
+{
+    var i, c;
+    i = 0;
+    c = 0;
+    do {
+        c++;
+        i++;
+    } while (i < 3);
+    assert(c === 3 && i === 3);
+}
+
+function test_for()
+{
+    var i, c;
+    c = 0;
+    for(i = 0; i < 3; i++) {
+        c++;
+    }
+    assert(c === 3 && i === 3);
+
+    c = 0;
+    for(var j = 0; j < 3; j++) {
+        c++;
+    }
+    assert(c === 3 && j === 3);
+}
+
+function test_for_in()
+{
+    var i, tab, a, b;
+
+    tab = [];
+    for(i in {x:1, y: 2}) {
+        tab.push(i);
+    }
+    assert(tab.toString(), "x,y", "for_in");
+
+    /* prototype chain test */
+    a = {x:2, y: 2, "1": 3};
+    b = {"4" : 3 };
+    Object.setPrototypeOf(a, b);
+    tab = [];
+    for(i in a) {
+        tab.push(i);
+    }
+    assert(tab.toString(), "1,x,y,4", "for_in");
+
+    /* non enumerable properties hide enumerables ones in the
+       prototype chain */
+    a = {y: 2, "1": 3};
+    Object.defineProperty(a, "x", { value: 1 });
+    b = {"x" : 3 };
+    Object.setPrototypeOf(a, b);
+    tab = [];
+    for(i in a) {
+        tab.push(i);
+    }
+    assert(tab.toString(), "1,y", "for_in");
+
+    /* array optimization */
+    a = [];
+    for(i = 0; i < 10; i++)
+        a.push(i);
+    tab = [];
+    for(i in a) {
+        tab.push(i);
+    }
+    assert(tab.toString(), "0,1,2,3,4,5,6,7,8,9", "for_in");
+
+    /* iterate with a field */
+    a={x:0};
+    tab = [];
+    for(a.x in {x:1, y: 2}) {
+        tab.push(a.x);
+    }
+    assert(tab.toString(), "x,y", "for_in");
+
+    /* iterate with a variable field */
+    a=[0];
+    tab = [];
+    for(a[0] in {x:1, y: 2}) {
+        tab.push(a[0]);
+    }
+    assert(tab.toString(), "x,y", "for_in");
+
+    /* variable definition in the for in */
+    tab = [];
+    for(var j in {x:1, y: 2}) {
+        tab.push(j);
+    }
+    assert(tab.toString(), "x,y", "for_in");
+
+    /* variable assigment in the for in */
+    tab = [];
+    for(var k = 2 in {x:1, y: 2}) {
+        tab.push(k);
+    }
+    assert(tab.toString(), "x,y", "for_in");
+}
+
+function test_for_in2()
+{
+    var i;
+    tab = [];
+    for(i in {x:1, y: 2, z:3}) {
+        if (i === "y")
+            continue;
+        tab.push(i);
+    }
+    assert(tab.toString() == "x,z");
+
+    tab = [];
+    for(i in {x:1, y: 2, z:3}) {
+        if (i === "z")
+            break;
+        tab.push(i);
+    }
+    assert(tab.toString() == "x,y");
+}
+
+function test_for_break()
+{
+    var i, c;
+    c = 0;
+    L1: for(i = 0; i < 3; i++) {
+        c++;
+        if (i == 0)
+            continue;
+        while (1) {
+            break L1;
+        }
+    }
+    assert(c === 2 && i === 1);
+}
+
+function test_switch1()
+{
+    var i, a, s;
+    s = "";
+    for(i = 0; i < 3; i++) {
+        a = "?";
+        switch(i) {
+        case 0:
+            a = "a";
+            break;
+        case 1:
+            a = "b";
+            break;
+        default:
+            a = "c";
+            break;
+        }
+        s += a;
+    }
+    assert(s === "abc" && i === 3);
+}
+
+function test_switch2()
+{
+    var i, a, s;
+    s = "";
+    for(i = 0; i < 4; i++) {
+        a = "?";
+        switch(i) {
+        case 0:
+            a = "a";
+            break;
+        case 1:
+            a = "b";
+            break;
+        case 2:
+            continue;
+        default:
+            a = "" + i;
+            break;
+        }
+        s += a;
+    }
+    assert(s === "ab3" && i === 4);
+}
+
+function test_try_catch1()
+{
+    try {
+        throw "hello";
+    } catch (e) {
+        assert(e, "hello", "catch");
+        return;
+    }
+    assert(false, "catch");
+}
+
+function test_try_catch2()
+{
+    var a;
+    try {
+        a = 1;
+    } catch (e) {
+        a = 2;
+    }
+    assert(a, 1, "catch");
+}
+
+function test_try_catch3()
+{
+    var s;
+    s = "";
+    try {
+        s += "t";
+    } catch (e) {
+        s += "c";
+    } finally {
+        s += "f";
+    }
+    assert(s, "tf", "catch");
+}
+
+function test_try_catch4()
+{
+    var s;
+    s = "";
+    try {
+        s += "t";
+        throw "c";
+    } catch (e) {
+        s += e;
+    } finally {
+        s += "f";
+    }
+    assert(s, "tcf", "catch");
+}
+
+function test_try_catch5()
+{
+    var s;
+    s = "";
+    for(;;) {
+        try {
+            s += "t";
+            break;
+            s += "b";
+        } finally {
+            s += "f";
+        }
+    }
+    assert(s, "tf", "catch");
+}
+
+function test_try_catch6()
+{
+    function f() {
+        try {
+            s += 't';
+            return 1;
+        } finally {
+            s += "f";
+        }
+    }
+    var s = "";
+    assert(f() === 1);
+    assert(s, "tf", "catch6");
+}
+
+function test_try_catch7()
+{
+    var s;
+    s = "";
+
+    try {
+        try {
+            s += "t";
+            throw "a";
+        } finally {
+            s += "f";
+        }
+    } catch(e) {
+        s += e;
+    } finally {
+        s += "g";
+    }
+    assert(s, "tfag", "catch");
+}
+
+function test_try_catch8()
+{
+    var i, s;
+    
+    s = "";
+    for(var i in {x:1, y:2}) {
+        try {
+            s += i;
+            throw "a";
+        } catch (e) {
+            s += e;
+        } finally {
+            s += "f";
+        }
+    }
+    assert(s === "xafyaf");
+}
+
+test_while();
+test_while_break();
+test_do_while();
+test_for();
+test_for_break();
+test_switch1();
+test_switch2();
+test_for_in();
+test_for_in2();
+
+test_try_catch1();
+test_try_catch2();
+test_try_catch3();
+test_try_catch4();
+test_try_catch5();
+test_try_catch6();
+test_try_catch7();
+test_try_catch8();

oden-js-sys/quickjs/tests/test_op_overloading.js

@@ -0,0 +1,207 @@
+"use strict";
+
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+/* operators overloading with Operators.create() */
+function test_operators_create() {
+    class Vec2
+    {
+        constructor(x, y) {
+            this.x = x;
+            this.y = y;
+        }
+        static mul_scalar(p1, a) {
+            var r = new Vec2();
+            r.x = p1.x * a;
+            r.y = p1.y * a;
+            return r;
+        }
+        toString() {
+            return "Vec2(" + this.x + "," + this.y + ")";
+        }
+    }
+    
+    Vec2.prototype[Symbol.operatorSet] = Operators.create(
+    {
+        "+"(p1, p2) {
+            var r = new Vec2();
+            r.x = p1.x + p2.x;
+            r.y = p1.y + p2.y;
+            return r;
+        },
+        "-"(p1, p2) {
+            var r = new Vec2();
+            r.x = p1.x - p2.x;
+            r.y = p1.y - p2.y;
+            return r;
+        },
+        "=="(a, b) {
+            return a.x == b.x && a.y == b.y;
+        },
+        "<"(a, b) {
+            var r;
+            /* lexicographic order */
+            if (a.x == b.x)
+                r = (a.y < b.y);
+            else
+                r = (a.x < b.x);
+            return r;
+        },
+        "++"(a) {
+            var r = new Vec2();
+            r.x = a.x + 1;
+            r.y = a.y + 1;
+            return r;
+        }
+    },
+    {
+        left: Number,
+        "*"(a, b) {
+            return Vec2.mul_scalar(b, a);
+        }
+    },
+    {
+        right: Number,
+        "*"(a, b) {
+            return Vec2.mul_scalar(a, b);
+        }
+    });
+
+    var a = new Vec2(1, 2);
+    var b = new Vec2(3, 4);
+    var r;
+
+    r = a * 2 + 3 * b;
+    assert(r.x === 11 && r.y === 16);
+    assert(a == a, true);
+    assert(a == b, false);
+    assert(a != a, false);
+    assert(a < b, true);
+    assert(a <= b, true);
+    assert(b < a, false);
+    assert(b <= a, false);
+    assert(a <= a, true);
+    assert(a >= a, true);
+    a++;
+    assert(a.x === 2 && a.y === 3);
+    r = ++a;
+    assert(a.x === 3 && a.y === 4);
+    assert(r === a);
+}
+
+/* operators overloading thru inheritance */
+function test_operators()
+{
+    var Vec2;
+
+    function mul_scalar(p1, a) {
+        var r = new Vec2();
+        r.x = p1.x * a;
+        r.y = p1.y * a;
+        return r;
+    }
+
+    var vec2_ops = Operators({
+        "+"(p1, p2) {
+            var r = new Vec2();
+            r.x = p1.x + p2.x;
+            r.y = p1.y + p2.y;
+            return r;
+        },
+        "-"(p1, p2) {
+            var r = new Vec2();
+            r.x = p1.x - p2.x;
+            r.y = p1.y - p2.y;
+            return r;
+        },
+        "=="(a, b) {
+            return a.x == b.x && a.y == b.y;
+        },
+        "<"(a, b) {
+            var r;
+            /* lexicographic order */
+            if (a.x == b.x)
+                r = (a.y < b.y);
+            else
+                r = (a.x < b.x);
+            return r;
+        },
+        "++"(a) {
+            var r = new Vec2();
+            r.x = a.x + 1;
+            r.y = a.y + 1;
+            return r;
+        }
+    },
+    {
+        left: Number,
+        "*"(a, b) {
+            return mul_scalar(b, a);
+        }
+    },
+    {
+        right: Number,
+        "*"(a, b) {
+            return mul_scalar(a, b);
+        }
+    });
+
+    Vec2 = class Vec2 extends vec2_ops
+    {
+        constructor(x, y) {
+            super();
+            this.x = x;
+            this.y = y;
+        }
+        toString() {
+            return "Vec2(" + this.x + "," + this.y + ")";
+        }
+    }
+    
+    var a = new Vec2(1, 2);
+    var b = new Vec2(3, 4);
+    var r;
+
+    r = a * 2 + 3 * b;
+    assert(r.x === 11 && r.y === 16);
+    assert(a == a, true);
+    assert(a == b, false);
+    assert(a != a, false);
+    assert(a < b, true);
+    assert(a <= b, true);
+    assert(b < a, false);
+    assert(b <= a, false);
+    assert(a <= a, true);
+    assert(a >= a, true);
+    a++;
+    assert(a.x === 2 && a.y === 3);
+    r = ++a;
+    assert(a.x === 3 && a.y === 4);
+    assert(r === a);
+}
+
+function test_default_op()
+{
+    assert(Object(1) + 2, 3);
+    assert(Object(1) + true, 2);
+    assert(-Object(1), -1);
+}
+
+test_operators_create();
+test_operators();
+test_default_op();

oden-js-sys/quickjs/tests/test_qjscalc.js

@@ -0,0 +1,256 @@
+"use math";
+"use strict";
+
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+function assertThrows(err, func)
+{
+    var ex;
+    ex = false;
+    try {
+        func();
+    } catch(e) {
+        ex = true;
+        assert(e instanceof err);
+    }
+    assert(ex, true, "exception expected");
+}
+
+// load more elaborate version of assert if available
+try { __loadScript("test_assert.js"); } catch(e) {}
+
+/*----------------*/
+
+function pow(a, n)
+{
+    var r, i;
+    r = 1;
+    for(i = 0; i < n; i++)
+        r *= a;
+    return r;
+}
+
+function test_integer()
+{
+    var a, r;
+    a = pow(3, 100);
+    assert((a - 1) != a);
+    assert(a == 515377520732011331036461129765621272702107522001);
+    assert(a == 0x5a4653ca673768565b41f775d6947d55cf3813d1);
+    assert(Integer.isInteger(1) === true);
+    assert(Integer.isInteger(1.0) === false);
+
+    assert(Integer.floorLog2(0) === -1);
+    assert(Integer.floorLog2(7) === 2);
+
+    r = 1 << 31;
+    assert(r, 2147483648, "1 << 31 === 2147483648");
+    
+    r = 1 << 32;
+    assert(r, 4294967296, "1 << 32 === 4294967296");
+    
+    r = (1 << 31) < 0;
+    assert(r, false, "(1 << 31) < 0 === false");
+
+    assert(typeof 1 === "number");
+    assert(typeof 9007199254740991 === "number");
+    assert(typeof 9007199254740992 === "bigint");
+}
+
+function test_float()
+{
+    assert(typeof 1.0 === "bigfloat");
+    assert(1 == 1.0);
+    assert(1 !== 1.0);
+}
+
+/* jscalc tests */
+
+function test_modulo()
+{
+    var i, p, a, b;
+
+    /* Euclidian modulo operator */
+    assert((-3) % 2 == 1);
+    assert(3 % (-2) == 1);
+
+    p = 101;
+    for(i = 1; i < p; i++) {
+        a = Integer.invmod(i, p);
+        assert(a >= 0 && a < p);
+        assert((i * a) % p == 1);
+    }
+
+    assert(Integer.isPrime(2^107-1));
+    assert(!Integer.isPrime((2^107-1) * (2^89-1)));
+    a = Integer.factor((2^89-1)*2^3*11*13^2*1009);
+    assert(a == [ 2,2,2,11,13,13,1009,618970019642690137449562111 ]);
+}
+
+function test_fraction()
+{
+    assert((1/3 + 1).toString(), "4/3")
+    assert((2/3)^30, 1073741824/205891132094649);
+    assert(1/3 < 2/3);
+    assert(1/3 < 1);
+    assert(1/3 == 1.0/3);
+    assert(1.0/3 < 2/3);
+}
+
+function test_mod()
+{
+    var a, b, p;
+    
+    a = Mod(3, 101);
+    b = Mod(-1, 101);
+    assert((a + b) == Mod(2, 101));
+    assert(a ^ 100 == Mod(1, 101));
+
+    p = 2 ^ 607 - 1; /* mersenne prime */
+    a = Mod(3, p) ^ (p - 1);
+    assert(a == Mod(1, p));
+}
+
+function test_polynomial()
+{
+    var a, b, q, r, t, i;
+    a = (1 + X) ^ 4;
+    assert(a == X^4+4*X^3+6*X^2+4*X+1);
+    
+    r = (1 + X);
+    q = (1+X+X^2);
+    b = (1 - X^2);
+    a = q * b + r;
+    t = Polynomial.divrem(a, b);
+    assert(t[0] == q);
+    assert(t[1] == r);
+
+    a = 1 + 2*X + 3*X^2;
+    assert(a.apply(0.1) == 1.23);
+
+    a = 1-2*X^2+2*X^3;
+    assert(deriv(a) == (6*X^2-4*X));
+    assert(deriv(integ(a)) == a);
+
+    a = (X-1)*(X-2)*(X-3)*(X-4)*(X-0.1);
+    r = polroots(a);
+    for(i = 0; i < r.length; i++) {
+        b = abs(a.apply(r[i]));
+        assert(b <= 1e-13);
+    }
+}
+
+function test_poly_mod()
+{
+    var a, p;
+
+    /* modulo using polynomials */
+    p = X^2 + X + 1;
+    a = PolyMod(3+X, p) ^ 10;
+    assert(a == PolyMod(-3725*X-18357, p));
+
+    a = PolyMod(1/X, 1+X^2);
+    assert(a == PolyMod(-X, X^2+1));
+}
+
+function test_rfunc()
+{
+    var a;
+    a = (X+1)/((X+1)*(X-1));
+    assert(a == 1/(X-1));
+    a = (X + 2) / (X - 2);
+    assert(a.apply(1/3) == -7/5);
+
+    assert(deriv((X^2-X+1)/(X-1)) == (X^2-2*X)/(X^2-2*X+1));
+}
+
+function test_series()
+{
+    var a, b;
+    a = 1+X+O(X^5);
+    b = a.inverse();
+    assert(b == 1-X+X^2-X^3+X^4+O(X^5));
+    assert(deriv(b) == -1+2*X-3*X^2+4*X^3+O(X^4));
+    assert(deriv(integ(b)) == b);
+
+    a = Series(1/(1-X), 5);
+    assert(a == 1+X+X^2+X^3+X^4+O(X^5));
+    b = a.apply(0.1);
+    assert(b == 1.1111);
+
+    assert(exp(3*X^2+O(X^10)) == 1+3*X^2+9/2*X^4+9/2*X^6+27/8*X^8+O(X^10));
+    assert(sin(X+O(X^6)) == X-1/6*X^3+1/120*X^5+O(X^6));
+    assert(cos(X+O(X^6)) == 1-1/2*X^2+1/24*X^4+O(X^6));
+    assert(tan(X+O(X^8)) == X+1/3*X^3+2/15*X^5+17/315*X^7+O(X^8));
+        assert((1+X+O(X^6))^(2+X) == 1+2*X+2*X^2+3/2*X^3+5/6*X^4+5/12*X^5+O(X^6));
+}
+
+function test_matrix()
+{
+    var a, b, r;
+    a = [[1, 2],[3, 4]];
+    b = [3, 4];
+    r = a * b;
+    assert(r == [11, 25]);
+    r = (a^-1) * 2;
+    assert(r == [[-4, 2],[3, -1]]);
+
+    assert(norm2([1,2,3]) == 14);
+
+    assert(diag([1,2,3]) == [ [ 1, 0, 0 ], [ 0, 2, 0 ], [ 0, 0, 3 ] ]);
+    assert(trans(a) == [ [ 1, 3 ], [ 2, 4 ] ]);
+    assert(trans([1,2,3]) == [[1,2,3]]);
+    assert(trace(a) == 5);
+
+    assert(charpoly(Matrix.hilbert(4)) == X^4-176/105*X^3+3341/12600*X^2-41/23625*X+1/6048000);
+    assert(det(Matrix.hilbert(4)) == 1/6048000);
+
+    a = [[1,2,1],[-2,-3,1],[3,5,0]];
+    assert(rank(a) == 2);
+    assert(ker(a) == [ [ 5 ], [ -3 ], [ 1 ] ]);
+
+    assert(dp([1, 2, 3], [3, -4, -7]) === -26);
+    assert(cp([1, 2, 3], [3, -4, -7]) == [ -2, 16, -10 ]);
+}
+
+function assert_eq(a, ref)
+{
+    assert(abs(a / ref - 1.0) <= 1e-15);
+}
+
+function test_trig()
+{
+    assert_eq(sin(1/2), 0.479425538604203);
+    assert_eq(sin(2+3*I), 9.154499146911428-4.168906959966565*I);
+    assert_eq(cos(2+3*I), -4.189625690968807-9.109227893755337*I);
+    assert_eq((2+0.5*I)^(1.1-0.5*I), 2.494363021357619-0.23076804554558092*I);
+    assert_eq(sqrt(2*I), 1 + I);
+}
+
+test_integer();
+test_float();
+
+test_modulo();
+test_fraction();
+test_mod();
+test_polynomial();
+test_poly_mod();
+test_rfunc();
+test_series();
+test_matrix();
+test_trig();

oden-js-sys/quickjs/tests/test_std.js

@@ -0,0 +1,281 @@
+import * as std from "std";
+import * as os from "os";
+
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+// load more elaborate version of assert if available
+try { std.loadScript("test_assert.js"); } catch(e) {}
+
+/*----------------*/
+
+function test_printf()
+{
+    assert(std.sprintf("a=%d s=%s", 123, "abc"), "a=123 s=abc");
+    assert(std.sprintf("%010d", 123), "0000000123");
+    assert(std.sprintf("%x", -2), "fffffffe");
+    assert(std.sprintf("%lx", -2), "fffffffffffffffe");
+    assert(std.sprintf("%10.1f", 2.1), "       2.1");
+    assert(std.sprintf("%*.*f", 10, 2, -2.13), "     -2.13");
+    assert(std.sprintf("%#lx", 0x7fffffffffffffffn), "0x7fffffffffffffff");
+}
+
+function test_file1()
+{
+    var f, len, str, size, buf, ret, i, str1;
+
+    f = std.tmpfile();
+    str = "hello world\n";
+    f.puts(str);
+
+    f.seek(0, std.SEEK_SET);
+    str1 = f.readAsString();
+    assert(str1 === str);
+    
+    f.seek(0, std.SEEK_END);
+    size = f.tell();
+    assert(size === str.length);
+
+    f.seek(0, std.SEEK_SET);
+
+    buf = new Uint8Array(size);
+    ret = f.read(buf.buffer, 0, size);
+    assert(ret === size);
+    for(i = 0; i < size; i++)
+        assert(buf[i] === str.charCodeAt(i));
+
+    f.close();
+}
+
+function test_file2()
+{
+    var f, str, i, size;
+    f = std.tmpfile();
+    str = "hello world\n";
+    size = str.length;
+    for(i = 0; i < size; i++)
+        f.putByte(str.charCodeAt(i));
+    f.seek(0, std.SEEK_SET);
+    for(i = 0; i < size; i++) {
+        assert(str.charCodeAt(i) === f.getByte());
+    }
+    assert(f.getByte() === -1);
+    f.close();
+}
+
+function test_getline()
+{
+    var f, line, line_count, lines, i;
+    
+    lines = ["hello world", "line 1", "line 2" ];
+    f = std.tmpfile();
+    for(i = 0; i < lines.length; i++) {
+        f.puts(lines[i], "\n");
+    }
+
+    f.seek(0, std.SEEK_SET);
+    assert(!f.eof());
+    line_count = 0;
+    for(;;) {
+        line = f.getline();
+        if (line === null)
+            break;
+        assert(line == lines[line_count]);
+        line_count++;
+    }
+    assert(f.eof());
+    assert(line_count === lines.length);
+
+    f.close();
+}
+ 
+function test_popen()
+{
+    var str, f, fname = "tmp_file.txt";
+    var content = "hello world";
+
+    f = std.open(fname, "w");
+    f.puts(content);
+    f.close();
+
+    /* test loadFile */
+    assert(std.loadFile(fname), content);
+    
+    /* execute the 'cat' shell command */
+    f = std.popen("cat " + fname, "r");
+    str = f.readAsString();
+    f.close();
+
+    assert(str, content);
+
+    os.remove(fname);
+}
+
+function test_ext_json()
+{
+    var expected, input, obj;
+    expected = '{"x":false,"y":true,"z2":null,"a":[1,8,160],"s":"str"}';
+    input = `{ "x":false, /*comments are allowed */
+               "y":true,  // also a comment
+               z2:null, // unquoted property names
+               "a":[+1,0o10,0xa0,], // plus prefix, octal, hexadecimal
+               "s":"str",} // trailing comma in objects and arrays
+            `;
+    obj = std.parseExtJSON(input);
+    assert(JSON.stringify(obj), expected);
+}
+
+function test_os()
+{
+    var fd, fpath, fname, fdir, buf, buf2, i, files, err, fdate, st, link_path;
+
+    assert(os.isatty(0));
+
+    fdir = "test_tmp_dir";
+    fname = "tmp_file.txt";
+    fpath = fdir + "/" + fname;
+    link_path = fdir + "/test_link";
+    
+    os.remove(link_path);
+    os.remove(fpath);
+    os.remove(fdir);
+
+    err = os.mkdir(fdir, 0o755);
+    assert(err === 0);
+    
+    fd = os.open(fpath, os.O_RDWR | os.O_CREAT | os.O_TRUNC);
+    assert(fd >= 0);
+    
+    buf = new Uint8Array(10);
+    for(i = 0; i < buf.length; i++)
+        buf[i] = i;
+    assert(os.write(fd, buf.buffer, 0, buf.length) === buf.length);
+
+    assert(os.seek(fd, 0, std.SEEK_SET) === 0);
+    buf2 = new Uint8Array(buf.length);
+    assert(os.read(fd, buf2.buffer, 0, buf2.length) === buf2.length);
+    
+    for(i = 0; i < buf.length; i++)
+        assert(buf[i] == buf2[i]);
+    
+    if (typeof BigInt !== "undefined") {
+        assert(os.seek(fd, BigInt(6), std.SEEK_SET), BigInt(6));
+        assert(os.read(fd, buf2.buffer, 0, 1) === 1);
+        assert(buf[6] == buf2[0]);
+    }
+    
+    assert(os.close(fd) === 0);
+
+    [files, err] = os.readdir(fdir);
+    assert(err, 0);
+    assert(files.indexOf(fname) >= 0);
+
+    fdate = 10000;
+
+    err = os.utimes(fpath, fdate, fdate);
+    assert(err, 0);
+    
+    [st, err] = os.stat(fpath);
+    assert(err, 0);
+    assert(st.mode & os.S_IFMT, os.S_IFREG);
+    assert(st.mtime, fdate);
+
+    err = os.symlink(fname, link_path);
+    assert(err === 0);
+    
+    [st, err] = os.lstat(link_path);
+    assert(err, 0);
+    assert(st.mode & os.S_IFMT, os.S_IFLNK);
+
+    [buf, err] = os.readlink(link_path);
+    assert(err, 0);
+    assert(buf, fname);
+    
+    assert(os.remove(link_path) === 0);
+
+    [buf, err] = os.getcwd();
+    assert(err, 0);
+
+    [buf2, err] = os.realpath(".");
+    assert(err, 0);
+
+    assert(buf, buf2);
+    
+    assert(os.remove(fpath) === 0);
+
+    fd = os.open(fpath, os.O_RDONLY);
+    assert(fd < 0);
+
+    assert(os.remove(fdir) === 0);
+}
+
+function test_os_exec()
+{
+    var ret, fds, pid, f, status;
+
+    ret = os.exec(["true"]);
+    assert(ret, 0);
+
+    ret = os.exec(["/bin/sh", "-c", "exit 1"], { usePath: false });
+    assert(ret, 1);
+    
+    fds = os.pipe();
+    pid = os.exec(["sh", "-c", "echo $FOO"], {
+        stdout: fds[1],
+        block: false,
+        env: { FOO: "hello" },
+    } );
+    assert(pid >= 0);
+    os.close(fds[1]); /* close the write end (as it is only in the child)  */
+    f = std.fdopen(fds[0], "r");
+    assert(f.getline(), "hello");
+    assert(f.getline(), null);
+    f.close();
+    [ret, status] = os.waitpid(pid, 0);
+    assert(ret, pid);
+    assert(status & 0x7f, 0); /* exited */
+    assert(status >> 8, 0); /* exit code */
+
+    pid = os.exec(["cat"], { block: false } );
+    assert(pid >= 0);
+    os.kill(pid, os.SIGQUIT);
+    [ret, status] = os.waitpid(pid, 0);
+    assert(ret, pid);
+    assert(status & 0x7f, os.SIGQUIT);
+}
+
+function test_timer()
+{
+    var th, i;
+
+    /* just test that a timer can be inserted and removed */
+    th = [];
+    for(i = 0; i < 3; i++)
+        th[i] = os.setTimeout(function () { }, 1000);
+    for(i = 0; i < 3; i++)
+        os.clearTimeout(th[i]);
+}
+
+test_printf();
+test_file1();
+test_file2();
+test_getline();
+test_popen();
+test_os();
+test_os_exec();
+test_timer();
+test_ext_json();

oden-js-sys/quickjs/tests/test_worker.js

@@ -0,0 +1,62 @@
+/* os.Worker API test */
+import * as std from "std";
+import * as os from "os";
+
+function assert(actual, expected, message) {
+    if (arguments.length == 1)
+        expected = true;
+
+    if (actual === expected)
+        return;
+
+    if (actual !== null && expected !== null
+    &&  typeof actual == 'object' && typeof expected == 'object'
+    &&  actual.toString() === expected.toString())
+        return;
+
+    throw Error("assertion failed: got |" + actual + "|" +
+                ", expected |" + expected + "|" +
+                (message ? " (" + message + ")" : ""));
+}
+
+var worker;
+
+function test_worker()
+{
+    var counter;
+
+    worker = new os.Worker("./test_worker_module.js");
+
+    counter = 0;
+    worker.onmessage = function (e) {
+        var ev = e.data;
+//        print("recv", JSON.stringify(ev));
+        switch(ev.type) {
+        case "num":
+            assert(ev.num, counter);
+            counter++;
+            if (counter == 10) {
+                /* test SharedArrayBuffer modification */
+                let sab = new SharedArrayBuffer(10);
+                let buf = new Uint8Array(sab);
+                worker.postMessage({ type: "sab", buf: buf });
+            }
+            break;
+        case "sab_done":
+            {
+                let buf = ev.buf;
+                /* check that the SharedArrayBuffer was modified */
+                assert(buf[2], 10);
+                worker.postMessage({ type: "abort" });
+            }
+            break;
+        case "done":
+            /* terminate */
+            worker.onmessage = null;
+            break;
+        }
+    };
+}
+
+
+test_worker();

oden-js-sys/quickjs/tests/test_worker_module.js

@@ -0,0 +1,31 @@
+/* Worker code for test_worker.js */
+import * as std from "std";
+import * as os from "os";
+
+var parent = os.Worker.parent;
+
+function handle_msg(e) {
+    var ev = e.data;
+    //          print("child_recv", JSON.stringify(ev));
+    switch(ev.type) {
+    case "abort":
+        parent.postMessage({ type: "done" });
+        break;
+    case "sab":
+        /* modify the SharedArrayBuffer */
+        ev.buf[2] = 10;
+        parent.postMessage({ type: "sab_done", buf: ev.buf });
+        break;
+    }
+}
+
+function worker_main() {
+    var i;
+    
+    parent.onmessage = handle_msg;
+    for(i = 0; i < 10; i++) {
+        parent.postMessage({ type: "num", num: i }); 
+    }
+}
+
+worker_main();