QDeclarativeBindingCompilerPrivate Struct Reference

Classes
struct	Result

Public Functions
int	acquireReg (int cleanup=Instr::Noop, int cleanupType=0)
QByteArray	buildExceptionData () const
bool	buildName (QStringList &, QDeclarativeJS::AST::Node *, QList< QDeclarativeJS::AST::ExpressionNode *> *nodes=0)
QByteArray	buildSignalTable () const
int	commitCompile ()
	Mark the last compile as successful, and add it to the "committed data" section. More...
bool	compile (QDeclarativeJS::AST::Node *)
QString	contextName () const
quint8	exceptionId (QDeclarativeJS::AST::ExpressionNode *)
bool	fetch (Result &type, const QMetaObject *, int reg, int idx, const QStringList &, QDeclarativeJS::AST::ExpressionNode *)
bool	numberArith (Result &, const Result &, const Result &, QSOperator::Op op)
bool	parseArith (QDeclarativeJS::AST::Node *, Result &)
bool	parseConditional (QDeclarativeJS::AST::Node *, Result &)
bool	parseConstant (QDeclarativeJS::AST::Node *, Result &)
bool	parseExpression (QDeclarativeJS::AST::Node *, Result &)
bool	parseLogic (QDeclarativeJS::AST::Node *, Result &)
bool	parseMethod (QDeclarativeJS::AST::Node *, Result &)
bool	parseName (QDeclarativeJS::AST::Node *, Result &)
	QDeclarativeBindingCompilerPrivate ()
void	registerCleanup (int reg, int cleanup, int cleanupType=0)
int	registerLiteralString (const QString &)
int	registerString (const QString &)
void	releaseReg (int)
void	resetInstanceState ()
	Clear the state associated with attempting to compile a specific binding. More...
bool	stringArith (Result &, const Result &, const Result &, QSOperator::Op op)
bool	subscription (const QStringList &, Result *)
int	subscriptionIndex (const QStringList &)
bool	subscriptionNeutral (const QSet< QString > &base, const QSet< QString > &lhs, const QSet< QString > &rhs)
bool	tryArith (QDeclarativeJS::AST::Node *)
bool	tryConditional (QDeclarativeJS::AST::Node *)
bool	tryConstant (QDeclarativeJS::AST::Node *)
bool	tryLogic (QDeclarativeJS::AST::Node *)
bool	tryMethod (QDeclarativeJS::AST::Node *)
bool	tryName (QDeclarativeJS::AST::Node *)

Public Variables
QVector< Instr >	bytecode
struct {
QVector< Instr >   bytecode
QByteArray   data
QList< QSet< int > >   dependencies
QVector< quint64 >   exceptions
QList< int >   offsets
QHash< QString, QPair< int, int > >   registeredStrings
QHash< QString, int >   subscriptionIds
}	committed
QDeclarativeParser::Object *	component
QDeclarativeParser::Object *	context
QByteArray	data
QDeclarativeParser::Property *	destination
QDeclarativeEnginePrivate *	engine
QVector< quint64 >	exceptions
QHash< QString, QDeclarativeParser::Object * >	ids
QDeclarativeImports	imports
QHash< int, QPair< int, int > >	registerCleanups
QHash< QString, QPair< int, int > >	registeredStrings
quint32	registers
QHash< QString, int >	subscriptionIds
QSet< QString >	subscriptionSet
QSet< int >	usedSubscriptionIds

Detailed Description

Definition at line 610 of file qdeclarativecompiledbindings.cpp.

Constructors and Destructors

QDeclarativeBindingCompilerPrivate()

QDeclarativeBindingCompilerPrivate::QDeclarativeBindingCompilerPrivate ( )

inline

Definition at line 631 of file qdeclarativecompiledbindings.cpp.

: registers(0) {}

Functions

acquireReg()

int QDeclarativeBindingCompilerPrivate::acquireReg	(	int	cleanup = Instr::Noop,
		int	cleanupType = 0
	)

Definition at line 2702 of file qdeclarativecompiledbindings.cpp.

{
    for (int ii = 0; ii < 32; ++ii) {
        if (!(registers & (1 << ii))) {
            registers |= (1 << ii);

            if (cleanup != Instr::Noop)
                registerCleanup(ii, cleanup, cleanupType);

            return ii;
        }
    }
    return -1;
}

buildExceptionData()

QByteArray QDeclarativeBindingCompilerPrivate::buildExceptionData

(

)

const

Definition at line 2907 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::program().

{
    QByteArray rv;
    rv.resize(committed.exceptions.count() * sizeof(quint64));
    ::memcpy(rv.data(), committed.exceptions.constData(), rv.size());
    return rv;
}

buildName()

bool QDeclarativeBindingCompilerPrivate::buildName	(	QStringList &	name,
		QDeclarativeJS::AST::Node *	node,
		QList< QDeclarativeJS::AST::ExpressionNode *> *	nodes = 0
	)

Definition at line 2595 of file qdeclarativecompiledbindings.cpp.

{
    if (node->kind == AST::Node::Kind_IdentifierExpression) {
        name << static_cast<AST::IdentifierExpression*>(node)->name->asString();
        if (nodes) *nodes << static_cast<AST::IdentifierExpression*>(node);
    } else if (node->kind == AST::Node::Kind_FieldMemberExpression) {
        AST::FieldMemberExpression *expr =
            static_cast<AST::FieldMemberExpression *>(node);

        if (!buildName(name, expr->base, nodes))
            return false;

        name << expr->name->asString();
        if (nodes) *nodes << expr;
    } else {
        return false;
    }

    return true;
}

buildSignalTable()

QByteArray QDeclarativeBindingCompilerPrivate::buildSignalTable

(

)

const

Definition at line 2883 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::program().

