← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/webkit/WebCore/bridge/qt/qt_runtime.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/webkit/WebCore/bridge/qt/qt_runtime.cpp
20
20
#include "config.h"
21
21
#include "qt_runtime.h"
22
22
 
 
23
#include "BooleanObject.h"
23
24
#include "DateInstance.h"
24
25
#include "DateMath.h"
25
26
#include "DatePrototype.h"
46
47
#include <JSFunction.h>
47
48
#include <limits.h>
48
49
#include <runtime.h>
 
50
#include <runtime/Error.h>
49
51
#include <runtime_array.h>
50
52
#include <runtime_object.h>
51
 
#include "BooleanObject.h"
52
53
 
53
54
// QtScript has these
54
55
Q_DECLARE_METATYPE(QObjectList);
113
114
}
114
115
#endif
115
116
 
116
 
static JSRealType valueRealType(ExecState* exec, JSValuePtr val)
 
117
static JSRealType valueRealType(ExecState* exec, JSValue val)
117
118
{
118
 
    if (val->isNumber())
 
119
    if (val.isNumber())
119
120
        return Number;
120
 
    else if (val->isString())
 
121
    else if (val.isString())
121
122
        return String;
122
 
    else if (val->isBoolean())
 
123
    else if (val.isBoolean())
123
124
        return Boolean;
124
 
    else if (val->isNull())
 
125
    else if (val.isNull())
125
126
        return Null;
126
 
    else if (exec->interpreter()->isJSByteArray(val))
 
127
    else if (isJSByteArray(&exec->globalData(), val))
127
128
        return JSByteArray;
128
 
    else if (val->isObject()) {
129
 
        JSObject *object = val->toObject(exec);
 
129
    else if (val.isObject()) {
 
130
        JSObject *object = val.toObject(exec);
130
131
        if (object->inherits(&RuntimeArray::s_info))  // RuntimeArray 'inherits' from Array, but not in C++
131
132
            return RTArray;
132
133
        else if (object->inherits(&JSArray::info))
143
144
    return String; // I don't know.
144
145
}
145
146
 
146
 
QVariant convertValueToQVariant(ExecState* exec, JSValuePtr value, QMetaType::Type hint, int *distance, HashSet<JSObject*>* visitedObjects)
 
147
QVariant convertValueToQVariant(ExecState* exec, JSValue value, QMetaType::Type hint, int *distance, HashSet<JSObject*>* visitedObjects)
147
148
{
 
149
    if (!value)
 
150
        return QVariant();
 
151
 
148
152
    JSObject* object = 0;
149
 
    if (value->isObject()) {
150
 
        object = value->toObject(exec);
 
153
    if (value.isObject()) {
 
154
        object = value.toObject(exec);
151
155
        if (visitedObjects->contains(object))
152
156
            return QVariant();
153
157
 
164
168
        return QVariant();
165
169
    }
166
170
 
167
 
    JSLock lock(false);
 
171
    JSLock lock(SilenceAssertionsOnly);
168
172
    JSRealType type = valueRealType(exec, value);
169
173
    if (hint == QMetaType::Void) {
170
174
        switch(type) {
222
226
    switch (hint) {
223
227
        case QMetaType::Bool:
224
228
            if (type == Object && object->inherits(&BooleanObject::info))
225
 
                ret = QVariant(asBooleanObject(value)->internalValue()->toBoolean(exec));
 
229
                ret = QVariant(asBooleanObject(value)->internalValue().toBoolean(exec));
226
230
            else
227
 
                ret = QVariant(value->toBoolean(exec));
 
231
                ret = QVariant(value.toBoolean(exec));
228
232
            if (type == Boolean)
229
233
                dist = 0;
230
234
            else
241
245
        case QMetaType::UShort:
242
246
        case QMetaType::Float:
243
247
        case QMetaType::Double:
244
 
            ret = QVariant(value->toNumber(exec));
 
248
            ret = QVariant(value.toNumber(exec));
245
249
            ret.convert((QVariant::Type)hint);
246
250
            if (type == Number) {
247
251
                switch (hint) {
279
283
 
280
284
        case QMetaType::QChar:
281
285
            if (type == Number || type == Boolean) {
282
 
                ret = QVariant(QChar((ushort)value->toNumber(exec)));
 
286
                ret = QVariant(QChar((ushort)value.toNumber(exec)));
283
287
                if (type == Boolean)
284
288
                    dist = 3;
285
289
                else
286
290
                    dist = 6;
287
291
            } else {
288
 
                UString str = value->toString(exec);
 
292
                UString str = value.toString(exec);
289
293
                ret = QVariant(QChar(str.size() ? *(const ushort*)str.rep()->data() : 0));
290
294
                if (type == String)
291
295
                    dist = 3;
295
299
            break;
296
300
 
297
301
        case QMetaType::QString: {
298
 
            if (value->isUndefinedOrNull()) {
 
302
            if (value.isUndefinedOrNull()) {
299
303
                if (distance)
300
304
                    *distance = 1;
301
305
                return QString();
302
306
            } else {
303
 
                UString ustring = value->toString(exec);
 
307
                UString ustring = value.toString(exec);
304
308
                ret = QVariant(QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size()));
305
309
                if (type == String)
306
310
                    dist = 0;
321
325
                int objdist = 0;
322
326
                while(it != properties.end()) {
323
327
                    if (object->propertyIsEnumerable(exec, *it)) {
324
 
                        JSValuePtr val = object->get(exec, *it);
 
328
                        JSValue val = object->get(exec, *it);
325
329
                        QVariant v = convertValueToQVariant(exec, val, QMetaType::Void, &objdist, visitedObjects);
326
330
                        if (objdist >= 0) {
327
331
                            UString ustring = (*it).ustring();
345
349
                int objdist = 0;
346
350
                qConvDebug() << "converting a " << len << " length Array";
347
351
                for (int i = 0; i < len; ++i) {
348
 
                    JSValuePtr val = rtarray->getConcreteArray()->valueAt(exec, i);
 
352
                    JSValue val = rtarray->getConcreteArray()->valueAt(exec, i);
349
353
                    result.append(convertValueToQVariant(exec, val, QMetaType::Void, &objdist, visitedObjects));
350
354
                    if (objdist == -1) {
351
355
                        qConvDebug() << "Failed converting element at index " << i;
364
368
                int objdist = 0;
365
369
                qConvDebug() << "converting a " << len << " length Array";
366
370
                for (int i = 0; i < len; ++i) {
367
 
                    JSValuePtr val = array->get(exec, i);
 
371
                    JSValue val = array->get(exec, i);
368
372
                    result.append(convertValueToQVariant(exec, val, QMetaType::Void, &objdist, visitedObjects));
369
373
                    if (objdist == -1) {
370
374
                        qConvDebug() << "Failed converting element at index " << i;
398
402
                QStringList result;
399
403
                int len = rtarray->getLength();
400
404
                for (int i = 0; i < len; ++i) {
401
 
                    JSValuePtr val = rtarray->getConcreteArray()->valueAt(exec, i);
402
 
                    UString ustring = val->toString(exec);
 
405
                    JSValue val = rtarray->getConcreteArray()->valueAt(exec, i);
 
406
                    UString ustring = val.toString(exec);
403
407
                    QString qstring = QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size());
404
408
 
405
409
                    result.append(qstring);
412
416
                QStringList result;
413
417
                int len = array->length();
414
418
                for (int i = 0; i < len; ++i) {
415
 
                    JSValuePtr val = array->get(exec, i);
416
 
                    UString ustring = val->toString(exec);
 
419
                    JSValue val = array->get(exec, i);
 
420
                    UString ustring = val.toString(exec);
417
421
                    QString qstring = QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size());
418
422
 
419
423
                    result.append(qstring);
422
426
                ret = QVariant(result);
423
427
            } else {
424
428
                // Make a single length array
425
 
                UString ustring = value->toString(exec);
 
429
                UString ustring = value.toString(exec);
426
430
                QString qstring = QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size());
427
431
                QStringList result;
428
432
                result.append(qstring);
434
438
 
435
439
        case QMetaType::QByteArray: {
436
440
            if (type == JSByteArray) {
437
 
                ByteArray* arr = asByteArray(value)->storage();
 
441
                WTF::ByteArray* arr = asByteArray(value)->storage();
438
442
                ret = QVariant(QByteArray(reinterpret_cast<const char*>(arr->data()), arr->length()));
439
443
                dist = 0;
440
444
            } else {
441
 
                UString ustring = value->toString(exec);
 
445
                UString ustring = value.toString(exec);
442
446
                ret = QVariant(QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size()).toLatin1());
443
447
                if (type == String)
444
448
                    dist = 5;
453
457
        case QMetaType::QTime:
454
458
            if (type == Date) {
455
459
                DateInstance* date = static_cast<DateInstance*>(object);
456
 
                GregorianDateTime gdt;
 
460
                WTF::GregorianDateTime gdt;
457
461
                date->getUTCTime(gdt);
458
462
                if (hint == QMetaType::QDateTime) {
459
463
                    ret = QDateTime(QDate(gdt.year + 1900, gdt.month + 1, gdt.monthDay), QTime(gdt.hour, gdt.minute, gdt.second), Qt::UTC);
466
470
                    dist = 2;
467
471
                }
468
472
            } else if (type == Number) {
469
 
                double b = value->toNumber(exec);
470
 
                GregorianDateTime gdt;
 
473
                double b = value.toNumber(exec);
 
474
                WTF::GregorianDateTime gdt;
471
475
                msToGregorianDateTime(b, true, gdt);
472
476
                if (hint == QMetaType::QDateTime) {
473
477
                    ret = QDateTime(QDate(gdt.year + 1900, gdt.month + 1, gdt.monthDay), QTime(gdt.hour, gdt.minute, gdt.second), Qt::UTC);
480
484
                    dist = 10;
481
485
                }
482
486
            } else if (type == String) {
483
 
                UString ustring = value->toString(exec);
 
487
                UString ustring = value.toString(exec);
484
488
                QString qstring = QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size());
485
489
 
486
490
                if (hint == QMetaType::QDateTime) {
529
533
                RegExpObject *re = static_cast<RegExpObject*>(object);
530
534
*/
531
535
                // Attempt to convert.. a bit risky
532
 
                UString ustring = value->toString(exec);
 
536
                UString ustring = value.toString(exec);
533
537
                QString qstring = QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size());
534
538
 
535
539
                // this is of the form '/xxxxxx/i'
549
553
                    qConvDebug() << "couldn't parse a JS regexp";
550
554
                }
551
555
            } else if (type == String) {
552
 
                UString ustring = value->toString(exec);
 
556
                UString ustring = value.toString(exec);
553
557
                QString qstring = QString::fromUtf16((const ushort*)ustring.rep()->data(),ustring.size());
554
558
 
555
559
                QRegExp re(qstring);
562
566
 
563
567
        case QMetaType::QObjectStar:
564
568
            if (type == QObj) {
565
 
                QtInstance* qtinst = static_cast<QtInstance*>(Instance::getInstance(object, Instance::QtLanguage));
 
569
                QtInstance* qtinst = QtInstance::getInstance(object);
566
570
                if (qtinst) {
567
571
                    if (qtinst->getObject()) {
568
572
                        qConvDebug() << "found instance, with object:" << (void*) qtinst->getObject();
586
590
 
587
591
        case QMetaType::VoidStar:
588
592
            if (type == QObj) {
589
 
                QtInstance* qtinst = static_cast<QtInstance*>(Instance::getInstance(object, Instance::QtLanguage));
 
593
                QtInstance* qtinst = QtInstance::getInstance(object);
590
594
                if (qtinst) {
591
595
                    if (qtinst->getObject()) {
592
596
                        qConvDebug() << "found instance, with object:" << (void*) qtinst->getObject();
605
609
            } else if (type == Number) {
606
610
                // I don't think that converting a double to a pointer is a wise
607
611
                // move.  Except maybe 0.
608
 
                qConvDebug() << "got number for void * - not converting, seems unsafe:" << value->toNumber(exec);
 
612
                qConvDebug() << "got number for void * - not converting, seems unsafe:" << value.toNumber(exec);
609
613
            } else {
610
614
                qConvDebug() << "void* - unhandled type" << type;
611
615
            }
621
625
                    QObjectList result;
622
626
                    int len = rtarray->getLength();
623
627
                    for (int i = 0; i < len; ++i) {
624
 
                        JSValuePtr val = rtarray->getConcreteArray()->valueAt(exec, i);
 
628
                        JSValue val = rtarray->getConcreteArray()->valueAt(exec, i);
625
629
                        int itemdist = -1;
626
630
                        QVariant item = convertValueToQVariant(exec, val, QMetaType::QObjectStar, &itemdist, visitedObjects);
627
631
                        if (itemdist >= 0)
635
639
                        ret = QVariant::fromValue(result);
636
640
                    }
637
641
                } else if (type == Array) {
638
 
                    JSObject* object = value->toObject(exec);
 
642
                    JSObject* object = value.toObject(exec);
639
643
                    JSArray* array = static_cast<JSArray *>(object);
640
644
                    QObjectList result;
641
645
                    int len = array->length();
642
646
                    for (int i = 0; i < len; ++i) {
643
 
                        JSValuePtr val = array->get(exec, i);
 
647
                        JSValue val = array->get(exec, i);
644
648
                        int itemdist = -1;
645
649
                        QVariant item = convertValueToQVariant(exec, val, QMetaType::QObjectStar, &itemdist, visitedObjects);
646
650
                        if (itemdist >= 0)
672
676
                    QList<int> result;
673
677
                    int len = rtarray->getLength();
674
678
                    for (int i = 0; i < len; ++i) {
675
 
                        JSValuePtr val = rtarray->getConcreteArray()->valueAt(exec, i);
 
679
                        JSValue val = rtarray->getConcreteArray()->valueAt(exec, i);
676
680
                        int itemdist = -1;
677
681
                        QVariant item = convertValueToQVariant(exec, val, QMetaType::Int, &itemdist, visitedObjects);
678
682
                        if (itemdist >= 0)
691
695
                    QList<int> result;
692
696
                    int len = array->length();
693
697
                    for (int i = 0; i < len; ++i) {
694
 
                        JSValuePtr val = array->get(exec, i);
 
698
                        JSValue val = array->get(exec, i);
695
699
                        int itemdist = -1;
696
700
                        QVariant item = convertValueToQVariant(exec, val, QMetaType::Int, &itemdist, visitedObjects);
697
701
                        if (itemdist >= 0)
717
721
                }
718
722
                break;
719
723
            } else if (hint == (QMetaType::Type) qMetaTypeId<QVariant>()) {
720
 
                if (value->isUndefinedOrNull()) {
 
724
                if (value.isUndefinedOrNull()) {
721
725
                    if (distance)
722
726
                        *distance = 1;
723
727
                    return QVariant();
746
750
    return ret;
747
751
}
748
752
 
749
 
QVariant convertValueToQVariant(ExecState* exec, JSValuePtr value, QMetaType::Type hint, int *distance)
 
753
QVariant convertValueToQVariant(ExecState* exec, JSValue value, QMetaType::Type hint, int *distance)
750
754
{
751
755
    HashSet<JSObject*> visitedObjects;
752
756
    return convertValueToQVariant(exec, value, hint, distance, &visitedObjects);
753
757
}
754
758
 
755
 
JSValuePtr convertQVariantToValue(ExecState* exec, PassRefPtr<RootObject> root, const QVariant& variant)
 
759
JSValue convertQVariantToValue(ExecState* exec, PassRefPtr<RootObject> root, const QVariant& variant)
756
760
{
757
761
    // Variants with QObject * can be isNull but not a null pointer
758
762
    // An empty QString variant is also null
767
771
        return jsNull();
768
772
    }
769
773
 
770
 
    JSLock lock(false);
 
774
    JSLock lock(SilenceAssertionsOnly);
771
775
 
772
776
    if (type == QMetaType::Bool)
773
777
        return jsBoolean(variant.toBool());
820
824
        }
821
825
 
822
826
        // Dates specified this way are in local time (we convert DateTimes above)
823
 
        GregorianDateTime dt;
 
827
        WTF::GregorianDateTime dt;
824
828
        dt.year = date.year() - 1900;
825
829
        dt.month = date.month() - 1;
826
830
        dt.monthDay = date.day();
828
832
        dt.minute = time.minute();
829
833
        dt.second = time.second();
830
834
        dt.isDST = -1;
831
 
        double ms = JSC::gregorianDateTimeToMS(dt, time.msec(), /*inputIsUTC*/ false);
 
835
        double ms = WTF::gregorianDateTimeToMS(dt, time.msec(), /*inputIsUTC*/ false);
832
836
 
833
837
        DateInstance* instance = new (exec) DateInstance(exec->lexicalGlobalObject()->dateStructure());
834
838
        instance->setInternalValue(jsNumber(exec, trunc(ms)));
837
841
 
838
842
    if (type == QMetaType::QByteArray) {
839
843
        QByteArray qtByteArray = variant.value<QByteArray>();
840
 
        WTF::RefPtr<ByteArray> wtfByteArray = ByteArray::create(qtByteArray.length());
 
844
        WTF::RefPtr<WTF::ByteArray> wtfByteArray = WTF::ByteArray::create(qtByteArray.length());
841
845
        qMemCopy(wtfByteArray->data(), qtByteArray.constData(), qtByteArray.length());
842
846
        return new (exec) JSC::JSByteArray(exec, JSC::JSByteArray::createStructure(jsNull()), wtfByteArray.get());
843
847
    }
844
848
 
845
849
    if (type == QMetaType::QObjectStar || type == QMetaType::QWidgetStar) {
846
850
        QObject* obj = variant.value<QObject*>();
847
 
        return Instance::createRuntimeObject(exec, QtInstance::getQtInstance(obj, root, QScriptEngine::QtOwnership));
 
851
        return QtInstance::getQtInstance(obj, root, QScriptEngine::QtOwnership)->createRuntimeObject(exec);
848
852
    }
849
853
 
850
854
    if (type == QMetaType::QVariantMap) {
854
858
        QVariantMap::const_iterator i = map.constBegin();
855
859
        while (i != map.constEnd()) {
856
860
            QString s = i.key();
857
 
            JSValuePtr val = convertQVariantToValue(exec, root, i.value());
 
861
            JSValue val = convertQVariantToValue(exec, root, i.value());
858
862
            if (val) {
859
863
                PutPropertySlot slot;
860
864
                ret->put(exec, Identifier(exec, (const UChar *)s.constData(), s.length()), val, slot);
904
908
const ClassInfo QtRuntimeMethod::s_info = { "QtRuntimeMethod", 0, 0, 0 };
905
909
 
906
910
QtRuntimeMethod::QtRuntimeMethod(QtRuntimeMethodData* dd, ExecState* exec, const Identifier& ident, PassRefPtr<QtInstance> inst)
907
 
    : InternalFunction(&exec->globalData(), getDOMStructure<QtRuntimeMethod>(exec), ident)
 
911
    : InternalFunction(&exec->globalData(), deprecatedGetDOMStructure<QtRuntimeMethod>(exec), ident)
908
912
    , d_ptr(dd)
909
913
{
910
914
    QW_D(QtRuntimeMethod);
913
917
 
914
918
QtRuntimeMethod::~QtRuntimeMethod()
915
919
{
 
920
    QW_D(QtRuntimeMethod);
 
921
    d->m_instance->removeCachedMethod(this);
916
922
    delete d_ptr;
917
923
}
918
924
 
1157
1163
        }
1158
1164
 
1159
1165
        // If the native method requires more arguments than what was passed from JavaScript
1160
 
        if (jsArgs.size() < (types.count() - 1)) {
 
1166
        if (jsArgs.size() + 1 < static_cast<unsigned>(types.count())) {
1161
1167
            qMatchDebug() << "Match:too few args for" << method.signature();
1162
1168
            tooFewArgs.append(index);
1163
1169
            continue;
1180
1186
 
1181
1187
        bool converted = true;
1182
1188
        int matchDistance = 0;
1183
 
        for (int i = 0; converted && i < types.count() - 1; ++i) {
1184
 
            JSValuePtr arg = i < jsArgs.size() ? jsArgs.at(exec, i) : jsUndefined();
 
1189
        for (unsigned i = 0; converted && i + 1 < static_cast<unsigned>(types.count()); ++i) {
 
1190
            JSValue arg = i < jsArgs.size() ? jsArgs.at(i) : jsUndefined();
1185
1191
 
1186
1192
            int argdistance = -1;
1187
1193
            QVariant v = convertValueToQVariant(exec, arg, types.at(i+1).typeId(), &argdistance);
1197
1203
        qMatchDebug() << "Match: " << method.signature() << (converted ? "converted":"failed to convert") << "distance " << matchDistance;
1198
1204
 
1199
1205
        if (converted) {
1200
 
            if ((jsArgs.size() == types.count() - 1)
 
1206
            if ((jsArgs.size() + 1 == static_cast<unsigned>(types.count()))
1201
1207
                && (matchDistance == 0)) {
1202
1208
                // perfect match, use this one
1203
1209
                chosenIndex = index;
1323
1329
    d->m_allowPrivate = allowPrivate;
1324
1330
}
1325
1331
 
1326
 
void QtRuntimeMetaMethod::mark()
 
1332
void QtRuntimeMetaMethod::markChildren(MarkStack& markStack)
1327
1333
{
1328
 
    QtRuntimeMethod::mark();
 
1334
    QtRuntimeMethod::markChildren(markStack);
1329
1335
    QW_D(QtRuntimeMetaMethod);
1330
1336
    if (d->m_connect)
1331
 
        d->m_connect->mark();
 
1337
        markStack.append(d->m_connect);
1332
1338
    if (d->m_disconnect)
1333
 
        d->m_disconnect->mark();
 
1339
        markStack.append(d->m_disconnect);
1334
1340
}
1335
1341
 
1336
 
JSValuePtr QtRuntimeMetaMethod::call(ExecState* exec, JSObject* functionObject, JSValuePtr thisValue, const ArgList& args)
 
1342
JSValue QtRuntimeMetaMethod::call(ExecState* exec, JSObject* functionObject, JSValue, const ArgList& args)
1337
1343
{
1338
1344
    QtRuntimeMetaMethodData* d = static_cast<QtRuntimeMetaMethod *>(functionObject)->d_func();
1339
1345
 
1342
1348
        return jsUndefined();
1343
1349
 
1344
1350
    // We have to pick a method that matches..
1345
 
    JSLock lock(false);
 
1351
    JSLock lock(SilenceAssertionsOnly);
1346
1352
 
1347
1353
    QObject *obj = d->m_instance->getObject();
1348
1354
    if (obj) {
1391
1397
    return QtRuntimeMethod::getOwnPropertySlot(exec, propertyName, slot);
1392
1398
}
1393
1399
 
1394
 
JSValuePtr QtRuntimeMetaMethod::lengthGetter(ExecState* exec, const Identifier&, const PropertySlot&)
 
1400
JSValue QtRuntimeMetaMethod::lengthGetter(ExecState* exec, const Identifier&, const PropertySlot&)
1395
1401
{
1396
1402
    // QtScript always returns 0
1397
1403
    return jsNumber(exec, 0);
1398
1404
}
1399
1405
 
1400
 
JSValuePtr QtRuntimeMetaMethod::connectGetter(ExecState* exec, const Identifier& ident, const PropertySlot& slot)
 
1406
JSValue QtRuntimeMetaMethod::connectGetter(ExecState* exec, const Identifier& ident, const PropertySlot& slot)
1401
1407
{
1402
1408
    QtRuntimeMetaMethod* thisObj = static_cast<QtRuntimeMetaMethod*>(asObject(slot.slotBase()));
1403
1409
    QW_DS(QtRuntimeMetaMethod, thisObj);
1407
1413
    return d->m_connect;
1408
1414
}
1409
1415
 
1410
 
JSValuePtr QtRuntimeMetaMethod::disconnectGetter(ExecState* exec, const Identifier& ident, const PropertySlot& slot)
 
1416
JSValue QtRuntimeMetaMethod::disconnectGetter(ExecState* exec, const Identifier& ident, const PropertySlot& slot)
1411
1417
{
1412
1418
    QtRuntimeMetaMethod* thisObj = static_cast<QtRuntimeMetaMethod*>(asObject(slot.slotBase()));
1413
1419
    QW_DS(QtRuntimeMetaMethod, thisObj);
1431
1437
    d->m_isConnect = isConnect;
1432
1438
}
1433
1439
 
1434
 
JSValuePtr QtRuntimeConnectionMethod::call(ExecState* exec, JSObject* functionObject, JSValuePtr thisValue, const ArgList& args)
 
1440
JSValue QtRuntimeConnectionMethod::call(ExecState* exec, JSObject* functionObject, JSValue, const ArgList& args)
1435
1441
{
1436
1442
    QtRuntimeConnectionMethodData* d = static_cast<QtRuntimeConnectionMethod *>(functionObject)->d_func();
1437
1443
 
1438
 
    JSLock lock(false);
 
1444
    JSLock lock(SilenceAssertionsOnly);
1439
1445
 
1440
1446
    QObject* sender = d->m_instance->getObject();
1441
1447
 
1454
1460
 
1455
1461
        if (signalIndex != -1) {
1456
1462
            if (args.size() == 1) {
1457
 
                funcObject = args.at(exec, 0)->toObject(exec);
 
1463
                funcObject = args.at(0).toObject(exec);
1458
1464
                CallData callData;
1459
1465
                if (funcObject->getCallData(callData) == CallTypeNone) {
1460
1466
                    if (d->m_isConnect)
1463
1469
                        return throwError(exec, TypeError, "QtMetaMethod.disconnect: target is not a function");
1464
1470
                }
1465
1471
            } else if (args.size() >= 2) {
1466
 
                if (args.at(exec, 0)->isObject()) {
1467
 
                    thisObject = args.at(exec, 0)->toObject(exec);
 
1472
                if (args.at(0).isObject()) {
 
1473
                    thisObject = args.at(0).toObject(exec);
1468
1474
 
1469
1475
                    // Get the actual function to call
1470
 
                    JSObject *asObj = args.at(exec, 1)->toObject(exec);
 
1476
                    JSObject *asObj = args.at(1).toObject(exec);
1471
1477
                    CallData callData;
1472
1478
                    if (asObj->getCallData(callData) != CallTypeNone) {
1473
1479
                        // Function version
1474
1480
                        funcObject = asObj;
1475
1481
                    } else {
1476
1482
                        // Convert it to a string
1477
 
                        UString funcName = args.at(exec, 1)->toString(exec);
 
1483
                        UString funcName = args.at(1).toString(exec);
1478
1484
                        Identifier funcIdent(exec, funcName);
1479
1485
 
1480
1486
                        // ### DropAllLocks
1481
1487
                        // This is resolved at this point in QtScript
1482
 
                        JSValuePtr val = thisObject->get(exec, funcIdent);
1483
 
                        JSObject* asFuncObj = val->toObject(exec);
 
1488
                        JSValue val = thisObject->get(exec, funcIdent);
 
1489
                        JSObject* asFuncObj = val.toObject(exec);
1484
1490
 
1485
1491
                        if (asFuncObj->getCallData(callData) != CallTypeNone) {
1486
1492
                            funcObject = asFuncObj;
1577
1583
    return QtRuntimeMethod::getOwnPropertySlot(exec, propertyName, slot);
1578
1584
}
1579
1585
 
1580
 
JSValuePtr QtRuntimeConnectionMethod::lengthGetter(ExecState* exec, const Identifier&, const PropertySlot&)
 
1586
JSValue QtRuntimeConnectionMethod::lengthGetter(ExecState* exec, const Identifier&, const PropertySlot&)
1581
1587
{
1582
1588
    // we have one formal argument, and one optional
1583
1589
    return jsNumber(exec, 1);
1665
1671
 
1666
1672
        int argc = parameterTypes.count();
1667
1673
 
1668
 
        JSLock lock(false);
 
1674
        JSLock lock(SilenceAssertionsOnly);
1669
1675
 
1670
1676
        // ### Should the Interpreter/ExecState come from somewhere else?
1671
1677
        RefPtr<RootObject> ro = m_instance->rootObject();
1675
1681
                ExecState* exec = globalobj->globalExec();
1676
1682
                if (exec) {
1677
1683
                    // Build the argument list (up to the formal argument length of the slot)
1678
 
                    ArgList l;
 
1684
                    MarkedArgumentBuffer l;
1679
1685
                    // ### DropAllLocks?
1680
 
                    int funcArgC = m_funcObject->get(exec, exec->propertyNames().length)->toInt32(exec);
 
1686
                    int funcArgC = m_funcObject->get(exec, exec->propertyNames().length).toInt32(exec);
1681
1687
                    int argTotal = qMax(funcArgC, argc);
1682
1688
                    for(int i=0; i < argTotal; i++) {
1683
1689
                        if (i < argc) {
1693
1699
                    if (m_funcObject->inherits(&JSFunction::info)) {
1694
1700
                        JSFunction* fimp = static_cast<JSFunction*>(m_funcObject.get());
1695
1701
 
1696
 
                        JSObject* qt_sender = Instance::createRuntimeObject(exec, QtInstance::getQtInstance(sender(), ro, QScriptEngine::QtOwnership));
 
1702
                        JSObject* qt_sender = QtInstance::getQtInstance(sender(), ro, QScriptEngine::QtOwnership)->createRuntimeObject(exec);
1697
1703
                        JSObject* wrapper = new (exec) JSObject(JSObject::createStructure(jsNull()));
1698
1704
                        PutPropertySlot slot;
1699
1705
                        wrapper->put(exec, Identifier(exec, "__qt_sender__"), qt_sender, slot);
1743
1749
    return _rootObject && _rootObject->isValid() ? _rootObject.get() : 0;
1744
1750
}
1745
1751
 
1746
 
template <typename T> void QtArray<T>::setValueAt(ExecState* exec, unsigned index, JSValuePtr aValue) const
 
1752
template <typename T> void QtArray<T>::setValueAt(ExecState* exec, unsigned index, JSValue aValue) const
1747
1753
{
1748
1754
    // QtScript sets the value, but doesn't forward it to the original source
1749
1755
    // (e.g. if you do 'object.intList[5] = 6', the object is not updated, but the
1757
1763
}
1758
1764
 
1759
1765
 
1760
 
template <typename T> JSValuePtr QtArray<T>::valueAt(ExecState *exec, unsigned int index) const
 
1766
template <typename T> JSValue QtArray<T>::valueAt(ExecState *exec, unsigned int index) const
1761
1767
{
1762
1768
    if (index < m_length) {
1763
1769
        T val = m_list.at(index);