Convert comparison methods to the new runtime syntax

Change-Id: Iad4dadddefca2d6322d4f778272b75d64e1a746f
Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>

3 files changed, 45 insertions, 35 deletions

diff --git a/src/qml/jsruntime/qv4runtime.cpp b/src/qml/jsruntime/qv4runtime.cpp
index 4c1be4a65d..7dae2cad32 100644
--- a/src/qml/jsruntime/qv4runtime.cpp
+++ b/src/qml/jsruntime/qv4runtime.cpp
@@ -742,9 +742,9 @@ uint RuntimeHelpers::equalHelper(const Value &x, const Value &y)
         double dx = RuntimeHelpers::toNumber(x);
         return dx == y.asDouble();
     } else if (x.isBoolean()) {
-        return Runtime::compareEqual(Primitive::fromDouble((double) x.booleanValue()), y);
+        return Runtime::method_compareEqual(Primitive::fromDouble((double) x.booleanValue()), y);
     } else if (y.isBoolean()) {
-        return Runtime::compareEqual(x, Primitive::fromDouble((double) y.booleanValue()));
+        return Runtime::method_compareEqual(x, Primitive::fromDouble((double) y.booleanValue()));
     } else {
 #ifdef V4_BOOTSTRAP
         Q_UNIMPLEMENTED();
@@ -752,11 +752,11 @@ uint RuntimeHelpers::equalHelper(const Value &x, const Value &y)
         if ((x.isNumber() || x.isString()) && y.isObject()) {
             Scope scope(y.objectValue()->engine());
             ScopedValue py(scope, RuntimeHelpers::toPrimitive(y, PREFERREDTYPE_HINT));
-            return Runtime::compareEqual(x, py);
+            return Runtime::method_compareEqual(x, py);
         } else if (x.isObject() && (y.isNumber() || y.isString())) {
             Scope scope(x.objectValue()->engine());
             ScopedValue px(scope, RuntimeHelpers::toPrimitive(x, PREFERREDTYPE_HINT));
-            return Runtime::compareEqual(px, y);
+            return Runtime::method_compareEqual(px, y);
         }
 #endif
     }
@@ -779,7 +779,7 @@ Bool RuntimeHelpers::strictEqual(const Value &x, const Value &y)
     return false;
 }
 
-QV4::Bool Runtime::compareGreaterThan(const Value &l, const Value &r)
+QV4::Bool Runtime::method_compareGreaterThan(const Value &l, const Value &r)
 {
     TRACE2(l, r);
     if (l.isInteger() && r.isInteger())
@@ -803,7 +803,7 @@ QV4::Bool Runtime::compareGreaterThan(const Value &l, const Value &r)
         QV4::Scope scope(e);
         QV4::ScopedValue pl(scope, RuntimeHelpers::toPrimitive(l, QV4::NUMBER_HINT));
         QV4::ScopedValue pr(scope, RuntimeHelpers::toPrimitive(r, QV4::NUMBER_HINT));
-        return Runtime::compareGreaterThan(pl, pr);
+        return Runtime::method_compareGreaterThan(pl, pr);
 #endif
     }
 
@@ -812,7 +812,7 @@ QV4::Bool Runtime::compareGreaterThan(const Value &l, const Value &r)
     return dl > dr;
 }
 
-QV4::Bool Runtime::compareLessThan(const Value &l, const Value &r)
+QV4::Bool Runtime::method_compareLessThan(const Value &l, const Value &r)
 {
     TRACE2(l, r);
     if (l.isInteger() && r.isInteger())
@@ -836,7 +836,7 @@ QV4::Bool Runtime::compareLessThan(const Value &l, const Value &r)
         QV4::Scope scope(e);
         QV4::ScopedValue pl(scope, RuntimeHelpers::toPrimitive(l, QV4::NUMBER_HINT));
         QV4::ScopedValue pr(scope, RuntimeHelpers::toPrimitive(r, QV4::NUMBER_HINT));
-        return Runtime::compareLessThan(pl, pr);
+        return Runtime::method_compareLessThan(pl, pr);
 #endif
     }
 
@@ -845,7 +845,7 @@ QV4::Bool Runtime::compareLessThan(const Value &l, const Value &r)
     return dl < dr;
 }
 