{
    QHash<int, QList<int> > table;

    for (int ii = 0; ii < committed.count(); ++ii) {
        const QSet<int> &deps = committed.dependencies.at(ii);
        for (QSet<int>::ConstIterator iter = deps.begin(); iter != deps.end(); ++iter) 
            table[*iter].append(ii);
    }

    QVector<quint32> header;
    QVector<quint32> data;
    for (int ii = 0; ii < committed.subscriptionIds.count(); ++ii) {
        header.append(committed.subscriptionIds.count() + data.count());
        const QList<int> &bindings = table[ii];
        data.append(bindings.count());
        for (int jj = 0; jj < bindings.count(); ++jj)
            data.append(bindings.at(jj));
    }
    header << data;

    return QByteArray((const char *)header.constData(), header.count() * sizeof(quint32));
}

commitCompile()

int QDeclarativeBindingCompilerPrivate::commitCompile

(

)

Mark the last compile as successful, and add it to the "committed data" section.

Returns the index for the committed binding.

Definition at line 1737 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::compile().

{
    int rv = committed.count();
    committed.offsets << committed.bytecode.count();
    committed.dependencies << usedSubscriptionIds;
    committed.bytecode << bytecode;
    committed.data = data;
    committed.exceptions = exceptions;
    committed.subscriptionIds = subscriptionIds;
    committed.registeredStrings = registeredStrings;
    return rv;
}

compile()

bool QDeclarativeBindingCompilerPrivate::compile

(

QDeclarativeJS::AST::Node *

node

)

Definition at line 1750 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::compile().

{
    resetInstanceState();

    if (destination->type == -1)
        return false;

    if (bindingsDump()) {
        QDeclarativeJS::AST::ExpressionNode *n = node->expressionCast();
        if (n) {
            Instr id;
            id.common.type = Instr::BindingId;
            id.id.column = n->firstSourceLocation().startColumn;
            id.id.line = n->firstSourceLocation().startLine;
            bytecode << id;
        }
    }

    Result type;

    if (!parseExpression(node, type)) 
        return false;

    if (subscriptionSet.count() > 0xFFFF ||
            registeredStrings.count() > 0xFFFF)
        return false;

    if (type.unknownType) {
        if (!qmlExperimental())
            return false;

        if (destination->type != QMetaType::QReal &&
            destination->type != QVariant::String &&
            destination->type != QMetaType::Bool &&
            destination->type != QVariant::Url)
            return false;

        int convertReg = acquireReg();
        if (convertReg == -1)
            return false;

        if (destination->type == QMetaType::QReal) {
            Instr convert;
            convert.common.type = Instr::ConvertGenericToReal;
            convert.unaryop.output = convertReg;
            convert.unaryop.src = type.reg;
            bytecode << convert;
        } else if (destination->type == QVariant::String) {
            Instr convert;
            convert.common.type = Instr::ConvertGenericToString;
            convert.unaryop.output = convertReg;
            convert.unaryop.src = type.reg;
            bytecode << convert;
        } else if (destination->type == QMetaType::Bool) {
            Instr convert;
            convert.common.type = Instr::ConvertGenericToBool;
            convert.unaryop.output = convertReg;
            convert.unaryop.src = type.reg;
            bytecode << convert;
        } else if (destination->type == QVariant::Url) {
            Instr convert;
            convert.common.type = Instr::ConvertGenericToUrl;
            convert.unaryop.output = convertReg;
            convert.unaryop.src = type.reg;
            bytecode << convert;
        }

        Instr cleanup;
        cleanup.common.type = Instr::CleanupGeneric;
        cleanup.cleanup.reg = type.reg;
        bytecode << cleanup;

        Instr instr;
        instr.common.type = Instr::Store;
        instr.store.output = 0;
        instr.store.index = destination->index;
        instr.store.reg = convertReg;
        instr.store.exceptionId = exceptionId(node->expressionCast());
        bytecode << instr;

        if (destination->type == QVariant::String) {
            Instr cleanup;
            cleanup.common.type = Instr::CleanupString;
            cleanup.cleanup.reg = convertReg;
            bytecode << cleanup;
        } else if (destination->type == QVariant::Url) {
            Instr cleanup;
            cleanup.common.type = Instr::CleanupUrl;
            cleanup.cleanup.reg = convertReg;
            bytecode << cleanup;
        }

        releaseReg(convertReg);

        Instr done;
        done.common.type = Instr::Done;
        bytecode << done;

    } else {
        // Can we store the final value?
        if (type.type == QVariant::Int &&
            destination->type == QMetaType::QReal) {
            Instr instr;
            instr.common.type = Instr::ConvertIntToReal;
            instr.unaryop.output = type.reg;
            instr.unaryop.src = type.reg;
            bytecode << instr;
            type.type = QMetaType::QReal;
        } else if (type.type == QMetaType::QReal &&
                   destination->type == QVariant::Int) {
            Instr instr;
            instr.common.type = Instr::ConvertRealToInt;
            instr.unaryop.output = type.reg;
            instr.unaryop.src = type.reg;
            bytecode << instr;
            type.type = QVariant::Int;
        } else if (type.type == destination->type) {
        } else {
            const QMetaObject *from = type.metaObject;
            const QMetaObject *to = engine->rawMetaObjectForType(destination->type);

            if (QDeclarativePropertyPrivate::canConvert(from, to))
                type.type = destination->type;
        }

        if (type.type == destination->type) {
            Instr instr;
            instr.common.type = Instr::Store;
            instr.store.output = 0;
            instr.store.index = destination->index;
            instr.store.reg = type.reg;
            instr.store.exceptionId = exceptionId(node->expressionCast());
            bytecode << instr;

            releaseReg(type.reg);

            Instr done;
            done.common.type = Instr::Done;
            bytecode << done;
        } else {
            return false;
        }
    }

    return true;
}

contextName()

QString QDeclarativeBindingCompilerPrivate::contextName ( ) const

inline

Definition at line 643 of file qdeclarativecompiledbindings.cpp.

