Qt 4.8
Public Functions | Private Functions | Properties | List of all members
QDeclarativeVME Class Reference

#include <qdeclarativevme_p.h>

Public Functions

QList< QDeclarativeError > errors () const
 
bool isError () const
 
 QDeclarativeVME ()
 
QObject * run (QDeclarativeContextData *, QDeclarativeCompiledData *, int start=-1, int count=-1, const QBitField &=QBitField())
 
void runDeferred (QObject *)
 

Private Functions

QObject * run (QDeclarativeVMEObjectStack &, QDeclarativeContextData *, QDeclarativeCompiledData *, int start, int count, const QBitField &)
 

Properties

QList< QDeclarativeError > vmeErrors
 

Detailed Description

Definition at line 72 of file qdeclarativevme_p.h.

Constructors and Destructors

◆ QDeclarativeVME()

QDeclarativeVME::QDeclarativeVME ( )

Definition at line 98 of file qdeclarativevme.cpp.

99 {
100 }

Functions

◆ errors()

QList< QDeclarativeError > QDeclarativeVME::errors ( ) const

Definition at line 1049 of file qdeclarativevme.cpp.

Referenced by QDeclarativeComponentPrivate::begin(), and QDeclarativeComponentPrivate::beginDeferred().

1050 {
1051  return vmeErrors;
1052 }
QDeclarativeVME::vmeErrors
QList< QDeclarativeError > vmeErrors
Definition: qdeclarativevme_p.h:90

◆ isError()

bool QDeclarativeVME::isError ( ) const

Definition at line 1044 of file qdeclarativevme.cpp.

Referenced by QDeclarativeComponentPrivate::begin(), and QDeclarativeComponentPrivate::beginDeferred().

1045 {
1046  return !vmeErrors.isEmpty();
1047 }
QList::isEmpty
bool isEmpty() const
Returns true if the list contains no items; otherwise returns false.
Definition: qlist.h:152
QDeclarativeVME::vmeErrors
QList< QDeclarativeError > vmeErrors
Definition: qdeclarativevme_p.h:90

◆ run() [1/2]

QObject * QDeclarativeVME::run ( QDeclarativeContextData *  ctxt,
QDeclarativeCompiledData *  comp,
int  start = -1,
int  count = -1,
const QBitField &  bindingSkipList = QBitField() 
)

Definition at line 125 of file qdeclarativevme.cpp.

Referenced by QDeclarativeComponentPrivate::begin().

127 {
128  QDeclarativeVMEObjectStack stack;
129 
130  if (start == -1) start = 0;
131  if (count == -1) count = comp->bytecode.count();
132 
133  return run(stack, ctxt, comp, start, count, bindingSkipList);
134 }
QList::count
int count(const T &t) const
Returns the number of occurrences of value in the list.
Definition: qlist.h:891
QDeclarativeVME::run
QObject * run(QDeclarativeContextData *, QDeclarativeCompiledData *, int start=-1, int count=-1, const QBitField &=QBitField())
Definition: qdeclarativevme.cpp:125
QDeclarativeCompiledData::bytecode
QList< QDeclarativeInstruction > bytecode
Definition: qdeclarativecompiler_p.h:120

◆ run() [2/2]

QObject * QDeclarativeVME::run ( QDeclarativeVMEObjectStack &  stack,
QDeclarativeContextData *  ctxt,
QDeclarativeCompiledData *  comp,
int  start,
int  count,
const QBitField &  bindingSkipList 
)
private

Definition at line 169 of file qdeclarativevme.cpp.

