rows->sqlQuery = query;
Scoped<Object> resultObject(scope, ctx->engine->newObject());
- result = resultObject.asValue();
+ result = resultObject.asReturnedValue();
// XXX optimize
ScopedString s(scope);
ScopedValue v(scope);
--instance->arrayAttributes;
*instance->arrayAttributes = Attr_Data;
}
- instance->arrayData->value = v;
+ instance->arrayData->value = v.asReturnedValue();
} else {
uint idx = instance->allocArrayValue(v);
instance->sparseArray->push_front(idx);
ctx->throwTypeError();
ScopedCallData callData(scope, 3);
- callData->args[2] = instance.asValue();
+ callData->args[2] = instance;
callData->thisObject = ctx->argument(1);
ScopedValue r(scope);
ScopedValue v(scope);
if (createProto) {
Scoped<Object> proto(s, scope->engine->newObject(scope->engine->protoClass));
proto->memberData[Index_ProtoConstructor].value = this->asReturnedValue();
- memberData[Index_Prototype].value = proto.asValue();
+ memberData[Index_Prototype].value = proto.asReturnedValue();
}
ScopedValue v(s, n.asReturnedValue());
ScopedObject obj(scope, v4->newObject(ic));
ExecutionContext *context = v4->current;
- callData->thisObject = obj.asValue();
+ callData->thisObject = obj.asReturnedValue();
ExecutionContext *ctx = context->newCallContext(f.getPointer(), callData);
ScopedValue result(scope);
ScopedString s(scope, context->engine->newIdentifier(key));
Property *p = o->insertMember(s, Attr_Data);
- p->value = val;
+ p->value = val.asReturnedValue();
END;
return true;
template <typename T1, typename T2>
inline void qYouForgotTheQ_MANAGED_Macro(T1, T2) {}
-template <typename T>
-struct Returned : private T
-{
- static Returned<T> *create(T *t) { return static_cast<Returned<T> *>(t); }
- T *getPointer() { return this; }
- template<typename X>
- static T *getPointer(Returned<X> *x) { return x->getPointer(); }
- template<typename X>
- Returned<X> *as() { return Returned<X>::create(Returned<X>::getPointer(this)); }
- using T::asReturnedValue;
-};
-
#define Q_MANAGED \
public: \
Q_MANAGED_CHECK \
newObject->setPrototype(O->asObject());
if (ctx->callData->argc > 1 && !ctx->callData->args[1].isUndefined()) {
- ctx->callData->args[0] = newObject.asValue();
+ ctx->callData->args[0] = newObject.asReturnedValue();
return method_defineProperties(ctx);
}
} else if (type == -1 || type == qMetaTypeId<QVariant>()) {
QVariant value = *qvariantPtr;
QV4::ScopedValue rv(scope, engine->fromVariant(value));
- if (QV4::QObjectWrapper *qobjectWrapper = rv->as<QV4::QObjectWrapper>()) {
+ if (QV4::Referenced<QObjectWrapper> qobjectWrapper = rv->asRef<QV4::QObjectWrapper>()) {
if (QObject *object = qobjectWrapper->object())
QQmlData::get(object, true)->setImplicitDestructible();
}
ScopedValue r(scope, callData->argument(0));
ScopedValue f(scope, callData->argument(1));
- if (RegExpObject *re = r->as<RegExpObject>()) {
+ Scoped<RegExpObject> re(scope, r);
+ if (re) {
if (!f->isUndefined())
ctx->throwTypeError();
}
}
- RegExp* re = RegExp::create(ctx->engine, pattern, ignoreCase, multiLine);
- if (!re->isValid())
+ RegExp *regexp = RegExp::create(ctx->engine, pattern, ignoreCase, multiLine);
+ if (!regexp->isValid())
ctx->throwSyntaxError(0);
- return Encode(ctx->engine->newRegExpObject(re, global));
+ return Encode(ctx->engine->newRegExpObject(regexp, global));
}
ReturnedValue RegExpCtor::call(Managed *that, CallData *callData)
array->setArrayLengthUnchecked(len);
array->memberData[Index_ArrayIndex].value = Primitive::fromInt32(result);
- array->memberData[Index_ArrayInput].value = arg;
+ array->memberData[Index_ArrayInput].value = arg.asReturnedValue();
if (r->global)
r->lastIndexProperty(ctx)->value = Primitive::fromInt32(matchOffsets[1]);
}
baseObject = __qmljs_convert_to_object(context, ValueRef(&callData->thisObject));
- callData->thisObject = baseObject.asValue();
+ callData->thisObject = baseObject.asReturnedValue();
}
Scoped<FunctionObject> o(scope, baseObject->get(name));
return *this;
}
- Value *operator->() {
+ SafeValue *operator->() {
return ptr;
}
- const Value *operator->() const {
+ const SafeValue *operator->() const {
return ptr;
}
- operator const Value &() const {
- return *ptr;
- }
-
ReturnedValue asReturnedValue() const { return ptr->val; }
SafeValue *ptr;
return static_cast<T *>(ptr->managed());
}
- Value asValue() const {
- if (ptr->m)
- return *ptr;
- return QV4::Primitive::undefinedValue();
- }
-
ReturnedValue asReturnedValue() const {
#if QT_POINTER_SIZE == 8
return ptr->val ? ptr->val : Primitive::undefinedValue().asReturnedValue();
operator Value *() {
return ptr;
}
- Value *operator->() {
+ SafeValue *operator->() {
return ptr;
}
}
operator const T *() const {
- return static_cast<T*>(ptr->managed());
+ return ptr ? static_cast<T*>(ptr->managed()) : 0;
}
const T *operator->() const {
return static_cast<T*>(ptr->managed());
}
operator T *() {
- return static_cast<T*>(ptr->managed());
+ return ptr ? static_cast<T*>(ptr->managed()) : 0;
}
T *operator->() {
return static_cast<T*>(ptr->managed());
return static_cast<T *>(ptr->managed());
}
ReturnedValue asReturnedValue() const { return ptr ? ptr->val : Primitive::undefinedValue().asReturnedValue(); }
+ operator Returned<T> *() const { return ptr ? Returned<T>::create(getPointer()) : 0; }
+
+ bool operator==(const Referenced<T> &other) {
+ if (ptr == other.ptr)
+ return true;
+ return ptr && other.ptr && ptr->m == other.ptr->m;
+ }
+ bool operator!=(const Referenced<T> &other) {
+ if (ptr == other.ptr)
+ return false;
+ return !ptr || ptr->m != other.ptr->m;
+ }
+ bool operator!() const { return !ptr || !ptr->managed(); }
static Referenced null() { return Referenced(Null); }
bool isNull() const { return !ptr; }
return Returned<T>::create(value_cast<T>(*this));
}
+template<typename T> inline
+Referenced<T> SafeValue::asRef()
+{
+ return Referenced<T>(*this);
+}
+
template<typename T>
inline Safe<T> &Safe<T>::operator =(T *t)
{
vmFunction = compilationUnit->linkToEngine(v4);
Q_ASSERT(vmFunction);
Scope valueScope(v4);
- ScopedValue holder(valueScope, Value::fromObject(new (v4->memoryManager) CompilationUnitHolder(v4, compilationUnit)));
+ ScopedValue holder(valueScope, new (v4->memoryManager) CompilationUnitHolder(v4, compilationUnit));
compilationUnitHolder = holder;
} else
vmFunction = 0;
#define NEW_REFERENCE_SEQUENCE(ElementType, ElementTypeName, SequenceType, unused) \
if (sequenceType == qMetaTypeId<SequenceType>()) { \
- QV4::Scoped<QV4::Object> obj(scope, QV4::Value::fromObject(new (engine->memoryManager) QQml##ElementTypeName##List(engine, object, propertyIndex))); \
+ QV4::Scoped<QV4::Object> obj(scope, new (engine->memoryManager) QQml##ElementTypeName##List(engine, object, propertyIndex)); \
return obj.asReturnedValue(); \
} else
#define NEW_COPY_SEQUENCE(ElementType, ElementTypeName, SequenceType, unused) \
if (sequenceType == qMetaTypeId<SequenceType>()) { \
- QV4::Scoped<QV4::Object> obj(scope, QV4::Value::fromObject(new (engine->memoryManager) QQml##ElementTypeName##List(engine, v.value<SequenceType >()))); \
+ QV4::Scoped<QV4::Object> obj(scope, new (engine->memoryManager) QQml##ElementTypeName##List(engine, v.value<SequenceType >())); \
return obj.asReturnedValue(); \
} else
array->arrayReserve(seqLength);
for (quint32 ii = 0; ii < seqLength; ++ii) {
value = deserialize(data, engine);
- array->arrayData[ii].value = value;
+ array->arrayData[ii].value = value.asReturnedValue();
array->arrayDataLen = ii + 1;
}
array->setArrayLengthUnchecked(seqLength);
typedef uint Bool;
+template <typename T>
+struct Returned : private T
+{
+ static Returned<T> *create(T *t) { return static_cast<Returned<T> *>(t); }
+ T *getPointer() { return this; }
+ template<typename X>
+ static T *getPointer(Returned<X> *x) { return x->getPointer(); }
+ template<typename X>
+ Returned<X> *as() { return Returned<X>::create(Returned<X>::getPointer(this)); }
+ using T::asReturnedValue;
+};
+
struct Q_QML_EXPORT Value
{
/*
return val;
}
- static Value fromObject(Object *o);
static Value fromManaged(Managed *o);
int toUInt16() const;
val = v.val;
return *this;
}
-
template<typename T>
- Returned<T> *as();
+ inline Returned<T> *as();
+ template<typename T>
+ inline Referenced<T> asRef();
};
struct Q_QML_EXPORT Primitive : public Value
return v;
}
-inline Value Value::fromObject(Object *o)
-{
- Value v;
-#if QT_POINTER_SIZE == 8
- v.o = o;
-#else
- v.tag = Managed_Type;
- v.o = o;
-#endif
- return v;
-}
-
inline Value Value::fromManaged(Managed *m)
{
if (!m)
// And, if the new value is a scarce resource, we need to ensure that it does not get
// automatically released by the engine until no other references to it exist.
QV4::ScopedValue newv(scope, QQmlEnginePrivate::get(ctxt->engine)->v8engine()->fromVariant(value));
- if (QV4::VariantObject *v = newv->as<QV4::VariantObject>())
+ if (QV4::Referenced<QV4::VariantObject> v = newv->asRef<QV4::VariantObject>())
v->addVmePropertyReference();
// Write the value and emit change signal as appropriate.
QQmlContextData *callingContext = QmlContextWrapper::getContext(activationObject);
if (callingContext) {
QV4::ScopedCallData callData(scope, 0);
- callData->thisObject = activationObject.asValue();
+ callData->thisObject = activationObject.asReturnedValue();
callback->call(callData);
}
if (!array)
m->engine()->current->throwTypeError();
- if (name == m->engine()->id_length) {
+ if (name->isEqualTo(m->engine()->id_length)) {
if (hasProperty)
*hasProperty = true;
return QV4::Encode(array->count());
}
QV4::Scoped<QQuickJSContext2DImageData> imageData(scope, new (v4->memoryManager) QQuickJSContext2DImageData(v4));
- imageData->pixelData = pixelData.asValue();
+ imageData->pixelData = pixelData.asReturnedValue();
return imageData.asReturnedValue();
}
r->context->buffer()->setFillStyle(color);
r->context->m_fillStyle = value;
} else {
- QQuickContext2DStyle *style = value->as<QQuickContext2DStyle>();
+ QV4::Scoped<QQuickContext2DStyle> style(scope, value->as<QQuickContext2DStyle>());
if (style && style->brush != r->context->state.fillStyle) {
r->context->state.fillStyle = style->brush;
r->context->buffer()->setFillStyle(style->brush, style->patternRepeatX, style->patternRepeatY);
r->context->buffer()->setStrokeStyle(color);
r->context->m_strokeStyle = value;
} else {
- QQuickContext2DStyle *style = value->as<QQuickContext2DStyle>();
+ QV4::Scoped<QQuickContext2DStyle> style(scope, value->as<QQuickContext2DStyle>());
if (style && style->brush != r->context->state.strokeStyle) {
r->context->state.strokeStyle = style->brush;
r->context->buffer()->setStrokeStyle(style->brush, style->patternRepeatX, style->patternRepeatY);
QV4::ScopedValue value(scope, ctx->argument(0));
r->context->beginPath();
- if (QV4::QObjectWrapper *qobjectWrapper =value->as<QV4::QObjectWrapper>()) {
+ if (QV4::Referenced<QV4::QObjectWrapper> qobjectWrapper = value->asRef<QV4::QObjectWrapper>()) {
if (QQuickPath *path = qobject_cast<QQuickPath*>(qobjectWrapper->object()))
r->context->m_path = path->path();
} else {
pixmap = r->context->createPixmap(url);
} else if (arg->isObject()) {
- if (QV4::QObjectWrapper *qobjectWrapper = arg->as<QV4::QObjectWrapper>()) {
+ if (QV4::Referenced<QV4::QObjectWrapper> qobjectWrapper = arg->asRef<QV4::QObjectWrapper>()) {
if (QQuickImage *imageItem = qobject_cast<QQuickImage*>(qobjectWrapper->object())) {
pixmap.take(r->context->createPixmap(imageItem->source()));
} else if (QQuickCanvasItem *canvas = qobject_cast<QQuickCanvasItem*>(qobjectWrapper->object())) {
} else {
V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
}
- } else if (QQuickJSContext2DImageData *imageData = arg->as<QQuickJSContext2DImageData>()) {
+ } else if (QV4::Referenced<QQuickJSContext2DImageData> imageData = arg->asRef<QQuickJSContext2DImageData>()) {
QV4::Scoped<QQuickJSContext2DPixelData> pix(scope, imageData->pixelData.as<QQuickJSContext2DPixelData>());
if (pix && !pix->image.isNull()) {
pixmap.take(new QQuickCanvasPixmap(pix->image, r->context->canvas()->window()));
if (ctx->callData->argc == 1) {
QV4::ScopedValue arg0(scope, ctx->callData->args[0]);
- if (QQuickJSContext2DImageData *imgData = arg0->as<QQuickJSContext2DImageData>()) {
+ if (QV4::Referenced<QQuickJSContext2DImageData> imgData = arg0->asRef<QQuickJSContext2DImageData>()) {
QV4::Scoped<QQuickJSContext2DPixelData> pa(scope, imgData->pixelData.as<QQuickJSContext2DPixelData>());
if (pa) {
qreal w = pa->image.width();
if (!qIsFinite(dx) || !qIsFinite(dy))
V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
- QQuickJSContext2DImageData *imageData = arg0->as<QQuickJSContext2DImageData>();
+ QV4::Referenced<QQuickJSContext2DImageData> imageData = arg0->asRef<QQuickJSContext2DImageData>();
if (!imageData)
return ctx->callData->thisObject.asReturnedValue();