{ return QLatin1String("$$$SCOPE_") + QString::number((quintptr)context, 16); }

exceptionId()

quint8 QDeclarativeBindingCompilerPrivate::exceptionId

(

QDeclarativeJS::AST::ExpressionNode *

n

)

Definition at line 2823 of file qdeclarativecompiledbindings.cpp.

{
    quint8 rv = 0xFF;
    if (n && exceptions.count() < 0xFF) {
        rv = (quint8)exceptions.count();
        QDeclarativeJS::AST::SourceLocation l = n->firstSourceLocation();
        quint64 e = l.startLine;
        e <<= 32;
        e |= l.startColumn;
        exceptions.append(e);
    }
    return rv;
}

fetch()

bool QDeclarativeBindingCompilerPrivate::fetch	(	Result &	type,
		const QMetaObject *	mo,
		int	reg,
		int	idx,
		const QStringList &	subName,
		QDeclarativeJS::AST::ExpressionNode *	node
	)

Definition at line 2618 of file qdeclarativecompiledbindings.cpp.

{
    QMetaProperty prop = mo->property(idx);
    rv.metaObject = 0;
    rv.type = 0;

    //XXX binding optimizer doesn't handle properties with a revision
    if (prop.revision() > 0)
        return false;

    int fastFetchIndex = fastProperties()->accessorIndexForProperty(mo, idx);

    Instr fetch;

    if (!qmlDisableFastProperties() && fastFetchIndex != -1) {
        fetch.common.type = Instr::FetchAndSubscribe;
        fetch.fetchAndSubscribe.objectReg = reg;
        fetch.fetchAndSubscribe.output = reg;
        fetch.fetchAndSubscribe.function = fastFetchIndex;
        fetch.fetchAndSubscribe.subscription = subscriptionIndex(subName);
        fetch.fetchAndSubscribe.exceptionId = exceptionId(node);
    } else {
        if (subscription(subName, &rv) && prop.hasNotifySignal() && prop.notifySignalIndex() != -1) {
            Instr sub;
            sub.common.type = Instr::Subscribe;
            sub.subscribe.offset = subscriptionIndex(subName);
            sub.subscribe.reg = reg;
            sub.subscribe.index = prop.notifySignalIndex();
            bytecode << sub;
        }

        fetch.common.type = Instr::Fetch;
        fetch.fetch.objectReg = reg;
        fetch.fetch.index = idx;
        fetch.fetch.output = reg;
        fetch.fetch.exceptionId = exceptionId(node);
    }

    rv.type = prop.userType();
    rv.metaObject = engine->metaObjectForType(rv.type);
    rv.reg = reg;

    if (rv.type == QMetaType::QString) {
        int tmp = acquireReg();
        if (tmp == -1)
            return false;
        Instr copy;
        copy.common.type = Instr::Copy;
        copy.copy.reg = tmp;
        copy.copy.src = reg;
        bytecode << copy;
        releaseReg(tmp);
        fetch.fetch.objectReg = tmp;

        Instr setup;
        setup.common.type = Instr::NewString;
        setup.construct.reg = reg;
        bytecode << setup;
        registerCleanup(reg, Instr::CleanupString);
    }

    bytecode << fetch;

    if (!rv.metaObject &&
        rv.type != QMetaType::QReal &&
        rv.type != QMetaType::Int &&
        rv.type != QMetaType::Bool &&
        rv.type != qMetaTypeId<QDeclarativeAnchorLine>() &&
        rv.type != QMetaType::QString) {
        rv.metaObject = 0;
        rv.type = 0;
        return false; // Unsupported type (string not supported yet);
    }

    return true;
}

numberArith()

bool QDeclarativeBindingCompilerPrivate::numberArith	(	Result &	type,
		const Result &	lhs,
		const Result &	rhs,
		QSOperator::Op	op
	)

Definition at line 2198 of file qdeclarativecompiledbindings.cpp.

{
    bool nativeReal = rhs.type == QMetaType::QReal ||
                      lhs.type == QMetaType::QReal ||
                      lhs.unknownType ||
                      rhs.unknownType;

    if (nativeReal && lhs.type == QMetaType::Int) {
        Instr convert;
        convert.common.type = Instr::ConvertIntToReal;
        convert.unaryop.output = lhs.reg;
        convert.unaryop.src = lhs.reg;
        bytecode << convert;
    }

    if (nativeReal && rhs.type == QMetaType::Int) {
        Instr convert;
        convert.common.type = Instr::ConvertIntToReal;
        convert.unaryop.output = rhs.reg;
        convert.unaryop.src = rhs.reg;
        bytecode << convert;
    }

    int lhsTmp = -1;
    int rhsTmp = -1;

    if (lhs.unknownType) {
        if (!qmlExperimental())
            return false;

        lhsTmp = acquireReg();
        if (lhsTmp == -1)
            return false;

        Instr conv;
        conv.common.type = Instr::ConvertGenericToReal;
        conv.unaryop.output = lhsTmp;
        conv.unaryop.src = lhs.reg;
        bytecode << conv;
    }

    if (rhs.unknownType) {
        if (!qmlExperimental())
            return false;

        rhsTmp = acquireReg();
        if (rhsTmp == -1)
            return false;

        Instr conv;
        conv.common.type = Instr::ConvertGenericToReal;
        conv.unaryop.output = rhsTmp;
        conv.unaryop.src = rhs.reg;
        bytecode << conv;
    }

    Instr arith;
    if (op == QSOperator::Add) {
        arith.common.type = nativeReal?Instr::AddReal:Instr::AddInt;
    } else if (op == QSOperator::Sub) {
        arith.common.type = nativeReal?Instr::MinusReal:Instr::MinusInt;
    } else {
        qFatal("Unsupported arithmetic operator");
    }

    arith.binaryop.output = type.reg;
    arith.binaryop.src1 = (lhsTmp == -1)?lhs.reg:lhsTmp;
    arith.binaryop.src2 = (rhsTmp == -1)?rhs.reg:rhsTmp;
    bytecode << arith;

    type.metaObject = 0;
    type.type = nativeReal?QMetaType::QReal:QMetaType::Int;
    type.subscriptionSet.unite(lhs.subscriptionSet);
    type.subscriptionSet.unite(rhs.subscriptionSet);

    if (lhsTmp != -1) releaseReg(lhsTmp);
    if (rhsTmp != -1) releaseReg(rhsTmp);
    releaseReg(lhs.reg);
    releaseReg(rhs.reg);

    return true;
}