174 {
175  Q_ASSERT(comp);
176  Q_ASSERT(ctxt);
177  const QList<QDeclarativeCompiledData::TypeReference> &types = comp->types;
178  const QList<QString> &primitives = comp->primitives;
179  const QList<QByteArray> &datas = comp->datas;
180  const QList<QDeclarativeCompiledData::CustomTypeData> &customTypeData = comp->customTypeData;
181  const QList<int> &intData = comp->intData;
182  const QList<float> &floatData = comp->floatData;
183  const QList<QDeclarativePropertyCache *> &propertyCaches = comp->propertyCaches;
184  const QList<QDeclarativeParser::Object::ScriptBlock> &scripts = comp->scripts;
185  const QList<QUrl> &urls = comp->urls;
186 
187  QDeclarativeEnginePrivate::SimpleList<QDeclarativeAbstractBinding> bindValues;
188  QDeclarativeEnginePrivate::SimpleList<QDeclarativeParserStatus> parserStatus;
189 
190  QDeclarativeVMEStack<ListInstance> qliststack;
191 
192  vmeErrors.clear();
193  QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(ctxt->engine);
194 
195  int status = -1; //for dbus
196  QDeclarativePropertyPrivate::WriteFlags flags = QDeclarativePropertyPrivate::BypassInterceptor |
197  QDeclarativePropertyPrivate::RemoveBindingOnAliasWrite;
198 
199  for (int ii = start; !isError() && ii < (start + count); ++ii) {
200  const QDeclarativeInstruction &instr = comp->bytecode.at(ii);
201 
202  switch(instr.type) {
203  case QDeclarativeInstruction::Init:
204  {
205  if (instr.init.bindingsSize)
206  bindValues = QDeclarativeEnginePrivate::SimpleList<QDeclarativeAbstractBinding>(instr.init.bindingsSize);
207  if (instr.init.parserStatusSize)
208  parserStatus = QDeclarativeEnginePrivate::SimpleList<QDeclarativeParserStatus>(instr.init.parserStatusSize);
209  if (instr.init.contextCache != -1)
210  ctxt->setIdPropertyData(comp->contextCaches.at(instr.init.contextCache));
211  if (instr.init.compiledBinding != -1)
212  ctxt->optimizedBindings = new QDeclarativeCompiledBindings(datas.at(instr.init.compiledBinding).constData(), ctxt, comp);
213  }
214  break;
215 
216  case QDeclarativeInstruction::CreateObject:
217  {
218  QBitField bindings;
219  if (instr.create.bindingBits != -1) {
220  const QByteArray &bits = datas.at(instr.create.bindingBits);
221  bindings = QBitField((const quint32*)bits.constData(),
222  bits.size() * 8);
223  }
224  if (stack.isEmpty())
225  bindings = bindings.united(bindingSkipList);
226 
227  QObject *o =
228  types.at(instr.create.type).createInstance(ctxt, bindings, &vmeErrors);
229 
230  if (!o) {
231  VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Unable to create object of type %1").arg(QString::fromLatin1(types.at(instr.create.type).className)));
232  }
233 
234  QDeclarativeData *ddata = QDeclarativeData::get(o);
235  Q_ASSERT(ddata);
236 
237  if (stack.isEmpty()) {
238  if (ddata->context) {
239  Q_ASSERT(ddata->context != ctxt);
240  Q_ASSERT(ddata->outerContext);
241  Q_ASSERT(ddata->outerContext != ctxt);
242  QDeclarativeContextData *c = ddata->context;
243  while (c->linkedContext) c = c->linkedContext;
244  c->linkedContext = ctxt;
245  } else {
246  ctxt->addObject(o);
247  }
248 
249  ddata->ownContext = true;
250  } else if (!ddata->context) {
251  ctxt->addObject(o);
252  }
253 
254  ddata->setImplicitDestructible();
255  ddata->outerContext = ctxt;
256  ddata->lineNumber = instr.line;
257  ddata->columnNumber = instr.create.column;
258 
259  if (instr.create.data != -1) {
260  QDeclarativeCustomParser *customParser =
261  types.at(instr.create.type).type->customParser();
262  customParser->setCustomData(o, datas.at(instr.create.data));
263  }
264  if (!stack.isEmpty()) {
265  QObject *parent = stack.top();
266  if (o->isWidgetType()) {
267  QWidget *widget = static_cast<QWidget*>(o);
268  if (parent->isWidgetType()) {
269  QWidget *parentWidget = static_cast<QWidget*>(parent);
270  widget->setParent(parentWidget);
271  } else {
272  // TODO: parent might be a layout
273  }
274  } else {
275  QDeclarative_setParent_noEvent(o, parent);
276  }
277  }
278  stack.push(o);
279  }
280  break;
281 
282  case QDeclarativeInstruction::CreateSimpleObject:
283  {
284  QObject *o = (QObject *)operator new(instr.createSimple.typeSize +
285  sizeof(QDeclarativeData));
286  ::memset(static_cast<void *>(o), 0, instr.createSimple.typeSize + sizeof(QDeclarativeData));
287  instr.createSimple.create(o);
288 
289  QDeclarativeData *ddata = (QDeclarativeData *)(((const char *)o) + instr.createSimple.typeSize);
290  const QDeclarativeCompiledData::TypeReference &ref = types.at(instr.createSimple.type);
291  if (!ddata->propertyCache && ref.typePropertyCache) {
292  ddata->propertyCache = ref.typePropertyCache;
293  ddata->propertyCache->addref();
294  }
295  ddata->lineNumber = instr.line;
296  ddata->columnNumber = instr.createSimple.column;
297 
298  QObjectPrivate::get(o)->declarativeData = ddata;
299  ddata->context = ddata->outerContext = ctxt;
300  ddata->nextContextObject = ctxt->contextObjects;
301  if (ddata->nextContextObject)
302  ddata->nextContextObject->prevContextObject = &ddata->nextContextObject;
303  ddata->prevContextObject = &ctxt->contextObjects;
304  ctxt->contextObjects = ddata;
305 
306  QObject *parent = stack.top();
307  QDeclarative_setParent_noEvent(o, parent);
308 
309  stack.push(o);
310  }
311  break;
312 
313  case QDeclarativeInstruction::SetId:
314  {
315  QObject *target = stack.top();
316  ctxt->setIdProperty(instr.setId.index, target);
317  }
318  break;
319 
320 
321  case QDeclarativeInstruction::SetDefault:
322  {
323  ctxt->contextObject = stack.top();
324  }
325  break;
326 
327  case QDeclarativeInstruction::CreateComponent:
328  {
329  QDeclarativeComponent *qcomp =
330  new QDeclarativeComponent(ctxt->engine, comp, ii + 1, instr.createComponent.count,
331  stack.isEmpty() ? 0 : stack.top());
332 
333  QDeclarativeData *ddata = QDeclarativeData::get(qcomp, true);
334  Q_ASSERT(ddata);
335 
336  ctxt->addObject(qcomp);
337 
338  if (stack.isEmpty())
339  ddata->ownContext = true;
340 
341  ddata->setImplicitDestructible();
342  ddata->outerContext = ctxt;
343  ddata->lineNumber = instr.line;
344  ddata->columnNumber = instr.create.column;
345 
346  QDeclarativeComponentPrivate::get(qcomp)->creationContext = ctxt;
347 
348  stack.push(qcomp);
349  ii += instr.createComponent.count;
350  }
351  break;
352 
353  case QDeclarativeInstruction::StoreMetaObject:
354  {
355  QObject *target = stack.top();
356 
357  QMetaObject mo;
358  const QByteArray &metadata = datas.at(instr.storeMeta.data);
359  QMetaObjectBuilder::fromRelocatableData(&mo, 0, metadata);
360 
361  const QDeclarativeVMEMetaData *data =
362  (const QDeclarativeVMEMetaData *)datas.at(instr.storeMeta.aliasData).constData();
363 
364  (void)new QDeclarativeVMEMetaObject(target, &mo, data, comp);
365 
366  if (instr.storeMeta.propertyCache != -1) {
367  QDeclarativeData *ddata = QDeclarativeData::get(target, true);
368  if (ddata->propertyCache) ddata->propertyCache->release();
369  ddata->propertyCache = propertyCaches.at(instr.storeMeta.propertyCache);
370  ddata->propertyCache->addref();
371  }
372  }
373  break;
374 
375  case QDeclarativeInstruction::StoreVariant:
376  {
377  QObject *target = stack.top();
378  CLEAN_PROPERTY(target, instr.storeString.propertyIndex);
379 
380  // XXX - can be more efficient
381  QVariant v = QDeclarativeStringConverters::variantFromString(primitives.at(instr.storeString.value));
382  void *a[] = { &v, 0, &status, &flags };
383  QMetaObject::metacall(target, QMetaObject::WriteProperty,
384  instr.storeString.propertyIndex, a);
385  }
386  break;
387 
388  case QDeclarativeInstruction::StoreVariantInteger:
389  {
390  QObject *target = stack.top();
391  CLEAN_PROPERTY(target, instr.storeString.propertyIndex);
392 
393  QVariant v(instr.storeInteger.value);
394  void *a[] = { &v, 0, &status, &flags };
395  QMetaObject::metacall(target, QMetaObject::WriteProperty,
396  instr.storeString.propertyIndex, a);
397  }
398  break;
399 
400  case QDeclarativeInstruction::StoreVariantDouble:
401  {
402  QObject *target = stack.top();
403  CLEAN_PROPERTY(target, instr.storeString.propertyIndex);
404 
405  QVariant v(instr.storeDouble.value);
406  void *a[] = { &v, 0, &status, &flags };
407  QMetaObject::metacall(target, QMetaObject::WriteProperty,
408  instr.storeString.propertyIndex, a);
409  }
410  break;
411 
412  case QDeclarativeInstruction::StoreVariantBool:
413  {
414  QObject *target = stack.top();
415  CLEAN_PROPERTY(target, instr.storeString.propertyIndex);
416 
417  QVariant v(instr.storeBool.value);
418  void *a[] = { &v, 0, &status, &flags };
419  QMetaObject::metacall(target, QMetaObject::WriteProperty,
420  instr.storeString.propertyIndex, a);
421  }
422  break;
423 
424  case QDeclarativeInstruction::StoreString:
425  {
426  QObject *target = stack.top();
427  CLEAN_PROPERTY(target, instr.storeString.propertyIndex);
428 
429  void *a[] = { (void *)&primitives.at(instr.storeString.value), 0, &status, &flags };
430  QMetaObject::metacall(target, QMetaObject::WriteProperty,
431  instr.storeString.propertyIndex, a);
432  }
433  break;
434 
435  case QDeclarativeInstruction::StoreUrl:
436  {
437  QObject *target = stack.top();
438  CLEAN_PROPERTY(target, instr.storeUrl.propertyIndex);
439 
440  void *a[] = { (void *)&urls.at(instr.storeUrl.value), 0, &status, &flags };
441  QMetaObject::metacall(target, QMetaObject::WriteProperty,
442  instr.storeUrl.propertyIndex, a);
443  }
444  break;
445 
446  case QDeclarativeInstruction::StoreFloat:
447  {
448  QObject *target = stack.top();
449  CLEAN_PROPERTY(target, instr.storeFloat.propertyIndex);
450 
451  float f = instr.storeFloat.value;
452  void *a[] = { &f, 0, &status, &flags };
453  QMetaObject::metacall(target, QMetaObject::WriteProperty,
454  instr.storeFloat.propertyIndex, a);
455  }
456  break;
457 
458  case QDeclarativeInstruction::StoreDouble:
459  {
460  QObject *target = stack.top();
461  CLEAN_PROPERTY(target, instr.storeDouble.propertyIndex);
462 
463  double d = instr.storeDouble.value;
464  void *a[] = { &d, 0, &status, &flags };
465  QMetaObject::metacall(target, QMetaObject::WriteProperty,
466  instr.storeDouble.propertyIndex, a);
467  }
468  break;
469 
470  case QDeclarativeInstruction::StoreBool:
471  {
472  QObject *target = stack.top();
473  CLEAN_PROPERTY(target, instr.storeBool.propertyIndex);
474 
475  void *a[] = { (void *)&instr.storeBool.value, 0, &status, &flags };
476  QMetaObject::metacall(target, QMetaObject::WriteProperty,
477  instr.storeBool.propertyIndex, a);
478  }
479  break;
480 
481  case QDeclarativeInstruction::StoreInteger:
482  {
483  QObject *target = stack.top();
484  CLEAN_PROPERTY(target, instr.storeInteger.propertyIndex);
485 
486  void *a[] = { (void *)&instr.storeInteger.value, 0, &status, &flags };
487  QMetaObject::metacall(target, QMetaObject::WriteProperty,
488  instr.storeInteger.propertyIndex, a);
489  }
490  break;
491 
492  case QDeclarativeInstruction::StoreColor:
493  {
494  QObject *target = stack.top();
495  CLEAN_PROPERTY(target, instr.storeColor.propertyIndex);
496 
497  QColor c = QColor::fromRgba(instr.storeColor.value);
498  void *a[] = { &c, 0, &status, &flags };
499  QMetaObject::metacall(target, QMetaObject::WriteProperty,
500  instr.storeColor.propertyIndex, a);
501  }
502  break;
503 
504  case QDeclarativeInstruction::StoreDate:
505  {
506  QObject *target = stack.top();
507  CLEAN_PROPERTY(target, instr.storeDate.propertyIndex);
508 
509  QDate d = QDate::fromJulianDay(instr.storeDate.value);
510  void *a[] = { &d, 0, &status, &flags };
511  QMetaObject::metacall(target, QMetaObject::WriteProperty,
512  instr.storeDate.propertyIndex, a);
513  }
514  break;
515 
516  case QDeclarativeInstruction::StoreTime:
517  {
518  QObject *target = stack.top();
519  CLEAN_PROPERTY(target, instr.storeTime.propertyIndex);
520 
521  QTime t;
522  t.setHMS(intData.at(instr.storeTime.valueIndex),
523  intData.at(instr.storeTime.valueIndex+1),
524  intData.at(instr.storeTime.valueIndex+2),
525  intData.at(instr.storeTime.valueIndex+3));
526  void *a[] = { &t, 0, &status, &flags };
527  QMetaObject::metacall(target, QMetaObject::WriteProperty,
528  instr.storeTime.propertyIndex, a);
529  }
530  break;
531 
532  case QDeclarativeInstruction::StoreDateTime:
533  {
534  QObject *target = stack.top();
535  CLEAN_PROPERTY(target, instr.storeDateTime.propertyIndex);
536 
537  QTime t;
538  t.setHMS(intData.at(instr.storeDateTime.valueIndex+1),
539  intData.at(instr.storeDateTime.valueIndex+2),
540  intData.at(instr.storeDateTime.valueIndex+3),
541  intData.at(instr.storeDateTime.valueIndex+4));
542  QDateTime dt(QDate::fromJulianDay(intData.at(instr.storeDateTime.valueIndex)), t);
543  void *a[] = { &dt, 0, &status, &flags };
544  QMetaObject::metacall(target, QMetaObject::WriteProperty,
545  instr.storeDateTime.propertyIndex, a);
546  }
547  break;
548 
549  case QDeclarativeInstruction::StorePoint:
550  {
551  QObject *target = stack.top();
552  CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex);
553 
554  QPoint p = QPointF(floatData.at(instr.storeRealPair.valueIndex),
555  floatData.at(instr.storeRealPair.valueIndex+1)).toPoint();
556  void *a[] = { &p, 0, &status, &flags };
557  QMetaObject::metacall(target, QMetaObject::WriteProperty,
558  instr.storeRealPair.propertyIndex, a);
559  }
560  break;
561 
562  case QDeclarativeInstruction::StorePointF:
563  {
564  QObject *target = stack.top();
565  CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex);
566 
567  QPointF p(floatData.at(instr.storeRealPair.valueIndex),
568  floatData.at(instr.storeRealPair.valueIndex+1));
569  void *a[] = { &p, 0, &status, &flags };
570  QMetaObject::metacall(target, QMetaObject::WriteProperty,
571  instr.storeRealPair.propertyIndex, a);
572  }
573  break;
574 
575  case QDeclarativeInstruction::StoreSize:
576  {
577  QObject *target = stack.top();
578  CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex);
579 
580  QSize p = QSizeF(floatData.at(instr.storeRealPair.valueIndex),
581  floatData.at(instr.storeRealPair.valueIndex+1)).toSize();
582  void *a[] = { &p, 0, &status, &flags };
583  QMetaObject::metacall(target, QMetaObject::WriteProperty,
584  instr.storeRealPair.propertyIndex, a);
585  }
586  break;
587 
588  case QDeclarativeInstruction::StoreSizeF:
589  {
590  QObject *target = stack.top();
591  CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex);
592 
593  QSizeF s(floatData.at(instr.storeRealPair.valueIndex),
594  floatData.at(instr.storeRealPair.valueIndex+1));
595  void *a[] = { &s, 0, &status, &flags };
596  QMetaObject::metacall(target, QMetaObject::WriteProperty,
597  instr.storeRealPair.propertyIndex, a);
598  }
599  break;
600 
601  case QDeclarativeInstruction::StoreRect:
602  {
603  QObject *target = stack.top();
604  CLEAN_PROPERTY(target, instr.storeRect.propertyIndex);
605 
606  QRect r = QRectF(floatData.at(instr.storeRect.valueIndex),
607  floatData.at(instr.storeRect.valueIndex+1),
608  floatData.at(instr.storeRect.valueIndex+2),
609  floatData.at(instr.storeRect.valueIndex+3)).toRect();
610  void *a[] = { &r, 0, &status, &flags };
611  QMetaObject::metacall(target, QMetaObject::WriteProperty,
612  instr.storeRect.propertyIndex, a);
613  }
614  break;
615 
616  case QDeclarativeInstruction::StoreRectF:
617  {
618  QObject *target = stack.top();
619  CLEAN_PROPERTY(target, instr.storeRect.propertyIndex);
620 
621  QRectF r(floatData.at(instr.storeRect.valueIndex),
622  floatData.at(instr.storeRect.valueIndex+1),
623  floatData.at(instr.storeRect.valueIndex+2),
624  floatData.at(instr.storeRect.valueIndex+3));
625  void *a[] = { &r, 0, &status, &flags };
626  QMetaObject::metacall(target, QMetaObject::WriteProperty,
627  instr.storeRect.propertyIndex, a);
628  }
629  break;
630 
631  case QDeclarativeInstruction::StoreVector3D:
632  {
633  QObject *target = stack.top();
634  CLEAN_PROPERTY(target, instr.storeVector3D.propertyIndex);
635 
636  QVector3D p(floatData.at(instr.storeVector3D.valueIndex),
637  floatData.at(instr.storeVector3D.valueIndex+1),
638  floatData.at(instr.storeVector3D.valueIndex+2));
639  void *a[] = { &p, 0, &status, &flags };
640  QMetaObject::metacall(target, QMetaObject::WriteProperty,
641  instr.storeVector3D.propertyIndex, a);
642  }
643  break;
644 
645  case QDeclarativeInstruction::StoreObject:
646  {
647  QObject *assignObj = stack.pop();
648  QObject *target = stack.top();
649  CLEAN_PROPERTY(target, instr.storeObject.propertyIndex);
650 
651  void *a[] = { (void *)&assignObj, 0, &status, &flags };
652  QMetaObject::metacall(target, QMetaObject::WriteProperty,
653  instr.storeObject.propertyIndex, a);
654  }
655  break;
656 
657 
658  case QDeclarativeInstruction::AssignCustomType:
659  {
660  QObject *target = stack.top();
661  CLEAN_PROPERTY(target, instr.assignCustomType.propertyIndex);
662 
663  QDeclarativeCompiledData::CustomTypeData data = customTypeData.at(instr.assignCustomType.valueIndex);
664  const QString &primitive = primitives.at(data.index);
665  QDeclarativeMetaType::StringConverter converter =
666  QDeclarativeMetaType::customStringConverter(data.type);
667  QVariant v = (*converter)(primitive);
668 
669  QMetaProperty prop =
670  target->metaObject()->property(instr.assignCustomType.propertyIndex);
671  if (v.isNull() || ((int)prop.type() != data.type && prop.userType() != data.type))
672  VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign value %1 to property %2").arg(primitive).arg(QString::fromUtf8(prop.name())));
673 
674  void *a[] = { (void *)v.data(), 0, &status, &flags };
675  QMetaObject::metacall(target, QMetaObject::WriteProperty,
676  instr.assignCustomType.propertyIndex, a);
677  }
678  break;
679 
680  case QDeclarativeInstruction::AssignSignalObject:
681  {
682  // XXX optimize
683 
684  QObject *assign = stack.pop();
685  QObject *target = stack.top();
686  int sigIdx = instr.assignSignalObject.signal;
687  const QByteArray &pr = datas.at(sigIdx);
688 
689  QDeclarativeProperty prop(target, QString::fromUtf8(pr));
690  if (prop.type() & QDeclarativeProperty::SignalProperty) {
691 
692  QMetaMethod method = QDeclarativeMetaType::defaultMethod(assign);
693  if (method.signature() == 0)
694  VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign object type %1 with no default method").arg(QString::fromLatin1(assign->metaObject()->className())));
695 
696  if (!QMetaObject::checkConnectArgs(prop.method().signature(), method.signature()))
697  VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot connect mismatched signal/slot %1 %vs. %2").arg(QString::fromLatin1(method.signature())).arg(QString::fromLatin1(prop.method().signature())));
698 
699  QDeclarativePropertyPrivate::connect(target, prop.index(), assign, method.methodIndex());
700 
701  } else {
702  VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign an object to signal property %1").arg(QString::fromUtf8(pr)));
703  }
704 
705 
706  }
707  break;
708 
709  case QDeclarativeInstruction::StoreSignal:
710  {
711  QObject *target = stack.top();
712  QObject *context = stack.at(stack.count() - 1 - instr.storeSignal.context);
713 
714  QMetaMethod signal = target->metaObject()->method(instr.storeSignal.signalIndex);
715 
716  QDeclarativeBoundSignal *bs = new QDeclarativeBoundSignal(target, signal, target);
717  QDeclarativeExpression *expr =
718  new QDeclarativeExpression(ctxt, context, primitives.at(instr.storeSignal.value));
719  expr->setSourceLocation(comp->name, instr.line);
720  static_cast<QDeclarativeExpressionPrivate *>(QObjectPrivate::get(expr))->name = datas.at(instr.storeSignal.name);
721  bs->setExpression(expr);
722  }
723  break;
724 
725  case QDeclarativeInstruction::StoreImportedScript:
726  {
727  ctxt->addImportedScript(scripts.at(instr.storeScript.value));
728  }
729  break;
730 
731  case QDeclarativeInstruction::StoreScriptString:
732  {
733  QObject *target = stack.top();
734  QObject *scope = stack.at(stack.count() - 1 - instr.storeScriptString.scope);
735  QDeclarativeScriptString ss;
736  ss.setContext(ctxt->asQDeclarativeContext());
737  ss.setScopeObject(scope);
738  ss.setScript(primitives.at(instr.storeScriptString.value));
739 
740  void *a[] = { &ss, 0, &status, &flags };
741  QMetaObject::metacall(target, QMetaObject::WriteProperty,
742  instr.storeScriptString.propertyIndex, a);
743  }
744  break;
745 
746  case QDeclarativeInstruction::BeginObject:
747  {
748  QObject *target = stack.top();
749  QDeclarativeParserStatus *status = reinterpret_cast<QDeclarativeParserStatus *>(reinterpret_cast<char *>(target) + instr.begin.castValue);
750  parserStatus.append(status);
751  status->d = &parserStatus.values[parserStatus.count - 1];
752 
753  status->classBegin();
754  }
755  break;
756 
757  case QDeclarativeInstruction::StoreBinding:
758  case QDeclarativeInstruction::StoreBindingOnAlias:
759  {
760  QObject *target =
761  stack.at(stack.count() - 1 - instr.assignBinding.owner);
762  QObject *context =
763  stack.at(stack.count() - 1 - instr.assignBinding.context);
764 
765  QDeclarativeProperty mp =
766  QDeclarativePropertyPrivate::restore(datas.at(instr.assignBinding.property), target, ctxt);
767 
768  int coreIndex = mp.index();
769 
770  if ((stack.count() - instr.assignBinding.owner) == 1 && bindingSkipList.testBit(coreIndex))
771  break;
772 
773  QDeclarativeBinding *bind = new QDeclarativeBinding((void *)datas.at(instr.assignBinding.value).constData(), comp, context, ctxt, comp->name, instr.line, 0);
774  bindValues.append(bind);
775  bind->m_mePtr = &bindValues.values[bindValues.count - 1];
776  bind->setTarget(mp);
777 
778  if (instr.type == QDeclarativeInstruction::StoreBindingOnAlias) {
779  QDeclarativeAbstractBinding *old = QDeclarativePropertyPrivate::setBindingNoEnable(target, coreIndex, QDeclarativePropertyPrivate::valueTypeCoreIndex(mp), bind);
780  if (old) { old->destroy(); }
781  } else {
782  bind->addToObject(target, QDeclarativePropertyPrivate::bindingIndex(mp));
783  }
784  }
785  break;
786 
787  case QDeclarativeInstruction::StoreCompiledBinding:
788  {
789  QObject *target =
790  stack.at(stack.count() - 1 - instr.assignBinding.owner);
791  QObject *scope =
792  stack.at(stack.count() - 1 - instr.assignBinding.context);
793 
794  int property = instr.assignBinding.property;
795  if (stack.count() == 1 && bindingSkipList.testBit(property & 0xFFFF))
796  break;
797 
798  QDeclarativeAbstractBinding *binding =
799  ctxt->optimizedBindings->configBinding(instr.assignBinding.value, target, scope, property);
800  bindValues.append(binding);
801  binding->m_mePtr = &bindValues.values[bindValues.count - 1];
802  binding->addToObject(target, property);
803  }
804  break;
805 
806  case QDeclarativeInstruction::StoreValueSource:
807  {
808  QObject *obj = stack.pop();
809  QDeclarativePropertyValueSource *vs = reinterpret_cast<QDeclarativePropertyValueSource *>(reinterpret_cast<char *>(obj) + instr.assignValueSource.castValue);
810  QObject *target = stack.at(stack.count() - 1 - instr.assignValueSource.owner);
811 
812  QDeclarativeProperty prop =
813  QDeclarativePropertyPrivate::restore(datas.at(instr.assignValueSource.property), target, ctxt);
814  obj->setParent(target);
815  vs->setTarget(prop);
816  }
817  break;
818 
819  case QDeclarativeInstruction::StoreValueInterceptor:
820  {
821  QObject *obj = stack.pop();
822  QDeclarativePropertyValueInterceptor *vi = reinterpret_cast<QDeclarativePropertyValueInterceptor *>(reinterpret_cast<char *>(obj) + instr.assignValueInterceptor.castValue);
823  QObject *target = stack.at(stack.count() - 1 - instr.assignValueInterceptor.owner);
824  QDeclarativeProperty prop =
825  QDeclarativePropertyPrivate::restore(datas.at(instr.assignValueInterceptor.property), target, ctxt);
826  obj->setParent(target);
827  vi->setTarget(prop);
828  QDeclarativeVMEMetaObject *mo = static_cast<QDeclarativeVMEMetaObject *>((QMetaObject*)target->metaObject());
829  mo->registerInterceptor(prop.index(), QDeclarativePropertyPrivate::valueTypeCoreIndex(prop), vi);
830  }
831  break;
832 
833  case QDeclarativeInstruction::StoreObjectQList:
834  {
835  QObject *assign = stack.pop();
836 
837  const ListInstance &list = qliststack.top();
838  list.qListProperty.append((QDeclarativeListProperty<void>*)&list.qListProperty, assign);
839  }
840  break;
841 
842  case QDeclarativeInstruction::AssignObjectList:
843  {
844  // This is only used for assigning interfaces
845  QObject *assign = stack.pop();
846  const ListInstance &list = qliststack.top();
847 
848  int type = list.type;
849 
850  void *ptr = 0;
851 
852  const char *iid = QDeclarativeMetaType::interfaceIId(type);
853  if (iid)
854  ptr = assign->qt_metacast(iid);
855  if (!ptr)
856  VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign object to list"));
857 
858 
859  list.qListProperty.append((QDeclarativeListProperty<void>*)&list.qListProperty, ptr);
860  }
861  break;
862 
863  case QDeclarativeInstruction::StoreVariantObject:
864  {
865  QObject *assign = stack.pop();
866  QObject *target = stack.top();
867  CLEAN_PROPERTY(target, instr.storeObject.propertyIndex);
868 
869  QVariant v = QVariant::fromValue(assign);
870  void *a[] = { &v, 0, &status, &flags };
871  QMetaObject::metacall(target, QMetaObject::WriteProperty,
872  instr.storeObject.propertyIndex, a);
873  }
874  break;
875 
876  case QDeclarativeInstruction::StoreInterface:
877  {
878  QObject *assign = stack.pop();
879  QObject *target = stack.top();
880  CLEAN_PROPERTY(target, instr.storeObject.propertyIndex);
881 
882  int coreIdx = instr.storeObject.propertyIndex;
883  QMetaProperty prop = target->metaObject()->property(coreIdx);
884  int t = prop.userType();
885  const char *iid = QDeclarativeMetaType::interfaceIId(t);
886  bool ok = false;
887  if (iid) {
888  void *ptr = assign->qt_metacast(iid);
889  if (ptr) {
890  void *a[] = { &ptr, 0, &status, &flags };
891  QMetaObject::metacall(target,
892  QMetaObject::WriteProperty,
893  coreIdx, a);
894  ok = true;
895  }
896  }
897 
898  if (!ok)
899  VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign object to interface property"));
900  }
901  break;
902 
903  case QDeclarativeInstruction::FetchAttached:
904  {
905  QObject *target = stack.top();
906 
907  QObject *qmlObject = qmlAttachedPropertiesObjectById(instr.fetchAttached.id, target);
908 
909  if (!qmlObject)
910  VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Unable to create attached object"));
911 
912  stack.push(qmlObject);
913  }
914  break;
915 
916  case QDeclarativeInstruction::FetchQList:
917  {
918  QObject *target = stack.top();
919 
920  qliststack.push(ListInstance(instr.fetchQmlList.type));
921 
922  void *a[1];
923  a[0] = (void *)&(qliststack.top().qListProperty);
924  QMetaObject::metacall(target, QMetaObject::ReadProperty,
925  instr.fetchQmlList.property, a);
926  }
927  break;
928 
929  case QDeclarativeInstruction::FetchObject:
930  {
931  QObject *target = stack.top();
932 
933  QObject *obj = 0;
934  // NOTE: This assumes a cast to QObject does not alter the
935  // object pointer
936  void *a[1];
937  a[0] = &obj;
938  QMetaObject::metacall(target, QMetaObject::ReadProperty,
939  instr.fetch.property, a);
940 
941  if (!obj)
942  VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot set properties on %1 as it is null").arg(QString::fromUtf8(target->metaObject()->property(instr.fetch.property).name())));
943 
944  stack.push(obj);
945  }
946  break;
947 
948  case QDeclarativeInstruction::PopQList:
949  {
950  qliststack.pop();
951  }
952  break;
953 
954  case QDeclarativeInstruction::Defer:
955  {
956  if (instr.defer.deferCount) {
957  QObject *target = stack.top();
958  QDeclarativeData *data =
959  QDeclarativeData::get(target, true);
960  comp->addref();
961  data->deferredComponent = comp;
962  data->deferredIdx = ii;
963  ii += instr.defer.deferCount;
964  }
965  }
966  break;
967 
968  case QDeclarativeInstruction::PopFetchedObject:
969  {
970  stack.pop();
971  }
972  break;
973 
974  case QDeclarativeInstruction::FetchValueType:
975  {
976  QObject *target = stack.top();
977 
978  if (instr.fetchValue.bindingSkipList != 0) {
979  // Possibly need to clear bindings
980  QDeclarativeData *targetData = QDeclarativeData::get(target);
981  if (targetData) {
982  QDeclarativeAbstractBinding *binding =
983  QDeclarativePropertyPrivate::binding(target, instr.fetchValue.property, -1);
984 
985  if (binding && binding->bindingType() != QDeclarativeAbstractBinding::ValueTypeProxy) {
986  QDeclarativePropertyPrivate::setBinding(target, instr.fetchValue.property, -1, 0);
987  binding->destroy();
988  } else if (binding) {
989  QDeclarativeValueTypeProxyBinding *proxy =
990  static_cast<QDeclarativeValueTypeProxyBinding *>(binding);
991  proxy->removeBindings(instr.fetchValue.bindingSkipList);
992  }
993  }
994  }
995 
996  QDeclarativeValueType *valueHandler = ep->valueTypes[instr.fetchValue.type];
997  valueHandler->read(target, instr.fetchValue.property);
998  stack.push(valueHandler);
999  }
1000  break;
1001 
1002  case QDeclarativeInstruction::PopValueType:
1003  {
1004  QDeclarativeValueType *valueHandler =
1005  static_cast<QDeclarativeValueType *>(stack.pop());
1006  QObject *target = stack.top();
1007  valueHandler->write(target, instr.fetchValue.property,
1008  QDeclarativePropertyPrivate::BypassInterceptor);
1009  }
1010  break;
1011 
1012  default:
1013  qFatal("QDeclarativeCompiledData: Internal error - unknown instruction %d", instr.type);
1014  break;
1015  }
1016  }
1017 
1018  if (isError()) {
1019  if (!stack.isEmpty()) {
1020  delete stack.at(0); // ### What about failures in deferred creation?
1021  } else {
1022  ctxt->destroy();
1023  }
1024 
1025  QDeclarativeEnginePrivate::clear(bindValues);
1026  QDeclarativeEnginePrivate::clear(parserStatus);
1027  return 0;
1028  }
1029 
1030  if (bindValues.count)
1031  ep->bindValues << bindValues;
1032  else if (bindValues.values)
1033  bindValues.clear();
1034 
1035  if (parserStatus.count)
1036  ep->parserStatus << parserStatus;
1037  else if (parserStatus.values)
1038  parserStatus.clear();
1039 
1040  Q_ASSERT(stack.count() == 1);
1041  return stack.top();
1042 }
QBitField::testBit
bool testBit(int) const
Definition: qbitfield_p.h:153
QDeclarativeData::outerContext
QDeclarativeContextData * outerContext
Definition: qdeclarativedata_p.h:112
QVariant
The QVariant class acts like a union for the most common Qt data types.
Definition: qvariant.h:92
QDeclarativeComponentPrivate::get
static QDeclarativeComponentPrivate * get(QDeclarativeComponent *c)
Definition: qdeclarativecomponent_p.h:126
QColor
The QColor class provides colors based on RGB, HSV or CMYK values.
Definition: qcolor.h:67
d
double d
Definition: qnumeric_p.h:62
QMetaObject
The QMetaObject class contains meta-information about Qt objects.
Definition: qobjectdefs.h:304
QDeclarativeMetaType::interfaceIId
static const char * interfaceIId(int)
Definition: qdeclarativemetatype.cpp:913
QDeclarativeData::context
QDeclarativeContextData * context
Definition: qdeclarativedata_p.h:110
QBitField::united
QBitField united(const QBitField &)
Definition: qbitfield_p.h:126
QDeclarativeData::propertyCache
QDeclarativePropertyCache * propertyCache
Definition: qdeclarativedata_p.h:136
QVector3D
The QVector3D class represents a vector or vertex in 3D space.
Definition: qvector3d.h:60
QDeclarativeData::get
static QDeclarativeData * get(const QObject *object, bool create=false)
Definition: qdeclarativedata_p.h:140
type
int type
Definition: qmetatype.cpp:239
c
unsigned char c[8]
Definition: qnumeric_p.h:62
QWidget::setParent
void setParent(QWidget *parent)
Sets the parent of the widget to parent, and resets the window flags.
Definition: qwidget.cpp:10479
widget
QPointer< QWidget > widget
Definition: qapplication_mac.mm:879
QMetaObjectBuilder::fromRelocatableData
static void fromRelocatableData(QMetaObject *, const QMetaObject *, const QByteArray &)
Definition: qmetaobjectbuilder.cpp:1501
QDeclarativeParserStatus::d
QDeclarativeParserStatus ** d
Definition: qdeclarativeparserstatus.h:67
QDeclarativeComponentPrivate::creationContext
QDeclarativeGuardedContextData creationContext
Definition: qdeclarativecomponent_p.h:122
QMetaMethod::methodIndex
int methodIndex() const
Returns this method&#39;s index.
Definition: qmetaobject.cpp:1458
QVariant::isNull
bool isNull() const
Returns true if this is a NULL variant, false otherwise.
Definition: qvariant.cpp:3102
QDeclarativeContextData::engine
QDeclarativeEngine * engine
Definition: qdeclarativecontext_p.h:125
QMetaObject::metacall
static int metacall(QObject *, Call, int, void **)
Definition: qmetaobject.cpp:249
QByteArray
The QByteArray class provides an array of bytes.
Definition: qbytearray.h:135
ListInstance::qListProperty
QDeclarativeListProperty< void > qListProperty
Definition: qdeclarativevme.cpp:120
QDeclarativeInstruction::fetchAttached
FetchAttachedInstruction fetchAttached
Definition: qdeclarativeinstruction_p.h:350
QDeclarativeAbstractBinding::addToObject
void addToObject(QObject *, int)
Add this binding to object.
Definition: qdeclarativebinding.cpp:97
QDeclarativeCompiledData::TypeReference::typePropertyCache
QDeclarativePropertyCache * typePropertyCache
Definition: qdeclarativecompiler_p.h:96
QPointF
The QPointF class defines a point in the plane using floating point precision.
Definition: qpoint.h:214
QDeclarativeVME::isError
bool isError() const
Definition: qdeclarativevme.cpp:1044
QDeclarativeBinding::setTarget
void setTarget(const QDeclarativeProperty &)
Definition: qdeclarativebinding.cpp:294
QDeclarativeAbstractBinding::destroy
virtual void destroy(DestroyMode mode=DisconnectBinding)
Destroy the binding.
Definition: qdeclarativebinding.cpp:78
QWidget
The QWidget class is the base class of all user interface objects.
Definition: qwidget.h:150
QDeclarativePropertyPrivate::binding
static QDeclarativeAbstractBinding * binding(QObject *, int coreIndex, int valueTypeIndex)
Definition: qdeclarativeproperty.cpp:684
QDeclarativeVMEMetaObject::registerInterceptor
void registerInterceptor(int index, int valueIndex, QDeclarativePropertyValueInterceptor *interceptor)
Definition: qdeclarativevmemetaobject.cpp:772
QDeclarativeVMEStack::top
const T & top() const
Definition: qdeclarativevme.cpp:1092
QDeclarativeCompiledData::scripts
QList< QDeclarativeParser::Object::ScriptBlock > scripts
Definition: qdeclarativecompiler_p.h:125
QDeclarativePropertyPrivate::connect
static bool connect(QObject *sender, int signal_index, const QObject *receiver, int method_index, int type=0, int *types=0)
Connect sender signal_index to receiver method_index with the specified type and types.
Definition: qdeclarativeproperty.cpp:1637
status
static LibLoadStatus status
Definition: qlocale_icu.cpp:69
QDeclarativePropertyPrivate::valueTypeCoreIndex
static int valueTypeCoreIndex(const QDeclarativeProperty &that)
Definition: qdeclarativeproperty.cpp:1431
QDate
The QDate class provides date functions.
Definition: qdatetime.h:55
a
long ASN1_INTEGER_get ASN1_INTEGER * a
Definition: qsslsocket_openssl_symbols.cpp:104
QDeclarativeValueType::write
virtual void write(QObject *, int, QDeclarativePropertyPrivate::WriteFlags flags)=0
QDeclarativeData::deferredIdx
unsigned int deferredIdx
Definition: qdeclarativedata_p.h:130
QString
The QString class provides a Unicode character string.
Definition: qstring.h:83
QDate::fromJulianDay
static QDate fromJulianDay(int jd)
Converts the Julian day jd to a QDate.
Definition: qdatetime.h:133
QDeclarativeContextData::linkedContext
QDeclarativeContextData * linkedContext
Definition: qdeclarativecontext_p.h:194
Q_ASSERT
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
QObject
The QObject class is the base class of all Qt objects.
Definition: qobject.h:111
CLEAN_PROPERTY
#define CLEAN_PROPERTY(o, index)
Definition: qdeclarativevme.cpp:167
QDeclarativeEnginePrivate::get
static QDeclarativeEnginePrivate * get(QDeclarativeEngine *e)
Definition: qdeclarativeengine_p.h:316
QSizeF
The QSizeF class defines the size of a two-dimensional object using floating point precision...
Definition: qsize.h:202
QObjectPrivate::get
static QObjectPrivate * get(QObject *o)
Definition: qobject_p.h:177
QDeclarativeInstruction::assignSignalObject
AssignSignalObjectInstruction assignSignalObject
Definition: qdeclarativeinstruction_p.h:348
QObject::setParent
void setParent(QObject *)
Makes the object a child of parent.
Definition: qobject.cpp:1950
QCoreApplication::translate
static QString translate(const char *context, const char *key, const char *disambiguation=0, Encoding encoding=CodecForTr)
Definition: qcoreapplication.cpp:1908
QDeclarativeData::deferredComponent
QDeclarativeCompiledData * deferredComponent
Definition: qdeclarativedata_p.h:129
qmlAttachedPropertiesObjectById
Q_DECLARATIVE_EXPORT QObject * qmlAttachedPropertiesObjectById(int, const QObject *, bool create=true)
Definition: qdeclarativeengine.cpp:1084
QDeclarativeVME::vmeErrors
QList< QDeclarativeError > vmeErrors
Definition: qdeclarativevme_p.h:90
QDeclarativeBoundSignal::setExpression
QDeclarativeExpression * setExpression(QDeclarativeExpression *)
Sets the signal expression to e.
Definition: qdeclarativeboundsignal.cpp:166
QVariant::data
void * data()
Definition: qvariant.cpp:3077
QDeclarativeInstruction::fetchValue
FetchValueInstruction fetchValue
Definition: qdeclarativeinstruction_p.h:327
QTime
The QTime class provides clock time functions.
Definition: qdatetime.h:148
QRectF
The QRectF class defines a rectangle in the plane using floating point precision. ...
Definition: qrect.h:511
QDeclarativeCompiledData::TypeReference::createInstance
QObject * createInstance(QDeclarativeContextData *, const QBitField &, QList< QDeclarativeError > *) const
Definition: qdeclarativevme.cpp:1055
QDeclarativeScriptString
The QDeclarativeScriptString class encapsulates a script and its context.
Definition: qdeclarativescriptstring.h:58
QDeclarativeComponent
The QDeclarativeComponent class encapsulates a QML component definition.
Definition: qdeclarativecomponent.h:63
QColor::fromRgba
static QColor fromRgba(QRgb rgba)
Static convenience function that returns a QColor constructed from the given QRgb value rgba...
Definition: qcolor.cpp:1974
QMetaProperty::userType
int userType() const
Returns this property&#39;s user type.
Definition: qmetaobject.cpp:2210
QDeclarativeProperty::index
int index() const
Return the Qt metaobject index of the property.
Definition: qdeclarativeproperty.cpp:1426
QDeclarativeScriptString::setScopeObject
void setScopeObject(QObject *)
Sets the scope object for the script.
Definition: qdeclarativescriptstring.cpp:147
QDeclarativeInstruction::storeRealPair
StoreRealPairInstruction storeRealPair
Definition: qdeclarativeinstruction_p.h:342
QDeclarativeParserStatus
The QDeclarativeParserStatus class provides updates on the QML parser state.
Definition: qdeclarativeparserstatus.h:53
name
const char * name
Definition: qkeysequence.cpp:396
QList::at
const T & at(int i) const
Returns the item at index position i in the list.
Definition: qlist.h:468
QDeclarativeInstruction::storeScript
StoreScriptInstruction storeScript
Definition: qdeclarativeinstruction_p.h:336
QDeclarativeScriptString::setContext
void setContext(QDeclarativeContext *)
Sets the context for the script.
Definition: qdeclarativescriptstring.cpp:131
QDeclarativeInstruction::storeColor
StoreColorInstruction storeColor
Definition: qdeclarativeinstruction_p.h:338
QString::fromUtf8
static QString fromUtf8(const char *, int size=-1)
Returns a QString initialized with the first size bytes of the UTF-8 string str.
Definition: qstring.cpp:4302
QDeclarativeStringConverters::variantFromString
QVariant Q_DECLARATIVE_PRIVATE_EXPORT variantFromString(const QString &)
Definition: qdeclarativestringconverters.cpp:81
data
static const char * data(const QByteArray &arr)
Definition: qdbusmessage.cpp:60
QDeclarativeContextData::contextObjects
QDeclarativeData * contextObjects
Definition: qdeclarativecontext_p.h:168
QDeclarativeInstruction::storeDateTime
StoreDateTimeInstruction storeDateTime
Definition: qdeclarativeinstruction_p.h:341
QDeclarativePropertyValueInterceptor::setTarget
virtual void setTarget(const QDeclarativeProperty &property)=0
Set the target property for the value interceptor.
QDeclarativeInstruction::storeFloat
StoreFloatInstruction storeFloat
Definition: qdeclarativeinstruction_p.h:330
QMetaObject::checkConnectArgs
static bool checkConnectArgs(const char *signal, const char *method)
Returns true if the signal and method arguments are compatible; otherwise returns false...
Definition: qmetaobject.cpp:964
ptr
const T * ptr(const T &t)
Definition: qdirectfbpaintengine.cpp:1498
QList::clear
void clear()
Removes all items from the list.
Definition: qlist.h:764
QDeclarativeCompiledData::propertyCaches
QList< QDeclarativePropertyCache * > propertyCaches
Definition: qdeclarativecompiler_p.h:123
QDeclarativePropertyPrivate::setBinding
static QDeclarativeAbstractBinding * setBinding(QObject *, int coreIndex, int valueTypeIndex, QDeclarativeAbstractBinding *, WriteFlags flags=DontRemoveBinding)
Definition: qdeclarativeproperty.cpp:758
QVariant::fromValue
static QVariant fromValue(const T &value)
Returns a QVariant containing a copy of value.
Definition: qvariant.h:336
QDeclarativeCustomParser
The QDeclarativeCustomParser class allows you to add new arbitrary types to QML.
Definition: qdeclarativecustomparser_p.h:114
QDeclarativePropertyPrivate::bindingIndex
static int bindingIndex(const QDeclarativeProperty &that)
Returns the "property index" for use in bindings.
Definition: qdeclarativeproperty.cpp:1440
QDeclarativeEnginePrivate::bindValues
QList< SimpleList< QDeclarativeAbstractBinding > > bindValues
Definition: qdeclarativeengine_p.h:217
QDeclarativeInstruction::storeObject
StoreObjectInstruction storeObject
Definition: qdeclarativeinstruction_p.h:345
QObjectPrivate::declarativeData
QAbstractDeclarativeData * declarativeData
Definition: qobject_p.h:214
QDeclarativeVMEStack::at
const T & at(int index) const
Definition: qdeclarativevme.cpp:1120
parentWidget
static QWidget * parentWidget(const QWidget *w)
Definition: qstylesheetstyle.cpp:1411
QDeclarativeContextData::addImportedScript
void addImportedScript(const QDeclarativeParser::Object::ScriptBlock &script)
Definition: qdeclarativecontext.cpp:668
QDeclarativeCompiledData::contextCaches
QList< QDeclarativeIntegerCache * > contextCaches
Definition: qdeclarativecompiler_p.h:124
QDeclarativeValueTypeProxyBinding::removeBindings
void removeBindings(quint32 mask)
Removes a collection of bindings, corresponding to the set bits in mask.
Definition: qdeclarativebinding.cpp:570
QByteArray::constData
const char * constData() const
Returns a pointer to the data stored in the byte array.
Definition: qbytearray.h:433
qFatal
Q_CORE_EXPORT void qFatal(const char *,...)
QObject::isWidgetType
bool isWidgetType() const
Returns true if the object is a widget; otherwise returns false.
Definition: qobject.h:146
QString::arg
QString arg(qlonglong a, int fieldwidth=0, int base=10, const QChar &fillChar=QLatin1Char(' ')) const Q_REQUIRED_RESULT
Definition: qstring.cpp:7186
VME_EXCEPTION
#define VME_EXCEPTION(desc)
Definition: qdeclarativevme.cpp:102
QDateTime
The QDateTime class provides date and time functions.
Definition: qdatetime.h:216
QDeclarativeParserStatus::classBegin
virtual void classBegin()=0
Invoked after class creation, but before any properties have been set.
QMetaProperty::name
const char * name() const
Returns this property&#39;s name.
Definition: qmetaobject.cpp:2145
types
static const struct @32 types[]
QDeclarativePropertyPrivate::setBindingNoEnable
static QDeclarativeAbstractBinding * setBindingNoEnable(QObject *, int coreIndex, int valueTypeIndex, QDeclarativeAbstractBinding *)
Definition: qdeclarativeproperty.cpp:812
QDeclarativeInstruction::createComponent
CreateComponentInstruction createComponent
Definition: qdeclarativeinstruction_p.h:349
QDeclarativeEnginePrivate::clear
static void clear(SimpleList< QDeclarativeAbstractBinding > &)
Definition: qdeclarativeengine.cpp:534
QDeclarativeEnginePrivate::valueTypes
QDeclarativeValueTypeFactory valueTypes
Definition: qdeclarativeengine_p.h:250
QString::fromLatin1
static QString fromLatin1(const char *, int size=-1)
Returns a QString initialized with the first size characters of the Latin-1 string str...
Definition: qstring.cpp:4188
QDeclarative_setParent_noEvent
void QDeclarative_setParent_noEvent(QObject *object, QObject *parent)
Makes the object a child of parent.
Definition: qdeclarativeglobal_p.h:101
QDeclarativeContextData::asQDeclarativeContext
QDeclarativeContext * asQDeclarativeContext()
Definition: qdeclarativecontext.cpp:765
QDeclarativeInstruction::assignBinding
AssignBindingInstruction assignBinding
Definition: qdeclarativeinstruction_p.h:325
QDeclarativePropertyPrivate::restore
static QDeclarativeProperty restore(const QByteArray &, QObject *, QDeclarativeContextData *)
Definition: qdeclarativeproperty.cpp:1489
QPoint
The QPoint class defines a point in the plane using integer precision.
Definition: qpoint.h:53
QDeclarativeInstruction::storeDouble
StoreDoubleInstruction storeDouble
Definition: qdeclarativeinstruction_p.h:331
quint32
unsigned int quint32
Definition: qglobal.h:938
QDeclarativeInstruction::storeSignal
StoreSignalInstruction storeSignal
Definition: qdeclarativeinstruction_p.h:347
QMetaObject::className
const char * className() const
Returns the class name.
Definition: qobjectdefs.h:491
QDeclarativeInstruction::createSimple
CreateSimpleInstruction createSimple
Definition: qdeclarativeinstruction_p.h:320
property
const char * property
Definition: qwizard.cpp:138
QRect
The QRect class defines a rectangle in the plane using integer precision.
Definition: qrect.h:58
QDeclarativeMetaType::customStringConverter
static StringConverter customStringConverter(int)
Return the custom string converter for type, previously installed through registerCustomStringConvert...
Definition: qdeclarativemetatype.cpp:961
QByteArray::size
int size() const
Returns the number of bytes in this byte array.
Definition: qbytearray.h:402
QDeclarativeCompiledData::customTypeData
QList< CustomTypeData > customTypeData
Definition: qdeclarativecompiler_p.h:117
QDeclarativeExpression::setSourceLocation
void setSourceLocation(const QString &fileName, int line)
Set the location of this expression to line of url.
Definition: qdeclarativeexpression.cpp:744
QDeclarativePropertyValueSource::setTarget
virtual void setTarget(const QDeclarativeProperty &)=0
Set the target property for the value source.
QDeclarativeType::customParser
QDeclarativeCustomParser * customParser() const
Definition: qdeclarativemetatype.cpp:469
QDeclarativeInstruction::fetchQmlList
FetchQmlListInstruction fetchQmlList
Definition: qdeclarativeinstruction_p.h:328
QDeclarativeProperty
The QDeclarativeProperty class abstracts accessing properties on objects created from QML...
Definition: qdeclarativeproperty.h:59
QDeclarativeContextData::setIdProperty
void setIdProperty(int, QObject *)
Definition: qdeclarativecontext.cpp:734
QMetaObject::method
QMetaMethod method(int index) const
Returns the meta-data for the method with the given index.
Definition: qmetaobject.cpp:830
QMetaProperty
The QMetaProperty class provides meta-data about a property.
Definition: qmetaobject.h:176
QDeclarativeData::prevContextObject
QDeclarativeData ** prevContextObject
Definition: qdeclarativedata_p.h:118
QDeclarativeScriptString::setScript
void setScript(const QString &)
Sets the script text.
Definition: qdeclarativescriptstring.cpp:163
QSize
The QSize class defines the size of a two-dimensional object using integer point precision.
Definition: qsize.h:53
QDeclarativeInstruction::storeVector3D
StoreVector3DInstruction storeVector3D
Definition: qdeclarativeinstruction_p.h:344
QDeclarativeCustomParser::setCustomData
virtual void setCustomData(QObject *, const QByteArray &)=0
QMetaMethod::signature
const char * signature() const
Returns the signature of this method (e.g., setValue(double)).
Definition: qmetaobject.cpp:1327
QDeclarativeInstruction::assignValueInterceptor
AssignValueInterceptorInstruction assignValueInterceptor
Definition: qdeclarativeinstruction_p.h:324
QDeclarativePropertyValueSource
The QDeclarativePropertyValueSource class is an interface for property value sources such as animatio...
Definition: qdeclarativepropertyvaluesource.h:54
QDeclarativeData::nextContextObject
QDeclarativeData * nextContextObject
Definition: qdeclarativedata_p.h:117
QDeclarativeContextData::optimizedBindings
QDeclarativeCompiledBindings * optimizedBindings
Definition: qdeclarativecontext_p.h:191
QDeclarativeExpression
The QDeclarativeExpression class evaluates JavaScript in a QML context.
Definition: qdeclarativeexpression.h:63
QDeclarativeContextData::setIdPropertyData
void setIdPropertyData(QDeclarativeIntegerCache *)
Definition: qdeclarativecontext.cpp:740
QDeclarativeMetaType::defaultMethod
static QMetaMethod defaultMethod(const QMetaObject *)
Definition: qdeclarativemetatype.cpp:863
QDeclarativeInstruction::storeInteger
StoreIntegerInstruction storeInteger
Definition: qdeclarativeinstruction_p.h:332
QDeclarativePropertyValueInterceptor
The QDeclarativePropertyValueInterceptor class is inherited by property interceptors such as Behavior...
Definition: qdeclarativepropertyvalueinterceptor.h:54
QDeclarativeCompiledData::types
QList< TypeReference > types
Definition: qdeclarativecompiler_p.h:104
QDeclarativeInstruction::assignValueSource
AssignValueSourceInstruction assignValueSource
Definition: qdeclarativeinstruction_p.h:323
QMetaMethod
The QMetaMethod class provides meta-data about a member function.
Definition: qmetaobject.h:56
QTime::setHMS
bool setHMS(int h, int m, int s, int ms=0)
Sets the time to hour h, minute m, seconds s and milliseconds ms.
Definition: qdatetime.cpp:1744
QDeclarativeEnginePrivate::parserStatus
QList< SimpleList< QDeclarativeParserStatus > > parserStatus
Definition: qdeclarativeengine_p.h:218
QObject::metaObject
virtual const QMetaObject * metaObject() const
Returns a pointer to the meta-object of this object.
QDeclarativeCompiledData::bytecode
QList< QDeclarativeInstruction > bytecode
Definition: qdeclarativecompiler_p.h:120
QMetaObject::property
QMetaProperty property(int index) const
Returns the meta-data for the property with the given index.
Definition: qmetaobject.cpp:871
QDeclarativeInstruction::storeString
StoreStringInstruction storeString
Definition: qdeclarativeinstruction_p.h:334
QDeclarativeInstruction::assignCustomType
AssignCustomTypeInstruction assignCustomType
Definition: qdeclarativeinstruction_p.h:346
QDeclarativeMetaType::StringConverter
QVariant(* StringConverter)(const QString &)
Definition: qdeclarativemetatype_p.h:105
QDeclarativeInstruction::storeScriptString
StoreScriptStringInstruction storeScriptString
Definition: qdeclarativeinstruction_p.h:335
QDeclarativeAbstractBinding::m_mePtr
QDeclarativeAbstractBinding ** m_mePtr
Definition: qdeclarativebinding_p.h:140
QDeclarativeValueType::read
virtual void read(QObject *, int)=0

