qmetaobjectbuilder.cpp File Reference

#include "private/qmetaobjectbuilder_p.h"

Go to the source code of this file.

Classes
class	QMetaEnumBuilderPrivate
class	QMetaMethodBuilderPrivate
class	QMetaObjectBuilderPrivate
struct	QMetaObjectPrivate
class	QMetaPropertyBuilderPrivate

Macros
#define	ALIGN(size, type)   (size) = ((size) + sizeof(type) - 1) & ~(sizeof(type) - 1)

Enumerations
enum	MethodFlags {   AccessPrivate = 0x00, AccessProtected = 0x01, AccessPublic = 0x02, AccessMask = 0x03,   MethodMethod = 0x00, MethodSignal = 0x04, MethodSlot = 0x08, MethodConstructor = 0x0c,   MethodTypeMask = 0x0c, MethodCompatibility = 0x10, MethodCloned = 0x20, MethodScriptable = 0x40,   MethodRevisioned = 0x80, AccessPrivate = 0x00, AccessProtected = 0x01, AccessPublic = 0x02,   AccessMask = 0x03, MethodMethod = 0x00, MethodSignal = 0x04, MethodSlot = 0x08,   MethodConstructor = 0x0c, MethodTypeMask = 0x0c, MethodCompatibility = 0x10, MethodCloned = 0x20,   MethodScriptable = 0x40, MethodRevisioned = 0x80 }
enum	PropertyFlags {   Invalid = 0x00000000, Readable = 0x00000001, Writable = 0x00000002, Resettable = 0x00000004,   EnumOrFlag = 0x00000008, StdCppSet = 0x00000100, Constant = 0x00000400, Final = 0x00000800,   Designable = 0x00001000, ResolveDesignable = 0x00002000, Scriptable = 0x00004000, ResolveScriptable = 0x00008000,   Stored = 0x00010000, ResolveStored = 0x00020000, Editable = 0x00040000, ResolveEditable = 0x00080000,   User = 0x00100000, ResolveUser = 0x00200000, Notify = 0x00400000, Revisioned = 0x00800000,   Invalid = 0x00000000, Readable = 0x00000001, Writable = 0x00000002, Resettable = 0x00000004,   EnumOrFlag = 0x00000008, StdCppSet = 0x00000100, Constant = 0x00000400, Final = 0x00000800,   Designable = 0x00001000, ResolveDesignable = 0x00002000, Scriptable = 0x00004000, ResolveScriptable = 0x00008000,   Stored = 0x00010000, ResolveStored = 0x00020000, Editable = 0x00040000, ResolveEditable = 0x00080000,   User = 0x00100000, ResolveUser = 0x00200000, Notify = 0x00400000, Revisioned = 0x00800000 }

Functions
static int	buildMetaObject (QMetaObjectBuilderPrivate *d, char *buf, bool relocatable)
static QByteArray	buildParameterNames (const QByteArray &signature, const QList< QByteArray > &parameterNames)
static int	buildString (char *buf, char *str, int *offset, const QByteArray &value, int empty)
bool	isVariantType (const char *type)
static const QMetaObjectPrivate *	priv (const uint *data)
uint	qvariant_nameToType (const char *name)
static const QMetaObject *	resolveClassName (const QMap< QByteArray, const QMetaObject *> &references, const QByteArray &name)

Macro Definition Documentation

ALIGN

#define ALIGN	(		size,
			type
	)		(size) = ((size) + sizeof(type) - 1) & ~(sizeof(type) - 1)

Definition at line 1122 of file qmetaobjectbuilder.cpp.

Referenced by buildMetaObject().

Enumeration Type Documentation

MethodFlags

enum MethodFlags