parseArith()

bool QDeclarativeBindingCompilerPrivate::parseArith	(	QDeclarativeJS::AST::Node *	node,
		Result &	type
	)

Definition at line 2171 of file qdeclarativecompiledbindings.cpp.

{
    AST::BinaryExpression *expression = static_cast<AST::BinaryExpression *>(node);

    type.reg = acquireReg();
    if (type.reg == -1)
        return false;

    Result lhs;
    Result rhs;

    if (!parseExpression(expression->left, lhs)) return false;
    if (!parseExpression(expression->right, rhs)) return false;

    if ((lhs.type == QVariant::Int || lhs.type == QMetaType::QReal) &&
        (rhs.type == QVariant::Int || rhs.type == QMetaType::QReal))
        return numberArith(type, lhs, rhs, (QSOperator::Op)expression->op);
    else if(expression->op == QSOperator::Sub)
        return numberArith(type, lhs, rhs, (QSOperator::Op)expression->op);
    else if ((lhs.type == QMetaType::QString || lhs.unknownType) && 
             (rhs.type == QMetaType::QString || rhs.unknownType) && 
             (lhs.type == QMetaType::QString || rhs.type == QMetaType::QString))
        return stringArith(type, lhs, rhs, (QSOperator::Op)expression->op);
    else
        return false;
}

parseConditional()

bool QDeclarativeBindingCompilerPrivate::parseConditional	(	QDeclarativeJS::AST::Node *	node,
		Result &	type
	)

Definition at line 2417 of file qdeclarativecompiledbindings.cpp.

{
    AST::ConditionalExpression *expression = static_cast<AST::ConditionalExpression *>(node);

    AST::Node *test = expression->expression;
    if (test->kind == AST::Node::Kind_NestedExpression)
        test = static_cast<AST::NestedExpression*>(test)->expression;

    Result etype;
    if (!parseExpression(test, etype)) return false;

    if (etype.type != QVariant::Bool) 
        return false;

    Instr skip;
    skip.common.type = Instr::Skip;
    skip.skip.reg = etype.reg;
    skip.skip.count = 0;
    int skipIdx = bytecode.count();
    bytecode << skip;

    // Release to allow reuse of reg
    releaseReg(etype.reg);

    QSet<QString> preSubSet = subscriptionSet;

    // int preConditionalSubscriptions = subscriptionSet.count();

    Result ok;
    if (!parseExpression(expression->ok, ok)) return false;
    if (ok.unknownType) return false;

    int skipIdx2 = bytecode.count();
    skip.skip.reg = -1;
    bytecode << skip;

    // Release to allow reuse of reg in else path
    releaseReg(ok.reg);
    bytecode[skipIdx].skip.count = bytecode.count() - skipIdx - 1;

    subscriptionSet = preSubSet;

    Result ko;
    if (!parseExpression(expression->ko, ko)) return false;
    if (ko.unknownType) return false;

    // Do not release reg here, so that its ownership passes to the caller
    bytecode[skipIdx2].skip.count = bytecode.count() - skipIdx2 - 1;

    if (ok != ko)
        return false; // Must be same type and in same register

    subscriptionSet = preSubSet;

    if (!subscriptionNeutral(subscriptionSet, ok.subscriptionSet, ko.subscriptionSet))
        return false; // Conditionals cannot introduce new subscriptions

    type = ok;

    return true;
}

parseConstant()

bool QDeclarativeBindingCompilerPrivate::parseConstant	(	QDeclarativeJS::AST::Node *	node,
		Result &	type
	)

Definition at line 2487 of file qdeclarativecompiledbindings.cpp.

{
    type.metaObject = 0;
    type.type = -1;
    type.reg = acquireReg();
    if (type.reg == -1)
        return false;

    if (node->kind == AST::Node::Kind_TrueLiteral) {
        type.type = QVariant::Bool;
        Instr instr;
        instr.common.type = Instr::Bool;
        instr.bool_value.reg = type.reg;
        instr.bool_value.value = true;
        bytecode << instr;
        return true;
    } else if (node->kind == AST::Node::Kind_FalseLiteral) {
        type.type = QVariant::Bool;
        Instr instr;
        instr.common.type = Instr::Bool;
        instr.bool_value.reg = type.reg;
        instr.bool_value.value = false;
        bytecode << instr;
        return true;
    } else if (node->kind == AST::Node::Kind_NumericLiteral) {
        qreal value = qreal(static_cast<AST::NumericLiteral *>(node)->value);

        if (qreal(float(value)) != value)
            return false;

        type.type = QMetaType::QReal;
        Instr instr;
        instr.common.type = Instr::Real;
        instr.real_value.reg = type.reg;
        instr.real_value.value = float(value);
        bytecode << instr;
        return true;
    } else if (node->kind == AST::Node::Kind_StringLiteral) {
        QString str = static_cast<AST::StringLiteral *>(node)->value->asString();
        type.type = QMetaType::QString;
        type.reg = registerLiteralString(str);
        return true;
    } else {
        return false;
    }
}

parseExpression()

bool QDeclarativeBindingCompilerPrivate::parseExpression	(	QDeclarativeJS::AST::Node *	node,
		Result &	type
	)