-QV4::Bool Runtime::compareGreaterEqual(const Value &l, const Value &r)
+QV4::Bool Runtime::method_compareGreaterEqual(const Value &l, const Value &r)
 {
     TRACE2(l, r);
     if (l.isInteger() && r.isInteger())
@@ -869,7 +869,7 @@ QV4::Bool Runtime::compareGreaterEqual(const Value &l, const Value &r)
         QV4::Scope scope(e);
         QV4::ScopedValue pl(scope, RuntimeHelpers::toPrimitive(l, QV4::NUMBER_HINT));
         QV4::ScopedValue pr(scope, RuntimeHelpers::toPrimitive(r, QV4::NUMBER_HINT));
-        return Runtime::compareGreaterEqual(pl, pr);
+        return Runtime::method_compareGreaterEqual(pl, pr);
 #endif
     }
 
@@ -878,7 +878,7 @@ QV4::Bool Runtime::compareGreaterEqual(const Value &l, const Value &r)
     return dl >= dr;
 }
 
-QV4::Bool Runtime::compareLessEqual(const Value &l, const Value &r)
+QV4::Bool Runtime::method_compareLessEqual(const Value &l, const Value &r)
 {
     TRACE2(l, r);
     if (l.isInteger() && r.isInteger())
@@ -902,7 +902,7 @@ QV4::Bool Runtime::compareLessEqual(const Value &l, const Value &r)
         QV4::Scope scope(e);
         QV4::ScopedValue pl(scope, RuntimeHelpers::toPrimitive(l, QV4::NUMBER_HINT));
         QV4::ScopedValue pr(scope, RuntimeHelpers::toPrimitive(r, QV4::NUMBER_HINT));
-        return Runtime::compareLessEqual(pl, pr);
+        return Runtime::method_compareLessEqual(pl, pr);
 #endif
     }
 
@@ -912,7 +912,7 @@ QV4::Bool Runtime::compareLessEqual(const Value &l, const Value &r)
 }
 
 #ifndef V4_BOOTSTRAP
