Convert qjsconverter to v4 based API

Longer term the whole class should go, but for
now this'll do.

Change-Id: I17b13848a07d415633606faa1c93ff3a9f54a45a
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

1 files changed, 36 insertions, 114 deletions

diff --git a/src/qml/qml/v8/qjsconverter_impl_p.h b/src/qml/qml/v8/qjsconverter_impl_p.h
index 165373c421..16bd3307ff 100644
--- a/src/qml/qml/v8/qjsconverter_impl_p.h
+++ b/src/qml/qml/v8/qjsconverter_impl_p.h
@@ -42,6 +42,10 @@
 #include "qjsconverter_p.h"
 #include <stdlib.h>
 
+#include <private/qv4jsir_p.h>
+#include <private/qv4regexpobject_p.h>
+#include <private/qv4dateobject_p.h>
+
 #ifndef QJSCONVERTER_IMPL_P_H
 #define QJSCONVERTER_IMPL_P_H
 
@@ -54,115 +58,21 @@ QT_BEGIN_NAMESPACE
 extern char *qdtoa(double d, int mode, int ndigits, int *decpt, int *sign, char **rve, char **digits_str);
 Q_CORE_EXPORT QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyntax);
 
-
-quint32 QJSConverter::toArrayIndex(const QString& string)
-{
-    // FIXME this function should be exported by JSC C API.
-    bool ok;
-    quint32 idx = string.toUInt(&ok);
-    if (!ok || toString(idx) != string)
-        idx = 0xffffffff;
-
-    return idx;
-}
-
-QString QJSConverter::toString(v8::Handle<v8::String> jsString)
-{
-    if (jsString.IsEmpty())
-        return QString();
-    QString qstr;
-    qstr.resize(jsString->Length());
-    jsString->Write(reinterpret_cast<uint16_t*>(qstr.data()));
-    return qstr;
-}
-
-v8::Local<v8::String> QJSConverter::toString(const QString& string)
-{
-    return v8::String::New(reinterpret_cast<const uint16_t*>(string.data()), string.size());
-}
-
-QString QJSConverter::toString(double value)
-{
-    // FIXME this should be easier. The ideal fix is to create
-    // a new function in V8 API which could cover the functionality.
-
-    if (qIsNaN(value))
-        return QString::fromLatin1("NaN");
-    if (qIsInf(value))
-        return QString::fromLatin1(value < 0 ? "-Infinity" : "Infinity");
-    if (!value)
-        return QString::fromLatin1("0");
-
-    QVarLengthArray<char, 25> buf;
-    int decpt;
-    int sign;
-    char* result = 0;
-    char* endresult;
-    (void)qdtoa(value, 0, 0, &decpt, &sign, &endresult, &result);
-
-    if (!result)
-        return QString();
-
-    int resultLen = endresult - result;
-    if (decpt <= 0 && decpt > -6) {
-        buf.resize(-decpt + 2 + sign);
-        memset(buf.data(), '0', -decpt + 2 + sign);
-        if (sign) // fix the sign.
-            buf[0] = '-';
-        buf[sign + 1] = '.';
-        buf.append(result, resultLen);
-    } else {
-        if (sign)
-            buf.append('-');
-        int length = buf.size() - sign + resultLen;
-        if (decpt <= 21 && decpt > 0) {
-            if (length <= decpt) {
-                const char* zeros = "0000000000000000000000000";
-                buf.append(result, resultLen);
-                buf.append(zeros, decpt - length);
-            } else {
-                buf.append(result, decpt);
-                buf.append('.');
-                buf.append(result + decpt, resultLen - decpt);
-            }
-        } else if (result[0] >= '0' && result[0] <= '9') {
-            if (length > 1) {
-                buf.append(result, 1);
-                buf.append('.');
-                buf.append(result + 1, resultLen - 1);
-            } else
-                buf.append(result, resultLen);
-            buf.append('e');
-            buf.append(decpt >= 0 ? '+' : '-');
-            int e = qAbs(decpt - 1);
-            if (e >= 100)
-                buf.append('0' + e / 100);
-            if (e >= 10)
-                buf.append('0' + (e % 100) / 10);
-            buf.append('0' + e % 10);
-        }
-    }
-    free(result);
-    buf.append(0);
-    return QString::fromLatin1(buf.constData());
-}
-
 // Converts a JS RegExp to a QRegExp.
 // The conversion is not 100% exact since ECMA regexp and QRegExp
 // have different semantics/flags, but we try to do our best.