Definition at line 1897 of file qdeclarativecompiledbindings.cpp.

{
    while (node->kind == AST::Node::Kind_NestedExpression)
        node = static_cast<AST::NestedExpression *>(node)->expression;

    if (tryArith(node)) {
        if (!parseArith(node, type)) return false;
    } else if (tryLogic(node)) {
        if (!parseLogic(node, type)) return false;
    } else if (tryConditional(node)) {
        if (!parseConditional(node, type)) return false;
    } else if (tryName(node)) {
        if (!parseName(node, type)) return false;
    } else if (tryConstant(node)) {
        if (!parseConstant(node, type)) return false;
    } else if (tryMethod(node)) {
        if (!parseMethod(node, type)) return false;
    } else {
        return false;
    }
    return true;
}

parseLogic()

bool QDeclarativeBindingCompilerPrivate::parseLogic	(	QDeclarativeJS::AST::Node *	node,
		Result &	type
	)

Definition at line 2354 of file qdeclarativecompiledbindings.cpp.

{
    AST::BinaryExpression *expression = static_cast<AST::BinaryExpression *>(node);

    Result lhs;
    Result rhs;

    if (!parseExpression(expression->left, lhs)) return false;
    if (!parseExpression(expression->right, rhs)) return false;

    type.reg = acquireReg();
    if (type.reg == -1)
        return false;

    type.metaObject = 0;
    type.type = QVariant::Bool;

    if (lhs.type == QMetaType::QReal && rhs.type == QMetaType::QReal) {

        Instr op;
        if (expression->op == QSOperator::Gt)
            op.common.type = Instr::GreaterThanReal;
        else if (expression->op == QSOperator::Equal)
            op.common.type = Instr::CompareReal;
        else if (expression->op == QSOperator::NotEqual)
            op.common.type = Instr::NotCompareReal;
        else
            return false;
        op.binaryop.output = type.reg;
        op.binaryop.src1 = lhs.reg;
        op.binaryop.src2 = rhs.reg;
        bytecode << op;


    } else if (lhs.type == QMetaType::QString && rhs.type == QMetaType::QString) {

        Instr op;
        if (expression->op == QSOperator::Equal)
            op.common.type = Instr::CompareString;
        else if (expression->op == QSOperator::NotEqual)
            op.common.type = Instr::NotCompareString;
        else
            return false;
        op.binaryop.output = type.reg;
        op.binaryop.src1 = lhs.reg;
        op.binaryop.src2 = rhs.reg;
        bytecode << op;

    } else {
        return false;
    }

    releaseReg(lhs.reg);
    releaseReg(rhs.reg);

    return true;
}

parseMethod()

bool QDeclarativeBindingCompilerPrivate::parseMethod	(	QDeclarativeJS::AST::Node *	node,
		Result &	result
	)

Definition at line 2539 of file qdeclarativecompiledbindings.cpp.

{
    AST::CallExpression *expr = static_cast<AST::CallExpression *>(node);

    QStringList name;
    if (!buildName(name, expr->base))
        return false;

    if (name.count() != 2 || name.at(0) != QLatin1String("Math"))
        return false;

    QString method = name.at(1);

    AST::ArgumentList *args = expr->arguments;
    if (!args) return false;
    AST::ExpressionNode *arg0 = args->expression;
    args = args->next;
    if (!args) return false;
    AST::ExpressionNode *arg1 = args->expression;
    if (args->next != 0) return false;
    if (!arg0 || !arg1) return false;

    Result r0;
    if (!parseExpression(arg0, r0)) return false;
    Result r1;
    if (!parseExpression(arg1, r1)) return false;

    if (r0.type != QMetaType::QReal || r1.type != QMetaType::QReal)
        return false;

    Instr op;
    if (method == QLatin1String("max")) {
        op.common.type = Instr::MaxReal;
    } else if (method == QLatin1String("min")) {
        op.common.type = Instr::MinReal;
    } else {
        return false;
    }
    // We release early to reuse registers
    releaseReg(r0.reg);
    releaseReg(r1.reg);

    op.binaryop.output = acquireReg();
    if (op.binaryop.output == -1)
        return false;

    op.binaryop.src1 = r0.reg;
    op.binaryop.src2 = r1.reg;
    bytecode << op;

    result.type = QMetaType::QReal;
    result.reg = op.binaryop.output;

    return true;
}

parseName()

bool QDeclarativeBindingCompilerPrivate::parseName	(	QDeclarativeJS::AST::Node *	node,
		Result &	type
	)

Definition at line 1926 of file qdeclarativecompiledbindings.cpp.

