Change the name of the Object.prototype.inherits function in...

benchmarks/deltablue.js

 // 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
@@ skipping 28 matching lines @@
  *
  * 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.inherits = function (shuper) {
+Object.prototype.inheritsFrom = function (shuper) {
   function Inheriter() { }
   Inheriter.prototype = shuper.prototype;
   this.prototype = new Inheriter();
   this.superConstructor = shuper;
 }
 
 function OrderedCollection() {
   this.elms = new Array();
 }
 
@@ skipping 149 matching lines @@
  * 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.inherits(Constraint);
+UnaryConstraint.inheritsFrom(Constraint);
 
 /**
  * Adds this constraint to the constraint graph
  */
 UnaryConstraint.prototype.addToGraph = function () {
   this.myOutput.addConstraint(this);
   this.satisfied = false;
 }
 
 /**
@@ skipping 57 matching lines @@
 /**
  * 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.inherits(UnaryConstraint);
+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.inherits(UnaryConstraint);
+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
@@ skipping 13 matching lines @@
  * variables.
  */
 function BinaryConstraint(var1, var2, strength) {
   BinaryConstraint.superConstructor.call(this, strength);
   this.v1 = var1;
   this.v2 = var2;
   this.direction = Direction.NONE;
   this.addConstraint();
 }
 
-BinaryConstraint.inherits(Constraint);
+BinaryConstraint.inheritsFrom(Constraint);
 
 /**
  * Decides if this constratint 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.v1.mark != mark && Strength.stronger(this.strength, this.v2.walkStrength))
       ? Direction.FORWARD
@@ skipping 92 matching lines @@
  * 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.inherits(BinaryConstraint);
+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);
 }
 
@@ skipping 35 matching lines @@
  * 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.inherits(BinaryConstraint);
+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
@@ skipping 342 matching lines @@
   edit.destroyConstraint();
 }
 
 // Global variable holding the current planner.
 var planner = null;
 
 function deltaBlue() {
   chainTest(100);
   projectionTest(100);
 }