Enumerator
AccessPrivate
AccessProtected
AccessPublic
AccessMask
MethodMethod
MethodSignal
MethodSlot
MethodConstructor
MethodTypeMask
MethodCompatibility
MethodCloned
MethodScriptable
MethodRevisioned
AccessPrivate
AccessProtected
AccessPublic
AccessMask
MethodMethod
MethodSignal
MethodSlot
MethodConstructor
MethodTypeMask
MethodCompatibility
MethodCloned
MethodScriptable
MethodRevisioned

Definition at line 133 of file qmetaobjectbuilder.cpp.

                  {
    AccessPrivate = 0x00,
    AccessProtected = 0x01,
    AccessPublic = 0x02,
    AccessMask = 0x03, //mask

    MethodMethod = 0x00,
    MethodSignal = 0x04,
    MethodSlot = 0x08,
    MethodConstructor = 0x0c,
    MethodTypeMask = 0x0c,

    MethodCompatibility = 0x10,
    MethodCloned = 0x20,
    MethodScriptable = 0x40,
    MethodRevisioned = 0x80
};

PropertyFlags

enum PropertyFlags

Enumerator
Invalid
Readable
Writable
Resettable
EnumOrFlag
StdCppSet
Constant
Final
Designable
ResolveDesignable
Scriptable
ResolveScriptable
Stored
ResolveStored
Editable
ResolveEditable
User
ResolveUser
Notify
Revisioned
Invalid
Readable
Writable
Resettable
EnumOrFlag
StdCppSet
Constant
Final
Designable
ResolveDesignable
Scriptable
ResolveScriptable
Stored
ResolveStored
Editable
ResolveEditable
User
ResolveUser
Notify
Revisioned

Definition at line 109 of file qmetaobjectbuilder.cpp.

                    {
    Invalid = 0x00000000,
    Readable = 0x00000001,
    Writable = 0x00000002,
    Resettable = 0x00000004,
    EnumOrFlag = 0x00000008,
    StdCppSet = 0x00000100,
//    Override = 0x00000200,
    Constant = 0x00000400,
    Final = 0x00000800,
    Designable = 0x00001000,
    ResolveDesignable = 0x00002000,
    Scriptable = 0x00004000,
    ResolveScriptable = 0x00008000,
    Stored = 0x00010000,
    ResolveStored = 0x00020000,
    Editable = 0x00040000,
    ResolveEditable = 0x00080000,
    User = 0x00100000,
    ResolveUser = 0x00200000,
    Notify = 0x00400000,
    Revisioned = 0x00800000
};

Function Documentation

buildMetaObject()

static int buildMetaObject ( QMetaObjectBuilderPrivate *  d, char *  buf, bool  relocatable  )

static

Definition at line 1186 of file qmetaobjectbuilder.cpp.

Referenced by QMetaObjectBuilder::toMetaObject(), and QMetaObjectBuilder::toRelocatableData().