{
    QStringList nameParts;
    QList<AST::ExpressionNode *> nameNodes;
    if (!buildName(nameParts, node, &nameNodes))
        return false;

    int reg = acquireReg();
    if (reg == -1)
        return false;
    type.reg = reg;

    QDeclarativeParser::Object *absType = 0;

    QStringList subscribeName;

    bool wasAttachedObject = false;

    for (int ii = 0; ii < nameParts.count(); ++ii) {
        const QString &name = nameParts.at(ii);

        // We don't handle signal properties or attached properties
        if (name.length() > 2 && name.startsWith(QLatin1String("on")) &&
            name.at(2).isUpper())
            return false;

        QDeclarativeType *attachType = 0;
        if (name.at(0).isUpper()) {
            // Could be an attached property
            if (ii == nameParts.count() - 1)
                return false;
            if (nameParts.at(ii + 1).at(0).isUpper())
                return false;

            QDeclarativeImportedNamespace *ns = 0;
            if (!imports.resolveType(name.toUtf8(), &attachType, 0, 0, 0, &ns))
                return false;
            if (ns || !attachType || !attachType->attachedPropertiesType())
                return false;

            wasAttachedObject = true;
        } 

        if (ii == 0) {

            if (attachType) {
                Instr instr;
                instr.common.type = Instr::LoadScope;
                instr.load.index = 0;
                instr.load.reg = reg;
                bytecode << instr;

                Instr attach;
                attach.common.type = Instr::LoadAttached;
                attach.attached.output = reg;
                attach.attached.reg = reg;
                attach.attached.id = attachType->attachedPropertiesId();
                attach.attached.exceptionId = exceptionId(nameNodes.at(ii));
                bytecode << attach;

                subscribeName << contextName();
                subscribeName << QLatin1String("$$$ATTACH_") + name;

                absType = 0;
                type.metaObject = attachType->attachedPropertiesType();

                continue;
            } else if (ids.contains(name)) {
                QDeclarativeParser::Object *idObject = ids.value(name);
                absType = idObject;
                type.metaObject = absType->metaObject();

                // We check if the id object is the root or 
                // scope object to avoid a subscription
                if (idObject == component) {
                    Instr instr;
                    instr.common.type = Instr::LoadRoot;
                    instr.load.index = 0;
                    instr.load.reg = reg;
                    bytecode << instr;
                } else if (idObject == context) {
                    Instr instr;
                    instr.common.type = Instr::LoadScope;
                    instr.load.index = 0;
                    instr.load.reg = reg;
                    bytecode << instr;
                } else {
                    Instr instr;
                    instr.common.type = Instr::LoadId;
                    instr.load.index = idObject->idIndex;
                    instr.load.reg = reg;
                    bytecode << instr;

                    subscribeName << QLatin1String("$$$ID_") + name;

                    if (subscription(subscribeName, &type)) {
                        Instr sub;
                        sub.common.type = Instr::SubscribeId;
                        sub.subscribe.offset = subscriptionIndex(subscribeName);
                        sub.subscribe.reg = reg;
                        sub.subscribe.index = instr.load.index;
                        bytecode << sub;
                    }
                }

            } else {

                QByteArray utf8Name = name.toUtf8();
                const char *cname = utf8Name.constData();

                int d0Idx = (context == component)?-1:context->metaObject()->indexOfProperty(cname);
                int d1Idx = -1;
                if (d0Idx == -1)
                    d1Idx = component->metaObject()->indexOfProperty(cname);

                if (d0Idx != -1) {
                    Instr instr;
                    instr.common.type = Instr::LoadScope;
                    instr.load.index = 0;
                    instr.load.reg = reg;
                    bytecode << instr;

                    subscribeName << contextName();
                    subscribeName << name;

                    if (!fetch(type, context->metaObject(), reg, d0Idx, subscribeName, nameNodes.at(ii)))
                        return false;
                } else if(d1Idx != -1) {
                    Instr instr;
                    instr.common.type = Instr::LoadRoot;
                    instr.load.index = 0;
                    instr.load.reg = reg;
                    bytecode << instr;

                    subscribeName << QLatin1String("$$$ROOT");
                    subscribeName << name;

                    if (!fetch(type, component->metaObject(), reg, d1Idx, subscribeName, nameNodes.at(ii)))
                        return false;
                } else if (qmlExperimental()) {
                    Instr find;
                    if (nameParts.count() == 1)
                        find.common.type = Instr::FindGenericTerminal;
                    else
                        find.common.type = Instr::FindGeneric;

                    find.find.reg = reg;
                    find.find.src = -1;
                    find.find.name = registerString(name);
                    find.find.exceptionId = exceptionId(nameNodes.at(ii));

                    subscribeName << QString(QLatin1String("$$$Generic_") + name);
                    if (subscription(subscribeName, &type)) 
                        find.find.subscribeIndex = subscriptionIndex(subscribeName);
                    else
                        find.find.subscribeIndex = -1;

                    bytecode << find;
                    type.unknownType = true;
                } 

                if (!type.unknownType && type.type == -1)
                    return false; // Couldn't fetch that type
            } 

        } else {

            if (attachType) {
                Instr attach;
                attach.common.type = Instr::LoadAttached;
                attach.attached.output = reg;
                attach.attached.reg = reg;
                attach.attached.id = attachType->attachedPropertiesId();
                bytecode << attach;

                absType = 0;
                type.metaObject = attachType->attachedPropertiesType();

                subscribeName << QLatin1String("$$$ATTACH_") + name;
                continue;
            }

            const QMetaObject *mo = 0;
            if (absType)
                mo = absType->metaObject();
            else if (type.metaObject)
                mo = type.metaObject;

            QByteArray utf8Name = name.toUtf8();
            const char *cname = utf8Name.constData();
            int idx = mo?mo->indexOfProperty(cname):-1;
            if (absType && idx == -1)
                return false;

            subscribeName << name;

            if (absType || (wasAttachedObject && idx != -1) || (mo && mo->property(idx).isFinal())) {
                absType = 0; 
                if (!fetch(type, mo, reg, idx, subscribeName, nameNodes.at(ii)))
                    return false;
            } else {

                Instr prop;
                if (ii == nameParts.count() -1 ) 
                    prop.common.type = Instr::FindPropertyTerminal;
                else
                    prop.common.type = Instr::FindProperty;

                prop.find.reg = reg;
                prop.find.src = reg;
                prop.find.name = registerString(name);
                prop.find.exceptionId = exceptionId(nameNodes.at(ii));

                if (subscription(subscribeName, &type))
                    prop.find.subscribeIndex = subscriptionIndex(subscribeName);
                else
                    prop.find.subscribeIndex = -1;

                type.unknownType = true;
                type.metaObject = 0;
                type.type = -1;
                type.reg = reg;
                bytecode << prop;
            }
        }

        wasAttachedObject = false;
    }

    return true;
}

registerCleanup()

void QDeclarativeBindingCompilerPrivate::registerCleanup	(	int	reg,
		int	cleanup,
		int	cleanupType = 0
	)

Definition at line 2697 of file qdeclarativecompiledbindings.cpp.

