tools/porting/src/codemodel.h
changeset 0 1918ee327afb
child 4 3b1da2848fc7
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/porting/src/codemodel.h	Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,777 @@
+/****************************************************************************
+**
+** Copyright (C) 2001-2004 Roberto Raggi
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the qt3to4 porting application of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef CODEMODEL_H
+#define CODEMODEL_H
+
+#include "smallobject.h"
+#include "tokenengine.h"
+
+#include <QByteArray>
+#include <QList>
+#include <QMap>
+#include <QHash>
+
+QT_BEGIN_NAMESPACE
+
+namespace CodeModel
+{
+
+// types
+struct Type;
+struct EnumType;
+struct EnumeratorType;
+struct ClassType;
+struct BuiltinType;
+struct PointerType;
+struct ReferenceType;
+struct GenericType;
+struct AliasType;
+struct FunctionType;
+struct UnknownType;
+
+// Scopes contain child scopes, members and types.
+struct Scope;
+struct ClassScope;
+struct NamespaceScope;
+struct BlockScope;
+
+// Members introduces names into scopes, and are also linked to a specific
+// token in a source file.
+struct Member;
+struct FunctionMember;
+struct VariableMember;
+struct UsingDeclarationMember;
+struct NamespaceMember;
+struct TypeMember;
+
+// Name uses links uses of a name to its declaration (a Member), and also to a
+// token in a source file.
+struct NameUse;
+
+struct Argument;
+struct UsingDirectiveLink;
+
+template <typename CollectedType>
+class Collection: public QMultiHash<QByteArray, CollectedType *>
+{
+public:
+     void add(CollectedType *collectedItem)
+    { insert(collectedItem->name(), collectedItem); }
+};
+
+typedef Collection<Scope> ScopeCollection;
+typedef Collection<Member> MemberCollection;
+typedef Collection<Type> TypeCollection;
+typedef Collection<NameUse> NameUseCollection;
+typedef Collection<Argument> ArgumentCollection;
+
+struct SemanticInfo
+{
+    CodeModel::NamespaceScope *codeModel;
+
+    // tokenindex -> NameUse* map. Use map here bacause we expect name uses to
+    // be sparesly distributed among the tokens.
+    QMap<int, NameUse*> nameUses;
+};
+
+
+struct Item
+{
+    Item()  {}
+    virtual ~Item() {}
+    virtual QByteArray name() const = 0;
+};
+
+struct Type: public Item
+{
+    virtual QByteArray name() const =0;
+
+    virtual EnumType *toEnumType() const
+    { return 0; }
+
+    virtual ClassType *toClassType() const
+    { return 0; }
+
+    virtual UnknownType *toUnknownType() const
+    { return 0; }
+
+    virtual BuiltinType *toBuiltinType() const
+    { return 0; }
+
+    virtual PointerType *toPointerType() const
+    { return 0; }
+
+    virtual ReferenceType *toReferenceType() const
+    { return 0; }
+
+    virtual GenericType *toGenericType() const
+    { return 0; }
+
+    virtual AliasType *toAliasType() const
+    { return 0; }
+};
+
+struct Scope: public Item
+{
+    Scope()
+     : m_parent(0) {}
+
+    void setParent(Scope *parent)
+    { m_parent = parent; }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    QByteArray name() const
+    { return m_name; }
+
+    void setName(const QByteArray &name)
+    { m_name=name; }
+
+    virtual NamespaceScope *toNamespaceScope() const
+    { return 0; }
+
+    virtual ClassScope *toClassScope() const
+    { return 0; }
+
+    virtual BlockScope *toBlockScope() const
+    { return 0; }
+
+    const Collection<Scope> scopes() const
+    { return m_scopes; }
+    const Collection<Type> types() const
+    { return m_types; }
+    const Collection<Member> members() const
+    { return m_members; }
+    const Collection<NameUse> nameUses() const
+    { return m_nameUses; }
+
+    void addScope(Scope *scope);
+    void addType(Type *type);
+    void addMember(Member *member);
+    void addNameUse(NameUse *nameUse);
+private:
+    Scope *m_parent;
+    QByteArray m_name;
+    Collection<Scope> m_scopes;
+    Collection<Type> m_types;
+    Collection<Member> m_members;
+    Collection<NameUse> m_nameUses;
+};
+
+struct Member: public Item
+{
+    enum Binding // ### not used yet
+    {
+        Static,
+        Instance
+    };
+
+    enum Access // ### not used yet
+    {
+        Public,
+        Protected,
+        Private
+    };
+
+    Member()
+        : m_binding(Static), m_access(Public),
+        m_parent(0), m_constant(0), m_static(0)   {}
+
+    QByteArray name() const
+    { return m_name; }
+
+    void setName(const QByteArray &name)
+    { m_name = name; }
+
+    TokenEngine::TokenRef nameToken() const
+    { return m_nameToken; }
+
+    void setNameToken(TokenEngine::TokenRef nameToken)
+    { m_nameToken = nameToken; }
+
+    Binding binding() const
+    { return m_binding; }
+
+    void setBinding(Binding binding)
+    { m_binding = binding; }
+
+    Access access() const
+    { return m_access; }
+
+    void setAccess(Access access)
+    { m_access = access; }
+
+    bool isConstant() const
+    { return m_constant; }
+
+    void setConstant(bool b)
+    { m_constant = b; }
+
+    bool isStatic() const
+    { return m_static; }
+
+    void setStatic(bool b)
+    { m_static = b; }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    void setParent(Scope *parent)
+    { m_parent = parent; }
+
+    virtual FunctionMember *toFunctionMember() const
+    { return 0; }
+
+    virtual VariableMember *toVariableMember() const
+    { return 0; }
+
+    virtual UsingDeclarationMember *toUsingDeclarationMember() const
+    { return 0; }
+
+    virtual NamespaceMember *toNamespaceMember() const
+    { return 0; }
+
+    virtual TypeMember *toTypeMember() const
+    { return 0; }
+
+ private:
+     Binding m_binding;
+     Access m_access;
+     Scope *m_parent;
+     QByteArray m_name;
+     TokenEngine::TokenRef m_nameToken;
+     uint m_constant : 1;
+     uint m_static : 1;
+};
+
+struct ClassScope: public Scope
+{
+    const Collection<Type> baseClasses() const
+    { return m_baseClasses; }
+
+    void addBaseClass(Type *baseClass)
+    {
+        Q_ASSERT(baseClass->toClassType());
+        m_baseClasses.add(baseClass);
+    }
+
+    virtual ClassScope *toClassScope() const
+    { return const_cast<ClassScope*>(this); }
+
+private:
+    Collection<Type> m_baseClasses;
+};
+
+struct UsingDirectiveLinkable : public Scope
+{
+    const QList<UsingDirectiveLink *> usingDirectiveLinks() const
+    { return m_usingDirectiveLinks; }
+
+    void addUsingDirectiveLink(UsingDirectiveLink *usingDirectiveLink)
+    { m_usingDirectiveLinks.append(usingDirectiveLink); }
+private:
+    QList<UsingDirectiveLink *> m_usingDirectiveLinks;
+};
+
+struct NamespaceScope: public UsingDirectiveLinkable
+{
+    NamespaceScope() {}
+
+    virtual NamespaceScope *toNamespaceScope() const
+    { return const_cast<NamespaceScope*>(this); }
+};
+
+struct BlockScope: public UsingDirectiveLinkable
+{
+    BlockScope() {}
+
+    virtual BlockScope *toBlockScope() const
+    { return const_cast<BlockScope*>(this); }
+};
+
+struct EnumType: public Type
+{
+    EnumType()
+        : m_parent(0) {}
+
+    QByteArray name() const
+    { return m_name; }
+
+    void setName(const QByteArray &name)
+    { m_name = name; }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    void setParent(Scope *parent)
+    { m_parent = parent; }
+
+    virtual EnumType *toEnumType() const
+    { return const_cast<EnumType*>(this); }
+
+private:
+    Scope *m_parent;
+    QByteArray m_name;
+};
+
+struct UnknownType: public Type
+{
+    UnknownType()
+        : m_parent(0) {}
+
+    QByteArray name() const
+    { return m_name; }
+
+    void setName(const QByteArray &name)
+    { m_name = name; }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    void setParent(Scope *parent)
+    { m_parent = parent; }
+
+    virtual UnknownType *toUnknownType() const
+    { return const_cast<UnknownType*>(this); }
+
+private:
+    Scope *m_parent;
+    QByteArray m_name;
+};
+
+struct ClassType: public Type
+{
+    ClassType()
+        : m_parent(0), m_scope(0) {}
+
+    ClassScope *scope() const
+    { return m_scope; }
+
+    void setScope(ClassScope *scope)
+    { m_scope = scope; }
+
+    QByteArray name() const
+    { return m_scope ? m_scope->name() : /*anonymous*/ QByteArray(); }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    void setParent(Scope *parent)
+    { m_parent = parent; }
+
+    virtual ClassType *toClassType() const
+    { return const_cast<ClassType*>(this); }
+
+private:
+    Scope *m_parent;
+    ClassScope *m_scope;
+
+};
+
+struct BuiltinType: public Type
+{
+protected:
+    BuiltinType(const QByteArray &name, Scope *parent)
+        : m_name(name), m_parent(parent) {}
+
+public:
+    QByteArray name() const
+    { return m_name; }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    virtual BuiltinType *toBuiltinType() const
+    { return const_cast<BuiltinType*>(this); }
+
+    static BuiltinType Bool;
+    static BuiltinType Void;
+    static BuiltinType Char;
+    static BuiltinType Short;
+    static BuiltinType Int;
+    static BuiltinType Long;
+    static BuiltinType Double;
+    static BuiltinType Float;
+    static BuiltinType Unsigned;
+    static BuiltinType Signed;
+    // ### more
+
+private:
+    QByteArray m_name;
+    Scope *m_parent;
+};
+
+struct PointerType: public Type
+{
+    PointerType()
+        : m_parent(0), m_baseType(0) {}
+
+    Type *baseType() const
+    { return m_baseType; }
+
+    void setBaseType(Type *baseType)
+    { m_baseType = baseType; }
+
+    QByteArray name() const
+    { return m_baseType->name(); }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    void setParent(Scope *parent)
+    { m_parent = parent; }
+
+    virtual PointerType *toPointerType() const
+    { return const_cast<PointerType*>(this); }
+
+private:
+    Scope *m_parent;
+    Type *m_baseType;
+};
+
+struct ReferenceType: public Type
+{
+    ReferenceType()
+        : m_parent(0), m_baseType(0) {}
+
+    Type *baseType() const
+    { return m_baseType; }
+
+    void setBaseType(Type *baseType)
+    { m_baseType = baseType; }
+
+    QByteArray name() const
+    { return m_baseType->name(); }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    void setParent(Scope *parent)
+    { m_parent = parent; }
+
+    virtual ReferenceType *toReferenceType() const
+    { return const_cast<ReferenceType*>(this); }
+
+private:
+    Scope *m_parent;
+    Type *m_baseType;
+};
+
+struct GenericType: public Type // ### implement me
+{
+    virtual GenericType *toGenericType() const
+    { return const_cast<GenericType*>(this); }
+};
+
+struct AliasType: public Type // ### implement me
+{
+    AliasType ()
+        : m_parent(0) {}
+
+    QByteArray name() const
+    {  return m_name;  }
+
+    Scope *parent() const
+    {  return m_parent;  }
+
+    virtual AliasType *toAliasType() const
+    { return const_cast<AliasType*>(this); }
+private:
+    QByteArray m_name;
+    Scope *m_parent;
+};
+
+struct Argument: public Item
+{
+    Argument()
+        : m_parent(0), m_type(0) {}
+
+    Type *type() const
+    { return m_type; }
+
+    void setType(Type *type)
+    { m_type = type; }
+
+    QByteArray name() const
+    { return m_name; }
+
+    void setName(const QByteArray &name)
+    { m_name = name; }
+
+    TokenEngine::TokenRef nameToken() const
+    { return m_nameToken; }
+
+    void setNameToken(TokenEngine::TokenRef nameToken)
+    { m_nameToken = nameToken; }
+
+    virtual FunctionMember *parent() const
+    { return m_parent; }
+
+    void setParent(FunctionMember *parent)
+    { m_parent = parent; }
+
+private:
+    FunctionMember *m_parent;
+    Type *m_type;
+    QByteArray m_name;
+    TokenEngine::TokenRef m_nameToken;
+};
+
+struct FunctionMember: public Member
+{
+    inline FunctionMember()
+        : m_returnType(0),
+          m_functionBodyScope(0),
+          m_signal(0),
+          m_virtual(0), m_abstract(0) { m_slot = 0; }
+
+    virtual FunctionMember *toFunctionMember() const
+    { return const_cast<FunctionMember*>(this); }
+
+    Type *returnType() const
+    { return m_returnType; }
+
+    void setReturnType(Type *type)
+    { m_returnType = type; }
+
+    const Collection<Argument> arguments() const
+    { return m_arguments; }
+
+    void addArgument(Argument *argument)
+    { m_arguments.insert(argument->name(), argument); }
+
+    void setFunctionBodyScope(BlockScope *functionBodyScope)
+    { m_functionBodyScope = functionBodyScope; }
+
+    BlockScope *functionBodyScope() const
+    {return m_functionBodyScope;}
+
+    bool isSignal() const
+    { return m_signal; }
+
+    void setSignal(bool b)
+    { m_signal = b; }
+
+    bool isSlot() const
+    { return m_slot; }
+
+    void setSlot(bool b)
+    { m_slot = b; }
+
+    bool isVirtual() const
+    { return m_virtual; }
+
+    void setVirtual(bool b)
+    { m_virtual = b; }
+
+    bool isAbstract() const
+    { return m_abstract; }
+
+    void setAbstract(bool b)
+    { m_abstract = b; }
+
+private:
+    Type *m_returnType;
+    Collection<Argument> m_arguments;
+    BlockScope *m_functionBodyScope;
+    uint m_signal: 1;
+    uint m_slot: 1;
+    uint m_virtual: 1;
+    uint m_abstract: 1;
+};
+
+struct VariableMember: public Member
+{
+    VariableMember()
+        : m_type(0) {}
+
+    Type *type() const
+    { return m_type; }
+
+    void setType(Type *type)
+    { m_type = type; }
+
+    virtual VariableMember *toVariableMember() const
+    { return const_cast<VariableMember*>(this); }
+
+private:
+    Type *m_type;
+};
+
+struct UsingDeclarationMember: public Member
+{
+    UsingDeclarationMember()
+    : m_member(0) {}
+
+    virtual UsingDeclarationMember *toUsingDeclarationMember() const
+    { return const_cast<UsingDeclarationMember*>(this); }
+
+    Member *member() const
+    { return m_member; }
+
+    void setMember(Member *member)
+    { m_member = member; }
+
+private:
+    Member *m_member;
+};
+
+struct NamespaceMember: public Member
+{
+    NamespaceMember()
+        :m_namespaceScope(0) {}
+
+    virtual NamespaceMember *toNamespaceMember() const
+    { return const_cast<NamespaceMember*>(this); }
+
+    NamespaceScope *namespaceScope() const
+    { return m_namespaceScope; }
+
+    void setNamespaceScope(NamespaceScope *namespaceScope)
+    { m_namespaceScope = namespaceScope; }
+private:
+    NamespaceScope *m_namespaceScope;
+};
+
+struct TypeMember: public Member
+{
+    TypeMember()
+        :m_type(0) {}
+
+    virtual TypeMember *toTypeMember() const
+    { return const_cast<TypeMember*>(this); }
+
+    Type *type() const
+    { return m_type; }
+
+    void setType(Type *type)
+    { m_type = type; }
+private:
+    Type *m_type;
+
+};
+
+struct NameUse: public Item
+{
+    NameUse()
+    : m_declaration(0), m_parent(0) {}
+
+    QByteArray name() const
+    { return m_name; }
+
+    void setName(const QByteArray &name)
+    {  m_name = name; }
+
+     TokenEngine::TokenRef nameToken() const
+    { return m_nameToken; }
+
+    void setNameToken(TokenEngine::TokenRef nameToken)
+    { m_nameToken = nameToken; }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    void setParent(Scope *parent)
+    { m_parent = parent; }
+
+    Member *declaration() const
+    { return m_declaration; }
+
+    void setDeclaration(Member *parent)
+    { m_declaration = parent; }
+
+private:
+    QByteArray m_name;
+    TokenEngine::TokenRef m_nameToken;
+    Member *m_declaration;
+    Scope *m_parent;
+};
+
+struct UsingDirectiveLink: public Item
+{
+    UsingDirectiveLink()
+        : m_parent(0), m_targetNamespace(0), m_insertionNamespace(0) {}
+
+    QByteArray name() const
+    { return QByteArray(); }
+
+    Scope *parent() const
+    { return m_parent; }
+
+    void setParent(Scope *parent)
+    { m_parent = parent; }
+
+    NamespaceScope *targetNamespace() const
+    { return m_targetNamespace; }
+
+    void setTargetNamespace(NamespaceScope *targetNamespace)
+    { m_targetNamespace = targetNamespace; }
+
+    NamespaceScope *insertionNamespace() const
+    { return m_insertionNamespace; }
+
+    void setInsertionNamespace(NamespaceScope *insertionNamespace)
+    { m_insertionNamespace = insertionNamespace; }
+private:
+    Scope *m_parent;
+    // targetNamespace is the namespace specified by the using directive.
+    NamespaceScope *m_targetNamespace;
+    // m_insertionNamespace is the namespace where the names from
+    // targetNamespace will be inserted. The C++ standard (7.3.4.1)
+    // defines this as the nearest namespace that includes both m_parent
+    // and m_targetNamespace.
+    NamespaceScope *m_insertionNamespace;
+};
+
+template <class T>
+T *Create(TypedPool<CodeModel::Item> *p)
+{
+    return new (p->allocate(sizeof(T))) T();
+}
+
+} // namespace CodeModel
+
+QT_END_NAMESPACE
+
+#endif // CODEMODEL_H