-QRegExp QJSConverter::toRegExp(v8::Handle<v8::RegExp> jsRegExp)
+QRegExp QJSConverter::toRegExp(const QV4::RegExpObject *jsRegExp)
 {
-    QString pattern = QJSConverter::toString(jsRegExp->GetSource());
-    Qt::CaseSensitivity caseSensitivity = Qt::CaseSensitive;
-    if (jsRegExp->GetFlags() & v8::RegExp::kIgnoreCase)
-        caseSensitivity = Qt::CaseInsensitive;
+    QV4::RegExp *re = jsRegExp->value;
+    QString pattern = re->pattern();
+    Qt::CaseSensitivity caseSensitivity = re->ignoreCase() ? Qt::CaseInsensitive : Qt::CaseSensitive;
     return QRegExp(pattern, caseSensitivity, QRegExp::RegExp2);
 }
 
 // Converts a QRegExp to a JS RegExp.
 // The conversion is not 100% exact since ECMA regexp and QRegExp
 // have different semantics/flags, but we try to do our best.
-v8::Local<v8::RegExp> QJSConverter::toRegExp(const QRegExp &re)
+QV4::RegExpObject *QJSConverter::toRegExp(const QRegExp &re)
 {
     // Convert the pattern to a ECMAScript pattern.
     QString pattern = qt_regexp_toCanonical(re.pattern(), re.patternSyntax());
@@ -201,54 +111,66 @@ v8::Local<v8::RegExp> QJSConverter::toRegExp(const QRegExp &re)
         pattern = ecmaPattern;
     }
 
-    int flags = v8::RegExp::kNone;
+    int flags = 0;
     if (re.caseSensitivity() == Qt::CaseInsensitive)
-        flags |= v8::RegExp::kIgnoreCase;
+        flags |= QQmlJS::V4IR::RegExp::RegExp_IgnoreCase;
 
-    return v8::RegExp::New(QJSConverter::toString(pattern), static_cast<v8::RegExp::Flags>(flags));
+    QV4::ExecutionEngine *e = v8::Isolate::GetCurrent()->GetEngine();
+    return e->newRegExpObject(pattern, flags);
 }
 
 // Converts a QStringList to JS.
 // The result is a new Array object with length equal to the length
 // of the QStringList, and the elements being the QStringList's
 // elements converted to JS Strings.
-v8::Local<v8::Array> QJSConverter::toStringList(const QStringList &lst)
+QV4::Value QJSConverter::toStringList(const QStringList &list)
 {
-    v8::Local<v8::Array> result = v8::Array::New(lst.size());
-    for (int i = 0; i < lst.size(); ++i)
-        result->Set(i, toString(lst.at(i)));
-    return result;
+    QV4::ExecutionEngine *e = v8::Isolate::GetCurrent()->GetEngine();
+    QV4::ArrayObject *a = e->newArrayObject(e->current);
+    int len = list.count();
+    a->arrayReserve(len);
+    for (int ii = 0; ii < len; ++ii)
+        a->arrayData[ii].value = QV4::Value::fromString(e->newString(list.at(ii)));
+    a->setArrayLengthUnchecked(len);
+    return QV4::Value::fromObject(a);
 }
 
 // Converts a JS Array object to a QStringList.
 // The result is a QStringList with length equal to the length
 // of the JS Array, and elements being the JS Array's elements
 // converted to QStrings.
-QStringList QJSConverter::toStringList(v8::Handle<v8::Array> jsArray)
+QStringList QJSConverter::toStringList(const QV4::Value &jsArray)
 {
     QStringList result;
-    uint32_t length = jsArray->Length();
+
+    QV4::ArrayObject *a = jsArray.asArrayObject();
+    if (!a)
+        return result;
+    QV4::ExecutionEngine *e = a->internalClass->engine;
+
+    uint32_t length = a->arrayLength();
     for (uint32_t i = 0; i < length; ++i)
-        result.append(toString(jsArray->Get(i)->ToString()));
+        result.append(a->getIndexed(e->current, i).toString(e->current)->toQString());
     return result;
 }
 
 
 // Converts a JS Date to a QDateTime.
-QDateTime QJSConverter::toDateTime(v8::Handle<v8::Date> jsDate)
+QDateTime QJSConverter::toDateTime(QV4::DateObject *jsDate)
 {
-    return QDateTime::fromMSecsSinceEpoch(jsDate->NumberValue());
+    return QDateTime::fromMSecsSinceEpoch(jsDate->value.doubleValue());
 }
 
 // Converts a QDateTime to a JS Date.
-v8::Local<v8::Value> QJSConverter::toDateTime(const QDateTime &dt)
+QV4::DateObject *QJSConverter::toDateTime(const QDateTime &dt)
 {
     double date;
     if (!dt.isValid())
         date = qSNaN();
     else
         date = dt.toMSecsSinceEpoch();
-    return v8::Date::New(date);
+    QV4::ExecutionEngine *e = v8::Isolate::GetCurrent()->GetEngine();
+    return e->newDateObject(QV4::Value::fromDouble(date));
 }
 
 QT_END_NAMESPACE