#include "qdeclarativescriptstring.h"
#include "private/qdeclarativeglobal_p.h"
#include "private/qdeclarativebinding_p.h"
-#include "private/qdeclarativev4compiler_p.h"
+#include "private/qv4compiler_p.h"
#include <QColor>
#include <QDebug>
aliasObject = compileState->aliasingObjects.next(aliasObject))
COMPILE_CHECK(buildDynamicMeta(aliasObject, ResolveAliases));
- QDeclarativeV4Compiler::Expression expr(unit->imports());
+ QV4Compiler::Expression expr(unit->imports());
expr.component = compileState->root;
expr.ids = &compileState->ids;
expr.importCache = output->importCache;
- QDeclarativeV4Compiler bindingCompiler;
+ QV4Compiler bindingCompiler;
QList<BindingReference*> sharedBindings;
#include "private/qdeclarativeengine_p.h"
#include "qdeclarativeengine.h"
#include "qdeclarativeinfo.h"
-#include "private/qdeclarativev4bindings_p.h"
+#include "private/qv4bindings_p.h"
#include "private/qv8bindings_p.h"
#include <qjsengine.h>
class QDeclarativeExpression;
class QDeclarativeExpressionPrivate;
class QDeclarativeAbstractExpression;
-class QDeclarativeV4Bindings;
+class QV4Bindings;
class QDeclarativeContextData;
class QDeclarativeContextPrivate : public QObjectPrivate
QDeclarativeComponentAttached *componentAttached;
// Optimized binding objects. Needed for deferred properties.
- QDeclarativeV4Bindings *v4bindings;
+ QV4Bindings *v4bindings;
QV8Bindings *v8bindings;
// Return the outermost id for obj, if any.
#include "private/qdeclarativevmemetaobject_p.h"
#include "private/qdeclarativebinding_p_p.h"
#include "private/qdeclarativecontext_p.h"
-#include "private/qdeclarativev4bindings_p.h"
+#include "private/qv4bindings_p.h"
#include "private/qv8bindings_p.h"
#include "private/qdeclarativeglobal_p.h"
#include "private/qfinitestack_p.h"
CTXT->setIdPropertyData(COMP->contextCaches.at(instr.contextCache));
if (instr.compiledBinding != -1) {
const char *v4data = DATAS.at(instr.compiledBinding).constData();
- CTXT->v4bindings = new QDeclarativeV4Bindings(v4data, CTXT, COMP);
+ CTXT->v4bindings = new QV4Bindings(v4data, CTXT, COMP);
}
if (states.count() == 1) {
rootContext = CTXT;
// #define REGISTER_CLEANUP_DEBUG
-#include "private/qdeclarativev4bindings_p.h"
-#include "private/qdeclarativev4program_p.h"
-#include "private/qdeclarativev4compiler_p.h"
-#include "private/qdeclarativev4compiler_p_p.h"
+#include "private/qv4bindings_p.h"
+#include "private/qv4program_p.h"
+#include "private/qv4compiler_p.h"
+#include "private/qv4compiler_p_p.h"
#include <private/qdeclarativefastproperties_p.h>
#include <private/qdeclarativedebugtrace_p.h>
} // end of anonymous namespace
-QDeclarativeV4Bindings::QDeclarativeV4Bindings(const char *programData,
+QV4Bindings::QV4Bindings(const char *programData,
QDeclarativeContextData *context,
QDeclarativeRefCount *ref)
: subscriptions(0), program(0), dataRef(0), bindings(0)
{
- program = (QDeclarativeV4Program *)programData;
+ program = (QV4Program *)programData;
dataRef = ref;
if (dataRef) dataRef->addref();
}
}
-QDeclarativeV4Bindings::~QDeclarativeV4Bindings()
+QV4Bindings::~QV4Bindings()
{
delete [] bindings;
delete [] subscriptions; subscriptions = 0;
if (dataRef) dataRef->release();
}
-QDeclarativeAbstractBinding *QDeclarativeV4Bindings::configBinding(int index, QObject *target,
+QDeclarativeAbstractBinding *QV4Bindings::configBinding(int index, QObject *target,
QObject *scope, int property)
{
Binding *rv = bindings + index;
return rv;
}
-void QDeclarativeV4Bindings::Binding::setEnabled(bool e, QDeclarativePropertyPrivate::WriteFlags flags)
+void QV4Bindings::Binding::setEnabled(bool e, QDeclarativePropertyPrivate::WriteFlags flags)
{
if (enabled != e) {
enabled = e;
}
}
-void QDeclarativeV4Bindings::Binding::update(QDeclarativePropertyPrivate::WriteFlags flags)
+void QV4Bindings::Binding::update(QDeclarativePropertyPrivate::WriteFlags flags)
{
QDeclarativeDebugTrace::startRange(QDeclarativeDebugTrace::Binding);
parent->run(this, flags);
QDeclarativeDebugTrace::endRange(QDeclarativeDebugTrace::Binding);
}
-void QDeclarativeV4Bindings::Binding::destroy()
+void QV4Bindings::Binding::destroy()
{
enabled = false;
removeFromObject();
parent->release();
}
-void QDeclarativeV4Bindings::Subscription::subscriptionCallback(QDeclarativeNotifierEndpoint *e)
+void QV4Bindings::Subscription::subscriptionCallback(QDeclarativeNotifierEndpoint *e)
{
Subscription *s = static_cast<Subscription *>(e);
s->bindings->subscriptionNotify(s->method);
}
-void QDeclarativeV4Bindings::subscriptionNotify(int id)
+void QV4Bindings::subscriptionNotify(int id)
{
- QDeclarativeV4Program::BindingReferenceList *list = program->signalTable(id);
+ QV4Program::BindingReferenceList *list = program->signalTable(id);
for (quint32 ii = 0; ii < list->count; ++ii) {
- QDeclarativeV4Program::BindingReference *bindingRef = list->bindings + ii;
+ QV4Program::BindingReference *bindingRef = list->bindings + ii;
Binding *binding = bindings + bindingRef->binding;
if (binding->executedBlocks & bindingRef->blockMask)
}
}
-void QDeclarativeV4Bindings::run(Binding *binding, QDeclarativePropertyPrivate::WriteFlags flags)
+void QV4Bindings::run(Binding *binding, QDeclarativePropertyPrivate::WriteFlags flags)
{
if (!binding->enabled)
return;
}
-void QDeclarativeV4Bindings::unsubscribe(int subIndex)
+void QV4Bindings::unsubscribe(int subIndex)
{
Subscription *sub = (subscriptions + subIndex);
sub->disconnect();
}
-void QDeclarativeV4Bindings::subscribeId(QDeclarativeContextData *p, int idIndex, int subIndex)
+void QV4Bindings::subscribeId(QDeclarativeContextData *p, int idIndex, int subIndex)
{
unsubscribe(subIndex);
}
}
-void QDeclarativeV4Bindings::subscribe(QObject *o, int notifyIndex, int subIndex)
+void QV4Bindings::subscribe(QObject *o, int notifyIndex, int subIndex)
{
Subscription *sub = (subscriptions + subIndex);
sub->bindings = this;
iserror = true;
if (iserror) {
- qWarning().nospace() << "QDeclarativeV4: Optimization error @" << context->url.toString().toUtf8().constData() << ":" << line << ":" << column;
+ qWarning().nospace() << "QV4: Optimization error @" << context->url.toString().toUtf8().constData() << ":" << line << ":" << column;
qWarning().nospace() << " Binding: " << binding;
qWarning().nospace() << " QtScript: " << qtscriptResult.constData();
if (!expression.hasError()) {
QByteArray qtscriptResult = testResultToString(value, isUndefined);
- qWarning().nospace() << "QDeclarativeV4: Optimization error @" << context->url.toString().toUtf8().constData() << ":" << line << ":" << column;
+ qWarning().nospace() << "QV4: Optimization error @" << context->url.toString().toUtf8().constData() << ":" << line << ":" << column;
qWarning().nospace() << " Binding: " << binding;
qWarning().nospace() << " QtScript: " << qtscriptResult.constData();
qWarning().nospace() << " V4: exception";
}
static void throwException(int id, QDeclarativeDelayedError *error,
- QDeclarativeV4Program *program, QDeclarativeContextData *context,
+ QV4Program *program, QDeclarativeContextData *context,
const QString &description = QString())
{
error->error.setUrl(context->url);
QDeclarativeEnginePrivate::warning(context->engine, error->error);
}
-const qreal QDeclarativeV4Bindings::D32 = 4294967296.0;
+const qreal QV4Bindings::D32 = 4294967296.0;
-qint32 QDeclarativeV4Bindings::toInt32(qreal n)
+qint32 QV4Bindings::toInt32(qreal n)
{
if (qIsNaN(n) || qIsInf(n) || (n == 0))
return 0;
return qint32 (n);
}
-inline quint32 QDeclarativeV4Bindings::toUint32(qreal n)
+inline quint32 QV4Bindings::toUint32(qreal n)
{
if (qIsNaN(n) || qIsInf(n) || (n == 0))
return 0;
}
#ifdef QML_THREADED_INTERPRETER
-void **QDeclarativeV4Bindings::getDecodeInstrTable()
+void **QV4Bindings::getDecodeInstrTable()
{
static void **decode_instr;
if (!decode_instr) {
- QDeclarativeV4Bindings *dummy = new QDeclarativeV4Bindings(0, 0, 0);
+ QV4Bindings *dummy = new QV4Bindings(0, 0, 0);
quint32 executedBlocks = 0;
dummy->run(0, executedBlocks, 0, 0, 0, 0,
QDeclarativePropertyPrivate::BypassInterceptor,
}
#endif
-void QDeclarativeV4Bindings::run(int instrIndex, quint32 &executedBlocks,
+void QV4Bindings::run(int instrIndex, quint32 &executedBlocks,
QDeclarativeContextData *context, QDeclarativeDelayedError *error,
QObject *scope, QObject *output,
QDeclarativePropertyPrivate::WriteFlags storeFlags
// nothing to do
#else
default:
- qFatal("QDeclarativeV4: Unknown instruction %d encountered.", instr->common.type);
+ qFatal("QV4: Unknown instruction %d encountered.", instr->common.type);
break;
} // switch
**
****************************************************************************/
-#ifndef QDECLARATIVEV4BINDINGS_P_H
-#define QDECLARATIVEV4BINDINGS_P_H
+#ifndef QV4BINDINGS_P_H
+#define QV4BINDINGS_P_H
//
// W A R N I N G
#include "private/qdeclarativeexpression_p.h"
#include "private/qdeclarativebinding_p.h"
-#include "private/qdeclarativev4instruction_p.h"
+#include "private/qv4instruction_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
-class QDeclarativeV4Program;
-class QDeclarativeV4Bindings : public QDeclarativeAbstractExpression,
+class QV4Program;
+class QV4Bindings : public QDeclarativeAbstractExpression,
public QDeclarativeRefCount
{
- Q_DECLARE_TR_FUNCTIONS(QDeclarativeV4Bindings)
+ Q_DECLARE_TR_FUNCTIONS(QV4Bindings)
public:
- QDeclarativeV4Bindings(const char *program, QDeclarativeContextData *context,
+ QV4Bindings(const char *program, QDeclarativeContextData *context,
QDeclarativeRefCount *);
- virtual ~QDeclarativeV4Bindings();
+ virtual ~QV4Bindings();
QDeclarativeAbstractBinding *configBinding(int index, QObject *target,
QObject *scope, int property);
#endif
private:
- Q_DISABLE_COPY(QDeclarativeV4Bindings)
+ Q_DISABLE_COPY(QV4Bindings)
struct Binding : public QDeclarativeAbstractBinding, public QDeclarativeDelayedError {
Binding() : enabled(false), updating(0), property(0),
QObject *target;
quint32 executedBlocks;
- QDeclarativeV4Bindings *parent;
+ QV4Bindings *parent;
};
struct Subscription : public QDeclarativeNotifierEndpoint
{
Subscription() : bindings(0), method(-1) { callback = &subscriptionCallback; }
static void subscriptionCallback(QDeclarativeNotifierEndpoint *e);
- QDeclarativeV4Bindings *bindings;
+ QV4Bindings *bindings;
int method;
};
friend class Subscription;
void subscriptionNotify(int);
void run(Binding *, QDeclarativePropertyPrivate::WriteFlags flags);
- QDeclarativeV4Program *program;
+ QV4Program *program;
QDeclarativeRefCount *dataRef;
Binding *bindings;
QT_END_HEADER
-#endif // QDECLARATIVEV4BINDINGS_P_H
+#endif // QV4BINDINGS_P_H
**
****************************************************************************/
-#include "qdeclarativev4compiler_p.h"
-#include "qdeclarativev4compiler_p_p.h"
-#include "qdeclarativev4program_p.h"
-#include "qdeclarativev4ir_p.h"
-#include "qdeclarativev4irbuilder_p.h"
+#include "qv4compiler_p.h"
+#include "qv4compiler_p_p.h"
+#include "qv4program_p.h"
+#include "qv4ir_p.h"
+#include "qv4irbuilder_p.h"
#include <private/qdeclarativejsast_p.h>
#include <private/qdeclarativefastproperties_p.h>
static bool qmlBindingsTest = false;
using namespace QDeclarativeJS;
-QDeclarativeV4CompilerPrivate::QDeclarativeV4CompilerPrivate()
+QV4CompilerPrivate::QV4CompilerPrivate()
: _function(0) , _block(0) , _discarded(false)
{
}
//
// tracing
//
-void QDeclarativeV4CompilerPrivate::trace(int line, int column)
+void QV4CompilerPrivate::trace(int line, int column)
{
bytecode.clear();
}
}
-void QDeclarativeV4CompilerPrivate::trace(QVector<IR::BasicBlock *> *blocks)
+void QV4CompilerPrivate::trace(QVector<IR::BasicBlock *> *blocks)
{
for (int i = 0; i < _function->basicBlocks.size(); ++i) {
IR::BasicBlock *block = _function->basicBlocks.at(i);
}
}
-void QDeclarativeV4CompilerPrivate::traceExpression(IR::Expr *e, quint8 r)
+void QV4CompilerPrivate::traceExpression(IR::Expr *e, quint8 r)
{
if (!e) {
discard();
//
// expressions
//
-void QDeclarativeV4CompilerPrivate::visitConst(IR::Const *e)
+void QV4CompilerPrivate::visitConst(IR::Const *e)
{
switch (e->type) {
case IR::BoolType: {
}
}
-void QDeclarativeV4CompilerPrivate::visitString(IR::String *e)
+void QV4CompilerPrivate::visitString(IR::String *e)
{
registerLiteralString(currentReg, e->value);
}
-void QDeclarativeV4CompilerPrivate::visitName(IR::Name *e)
+void QV4CompilerPrivate::visitName(IR::Name *e)
{
if (e->base) {
// fetch the object and store it in reg.
} // switch
}
-void QDeclarativeV4CompilerPrivate::visitTemp(IR::Temp *e)
+void QV4CompilerPrivate::visitTemp(IR::Temp *e)
{
if (currentReg != e->index) {
Instr::Copy i;
}
}
-void QDeclarativeV4CompilerPrivate::visitUnop(IR::Unop *e)
+void QV4CompilerPrivate::visitUnop(IR::Unop *e)
{
quint8 src = currentReg;
} // switch
}
-void QDeclarativeV4CompilerPrivate::convertToReal(IR::Expr *expr, int reg)
+void QV4CompilerPrivate::convertToReal(IR::Expr *expr, int reg)
{
if (expr->type == IR::RealType)
return;
} // switch
}
-void QDeclarativeV4CompilerPrivate::convertToInt(IR::Expr *expr, int reg)
+void QV4CompilerPrivate::convertToInt(IR::Expr *expr, int reg)
{
if (expr->type == IR::IntType)
return;
} // switch
}
-void QDeclarativeV4CompilerPrivate::convertToBool(IR::Expr *expr, int reg)
+void QV4CompilerPrivate::convertToBool(IR::Expr *expr, int reg)
{
if (expr->type == IR::BoolType)
return;
} // switch
}
-quint8 QDeclarativeV4CompilerPrivate::instructionOpcode(IR::Binop *e)
+quint8 QV4CompilerPrivate::instructionOpcode(IR::Binop *e)
{
switch (e->op) {
case IR::OpInvalid:
return V4Instr::Noop;
}
-void QDeclarativeV4CompilerPrivate::visitBinop(IR::Binop *e)
+void QV4CompilerPrivate::visitBinop(IR::Binop *e)
{
int left = currentReg;
int right = currentReg + 1;
}
}
-void QDeclarativeV4CompilerPrivate::visitCall(IR::Call *call)
+void QV4CompilerPrivate::visitCall(IR::Call *call)
{
if (IR::Name *name = call->base->asName()) {
IR::Expr *arg = call->onlyArgument();
//
// statements
//
-void QDeclarativeV4CompilerPrivate::visitExp(IR::Exp *s)
+void QV4CompilerPrivate::visitExp(IR::Exp *s)
{
traceExpression(s->expr, currentReg);
}
-void QDeclarativeV4CompilerPrivate::visitMove(IR::Move *s)
+void QV4CompilerPrivate::visitMove(IR::Move *s)
{
IR::Temp *target = s->target->asTemp();
Q_ASSERT(target != 0);
}
}
-void QDeclarativeV4CompilerPrivate::visitJump(IR::Jump *s)
+void QV4CompilerPrivate::visitJump(IR::Jump *s)
{
patches.append(Patch(s->target, bytecode.size()));
gen(i);
}
-void QDeclarativeV4CompilerPrivate::visitCJump(IR::CJump *s)
+void QV4CompilerPrivate::visitCJump(IR::CJump *s)
{
traceExpression(s->cond, currentReg);
gen(i);
}
-void QDeclarativeV4CompilerPrivate::visitRet(IR::Ret *s)
+void QV4CompilerPrivate::visitRet(IR::Ret *s)
{
Q_ASSERT(s->expr != 0);
gen(store);
}
-void QDeclarativeV4Compiler::dump(const QByteArray &programData)
+void QV4Compiler::dump(const QByteArray &programData)
{
- const QDeclarativeV4Program *program = (const QDeclarativeV4Program *)programData.constData();
+ const QV4Program *program = (const QV4Program *)programData.constData();
qWarning() << "Program.bindings:" << program->bindings;
qWarning() << "Program.dataLength:" << program->dataLength;
Clear the state associated with attempting to compile a specific binding.
This does not clear the global "committed binding" states.
*/
-void QDeclarativeV4CompilerPrivate::resetInstanceState()
+void QV4CompilerPrivate::resetInstanceState()
{
data = committed.data;
exceptions = committed.exceptions;
Returns the index for the committed binding.
*/
-int QDeclarativeV4CompilerPrivate::commitCompile()
+int QV4CompilerPrivate::commitCompile()
{
int rv = committed.count();
committed.offsets << committed.bytecode.count();
return rv;
}
-bool QDeclarativeV4CompilerPrivate::compile(QDeclarativeJS::AST::Node *node)
+bool QV4CompilerPrivate::compile(QDeclarativeJS::AST::Node *node)
{
resetInstanceState();
IR::Function thisFunction(&pool), *function = &thisFunction;
- QDeclarativeV4IRBuilder irBuilder(expression, engine);
+ QV4IRBuilder irBuilder(expression, engine);
if (!irBuilder(function, node))
return false;
}
// Returns a reg
-int QDeclarativeV4CompilerPrivate::registerLiteralString(quint8 reg, const QStringRef &str)
+int QV4CompilerPrivate::registerLiteralString(quint8 reg, const QStringRef &str)
{
// ### string cleanup
}
// Returns an identifier offset
-int QDeclarativeV4CompilerPrivate::registerString(const QString &string)
+int QV4CompilerPrivate::registerString(const QString &string)
{
Q_ASSERT(!string.isEmpty());
/*!
Returns true if the current expression has not already subscribed to \a sub in currentBlockMask.
*/
-bool QDeclarativeV4CompilerPrivate::blockNeedsSubscription(const QStringList &sub)
+bool QV4CompilerPrivate::blockNeedsSubscription(const QStringList &sub)
{
QString str = sub.join(QLatin1String("."));
return !(*uiter & currentBlockMask);
}
-int QDeclarativeV4CompilerPrivate::subscriptionIndex(const QStringList &sub)
+int QV4CompilerPrivate::subscriptionIndex(const QStringList &sub)
{
QString str = sub.join(QLatin1String("."));
int *iter = subscriptionIds.value(str);
return *iter;
}
-quint32 QDeclarativeV4CompilerPrivate::subscriptionBlockMask(const QStringList &sub)
+quint32 QV4CompilerPrivate::subscriptionBlockMask(const QStringList &sub)
{
QString str = sub.join(QLatin1String("."));
return *uiter;
}
-quint8 QDeclarativeV4CompilerPrivate::exceptionId(quint32 line, quint32 column)
+quint8 QV4CompilerPrivate::exceptionId(quint32 line, quint32 column)
{
quint8 rv = 0xFF;
if (exceptions.count() < 0xFF) {
return rv;
}
-quint8 QDeclarativeV4CompilerPrivate::exceptionId(QDeclarativeJS::AST::ExpressionNode *n)
+quint8 QV4CompilerPrivate::exceptionId(QDeclarativeJS::AST::ExpressionNode *n)
{
quint8 rv = 0xFF;
if (n && exceptions.count() < 0xFF) {
return rv;
}
-QDeclarativeV4Compiler::QDeclarativeV4Compiler()
-: d(new QDeclarativeV4CompilerPrivate)
+QV4Compiler::QV4Compiler()
+: d(new QV4CompilerPrivate)
{
qmlBindingsTest |= qmlBindingsTestEnv();
}
-QDeclarativeV4Compiler::~QDeclarativeV4Compiler()
+QV4Compiler::~QV4Compiler()
{
delete d; d = 0;
}
/*
Returns true if any bindings were compiled.
*/
-bool QDeclarativeV4Compiler::isValid() const
+bool QV4Compiler::isValid() const
{
return !d->committed.bytecode.isEmpty();
}
/*
-1 on failure, otherwise the binding index to use.
*/
-int QDeclarativeV4Compiler::compile(const Expression &expression, QDeclarativeEnginePrivate *engine)
+int QV4Compiler::compile(const Expression &expression, QDeclarativeEnginePrivate *engine)
{
if (!expression.expression.asAST()) return false;
}
}
-QByteArray QDeclarativeV4CompilerPrivate::buildSignalTable() const
+QByteArray QV4CompilerPrivate::buildSignalTable() const
{
QHash<int, QList<QPair<int, quint32> > > table;
return QByteArray((const char *)header.constData(), header.count() * sizeof(quint32));
}
-QByteArray QDeclarativeV4CompilerPrivate::buildExceptionData() const
+QByteArray QV4CompilerPrivate::buildExceptionData() const
{
QByteArray rv;
rv.resize(committed.exceptions.count() * sizeof(quint64));
/*
Returns the compiled program.
*/
-QByteArray QDeclarativeV4Compiler::program() const
+QByteArray QV4Compiler::program() const
{
QByteArray programData;
if (isValid()) {
- QDeclarativeV4Program prog;
+ QV4Program prog;
prog.bindings = d->committed.count();
Bytecode bc;
- QDeclarativeV4CompilerPrivate::Instr::Jump jump;
+ QV4CompilerPrivate::Instr::Jump jump;
jump.reg = -1;
for (int ii = 0; ii < d->committed.count(); ++ii) {
prog.subscriptions = d->committed.subscriptionIds.count();
prog.identifiers = d->committed.registeredStrings.count();
prog.instructionCount = bytecode.count();
- int size = sizeof(QDeclarativeV4Program) + bytecode.count();
+ int size = sizeof(QV4Program) + bytecode.count();
size += prog.dataLength;
programData.resize(size);
- memcpy(programData.data(), &prog, sizeof(QDeclarativeV4Program));
+ memcpy(programData.data(), &prog, sizeof(QV4Program));
if (prog.dataLength)
- memcpy((char *)((QDeclarativeV4Program *)programData.data())->data(), data.constData(),
+ memcpy((char *)((QV4Program *)programData.data())->data(), data.constData(),
data.size());
- memcpy((char *)((QDeclarativeV4Program *)programData.data())->instructions(), bytecode.constData(),
+ memcpy((char *)((QV4Program *)programData.data())->instructions(), bytecode.constData(),
bytecode.count());
}
qWarning().nospace() << " " << iter->first << "\t-> " << iter->second;
}
- QDeclarativeV4Compiler::dump(programData);
+ QV4Compiler::dump(programData);
}
return programData;
}
-void QDeclarativeV4Compiler::enableBindingsTest(bool e)
+void QV4Compiler::enableBindingsTest(bool e)
{
if (e)
qmlBindingsTest = true;
**
****************************************************************************/
-#ifndef QDECLARATIVEV4COMPILER_P_H
-#define QDECLARATIVEV4COMPILER_P_H
+#ifndef QV4COMPILER_P_H
+#define QV4COMPILER_P_H
//
// W A R N I N G
QT_BEGIN_NAMESPACE
class QDeclarativeTypeNameCache;
-class QDeclarativeV4CompilerPrivate;
-class Q_AUTOTEST_EXPORT QDeclarativeV4Compiler
+class QV4CompilerPrivate;
+class Q_AUTOTEST_EXPORT QV4Compiler
{
public:
- QDeclarativeV4Compiler();
- ~QDeclarativeV4Compiler();
+ QV4Compiler();
+ ~QV4Compiler();
// Returns true if bindings were compiled
bool isValid() const;
static void dump(const QByteArray &);
static void enableBindingsTest(bool);
private:
- QDeclarativeV4CompilerPrivate *d;
+ QV4CompilerPrivate *d;
};
QT_END_NAMESPACE
QT_END_HEADER
-#endif // QDECLARATIVEV4COMPILER_P_H
+#endif // QV4COMPILER_P_H
**
****************************************************************************/
-#ifndef QDECLARATIVEV4COMPILER_P_P_H
-#define QDECLARATIVEV4COMPILER_P_P_H
+#ifndef QV4COMPILER_P_P_H
+#define QV4COMPILER_P_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qdeclarativev4instruction_p.h"
-#include "qdeclarativev4ir_p.h"
+#include "qv4instruction_p.h"
+#include "qv4ir_p.h"
#include <private/qdeclarativescript_p.h>
#include <private/qdeclarativeimport_p.h>
#include <private/qdeclarativeengine_p.h>
Container _container;
};
-class QDeclarativeV4CompilerPrivate: protected QDeclarativeJS::IR::ExprVisitor,
+class QV4CompilerPrivate: protected QDeclarativeJS::IR::ExprVisitor,
protected QDeclarativeJS::IR::StmtVisitor
{
public:
- QDeclarativeV4CompilerPrivate();
+ QV4CompilerPrivate();
void resetInstanceState();
int commitCompile();
- const QDeclarativeV4Compiler::Expression *expression;
+ const QV4Compiler::Expression *expression;
QDeclarativeEnginePrivate *engine;
QString contextName() const { return QLatin1String("$$$SCOPE_") + QString::number((quintptr)expression->context, 16); }
QT_END_HEADER
-#endif // QDECLARATIVEV4COMPILER_P_P_H
+#endif // QV4COMPILER_P_P_H
**
****************************************************************************/
-#include "qdeclarativev4instruction_p.h"
-#include "qdeclarativev4bindings_p.h"
+#include "qv4instruction_p.h"
+#include "qv4bindings_p.h"
#include <QtCore/qdebug.h>
#include <private/qdeclarativeglobal_p.h>
Bytecode::Bytecode()
{
#ifdef QML_THREADED_INTERPRETER
- decodeInstr = QDeclarativeV4Bindings::getDecodeInstrTable();
+ decodeInstr = QV4Bindings::getDecodeInstrTable();
#endif
}
**
****************************************************************************/
-#ifndef QDECLARATIVEV4INSTRUCTION_P_H
-#define QDECLARATIVEV4INSTRUCTION_P_H
+#ifndef QV4INSTRUCTION_P_H
+#define QV4INSTRUCTION_P_H
//
// W A R N I N G
QT_END_HEADER
-#endif // QDECLARATIVEV4INSTRUCTION_P_H
+#endif // QV4INSTRUCTION_P_H
**
****************************************************************************/
-#include "qdeclarativev4ir_p.h"
+#include "qv4ir_p.h"
#include <QtCore/qtextstream.h>
#include <QtCore/qdebug.h>
**
****************************************************************************/
-#ifndef QDECLARATIVEV4IR_P_H
-#define QDECLARATIVEV4IR_P_H
+#ifndef QV4IR_P_H
+#define QV4IR_P_H
//
// W A R N I N G
#include <private/qdeclarativescript_p.h>
#include <private/qdeclarativeimport_p.h>
#include <private/qdeclarativeengine_p.h>
-#include <private/qdeclarativev4compiler_p.h>
+#include <private/qv4compiler_p.h>
#include <qdeclarativepool_p.h>
#include <QtCore/qvarlengtharray.h>
QT_END_HEADER
-#endif // QDECLARATIVEV4IR_P_H
+#endif // QV4IR_P_H
**
****************************************************************************/
-#include "qdeclarativev4irbuilder_p.h"
-#include "qdeclarativev4compiler_p_p.h"
+#include "qv4irbuilder_p.h"
+#include "qv4compiler_p_p.h"
#include <private/qsganchors_p_p.h> // For AnchorLine
#include <private/qdeclarativetypenamecache_p.h>
}
}
-QDeclarativeV4IRBuilder::QDeclarativeV4IRBuilder(const QDeclarativeV4Compiler::Expression *expr,
+QV4IRBuilder::QV4IRBuilder(const QV4Compiler::Expression *expr,
QDeclarativeEnginePrivate *engine)
: m_expression(expr), m_engine(engine), _function(0), _block(0), _discard(false)
{
}
-bool QDeclarativeV4IRBuilder::operator()(QDeclarativeJS::IR::Function *function,
+bool QV4IRBuilder::operator()(QDeclarativeJS::IR::Function *function,
QDeclarativeJS::AST::Node *ast)
{
bool discarded = false;
return !discarded;
}
-bool QDeclarativeV4IRBuilder::buildName(QList<QStringRef> &name,
+bool QV4IRBuilder::buildName(QList<QStringRef> &name,
AST::Node *node,
QList<AST::ExpressionNode *> *nodes)
{
return true;
}
-void QDeclarativeV4IRBuilder::discard()
+void QV4IRBuilder::discard()
{
_discard = true;
}
-QDeclarativeV4IRBuilder::ExprResult
-QDeclarativeV4IRBuilder::expression(AST::ExpressionNode *ast)
+QV4IRBuilder::ExprResult
+QV4IRBuilder::expression(AST::ExpressionNode *ast)
{
ExprResult r;
if (ast) {
return r;
}
-void QDeclarativeV4IRBuilder::condition(AST::ExpressionNode *ast, IR::BasicBlock *iftrue, IR::BasicBlock *iffalse)
+void QV4IRBuilder::condition(AST::ExpressionNode *ast, IR::BasicBlock *iftrue, IR::BasicBlock *iffalse)
{
if (! ast)
return;
}
}
-QDeclarativeV4IRBuilder::ExprResult
-QDeclarativeV4IRBuilder::statement(AST::Statement *ast)
+QV4IRBuilder::ExprResult
+QV4IRBuilder::statement(AST::Statement *ast)
{
ExprResult r;
if (ast) {
return r;
}
-void QDeclarativeV4IRBuilder::sourceElement(AST::SourceElement *ast)
+void QV4IRBuilder::sourceElement(AST::SourceElement *ast)
{
accept(ast);
}
-void QDeclarativeV4IRBuilder::implicitCvt(ExprResult &expr, IR::Type type)
+void QV4IRBuilder::implicitCvt(ExprResult &expr, IR::Type type)
{
if (expr.type() == type)
return; // nothing to do
}
// QML
-bool QDeclarativeV4IRBuilder::visit(AST::UiProgram *)
+bool QV4IRBuilder::visit(AST::UiProgram *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiImportList *)
+bool QV4IRBuilder::visit(AST::UiImportList *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiImport *)
+bool QV4IRBuilder::visit(AST::UiImport *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiPublicMember *)
+bool QV4IRBuilder::visit(AST::UiPublicMember *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiSourceElement *)
+bool QV4IRBuilder::visit(AST::UiSourceElement *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiObjectDefinition *)
+bool QV4IRBuilder::visit(AST::UiObjectDefinition *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiObjectInitializer *)
+bool QV4IRBuilder::visit(AST::UiObjectInitializer *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiObjectBinding *)
+bool QV4IRBuilder::visit(AST::UiObjectBinding *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiScriptBinding *)
+bool QV4IRBuilder::visit(AST::UiScriptBinding *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiArrayBinding *)
+bool QV4IRBuilder::visit(AST::UiArrayBinding *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiObjectMemberList *)
+bool QV4IRBuilder::visit(AST::UiObjectMemberList *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiArrayMemberList *)
+bool QV4IRBuilder::visit(AST::UiArrayMemberList *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiQualifiedId *)
+bool QV4IRBuilder::visit(AST::UiQualifiedId *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiSignature *)
+bool QV4IRBuilder::visit(AST::UiSignature *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiFormalList *)
+bool QV4IRBuilder::visit(AST::UiFormalList *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UiFormal *)
+bool QV4IRBuilder::visit(AST::UiFormal *)
{
Q_ASSERT(!"unreachable");
return false;
// JS
-bool QDeclarativeV4IRBuilder::visit(AST::Program *)
+bool QV4IRBuilder::visit(AST::Program *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::SourceElements *)
+bool QV4IRBuilder::visit(AST::SourceElements *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::FunctionSourceElement *)
+bool QV4IRBuilder::visit(AST::FunctionSourceElement *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::StatementSourceElement *)
+bool QV4IRBuilder::visit(AST::StatementSourceElement *)
{
Q_ASSERT(!"unreachable");
return false;
}
// object literals
-bool QDeclarativeV4IRBuilder::visit(AST::PropertyNameAndValueList *)
+bool QV4IRBuilder::visit(AST::PropertyNameAndValueList *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::IdentifierPropertyName *)
+bool QV4IRBuilder::visit(AST::IdentifierPropertyName *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::StringLiteralPropertyName *)
+bool QV4IRBuilder::visit(AST::StringLiteralPropertyName *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::NumericLiteralPropertyName *)
+bool QV4IRBuilder::visit(AST::NumericLiteralPropertyName *)
{
Q_ASSERT(!"unreachable");
return false;
// array literals
-bool QDeclarativeV4IRBuilder::visit(AST::ElementList *)
+bool QV4IRBuilder::visit(AST::ElementList *)
{
Q_ASSERT(!"unreachable");
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::Elision *)
+bool QV4IRBuilder::visit(AST::Elision *)
{
Q_ASSERT(!"unreachable");
return false;
// function calls
-bool QDeclarativeV4IRBuilder::visit(AST::ArgumentList *)
+bool QV4IRBuilder::visit(AST::ArgumentList *)
{
Q_ASSERT(!"unreachable");
return false;
}
// expressions
-bool QDeclarativeV4IRBuilder::visit(AST::ObjectLiteral *)
+bool QV4IRBuilder::visit(AST::ObjectLiteral *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::ArrayLiteral *)
+bool QV4IRBuilder::visit(AST::ArrayLiteral *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::ThisExpression *)
+bool QV4IRBuilder::visit(AST::ThisExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::IdentifierExpression *ast)
+bool QV4IRBuilder::visit(AST::IdentifierExpression *ast)
{
const quint32 line = ast->identifierToken.startLine;
const quint32 column = ast->identifierToken.startColumn;
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::NullExpression *)
+bool QV4IRBuilder::visit(AST::NullExpression *)
{
// ### TODO: cx format
_expr.code = _block->CONST(IR::NullType, 0);
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::TrueLiteral *)
+bool QV4IRBuilder::visit(AST::TrueLiteral *)
{
// ### TODO: cx format
_expr.code = _block->CONST(IR::BoolType, 1);
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::FalseLiteral *)
+bool QV4IRBuilder::visit(AST::FalseLiteral *)
{
// ### TODO: cx format
_expr.code = _block->CONST(IR::BoolType, 0);
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::StringLiteral *ast)
+bool QV4IRBuilder::visit(AST::StringLiteral *ast)
{
// ### TODO: cx format
_expr.code = _block->STRING(ast->value);
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::NumericLiteral *ast)
+bool QV4IRBuilder::visit(AST::NumericLiteral *ast)
{
if (_expr.hint == ExprResult::cx) {
_expr.format = ExprResult::cx;
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::RegExpLiteral *)
+bool QV4IRBuilder::visit(AST::RegExpLiteral *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::NestedExpression *)
+bool QV4IRBuilder::visit(AST::NestedExpression *)
{
return true; // the value of the nested expression
}
-bool QDeclarativeV4IRBuilder::visit(AST::ArrayMemberExpression *)
+bool QV4IRBuilder::visit(AST::ArrayMemberExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::FieldMemberExpression *ast)
+bool QV4IRBuilder::visit(AST::FieldMemberExpression *ast)
{
if (IR::Expr *left = expression(ast->base)) {
if (IR::Name *baseName = left->asName()) {
return false;
}
-bool QDeclarativeV4IRBuilder::preVisit(AST::Node *)
+bool QV4IRBuilder::preVisit(AST::Node *)
{
return ! _discard;
}
-bool QDeclarativeV4IRBuilder::visit(AST::NewMemberExpression *)
+bool QV4IRBuilder::visit(AST::NewMemberExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::NewExpression *)
+bool QV4IRBuilder::visit(AST::NewExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::CallExpression *ast)
+bool QV4IRBuilder::visit(AST::CallExpression *ast)
{
QList<QStringRef> names;
QList<AST::ExpressionNode *> nameNodes;
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::PostIncrementExpression *)
+bool QV4IRBuilder::visit(AST::PostIncrementExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::PostDecrementExpression *)
+bool QV4IRBuilder::visit(AST::PostDecrementExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::DeleteExpression *)
+bool QV4IRBuilder::visit(AST::DeleteExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::VoidExpression *)
+bool QV4IRBuilder::visit(AST::VoidExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::TypeOfExpression *)
+bool QV4IRBuilder::visit(AST::TypeOfExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::PreIncrementExpression *)
+bool QV4IRBuilder::visit(AST::PreIncrementExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::PreDecrementExpression *)
+bool QV4IRBuilder::visit(AST::PreDecrementExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UnaryPlusExpression *ast)
+bool QV4IRBuilder::visit(AST::UnaryPlusExpression *ast)
{
ExprResult expr = expression(ast->expression);
if (expr.isNot(IR::InvalidType)) {
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::UnaryMinusExpression *ast)
+bool QV4IRBuilder::visit(AST::UnaryMinusExpression *ast)
{
ExprResult expr = expression(ast->expression);
if (expr.isNot(IR::InvalidType)) {
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::TildeExpression *ast)
+bool QV4IRBuilder::visit(AST::TildeExpression *ast)
{
ExprResult expr = expression(ast->expression);
if (expr.isNot(IR::InvalidType)) {
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::NotExpression *ast)
+bool QV4IRBuilder::visit(AST::NotExpression *ast)
{
ExprResult expr = expression(ast->expression);
return false;
}
-void QDeclarativeV4IRBuilder::binop(AST::BinaryExpression *ast, ExprResult left, ExprResult right)
+void QV4IRBuilder::binop(AST::BinaryExpression *ast, ExprResult left, ExprResult right)
{
if (IR::Type t = maxType(left.type(), right.type())) {
implicitCvt(left, t);
}
}
-bool QDeclarativeV4IRBuilder::visit(AST::BinaryExpression *ast)
+bool QV4IRBuilder::visit(AST::BinaryExpression *ast)
{
switch (ast->op) {
case QSOperator::And: {
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::ConditionalExpression *ast)
+bool QV4IRBuilder::visit(AST::ConditionalExpression *ast)
{
IR::BasicBlock *iftrue = _function->newBasicBlock();
IR::BasicBlock *iffalse = _function->newBasicBlock();
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::Expression *ast)
+bool QV4IRBuilder::visit(AST::Expression *ast)
{
_block->EXP(expression(ast->left));
_expr = expression(ast->right);
// statements
-bool QDeclarativeV4IRBuilder::visit(AST::Block *ast)
+bool QV4IRBuilder::visit(AST::Block *ast)
{
if (ast->statements && ! ast->statements->next) {
// we have one and only one statement
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::StatementList *)
+bool QV4IRBuilder::visit(AST::StatementList *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::VariableStatement *)
+bool QV4IRBuilder::visit(AST::VariableStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::VariableDeclarationList *)
+bool QV4IRBuilder::visit(AST::VariableDeclarationList *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::VariableDeclaration *)
+bool QV4IRBuilder::visit(AST::VariableDeclaration *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::EmptyStatement *)
+bool QV4IRBuilder::visit(AST::EmptyStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::ExpressionStatement *ast)
+bool QV4IRBuilder::visit(AST::ExpressionStatement *ast)
{
if (ast->expression) {
// return the value of this expression
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::IfStatement *ast)
+bool QV4IRBuilder::visit(AST::IfStatement *ast)
{
if (! ast->ko) {
// This is an if statement without an else branch.
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::DoWhileStatement *)
+bool QV4IRBuilder::visit(AST::DoWhileStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::WhileStatement *)
+bool QV4IRBuilder::visit(AST::WhileStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::ForStatement *)
+bool QV4IRBuilder::visit(AST::ForStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::LocalForStatement *)
+bool QV4IRBuilder::visit(AST::LocalForStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::ForEachStatement *)
+bool QV4IRBuilder::visit(AST::ForEachStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::LocalForEachStatement *)
+bool QV4IRBuilder::visit(AST::LocalForEachStatement *)
{
discard();
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::ContinueStatement *)
+bool QV4IRBuilder::visit(AST::ContinueStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::BreakStatement *)
+bool QV4IRBuilder::visit(AST::BreakStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::ReturnStatement *ast)
+bool QV4IRBuilder::visit(AST::ReturnStatement *ast)
{
if (ast->expression) {
// return the value of the expression
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::WithStatement *)
+bool QV4IRBuilder::visit(AST::WithStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::SwitchStatement *)
+bool QV4IRBuilder::visit(AST::SwitchStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::CaseBlock *)
+bool QV4IRBuilder::visit(AST::CaseBlock *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::CaseClauses *)
+bool QV4IRBuilder::visit(AST::CaseClauses *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::CaseClause *)
+bool QV4IRBuilder::visit(AST::CaseClause *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::DefaultClause *)
+bool QV4IRBuilder::visit(AST::DefaultClause *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::LabelledStatement *)
+bool QV4IRBuilder::visit(AST::LabelledStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::ThrowStatement *)
+bool QV4IRBuilder::visit(AST::ThrowStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::TryStatement *)
+bool QV4IRBuilder::visit(AST::TryStatement *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::Catch *)
+bool QV4IRBuilder::visit(AST::Catch *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::Finally *)
+bool QV4IRBuilder::visit(AST::Finally *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::FunctionDeclaration *)
+bool QV4IRBuilder::visit(AST::FunctionDeclaration *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::FunctionExpression *)
+bool QV4IRBuilder::visit(AST::FunctionExpression *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::FormalParameterList *)
+bool QV4IRBuilder::visit(AST::FormalParameterList *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::FunctionBody *)
+bool QV4IRBuilder::visit(AST::FunctionBody *)
{
return false;
}
-bool QDeclarativeV4IRBuilder::visit(AST::DebuggerStatement *)
+bool QV4IRBuilder::visit(AST::DebuggerStatement *)
{
return false;
}
**
****************************************************************************/
-#ifndef QDECLARATIVEV4IRBUILDER_P_H
-#define QDECLARATIVEV4IRBUILDER_P_H
+#ifndef QV4IRBUILDER_P_H
+#define QV4IRBUILDER_P_H
#include <QtCore/qglobal.h>
-#include "qdeclarativev4ir_p.h"
+#include "qv4ir_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
-class QDeclarativeV4IRBuilder : public QDeclarativeJS::AST::Visitor
+class QV4IRBuilder : public QDeclarativeJS::AST::Visitor
{
public:
- QDeclarativeV4IRBuilder(const QDeclarativeV4Compiler::Expression *, QDeclarativeEnginePrivate *);
+ QV4IRBuilder(const QV4Compiler::Expression *, QDeclarativeEnginePrivate *);
bool operator()(QDeclarativeJS::IR::Function *, QDeclarativeJS::AST::Node *);
QList<QDeclarativeJS::AST::ExpressionNode *> *nodes);
void discard();
- const QDeclarativeV4Compiler::Expression *m_expression;
+ const QV4Compiler::Expression *m_expression;
QDeclarativeEnginePrivate *m_engine;
QDeclarativeJS::IR::Function *_function;
QT_END_HEADER
-#endif // QDECLARATIVEV4IRBUILDER_P_H
+#endif // QV4IRBUILDER_P_H
**
****************************************************************************/
-#ifndef QDECLARATIVEV4PROGRAM_P_H
-#define QDECLARATIVEV4PROGRAM_P_H
+#ifndef QV4PROGRAM_P_H
+#define QV4PROGRAM_P_H
//
// W A R N I N G
// We mean it.
//
-#include "qdeclarativev4instruction_p.h"
+#include "qv4instruction_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
-struct QDeclarativeV4Program {
+struct QV4Program {
quint32 bindings;
quint32 dataLength;
quint32 signalTableOffset;
QVariantType,
};
-const char *QDeclarativeV4Program::data() const
+const char *QV4Program::data() const
{
- return ((const char *)this) + sizeof(QDeclarativeV4Program);
+ return ((const char *)this) + sizeof(QV4Program);
}
-const char *QDeclarativeV4Program::instructions() const
+const char *QV4Program::instructions() const
{
return (const char *)(data() + dataLength);
}
-QDeclarativeV4Program::BindingReferenceList *QDeclarativeV4Program::signalTable(int signalIndex) const
+QV4Program::BindingReferenceList *QV4Program::signalTable(int signalIndex) const
{
quint32 *signalTable = (quint32 *)(data() + signalTableOffset);
return (BindingReferenceList *)(signalTable + signalTable[signalIndex]);
QT_END_HEADER
-#endif // QDECLARATIVEV4PROGRAM_P_H
+#endif // QV4PROGRAM_P_H
INCLUDEPATH += $$PWD
HEADERS += \
- $$PWD/qdeclarativev4compiler_p.h \
- $$PWD/qdeclarativev4compiler_p_p.h \
- $$PWD/qdeclarativev4ir_p.h \
- $$PWD/qdeclarativev4irbuilder_p.h \
- $$PWD/qdeclarativev4instruction_p.h \
- $$PWD/qdeclarativev4bindings_p.h \
- $$PWD/qdeclarativev4program_p.h \
+ $$PWD/qv4compiler_p.h \
+ $$PWD/qv4compiler_p_p.h \
+ $$PWD/qv4ir_p.h \
+ $$PWD/qv4irbuilder_p.h \
+ $$PWD/qv4instruction_p.h \
+ $$PWD/qv4bindings_p.h \
+ $$PWD/qv4program_p.h \
SOURCES += \
- $$PWD/qdeclarativev4compiler.cpp \
- $$PWD/qdeclarativev4ir.cpp \
- $$PWD/qdeclarativev4irbuilder.cpp \
- $$PWD/qdeclarativev4instruction.cpp \
- $$PWD/qdeclarativev4bindings.cpp \
+ $$PWD/qv4compiler.cpp \
+ $$PWD/qv4ir.cpp \
+ $$PWD/qv4irbuilder.cpp \
+ $$PWD/qv4instruction.cpp \
+ $$PWD/qv4bindings.cpp \
#include "private/qdeclarativeexpression_p.h"
#include "private/qdeclarativebinding_p.h"
-#include "private/qdeclarativev4instruction_p.h"
QT_BEGIN_HEADER
qdeclarativeworkerscript \
qdeclarativexmllistmodel \
qpacketprotocol \
- qdeclarativev4
+ v4
SGTESTS = \
qsganimatedimage \
#include <QtDeclarative/qdeclarativecomponent.h>
#include <QtCore/qdebug.h>
-#include <private/qdeclarativev4compiler_p.h>
+#include <private/qv4compiler_p.h>
#include "testtypes.h"
return TEST_FILE(QLatin1String(filename));
}
-class tst_qdeclarativev4 : public QObject
+class tst_v4 : public QObject
{
Q_OBJECT
public:
- tst_qdeclarativev4() {}
+ tst_v4() {}
private slots:
void initTestCase();
QDeclarativeEngine engine;
};
-void tst_qdeclarativev4::initTestCase()
+void tst_v4::initTestCase()
{
registerTypes();
}
static void v4ErrorsMsgHandler(QtMsgType, const char *message)
{
QByteArray m(message);
- if (m.contains("QDeclarativeV4"))
+ if (m.contains("QV4"))
v4ErrorsMsgCount++;
}
-void tst_qdeclarativev4::qtscript()
+void tst_v4::qtscript()
{
QFETCH(QString, file);
- QDeclarativeV4Compiler::enableBindingsTest(true);
+ QV4Compiler::enableBindingsTest(true);
QDeclarativeComponent component(&engine, TEST_FILE(file));
QCOMPARE(v4ErrorsMsgCount, 0);
- QDeclarativeV4Compiler::enableBindingsTest(false);
+ QV4Compiler::enableBindingsTest(false);
}
-void tst_qdeclarativev4::qtscript_data()
+void tst_v4::qtscript_data()
{
QTest::addColumn<QString>("file");
QTest::newRow("null qobject") << "nullQObject.qml";
}
-void tst_qdeclarativev4::unnecessaryReeval()
+void tst_v4::unnecessaryReeval()
{
QDeclarativeComponent component(&engine, TEST_FILE("unnecessaryReeval.qml"));
delete o;
}
-void tst_qdeclarativev4::logicalOr()
+void tst_v4::logicalOr()
{
{
QDeclarativeComponent component(&engine, TEST_FILE("logicalOr.qml"));
}
}
-void tst_qdeclarativev4::conditionalExpr()
+void tst_v4::conditionalExpr()
{
{
QDeclarativeComponent component(&engine, TEST_FILE("conditionalExpr.qml"));
// This would previously use the metaObject of the root element to result the nested access.
// That is, the index for accessing "result" would have been RootObject::result, instead of
// NestedObject::result.
-void tst_qdeclarativev4::nestedObjectAccess()
+void tst_v4::nestedObjectAccess()
{
QDeclarativeComponent component(&engine, TEST_FILE("nestedObjectAccess.qml"));
delete o;
}
-void tst_qdeclarativev4::subscriptionsInConditionalExpressions()
+void tst_v4::subscriptionsInConditionalExpressions()
{
QDeclarativeComponent component(&engine, TEST_FILE("subscriptionsInConditionalExpressions.qml"));
delete o;
}
-QTEST_MAIN(tst_qdeclarativev4)
+QTEST_MAIN(tst_v4)
-#include "tst_qdeclarativev4.moc"
+#include "tst_v4.moc"
TARGET = tst_qdeclarativev4
macx:CONFIG -= app_bundle
-SOURCES += tst_qdeclarativev4.cpp \
+SOURCES += tst_v4.cpp \
testtypes.cpp
HEADERS += testtypes.h