{
    registerCleanups.insert(reg, qMakePair(cleanup, cleanupType));
}

registerLiteralString()

int QDeclarativeBindingCompilerPrivate::registerLiteralString

(

const QString &

str

)

Definition at line 2735 of file qdeclarativecompiledbindings.cpp.

{
    QByteArray strdata((const char *)str.constData(), str.length() * sizeof(QChar));
    int offset = data.count();
    data += strdata;

    int reg = acquireReg(Instr::CleanupString);
    if (reg == -1)
        return false;

    Instr string;
    string.common.type = Instr::String;
    string.string_value.reg = reg;
    string.string_value.offset = offset;
    string.string_value.length = str.length();
    bytecode << string;

    return reg;
}

registerString()

int QDeclarativeBindingCompilerPrivate::registerString

(

const QString &

string

)

Definition at line 2756 of file qdeclarativecompiledbindings.cpp.

{
    Q_ASSERT(!string.isEmpty());

    QHash<QString, QPair<int, int> >::ConstIterator iter = registeredStrings.find(string);

    if (iter == registeredStrings.end()) {
        quint32 len = string.length();
        QByteArray lendata((const char *)&len, sizeof(quint32));
        QByteArray strdata((const char *)string.constData(), string.length() * sizeof(QChar));
        strdata.prepend(lendata);
        int rv = data.count();
        data += strdata;

        iter = registeredStrings.insert(string, qMakePair(registeredStrings.count(), rv));
    } 

    Instr reg;
    reg.common.type = Instr::InitString;
    reg.initstring.offset = iter->first;
    reg.initstring.dataIdx = iter->second;
    bytecode << reg;
    return reg.initstring.offset;
}

releaseReg()

void QDeclarativeBindingCompilerPrivate::releaseReg

(

int

reg

)

Definition at line 2717 of file qdeclarativecompiledbindings.cpp.

{
    Q_ASSERT(reg >= 0 && reg <= 31);

    if (registerCleanups.contains(reg)) {
        QPair<int, int> c = registerCleanups[reg];
        registerCleanups.remove(reg);
        Instr cleanup;
        cleanup.common.type = (quint8)c.first;
        cleanup.cleanup.reg = reg;
        bytecode << cleanup;
    }

    quint32 mask = 1 << reg;
    registers &= ~mask;
}

resetInstanceState()

void QDeclarativeBindingCompilerPrivate::resetInstanceState

(

)

Clear the state associated with attempting to compile a specific binding.

This does not clear the global "committed binding" states.

Definition at line 1718 of file qdeclarativecompiledbindings.cpp.

{
    registers = 0;
    registerCleanups.clear();
    data = committed.data;
    exceptions = committed.exceptions;
    usedSubscriptionIds.clear();
    subscriptionSet.clear();
    subscriptionIds = committed.subscriptionIds;
    registeredStrings = committed.registeredStrings;
    bytecode.clear();
}

stringArith()

bool QDeclarativeBindingCompilerPrivate::stringArith	(	Result &	type,
		const Result &	lhs,
		const Result &	rhs,
		QSOperator::Op	op
	)

Definition at line 2281 of file qdeclarativecompiledbindings.cpp.

{
    if (op != QSOperator::Add)
        return false;

    int lhsTmp = -1;
    int rhsTmp = -1;

    if (lhs.unknownType) {
        if (!qmlExperimental())
            return false;

        lhsTmp = acquireReg(Instr::CleanupString);
        if (lhsTmp == -1)
            return false;

        Instr convert;
        convert.common.type = Instr::ConvertGenericToString;
        convert.unaryop.output = lhsTmp;
        convert.unaryop.src = lhs.reg;
        bytecode << convert;
    }

    if (rhs.unknownType) {
        if (!qmlExperimental())
            return false;

        rhsTmp = acquireReg(Instr::CleanupString);
        if (rhsTmp == -1)
            return false;

        Instr convert;
        convert.common.type = Instr::ConvertGenericToString;
        convert.unaryop.output = rhsTmp;
        convert.unaryop.src = rhs.reg;
        bytecode << convert;
    }

    type.reg = acquireReg(Instr::CleanupString);
    if (type.reg == -1)
        return false;

    type.type = QMetaType::QString;

    Instr add;
    add.common.type = Instr::AddString;
    add.binaryop.output = type.reg;
    add.binaryop.src1 = (lhsTmp == -1)?lhs.reg:lhsTmp;
    add.binaryop.src2 = (rhsTmp == -1)?rhs.reg:rhsTmp;
    bytecode << add;

    if (lhsTmp != -1) releaseReg(lhsTmp);
    if (rhsTmp != -1) releaseReg(rhsTmp);
    releaseReg(lhs.reg);
    releaseReg(rhs.reg);

    return true;
}

subscription()

bool QDeclarativeBindingCompilerPrivate::subscription	(	const QStringList &	sub,
		Result *	result
	)

Definition at line 2781 of file qdeclarativecompiledbindings.cpp.

{
    QString str = sub.join(QLatin1String("."));
    result->subscriptionSet.insert(str);

    if (subscriptionSet.contains(str)) {
        return false;
    } else {
        subscriptionSet.insert(str);
        return true;
    }
}

subscriptionIndex()

int QDeclarativeBindingCompilerPrivate::subscriptionIndex

(

const QStringList &

sub

)

Definition at line 2794 of file qdeclarativecompiledbindings.cpp.

{
    QString str = sub.join(QLatin1String("."));
    QHash<QString, int>::ConstIterator iter = subscriptionIds.find(str);
    if (iter == subscriptionIds.end()) 
        iter = subscriptionIds.insert(str, subscriptionIds.count());
    usedSubscriptionIds.insert(*iter);
    return *iter;
}

subscriptionNeutral()

bool QDeclarativeBindingCompilerPrivate::subscriptionNeutral	(	const QSet< QString > &	base,
		const QSet< QString > &	lhs,
		const QSet< QString > &	rhs
	)