{
    int size = 0;
    int dataIndex;
    int enumIndex;
    int index;
    bool hasNotifySignals = false;

    if (relocatable && 
        (d->relatedMetaObjects.size() > 0 || d->staticMetacallFunction))
        return -1;

    // Create the main QMetaObject structure at the start of the buffer.
    QMetaObject *meta = reinterpret_cast<QMetaObject *>(buf);
    size += sizeof(QMetaObject);
    ALIGN(size, int);
    if (buf) {
        if (!relocatable) meta->d.superdata = d->superClass;
        meta->d.extradata = 0;
    }

    // Populate the QMetaObjectPrivate structure.
    QMetaObjectPrivate *pmeta
        = reinterpret_cast<QMetaObjectPrivate *>(buf + size);
    int pmetaSize = size;
    dataIndex = 13;     // Number of fields in the QMetaObjectPrivate.
    for (index = 0; index < d->properties.size(); ++index) {
        if (d->properties[index].notifySignal != -1) {
            hasNotifySignals = true;
            break;
        }
    }
    if (buf) {
        pmeta->revision = 3;
        pmeta->flags = d->flags;
        pmeta->className = 0;   // Class name is always the first string.

        pmeta->classInfoCount = d->classInfoNames.size();
        pmeta->classInfoData = dataIndex;
        dataIndex += 2 * d->classInfoNames.size();

        pmeta->methodCount = d->methods.size();
        pmeta->methodData = dataIndex;
        dataIndex += 5 * d->methods.size();

        pmeta->propertyCount = d->properties.size();
        pmeta->propertyData = dataIndex;
        dataIndex += 3 * d->properties.size();
        if (hasNotifySignals)
            dataIndex += d->properties.size();

        pmeta->enumeratorCount = d->enumerators.size();
        pmeta->enumeratorData = dataIndex;
        dataIndex += 4 * d->enumerators.size();

        pmeta->constructorCount = d->constructors.size();
        pmeta->constructorData = dataIndex;
        dataIndex += 5 * d->constructors.size();
    } else {
        dataIndex += 2 * d->classInfoNames.size();
        dataIndex += 5 * d->methods.size();
        dataIndex += 3 * d->properties.size();
        if (hasNotifySignals)
            dataIndex += d->properties.size();
        dataIndex += 4 * d->enumerators.size();
        dataIndex += 5 * d->constructors.size();
    }

    // Allocate space for the enumerator key names and values.
    enumIndex = dataIndex;
    for (index = 0; index < d->enumerators.size(); ++index) {
        QMetaEnumBuilderPrivate *enumerator = &(d->enumerators[index]);
        dataIndex += 2 * enumerator->keys.size();
    }

    // Zero terminator at the end of the data offset table.
    ++dataIndex;

    // Find the start of the data and string tables.
    int *data = reinterpret_cast<int *>(pmeta);
    size += dataIndex * sizeof(int);
    char *str = reinterpret_cast<char *>(buf + size);
    if (buf) {
        if (relocatable) {
            meta->d.stringdata = reinterpret_cast<const char *>((quintptr)size);
            meta->d.data = reinterpret_cast<uint *>((quintptr)pmetaSize);
        } else {
            meta->d.stringdata = str;
            meta->d.data = reinterpret_cast<uint *>(data);
        }
    }

    // Reset the current data position to just past the QMetaObjectPrivate.
    dataIndex = 13;

    // Add the class name to the string table.
    int offset = 0;
    buildString(buf, str, &offset, d->className, -1);

    // Add a common empty string, which is used to indicate "void"
    // method returns, empty tag strings, etc.
    int empty = buildString(buf, str, &offset, QByteArray(), -1);

    // Output the class infos,
    for (index = 0; index < d->classInfoNames.size(); ++index) {
        int name = buildString(buf, str, &offset, d->classInfoNames[index], empty);
        int value = buildString(buf, str, &offset, d->classInfoValues[index], empty);
        if (buf) {
            data[dataIndex] = name;
            data[dataIndex + 1] = value;
        }
        dataIndex += 2;
    }

    // Output the methods in the class.
    for (index = 0; index < d->methods.size(); ++index) {
        QMetaMethodBuilderPrivate *method = &(d->methods[index]);
        int sig = buildString(buf, str, &offset, method->signature, empty);
        int params;
        QByteArray names = buildParameterNames
            (method->signature, method->parameterNames);
        params = buildString(buf, str, &offset, names, empty);
        int ret = buildString(buf, str, &offset, method->returnType, empty);
        int tag = buildString(buf, str, &offset, method->tag, empty);
        int attrs = method->attributes;
        if (buf) {
            data[dataIndex]     = sig;
            data[dataIndex + 1] = params;
            data[dataIndex + 2] = ret;
            data[dataIndex + 3] = tag;
            data[dataIndex + 4] = attrs;
        }
        dataIndex += 5;
    }

    // Output the properties in the class.
    for (index = 0; index < d->properties.size(); ++index) {
        QMetaPropertyBuilderPrivate *prop = &(d->properties[index]);
        int name = buildString(buf, str, &offset, prop->name, empty);
        int type = buildString(buf, str, &offset, prop->type, empty);
        int flags = prop->flags;

        if (!isVariantType(prop->type)) {
            flags |= EnumOrFlag;
        } else {
            flags |= qvariant_nameToType(prop->type) << 24;
        }

        if (buf) {
            data[dataIndex]     = name;
            data[dataIndex + 1] = type;
            data[dataIndex + 2] = flags;
        }
        dataIndex += 3;
    }
    if (hasNotifySignals) {
        for (index = 0; index < d->properties.size(); ++index) {
            QMetaPropertyBuilderPrivate *prop = &(d->properties[index]);
            if (buf) {
                if (prop->notifySignal != -1)
                    data[dataIndex] = prop->notifySignal;
                else
                    data[dataIndex] = 0;
            }
            ++dataIndex;
        }
    }

    // Output the enumerators in the class.
    for (index = 0; index < d->enumerators.size(); ++index) {
        QMetaEnumBuilderPrivate *enumerator = &(d->enumerators[index]);
        int name = buildString(buf, str, &offset, enumerator->name, empty);
        int isFlag = (int)(enumerator->isFlag);
        int count = enumerator->keys.size();
        int enumOffset = enumIndex;
        if (buf) {
            data[dataIndex]     = name;
            data[dataIndex + 1] = isFlag;
            data[dataIndex + 2] = count;
            data[dataIndex + 3] = enumOffset;
        }
        for (int key = 0; key < count; ++key) {
            int keyIndex = buildString(buf, str, &offset, enumerator->keys[key], empty);
            if (buf) {
                data[enumOffset++] = keyIndex;
                data[enumOffset++] = enumerator->values[key];
            }
        }
        dataIndex += 4;
        enumIndex += 2 * count;
    }

    // Output the constructors in the class.
    for (index = 0; index < d->constructors.size(); ++index) {
        QMetaMethodBuilderPrivate *method = &(d->constructors[index]);
        int sig = buildString(buf, str, &offset, method->signature, empty);
        int params;
        QByteArray names = buildParameterNames
            (method->signature, method->parameterNames);
        params = buildString(buf, str, &offset, names, empty);
        int ret = buildString(buf, str, &offset, method->returnType, empty);
        int tag = buildString(buf, str, &offset, method->tag, empty);
        int attrs = method->attributes;
        if (buf) {
            data[dataIndex]     = sig;
            data[dataIndex + 1] = params;
            data[dataIndex + 2] = ret;
            data[dataIndex + 3] = tag;
            data[dataIndex + 4] = attrs;
        }
        dataIndex += 5;
    }

    // One more empty string to act as a terminator.
    buildString(buf, str, &offset, QByteArray(), -1);
    size += offset;

    // Output the zero terminator in the data array.
    if (buf)
        data[enumIndex] = 0;

    // Create the extradata block if we need one.
    if (d->relatedMetaObjects.size() > 0 || d->staticMetacallFunction) {
        ALIGN(size, QMetaObject **);
        ALIGN(size, QMetaObjectBuilder::StaticMetacallFunction);
        QMetaObjectExtraData *extra =
            reinterpret_cast<QMetaObjectExtraData *>(buf + size);
        size += sizeof(QMetaObjectExtraData);
        ALIGN(size, QMetaObject *);
#ifdef Q_NO_DATA_RELOCATION
        QMetaObjectAccessor *objects =
            reinterpret_cast<QMetaObjectAccessor *>(buf + size);
#else
        const QMetaObject **objects =
            reinterpret_cast<const QMetaObject **>(buf + size);
#endif
        if (buf) {
            if (d->relatedMetaObjects.size() > 0) {
                extra->objects = objects;
                for (index = 0; index < d->relatedMetaObjects.size(); ++index)
                    objects[index] = d->relatedMetaObjects[index];
                objects[index] = 0;
            } else {
                extra->objects = 0;
            }
            extra->static_metacall = d->staticMetacallFunction;
            meta->d.extradata = reinterpret_cast<void *>(extra);
        }
        if (d->relatedMetaObjects.size() > 0)
            size += sizeof(QMetaObject *) * (d->relatedMetaObjects.size() + 1);
    }

    // Align the final size and return it.
    ALIGN(size, void *);
    return size;
}