◆ runDeferred()

void QDeclarativeVME::runDeferred ( QObject *  object)

Definition at line 136 of file qdeclarativevme.cpp.

Referenced by QDeclarativeComponentPrivate::beginDeferred().

137 {
138  QDeclarativeData *data = QDeclarativeData::get(object);
139 
140  if (!data || !data->context || !data->deferredComponent)
141  return;
142 
143  QDeclarativeContextData *ctxt = data->context;
144  QDeclarativeCompiledData *comp = data->deferredComponent;
145  int start = data->deferredIdx + 1;
146  int count = data->deferredComponent->bytecode.at(data->deferredIdx).defer.deferCount;
147  QDeclarativeVMEObjectStack stack;
148  stack.push(object);
149 
150  run(stack, ctxt, comp, start, count, QBitField());
151 }
QDeclarativeData::context
QDeclarativeContextData * context
Definition: qdeclarativedata_p.h:110
QDeclarativeData::get
static QDeclarativeData * get(const QObject *object, bool create=false)
Definition: qdeclarativedata_p.h:140
QDeclarativeData::deferredIdx
unsigned int deferredIdx
Definition: qdeclarativedata_p.h:130
QDeclarativeData::deferredComponent
QDeclarativeCompiledData * deferredComponent
Definition: qdeclarativedata_p.h:129
QList::at
const T & at(int i) const
Returns the item at index position i in the list.
Definition: qlist.h:468
data
static const char * data(const QByteArray &arr)
Definition: qdbusmessage.cpp:60
QDeclarativeVME::run
QObject * run(QDeclarativeContextData *, QDeclarativeCompiledData *, int start=-1, int count=-1, const QBitField &=QBitField())
Definition: qdeclarativevme.cpp:125
QDeclarativeCompiledData::bytecode
QList< QDeclarativeInstruction > bytecode
Definition: qdeclarativecompiler_p.h:120

Properties

◆ vmeErrors

QList<QDeclarativeError> QDeclarativeVME::vmeErrors
private

Definition at line 90 of file qdeclarativevme_p.h.

The documentation for this class was generated from the following files:
Qt 4.8 Source Code Browser