Definition at line 2808 of file qdeclarativecompiledbindings.cpp.

{
    QSet<QString> difflhs = lhs;
    difflhs.subtract(rhs);
    QSet<QString> diffrhs = rhs;
    diffrhs.subtract(lhs);

    difflhs.unite(diffrhs);
    difflhs.subtract(base);

    return difflhs.isEmpty();
}

tryArith()

bool QDeclarativeBindingCompilerPrivate::tryArith

(

QDeclarativeJS::AST::Node *

node

)

Definition at line 2158 of file qdeclarativecompiledbindings.cpp.

{
    if (node->kind != AST::Node::Kind_BinaryExpression)
        return false;

    AST::BinaryExpression *expression = static_cast<AST::BinaryExpression *>(node);
    if (expression->op == QSOperator::Add ||
        expression->op == QSOperator::Sub)
        return true;
    else
        return false;
}

tryConditional()

bool QDeclarativeBindingCompilerPrivate::tryConditional

(

QDeclarativeJS::AST::Node *

node

)

Definition at line 2412 of file qdeclarativecompiledbindings.cpp.

{
    return (node->kind == AST::Node::Kind_ConditionalExpression);
}

tryConstant()

bool QDeclarativeBindingCompilerPrivate::tryConstant

(

QDeclarativeJS::AST::Node *

node

)

Definition at line 2479 of file qdeclarativecompiledbindings.cpp.

{
    return node->kind == AST::Node::Kind_TrueLiteral ||
           node->kind == AST::Node::Kind_FalseLiteral ||
           node->kind == AST::Node::Kind_NumericLiteral ||
           node->kind == AST::Node::Kind_StringLiteral;
}

tryLogic()

bool QDeclarativeBindingCompilerPrivate::tryLogic

(

QDeclarativeJS::AST::Node *

node

)

Definition at line 2340 of file qdeclarativecompiledbindings.cpp.

{
    if (node->kind != AST::Node::Kind_BinaryExpression)
        return false;

    AST::BinaryExpression *expression = static_cast<AST::BinaryExpression *>(node);
    if (expression->op == QSOperator::Gt ||
        expression->op == QSOperator::Equal ||
        expression->op == QSOperator::NotEqual)
        return true;
    else
        return false;
}

tryMethod()

bool QDeclarativeBindingCompilerPrivate::tryMethod

(

QDeclarativeJS::AST::Node *

node

)

Definition at line 2534 of file qdeclarativecompiledbindings.cpp.

{
    return node->kind == AST::Node::Kind_CallExpression; 
}

tryName()

bool QDeclarativeBindingCompilerPrivate::tryName

(

QDeclarativeJS::AST::Node *

node

)

Definition at line 1920 of file qdeclarativecompiledbindings.cpp.

{
    return node->kind == AST::Node::Kind_IdentifierExpression ||
           node->kind == AST::Node::Kind_FieldMemberExpression;
}

Properties

bytecode

QVector<Instr> QDeclarativeBindingCompilerPrivate::bytecode

Definition at line 693 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::isValid(), and QDeclarativeBindingCompiler::program().

committed

struct { ... } QDeclarativeBindingCompilerPrivate::committed

Referenced by QDeclarativeBindingCompiler::isValid(), and QDeclarativeBindingCompiler::program().

component

QDeclarativeParser::Object* QDeclarativeBindingCompilerPrivate::component

Definition at line 637 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::compile().

context

QDeclarativeParser::Object* QDeclarativeBindingCompilerPrivate::context

Definition at line 636 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::compile().

data

QByteArray QDeclarativeBindingCompilerPrivate::data

Definition at line 681 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::program().

dependencies

QList<QSet<int> > QDeclarativeBindingCompilerPrivate::dependencies

Definition at line 698 of file qdeclarativecompiledbindings.cpp.

destination

QDeclarativeParser::Property* QDeclarativeBindingCompilerPrivate::destination

Definition at line 638 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::compile().

engine

QDeclarativeEnginePrivate* QDeclarativeBindingCompilerPrivate::engine

Definition at line 641 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::compile().

exceptions

QVector<quint64> QDeclarativeBindingCompilerPrivate::exceptions

Definition at line 688 of file qdeclarativecompiledbindings.cpp.

ids

QHash<QString, QDeclarativeParser::Object *> QDeclarativeBindingCompilerPrivate::ids

Definition at line 639 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::compile().

imports

QDeclarativeImports QDeclarativeBindingCompilerPrivate::imports

Definition at line 640 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::compile().

offsets

QList<int> QDeclarativeBindingCompilerPrivate::offsets

Definition at line 697 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::program().

registerCleanups

QHash<int, QPair<int, int> > QDeclarativeBindingCompilerPrivate::registerCleanups

Definition at line 673 of file qdeclarativecompiledbindings.cpp.

registeredStrings

QHash<QString, QPair<int, int> > QDeclarativeBindingCompilerPrivate::registeredStrings

Definition at line 680 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::program().

registers

quint32 QDeclarativeBindingCompilerPrivate::registers

Definition at line 672 of file qdeclarativecompiledbindings.cpp.

subscriptionIds

QHash<QString, int> QDeclarativeBindingCompilerPrivate::subscriptionIds

Definition at line 692 of file qdeclarativecompiledbindings.cpp.

Referenced by QDeclarativeBindingCompiler::program().

subscriptionSet

QSet<QString> QDeclarativeBindingCompilerPrivate::subscriptionSet

Definition at line 691 of file qdeclarativecompiledbindings.cpp.

usedSubscriptionIds

QSet<int> QDeclarativeBindingCompilerPrivate::usedSubscriptionIds

Definition at line 690 of file qdeclarativecompiledbindings.cpp.

---

The documentation for this struct was generated from the following file:

• /src/declarative/qml/qdeclarativecompiledbindings.cpp