buildParameterNames()

static QByteArray buildParameterNames ( const QByteArray &  signature, const QList< QByteArray > &  parameterNames  )

static

Definition at line 1143 of file qmetaobjectbuilder.cpp.

Referenced by buildMetaObject(), and buildString().

{
    // If the parameter name list is specified, then concatenate them.
    if (!parameterNames.isEmpty()) {
        QByteArray names;
        bool first = true;
        foreach (const QByteArray &name, parameterNames) {
            if (first)
                first = false;
            else
                names += (char)',';
            names += name;
        }
        return names;
    }

    // Count commas in the signature, excluding those inside template arguments.
    int index = signature.indexOf('(');
    if (index < 0)
        return QByteArray();
    ++index;
    if (index >= signature.size())
        return QByteArray();
    if (signature[index] == ')')
        return QByteArray();
    int count = 1;
    int brackets = 0;
    while (index < signature.size() && signature[index] != ',') {
        char ch = signature[index++];
        if (ch == '<')
            ++brackets;
        else if (ch == '>')
            --brackets;
        else if (ch == ',' && brackets <= 0)
            ++count;
    }
    return QByteArray(count - 1, ',');
}

buildString()

static int buildString ( char *  buf, char *  str, int *  offset, const QByteArray &  value, int  empty  )