-Bool Runtime::compareInstanceof(ExecutionEngine *engine, const Value &left, const Value &right)
+Bool Runtime::method_compareInstanceof(ExecutionEngine *engine, const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -921,7 +921,7 @@ Bool Runtime::compareInstanceof(ExecutionEngine *engine, const Value &left, cons
     return v->booleanValue();
 }
 
-uint Runtime::compareIn(ExecutionEngine *engine, const Value &left, const Value &right)
+uint Runtime::method_compareIn(ExecutionEngine *engine, const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
diff --git a/src/qml/jsruntime/qv4runtime_p.h b/src/qml/jsruntime/qv4runtime_p.h
index 12b9a11a38..d9a9f0b780 100644
--- a/src/qml/jsruntime/qv4runtime_p.h
+++ b/src/qml/jsruntime/qv4runtime_p.h
@@ -313,7 +313,7 @@ inline ReturnedValue Runtime::greaterThan(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = Runtime::compareGreaterThan(left, right);
+    bool r = method_compareGreaterThan(left, right);
     return Encode(r);
 }
 
@@ -321,7 +321,7 @@ inline ReturnedValue Runtime::lessThan(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = Runtime::compareLessThan(left, right);
+    bool r = method_compareLessThan(left, right);
     return Encode(r);
 }
 
@@ -329,7 +329,7 @@ inline ReturnedValue Runtime::greaterEqual(const Value &left, const Value &right
 {
     TRACE2(left, right);
 
-    bool r = Runtime::compareGreaterEqual(left, right);
+    bool r = method_compareGreaterEqual(left, right);
     return Encode(r);
 }
 
@@ -337,11 +337,11 @@ inline ReturnedValue Runtime::lessEqual(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = Runtime::compareLessEqual(left, right);
+    bool r = method_compareLessEqual(left, right);
     return Encode(r);
 }
 
-inline Bool Runtime::compareEqual(const Value &left, const Value &right)
+inline Bool Runtime::method_compareEqual(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
@@ -363,7 +363,7 @@ inline ReturnedValue Runtime::equal(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = Runtime::compareEqual(left, right);
+    bool r = method_compareEqual(left, right);
     return Encode(r);
 }
 
@@ -371,7 +371,7 @@ inline ReturnedValue Runtime::notEqual(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    bool r = !Runtime::compareEqual(left, right);
+    bool r = !method_compareEqual(left, right);
     return Encode(r);
 }
 
@@ -391,21 +391,21 @@ inline ReturnedValue Runtime::strictNotEqual(const Value &left, const Value &rig
     return Encode(r);
 }
 
-inline Bool Runtime::compareNotEqual(const Value &left, const Value &right)
+inline Bool Runtime::method_compareNotEqual(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
-    return !Runtime::compareEqual(left, right);
+    return !Runtime::method_compareEqual(left, right);
 }
 
-inline Bool Runtime::compareStrictEqual(const Value &left, const Value &right)
+inline Bool Runtime::method_compareStrictEqual(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
     return RuntimeHelpers::strictEqual(left, right);
 }
 
-inline Bool Runtime::compareStrictNotEqual(const Value &left, const Value &right)
+inline Bool Runtime::method_compareStrictNotEqual(const Value &left, const Value &right)
 {
     TRACE2(left, right);
 
diff --git a/src/qml/jsruntime/qv4runtimeapi_p.h b/src/qml/jsruntime/qv4runtimeapi_p.h
index 8f5a010107..e17b1803d8 100644
--- a/src/qml/jsruntime/qv4runtimeapi_p.h
+++ b/src/qml/jsruntime/qv4runtimeapi_p.h
@@ -106,6 +106,16 @@ struct Q_QML_PRIVATE_EXPORT Runtime {
         , INIT_RUNTIME_METHOD(complement)
         , INIT_RUNTIME_METHOD(increment)
         , INIT_RUNTIME_METHOD(decrement)
+        , INIT_RUNTIME_METHOD(compareGreaterThan)
+        , INIT_RUNTIME_METHOD(compareLessThan)
+        , INIT_RUNTIME_METHOD(compareGreaterEqual)
+        , INIT_RUNTIME_METHOD(compareLessEqual)
+        , INIT_RUNTIME_METHOD(compareEqual)
+        , INIT_RUNTIME_METHOD(compareNotEqual)
+        , INIT_RUNTIME_METHOD(compareStrictEqual)
+        , INIT_RUNTIME_METHOD(compareStrictNotEqual)
+        , INIT_RUNTIME_METHOD(compareInstanceof)
+        , INIT_RUNTIME_METHOD(compareIn)
         , INIT_RUNTIME_METHOD(toBoolean)
         , INIT_RUNTIME_METHOD(toDouble)
         , INIT_RUNTIME_METHOD(toInt)
@@ -227,18 +237,18 @@ struct Q_QML_PRIVATE_EXPORT Runtime {
 
     // comparisons
     typedef Bool (*CompareOperation)(const Value &left, const Value &right);
-    static Bool compareGreaterThan(const Value &l, const Value &r);
-    static Bool compareLessThan(const Value &l, const Value &r);
-    static Bool compareGreaterEqual(const Value &l, const Value &r);
-    static Bool compareLessEqual(const Value &l, const Value &r);
-    static Bool compareEqual(const Value &left, const Value &right);
-    static Bool compareNotEqual(const Value &left, const Value &right);
-    static Bool compareStrictEqual(const Value &left, const Value &right);
-    static Bool compareStrictNotEqual(const Value &left, const Value &right);
+    RUNTIME_METHOD(Bool, compareGreaterThan, (const Value &l, const Value &r));
+    RUNTIME_METHOD(Bool, compareLessThan, (const Value &l, const Value &r));
+    RUNTIME_METHOD(Bool, compareGreaterEqual, (const Value &l, const Value &r));
+    RUNTIME_METHOD(Bool, compareLessEqual, (const Value &l, const Value &r));
+    RUNTIME_METHOD(Bool, compareEqual, (const Value &left, const Value &right));
+    RUNTIME_METHOD(Bool, compareNotEqual, (const Value &left, const Value &right));
+    RUNTIME_METHOD(Bool, compareStrictEqual, (const Value &left, const Value &right));
+    RUNTIME_METHOD(Bool, compareStrictNotEqual, (const Value &left, const Value &right));
 
     typedef Bool (*CompareOperationContext)(ExecutionEngine *engine, const Value &left, const Value &right);
-    static Bool compareInstanceof(ExecutionEngine *engine, const Value &left, const Value &right);
-    static Bool compareIn(ExecutionEngine *engine, const Value &left, const Value &right);
+    RUNTIME_METHOD(Bool, compareInstanceof, (ExecutionEngine *engine, const Value &left, const Value &right));
+    RUNTIME_METHOD(Bool, compareIn, (ExecutionEngine *engine, const Value &left, const Value &right));
 
     // conversions
     RUNTIME_METHOD(Bool, toBoolean, (const Value &value));