rock-qtbindings 4.8.6.5

data/ext/generator/type.cpp

@@ -0,0 +1,204 @@
+/*
+    Copyright (C) 2009 Arno Rehn <arno@arnorehn.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "type.h"
+#include "options.h"
+
+QHash<QString, Class> classes;
+QHash<QString, Typedef> typedefs;
+QHash<QString, Enum> enums;
+QHash<QString, Function> functions;
+QHash<QString, GlobalVar> globals;
+QHash<QString, Type> types;
+
+QString BasicTypeDeclaration::toString() const
+{
+    QString ret;
+    Class* parent = m_parent;
+    while (parent) {
+        ret.prepend(parent->name() + "::");
+        parent = parent->parent();
+    }
+    if (!m_nspace.isEmpty())
+        ret.prepend(m_nspace + "::");
+    ret += m_name;
+    return ret;
+}
+
+QString Member::toString(bool withAccess, bool withClass) const
+{
+    QString ret;
+    if (withAccess) {
+        if (m_access == Access_public)
+            ret += "public ";
+        else if (m_access == Access_protected)
+            ret += "protected ";
+        else if (m_access == Access_private)
+            ret += "private ";
+    }
+    if (m_flags & Static)
+        ret += "static ";
+    if (m_flags & Virtual)
+        ret += "virtual ";
+    ret += m_type->toString() + " ";
+    if (withClass)
+        ret += m_typeDecl->toString() + "::";
+    ret += m_name;
+    return ret;
+}
+
+QString EnumMember::toString() const
+{
+    QString ret;
+    if (m_typeDecl->parent())
+        ret += m_typeDecl->parent()->toString();
+    else
+        ret += m_typeDecl->nameSpace();
+    return ret + "::" + name();
+}
+
+QString Parameter::toString() const
+{
+    return m_type->toString();
+}
+
+QString Method::toString(bool withAccess, bool withClass, bool withInitializer) const
+{
+    QString ret = Member::toString(withAccess, withClass);
+    ret += "(";
+    for (int i = 0; i < m_params.count(); i++) {
+        ret += m_params[i].toString();
+        if (i < m_params.count() - 1) ret += ", ";
+    }
+    ret += ")";
+    if (m_isConst) ret += " const";
+    if ((m_flags & Member::PureVirtual) && withInitializer) ret += " = 0";
+    return ret;
+}
+
+const Type* Type::Void = Type::registerType(Type("void"));
+
+#ifdef Q_OS_WIN
+Type* Type::registerType(const Type& type)
+{
+    QString typeString = type.toString();
+    QHash<QString, Type>::iterator iter = types.insert(typeString, type);
+    return &iter.value();
+}
+#endif
+
+Type Typedef::resolve() const {
+    bool isRef = false, isConst = false, isVolatile = false;
+    QList<bool> pointerDepth;
+
+    // not pretty, but safe. 'this' (without const) will never be returned or modified from here on.
+    const Type tmp(const_cast<Typedef*>(this));
+    const Type* t = &tmp;
+
+    while (t->getTypedef() && !ParserOptions::notToBeResolved.contains(t->getTypedef()->name())) {
+        if (!isRef) isRef = t->isRef();
+        if (!isConst) isConst = t->isConst();
+        if (!isVolatile) isVolatile = t->isVolatile();
+        t = t->getTypedef()->type();
+        for (int i = t->pointerDepth() - 1; i >= 0; i--) {
+            pointerDepth.prepend(t->isConstPointer(i));
+        }
+    }
+    Type ret = *t;
+
+    // not fully resolved -> erase the typedef pointer and only set a name
+    if (ret.getTypedef()) {
+        ret.setName(ret.getTypedef()->name());
+        ret.setTypedef(0);
+    }
+
+    if (isRef) ret.setIsRef(true);
+    if (isConst) ret.setIsConst(true);
+    if (isVolatile) ret.setIsVolatile(true);
+
+    ret.setPointerDepth(pointerDepth.count());
+    for (int i = 0; i < pointerDepth.count(); i++) {
+        ret.setIsConstPointer(i, pointerDepth[i]);
+    }
+    return ret;
+}
+
+QString GlobalVar::toString() const
+{
+    QString ret = m_type->toString() + " ";
+    if (!m_nspace.isEmpty())
+        ret += m_nspace + "::";
+    ret += m_name;
+    return ret;
+}
+
+QString Function::toString() const
+{
+    QString ret = GlobalVar::toString();
+    ret += "(";
+    for (int i = 0; i < m_params.count(); i++) {
+        ret += m_params[i].type()->toString();
+        if (i < m_params.count() - 1) ret += ", ";
+    }
+    ret += ")";
+    return ret;
+}
+
+QString Type::toString(const QString& fnPtrName) const
+{
+    QString ret;
+    if (m_isVolatile) ret += "volatile ";
+    if (m_isConst) ret += "const ";
+    ret += name();
+    if (!m_templateArgs.isEmpty()) {
+        ret += "<";
+        for (int i = 0; i < m_templateArgs.count(); i++) {
+            if (i > 0) ret += ',';
+            ret += m_templateArgs[i].toString();
+        }
+        ret += ">";
+    }
+    
+    // FIXME: This won't work for an array of function pointers!
+    if (isArray() && (m_pointerDepth > 0 || m_isRef)) ret += '(';
+    
+    for (int i = 0; i < m_pointerDepth; i++) {
+        ret += "*";
+        if (isConstPointer(i)) ret += " const ";
+    }
+    ret = ret.trimmed();
+    if (m_isRef) ret += "&";
+    
+    if (isArray()) ret += fnPtrName;
+    if (isArray() && (m_pointerDepth > 0 || m_isRef)) ret += ')';
+    
+    foreach(int size, m_arrayLengths) {
+        ret += '[' + QString::number(size) + ']';
+    }
+    
+    if (m_isFunctionPointer) {
+        ret += "(*" + fnPtrName + ")(";
+        for (int i = 0; i < m_params.count(); i++) {
+            if (i > 0) ret += ',';
+            ret += m_params[i].type()->toString();
+        }
+        ret += ')';
+    }
+    // the compiler would misinterpret ">>" as the operator - replace it with "> >"
+    return ret.replace(">>", "> >");
+}

data/ext/generator/type.h

@@ -0,0 +1,497 @@
+/*
+    Copyright (C) 2009 Arno Rehn <arno@arnorehn.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef TYPE_H
+#define TYPE_H
+
+#include <QString>
+#include <QStringList>
+#include <QHash>
+#include <QtDebug>
+
+#include "generator_export.h"
+
+class Class;
+class Typedef;
+class Enum;
+class GlobalVar;
+class Function;
+class Type;
+
+extern GENERATOR_EXPORT QHash<QString, Class> classes;
+extern GENERATOR_EXPORT QHash<QString, Typedef> typedefs;
+extern GENERATOR_EXPORT QHash<QString, Enum> enums;
+extern GENERATOR_EXPORT QHash<QString, Function> functions;
+extern GENERATOR_EXPORT QHash<QString, GlobalVar> globals;
+extern GENERATOR_EXPORT QHash<QString, Type> types;
+
+class Method;
+class Field;
+
+enum Access {
+    Access_public,
+    Access_protected,
+    Access_private
+};
+
+class Class;
+
+class GENERATOR_EXPORT BasicTypeDeclaration
+{
+public:
+    BasicTypeDeclaration() : m_access(Access_public) {}
+    virtual ~BasicTypeDeclaration() {}
+    virtual bool isValid() const { return !m_name.isEmpty(); }
+    
+    void setName(const QString& name) { m_name = name; }
+    QString name() const { return m_name; }
+    
+    void setNameSpace(const QString& nspace) { m_nspace = nspace; }
+    QString nameSpace() const { return m_nspace; }
+
+    void setParent(Class* parent) { m_parent = parent; }
+    Class* parent() const { return m_parent; }
+
+    void setAccess(Access access) { m_access = access; }
+    Access access() const { return m_access; }
+
+    void setFileName(const QString& fileName) { m_file = fileName; }
+    QString fileName() const { return m_file; }
+
+    QString toString() const;
+
+protected:
+    BasicTypeDeclaration(const QString& name, const QString& nspace = QString(), Class* parent = 0)
+        : m_name(name), m_nspace(nspace), m_parent(parent) {}
+
+    QString m_name;
+    QString m_nspace;
+    Class* m_parent;
+    QString m_file;
+    Access m_access;
+};
+
+class GENERATOR_EXPORT Class : public BasicTypeDeclaration
+{
+public:
+    enum Kind {
+        Kind_Class,
+        Kind_Struct,
+        Kind_Union
+    };
+    
+    struct BaseClassSpecifier {
+        Class *baseClass;
+        Access access;
+        bool isVirtual;
+    };
+    
+    Class(const QString& name = QString(), const QString nspace = QString(), Class* parent = 0, Kind kind = Kind_Class, bool isForward = true)
+          : BasicTypeDeclaration(name, nspace, parent), m_kind(kind), m_forward(isForward), m_isNamespace(false), m_isTemplate(false) {}
+    virtual ~Class() {}
+    
+    void setKind(Kind kind) { m_kind = kind; }
+    Kind kind() const { return m_kind; }
+    
+    void setIsForwardDecl(bool forward) { m_forward = forward; }
+    bool isForwardDecl() const { return m_forward; }
+    
+    void setIsNameSpace(bool isNamespace) { m_isNamespace = isNamespace; }
+    bool isNameSpace() const { return m_isNamespace; }
+    
+    const QList<Method>& methods() const { return m_methods; }
+    QList<Method>& methodsRef() { return m_methods; }
+    void appendMethod(const Method& method) { m_methods.append(method); }
+    
+    const QList<Field>& fields() const { return m_fields; }
+    QList<Field>& fieldsRef() { return m_fields; }
+    void appendField(const Field& field) {  m_fields.append(field); }
+    
+    const QList<BaseClassSpecifier>& baseClasses() const { return m_bases; }
+    void appendBaseClass(const BaseClassSpecifier& baseClass) { m_bases.append(baseClass); }
+    
+    const QList<BasicTypeDeclaration*>& children() const { return m_children; }
+    void appendChild(BasicTypeDeclaration* child) { m_children.append(child); }
+    
+    bool isTemplate() const { return m_isTemplate; }
+    void setIsTemplate(bool isTemplate) { m_isTemplate = isTemplate; }
+    
+private:
+    Kind m_kind;
+    bool m_forward;
+    bool m_isNamespace;
+    bool m_isTemplate;
+    QList<Method> m_methods;
+    QList<Field> m_fields;
+    QList<BaseClassSpecifier> m_bases;
+    QList<BasicTypeDeclaration*> m_children;
+};
+
+class GENERATOR_EXPORT Typedef : public BasicTypeDeclaration
+{
+public:
+    Typedef(Type* type = 0, const QString& name = QString(), const QString nspace = QString(), Class* parent = 0)
+            : BasicTypeDeclaration(name, nspace, parent), m_type(type) {}
+    virtual ~Typedef() {}
+
+    virtual bool isValid() const { return (!m_name.isEmpty() && m_type); }
+
+    void setType(Type* type) { m_type = type; }
+    Type* type() const { return m_type; }
+
+    Type resolve() const;
+
+private:
+    Type* m_type;
+};
+
+class EnumMember;
+
+class GENERATOR_EXPORT Enum : public BasicTypeDeclaration
+{
+public:
+    Enum(const QString& name = QString(), const QString nspace = QString(), Class* parent = 0)
+         : BasicTypeDeclaration(name, nspace, parent) {}
+    virtual ~Enum() {}
+
+    const QList<EnumMember>& members() const { return m_members; }
+    QList<EnumMember>& membersRef() { return m_members; }
+    void appendMember(const EnumMember& member) { m_members.append(member); }
+
+private:
+    QList<EnumMember> m_members;
+};
+
+class GENERATOR_EXPORT Member
+{
+public:
+    enum Flag {
+        Virtual = 0x1,
+        PureVirtual = 0x2,
+        Static = 0x4,
+        DynamicDispatch = 0x8,
+        Explicit = 0x10,
+    };
+    Q_DECLARE_FLAGS(Flags, Flag)
+
+    Member(BasicTypeDeclaration* typeDecl = 0, const QString& name = QString(), Type* type = 0, Access access = Access_public)
+        : m_typeDecl(typeDecl), m_name(name), m_type(type), m_access(access) {}
+    virtual ~Member() {}
+
+    bool isValid() const { return (!m_name.isEmpty() && m_type && m_typeDecl); }
+
+    void setDeclaringType(Class* klass) { m_typeDecl = klass; }
+    BasicTypeDeclaration* declaringType() const { return m_typeDecl; }
+
+    void setName(const QString& name) { m_name = name; }
+    QString name() const { return m_name; }
+
+    void setType(Type* type) { m_type = type; }
+    Type* type() const { return m_type; }
+
+    void setAccess(Access access) { m_access = access; }
+    Access access() const { return m_access; }
+
+    void setFlag(Flag flag) { m_flags |= flag; }
+    void removeFlag(Flag flag) { m_flags &= ~flag; }
+    Flags flags() const { return m_flags; }
+
+    virtual QString toString(bool withAccess = false, bool withClass = false) const;
+
+protected:
+    BasicTypeDeclaration* m_typeDecl;
+    QString m_name;
+    Type* m_type;
+    Access m_access;
+    Flags m_flags;
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(Member::Flags)
+
+class GENERATOR_EXPORT EnumMember : public Member
+{
+public:
+    EnumMember(Enum* e = 0, const QString& name = QString(), const QString& value = QString(), Type* type = 0)
+        : Member(e, name, type), m_value(value) {}
+
+    Enum* getEnum() const { return static_cast<Enum*>(m_typeDecl); }
+
+    void setValue(const QString& value) { m_value = value; }
+    QString value() const { return m_value; }
+
+    QString toString() const;
+
+protected:
+    QString m_value;
+};
+
+class GENERATOR_EXPORT Parameter
+{
+public:
+    Parameter(const QString& name = QString(), Type* type = 0, const QString& defaultValue = QString())
+        : m_name(name), m_type(type), m_defaultValue(defaultValue) {}
+    virtual ~Parameter() {}
+
+    bool isValid() const { return m_type; }
+
+    void setName(const QString& name) { m_name = name; }
+    QString name() const { return m_name; }
+
+    void setType(Type* type) { m_type = type; }
+    Type* type() const { return m_type; }
+
+    bool isDefault() const { return !m_defaultValue.isEmpty(); }
+
+    QString defaultValue() const { return m_defaultValue; }
+    void setDefaultValue(const QString& value) { m_defaultValue = value; }
+
+    QString toString() const;
+
+protected:
+    QString m_name;
+    Type* m_type;
+    QString m_defaultValue;
+};
+
+typedef QList<Parameter> ParameterList;
+
+class GENERATOR_EXPORT Method : public Member
+{
+public:
+    Method(Class* klass = 0, const QString& name = QString(), Type* type = 0, Access access = Access_public, ParameterList params = ParameterList())
+        : Member(klass, name, type, access), m_params(params), m_isConstructor(false), m_isDestructor(false), m_isConst(false), m_is_accessor(false),
+          m_hasExceptionSpec(false), m_isSignal(false), m_isSlot(false) {}
+    virtual ~Method() {}
+
+    Class* getClass() const { return static_cast<Class*>(m_typeDecl); }
+
+    const ParameterList& parameters() const { return m_params; }
+    void appendParameter(const Parameter& param) { m_params.append(param); }
+    void setParameterList(const ParameterList& params) { m_params = params; }
+
+    void setIsConstructor(bool isCtor) { m_isConstructor = isCtor; }
+    bool isConstructor() const { return m_isConstructor; }
+
+    void setIsDestructor(bool isDtor) { m_isDestructor = isDtor; }
+    bool isDestructor() const { return m_isDestructor; }
+
+    void setIsConst(bool isConst) { m_isConst = isConst; }
+    bool isConst() const { return m_isConst; }
+
+    void setIsQPropertyAccessor(bool isAccessor) { m_is_accessor = isAccessor; }
+    bool isQPropertyAccessor() const { return m_is_accessor; }
+
+    void setIsSignal(bool isSignal) { m_isSignal = isSignal; }
+    bool isSignal() const { return m_isSignal; }
+    
+    void setIsSlot(bool isSlot) { m_isSlot = isSlot; }
+    bool isSlot() const { return m_isSlot; }
+
+    // TODO: This actually doesn't belong here. Better add a dynamic property system to Member subclasses.
+    //       Then we can also get rid of the various method => foo maps in the 'Util' struct.
+    const QStringList& remainingDefaultValues() const { return m_remainingValues; }
+    void setRemainingDefaultValues(const QStringList& params) { m_remainingValues = params; }
+
+    void setHasExceptionSpec(bool hasSpec) { m_hasExceptionSpec = hasSpec; }
+    bool hasExceptionSpec() const { return m_hasExceptionSpec; }
+
+    void appendExceptionType(const Type& type) { m_exceptionTypes.append(type); }
+    const QList<Type>& exceptionTypes() const { return m_exceptionTypes; }
+
+    virtual QString toString(bool withAccess = false, bool withClass = false, bool withInitializer = true) const;
+
+protected:
+    ParameterList m_params;
+    bool m_isConstructor;
+    bool m_isDestructor;
+    bool m_isConst;
+    bool m_is_accessor;
+    bool m_hasExceptionSpec;
+    bool m_isSignal;
+    bool m_isSlot;
+    QList<Type> m_exceptionTypes;
+    QStringList m_remainingValues;
+};
+
+class GENERATOR_EXPORT Field : public Member
+{
+public:
+    Field(Class* klass = 0, const QString& name = QString(), Type* type = 0, Access access = Access_public)
+        : Member(klass, name, type, access) {}
+    virtual ~Field() {}
+
+    Class* getClass() const { return static_cast<Class*>(m_typeDecl); }
+};
+
+class GENERATOR_EXPORT GlobalVar
+{
+public:
+    GlobalVar(const QString& name = QString(), const QString nspace = QString(), Type* type = 0) : m_name(name), m_nspace(nspace), m_type(type) {}
+    virtual ~GlobalVar() {}
+
+    bool isValid() const { return (!m_name.isEmpty() && m_type); }
+
+    void setName(const QString& name) { m_name = name; }
+    QString name() const { return m_name; }
+    QString qualifiedName() const {
+        QString ret = m_nspace;
+        if (!ret.isEmpty())
+            ret += "::";
+        ret += m_name;
+        return ret;
+    }
+
+    void setNameSpace(const QString& nspace) { m_nspace = nspace; }
+    QString nameSpace() const { return m_nspace; }
+
+    void setType(Type* type) { m_type = type; }
+    Type* type() const { return m_type; }
+
+    void setFileName(const QString& fileName) { m_file = fileName; }
+    QString fileName() const { return m_file; }
+
+    virtual QString toString() const;
+
+protected:
+    QString m_name;
+    QString m_nspace;
+    Type* m_type;
+    QString m_file;
+};
+
+class GENERATOR_EXPORT Function : public GlobalVar
+{
+public:
+    Function(const QString& name = QString(), const QString nspace = QString(), Type* type = 0, ParameterList params = ParameterList())
+        : GlobalVar(name, nspace, type), m_params(params) {}
+
+    const ParameterList& parameters() const { return m_params; }
+    void appendParameter(const Parameter& param) { m_params.append(param); }
+
+    virtual QString toString() const;
+
+protected:
+    ParameterList m_params;
+};
+
+class GENERATOR_EXPORT Type
+{
+public:
+    Type(Class* klass = 0, bool isConst = false, bool isVolatile = false, int pointerDepth = 0, bool isRef = false)
+        : m_class(klass), m_typedef(0), m_enum(0), m_isConst(isConst), m_isVolatile(isVolatile), 
+          m_pointerDepth(pointerDepth), m_isRef(isRef), m_isIntegral(false), m_isFunctionPointer(false) {}
+    Type(Typedef* tdef, bool isConst = false, bool isVolatile = false, int pointerDepth = 0, bool isRef = false)
+        : m_class(0), m_typedef(tdef), m_enum(0), m_isConst(isConst), m_isVolatile(isVolatile), 
+          m_pointerDepth(pointerDepth), m_isRef(isRef), m_isIntegral(false), m_isFunctionPointer(false) {}
+    Type(Enum* e, bool isConst = false, bool isVolatile = false, int pointerDepth = 0, bool isRef = false)
+        : m_class(0), m_typedef(0), m_enum(e), m_isConst(isConst), m_isVolatile(isVolatile), 
+          m_pointerDepth(pointerDepth), m_isRef(isRef), m_isIntegral(false), m_isFunctionPointer(false) {}
+    Type(const QString& name, bool isConst = false, bool isVolatile = false, int pointerDepth = 0, bool isRef = false)
+        : m_class(0), m_typedef(0), m_enum(0), m_name(name), m_isConst(isConst), m_isVolatile(isVolatile), 
+          m_pointerDepth(pointerDepth), m_isRef(isRef), m_isIntegral(false), m_isFunctionPointer(false) {}
+
+    void setClass(Class* klass) { m_class = klass; m_typedef = 0; m_enum = 0; }
+    Class* getClass() const { return m_class; }
+    
+    void setTypedef(Typedef* tdef) { m_typedef = tdef; m_class = 0; m_enum = 0; }
+    Typedef* getTypedef() const { return m_typedef; }
+
+    void setEnum(Enum* e) { m_enum = e; m_class = 0; m_typedef = 0; }
+    Enum* getEnum() const { return m_enum; }
+
+    void setName(const QString& name) { m_name = name; }
+    QString name() const {
+        if (m_class) {
+            return m_class->toString();
+        } else if (m_typedef) {
+            return m_typedef->toString();
+        } else if (m_enum) {
+            return m_enum->toString();
+        } else {
+            return m_name;
+        }
+    }
+
+    bool isValid() const { return (m_class || m_typedef || !m_name.isEmpty()); }
+    
+    void setIsConst(bool isConst) { m_isConst = isConst; }
+    bool isConst() const { return m_isConst; }
+    void setIsVolatile(bool isVolatile) { m_isVolatile = isVolatile; }
+    bool isVolatile() const { return m_isVolatile; }
+    
+    void setPointerDepth(int depth) { m_pointerDepth = depth; }
+    int pointerDepth() const { return m_pointerDepth; }
+    
+    void setIsConstPointer(int depth, bool isConst) { m_constPointer[depth] = isConst; }
+    bool isConstPointer(int depth) const { return m_constPointer.value(depth, false); }
+    
+    void setIsRef(bool isRef) { m_isRef = isRef; }
+    bool isRef() const { return m_isRef; }
+
+    void setIsIntegral(bool isIntegral) { m_isIntegral = isIntegral; }
+    bool isIntegral() const { return m_isIntegral; }
+
+    void setArrayDimensions(int dim) { m_arrayLengths.resize(dim); }
+    int arrayDimensions() const { return m_arrayLengths.size(); }
+    bool isArray() const { return m_arrayLengths.size(); }
+
+    void setArrayLength(int dim, int length) { m_arrayLengths[dim] = length; }
+    int arrayLength(int dim) const { return m_arrayLengths[dim]; }
+
+    const QList<Type>& templateArguments() const { return m_templateArgs; }
+    void appendTemplateArgument(const Type& type) { m_templateArgs.append(type); }
+    void setTemplateArguments(const QList<Type>& types) { m_templateArgs = types; }
+
+    void setIsFunctionPointer(bool isPtr) { m_isFunctionPointer = isPtr; }
+    bool isFunctionPointer() const { return m_isFunctionPointer; }
+    const ParameterList& parameters() const { return m_params; }
+    void appendParameter(const Parameter& param) { m_params.append(param); }
+
+    QString toString(const QString& fnPtrName = QString()) const;
+
+    // on windows, we can't reference 'types' here, because it's marked __declspec(dllexport) above.
+    static Type* registerType(const Type& type)
+#ifndef Q_OS_WIN
+    {
+        QString typeString = type.toString();
+        QHash<QString, Type>::iterator iter = types.insert(typeString, type);
+        return &iter.value();
+    }
+#else
+    ;
+#endif
+
+    static const Type* Void;
+
+protected:
+    Class* m_class;
+    Typedef* m_typedef;
+    Enum* m_enum;
+    QString m_name;
+    bool m_isConst, m_isVolatile;
+    int m_pointerDepth;
+    QHash<int, bool> m_constPointer;
+    bool m_isRef;
+    bool m_isIntegral;
+    QList<Type> m_templateArgs;
+    bool m_isFunctionPointer;
+    ParameterList m_params;
+    QVector<int> m_arrayLengths;
+};
+
+#endif // TYPE_H