static

Definition at line 1128 of file qmetaobjectbuilder.cpp.

Referenced by buildMetaObject().

{
    if (value.size() == 0 && empty >= 0)
        return empty;
    if (buf) {
        memcpy(str + *offset, value.constData(), value.size());
        str[*offset + value.size()] = '\0';
    }
    int posn = *offset;
    *offset += value.size() + 1;
    return posn;
}

isVariantType()

bool isVariantType

(

const char *

type

)

Definition at line 102 of file qmetaobjectbuilder.cpp.

Referenced by buildMetaObject().

{
    return qvariant_nameToType(type) != 0;
}

priv()

static const QMetaObjectPrivate* priv ( const uint *  data )

inlinestatic

Definition at line 163 of file qmetaobjectbuilder.cpp.

Referenced by QMetaObjectBuilder::addMetaObject().

{ return reinterpret_cast<const QMetaObjectPrivate*>(data); }

qvariant_nameToType()

uint qvariant_nameToType

(

const char *

name

)

Definition at line 79 of file qmetaobjectbuilder.cpp.

Referenced by buildMetaObject(), and isVariantType().

{
    if (!name)
        return 0;

    if (strcmp(name, "QVariant") == 0)
        return 0xffffffff;
    if (strcmp(name, "QCString") == 0)
        return QMetaType::QByteArray;
    if (strcmp(name, "Q_LLONG") == 0)
        return QMetaType::LongLong;
    if (strcmp(name, "Q_ULLONG") == 0)
        return QMetaType::ULongLong;
    if (strcmp(name, "QIconSet") == 0)
        return QMetaType::QIcon;

    uint tp = QMetaType::type(name);
    return tp < QMetaType::User ? tp : 0;
}

resolveClassName()

static const QMetaObject* resolveClassName ( const QMap< QByteArray, const QMetaObject *> &  references, const QByteArray &  name  )

static

Definition at line 1641 of file qmetaobjectbuilder.cpp.

Referenced by QMetaObjectBuilder::deserialize(), and QMetaObjectBuilder::serialize().

{
    if (name == QByteArray("QObject"))
        return &QObject::staticMetaObject;
    else
        return references.value(name, 0);
}