diff -r 000000000000 -r 1918ee327afb tools/qdoc3/node.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/qdoc3/node.h	Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,717 @@
+/****************************************************************************
+**
+** 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 tools applications 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$
+**
+****************************************************************************/
+
+/*
+  node.h
+*/
+
+#ifndef NODE_H
+#define NODE_H
+
+#include <qdir.h>
+#include <qmap.h>
+#include <qpair.h>
+#include <qstringlist.h>
+
+#include "codechunk.h"
+#include "doc.h"
+#include "location.h"
+#include "text.h"
+
+QT_BEGIN_NAMESPACE
+
+class InnerNode;
+
+class Node
+{
+ public:
+    enum Type { 
+        Namespace, 
+        Class, 
+        Fake, 
+        Enum, 
+        Typedef, 
+        Function, 
+        Property,
+        Variable, 
+#ifdef QDOC_QML
+        Target,
+        QmlProperty,
+        QmlSignal,
+        QmlMethod,
+        LastType
+#else
+        Target,
+        LastType
+#endif
+    };
+
+    enum SubType { 
+        NoSubType,
+        Example, 
+        HeaderFile, 
+        File,
+        Group,
+        Module,
+        Page,
+#ifdef QDOC_QML
+        ExternalPage,
+        QmlClass,
+        QmlPropertyGroup
+#else
+        ExternalPage
+#endif
+    };
+    
+    enum Access { Public, Protected, Private };
+    
+    enum Status { 
+        Compat, 
+        Obsolete, 
+        Deprecated, 
+        Preliminary, 
+        Commendable, 
+        Main, 
+        Internal 
+    }; // don't reorder thisw enum
+    
+    enum ThreadSafeness { 
+        UnspecifiedSafeness, 
+        NonReentrant, 
+        Reentrant, 
+        ThreadSafe 
+    };
+    
+    enum LinkType { 
+        StartLink, 
+        NextLink, 
+        PreviousLink,
+        ContentsLink, 
+        IndexLink,
+        InheritsLink /*, 
+        GlossaryLink, 
+        CopyrightLink,
+        ChapterLink, 
+        SectionLink, 
+        SubsectionLink, 
+        AppendixLink */ 
+    };
+
+    virtual ~Node();
+
+    void setAccess(Access access) { acc = access; }
+    void setLocation(const Location& location) { loc = location; }
+    void setDoc(const Doc& doc, bool replace = false);
+    void setStatus(Status status) { sta = status; }
+    void setThreadSafeness(ThreadSafeness safeness) { saf = safeness; }
+    void setSince(const QString &since) { sinc = since; }
+    void setRelates(InnerNode *pseudoParent);
+    void setModuleName(const QString &module) { mod = module; }
+    void setLink(LinkType linkType, const QString &link, const QString &desc);
+    void setUrl(const QString &url);
+    void setTemplateStuff(const QString &templateStuff) { tpl = templateStuff; }
+
+    virtual bool isInnerNode() const = 0;
+    virtual bool isReimp() const { return false; }
+    Type type() const { return typ; }
+    virtual SubType subType() const { return NoSubType; }
+    InnerNode *parent() const { return par; }
+    InnerNode *relates() const { return rel; }
+    const QString& name() const { return nam; }
+    QMap<LinkType, QPair<QString,QString> > links() const { return linkMap; }
+    QString moduleName() const;
+    QString url() const;
+    virtual QString nameForLists() const { return nam; }
+
+    Access access() const { return acc; }
+    const Location& location() const { return loc; }
+    const Doc& doc() const { return d; }
+    Status status() const { return sta; }
+    Status inheritedStatus() const;
+    ThreadSafeness threadSafeness() const;
+    ThreadSafeness inheritedThreadSafeness() const;
+    QString since() const { return sinc; }
+    QString templateStuff() const { return tpl; }
+
+    void clearRelated() { rel = 0; }
+
+    virtual QString fileBase() const;
+
+ protected:
+    Node(Type type, InnerNode *parent, const QString& name);
+
+ private:
+
+#ifdef Q_WS_WIN
+    Type typ;
+    Access acc;
+    Status sta;
+    ThreadSafeness saf;
+#else
+    Type typ : 4;
+    Access acc : 2;
+    Status sta : 3;
+    ThreadSafeness saf : 2;
+#endif
+    InnerNode *par;
+    InnerNode *rel;
+    QString nam;
+    Location loc;
+    Doc d;
+    QMap<LinkType, QPair<QString, QString> > linkMap;
+    QString mod;
+    QString u;
+    QString sinc;
+    QString tpl;
+};
+
+class FunctionNode;
+class EnumNode;
+
+typedef QList<Node *> NodeList;
+
+class InnerNode : public Node
+{
+ public:
+    virtual ~InnerNode();
+
+    Node *findNode(const QString& name);
+    Node *findNode(const QString& name, Type type);
+    FunctionNode *findFunctionNode(const QString& name);
+    FunctionNode *findFunctionNode(const FunctionNode *clone);
+    void addInclude(const QString &include);
+    void setIncludes(const QStringList &includes);
+    void setOverload(const FunctionNode *func, bool overlode);
+    void normalizeOverloads();
+    void makeUndocumentedChildrenInternal();
+    void deleteChildren();
+    void removeFromRelated();
+
+    virtual bool isInnerNode() const;
+    const Node *findNode(const QString& name) const;
+    const Node *findNode(const QString& name, Type type) const;
+    const FunctionNode *findFunctionNode(const QString& name) const;
+    const FunctionNode *findFunctionNode(const FunctionNode *clone) const;
+    const EnumNode *findEnumNodeForValue(const QString &enumValue) const;
+    const NodeList & childNodes() const { return children; }
+    const NodeList & relatedNodes() const { return related; }
+    int count() const { return children.size(); }
+    int overloadNumber(const FunctionNode *func) const;
+    int numOverloads(const QString& funcName) const;
+    NodeList overloads(const QString &funcName) const;
+    const QStringList& includes() const { return inc; }
+
+ protected:
+    InnerNode(Type type, InnerNode *parent, const QString& name);
+
+ private:
+    friend class Node;
+
+    static bool isSameSignature(const FunctionNode *f1, const FunctionNode *f2);
+    void addChild(Node *child);
+    void removeChild(Node *child);
+    void removeRelated(Node *pseudoChild);
+
+    QStringList inc;
+    NodeList children;
+    NodeList enumChildren;
+    NodeList related;
+    QMap<QString, Node *> childMap;
+    QMap<QString, Node *> primaryFunctionMap;
+    QMap<QString, NodeList> secondaryFunctionMap;
+};
+
+class LeafNode : public Node
+{
+ public:
+    LeafNode();
+    virtual ~LeafNode() { }
+
+    virtual bool isInnerNode() const;
+
+ protected:
+    LeafNode(Type type, InnerNode* parent, const QString& name);
+};
+
+class NamespaceNode : public InnerNode
+{
+ public:
+    NamespaceNode(InnerNode *parent, const QString& name);
+    virtual ~NamespaceNode() { }
+};
+
+class ClassNode;
+
+struct RelatedClass
+{
+    RelatedClass() { }
+    RelatedClass(Node::Access access0, 
+                 ClassNode* node0,
+                 const QString& dataTypeWithTemplateArgs0 = "")
+      : access(access0), 
+        node(node0),
+        dataTypeWithTemplateArgs(dataTypeWithTemplateArgs0) { }
+
+    Node::Access        access;
+    ClassNode*          node;
+    QString             dataTypeWithTemplateArgs;
+};
+
+class ClassNode : public InnerNode
+{
+ public:
+    ClassNode(InnerNode *parent, const QString& name);
+    virtual ~ClassNode() { }
+
+    void addBaseClass(Access access, 
+                      ClassNode *node, 
+                      const QString &dataTypeWithTemplateArgs = "");
+    void fixBaseClasses();
+
+    const QList<RelatedClass> &baseClasses() const { return bas; }
+    const QList<RelatedClass> &derivedClasses() const { return der; }
+
+    bool hideFromMainList() const { return hidden; }
+    void setHideFromMainList(bool value) { hidden = value; }
+
+    QString serviceName() const { return sname; }
+    void setServiceName(const QString& value) { sname = value; }
+    QString qmlElement() const { return qmlelement; }
+    void setQmlElement(const QString& value) { qmlelement = value; }
+
+ private:
+    QList<RelatedClass> bas;
+    QList<RelatedClass> der;
+    bool hidden;
+    QString sname;
+    QString qmlelement;
+};
+
+class FakeNode : public InnerNode
+{
+ public:
+
+    FakeNode(InnerNode *parent, const QString& name, SubType subType);
+    virtual ~FakeNode() { }
+
+    void setTitle(const QString &title) { tle = title; }
+    void setSubTitle(const QString &subTitle) { stle = subTitle; }
+    void addGroupMember(Node *node) { gr.append(node); }
+
+    SubType subType() const { return sub; }
+    QString title() const { return tle; }
+    QString fullTitle() const;
+    QString subTitle() const;
+    const NodeList &groupMembers() const { return gr; }
+    virtual QString nameForLists() const { return title(); }
+
+ private:
+    SubType sub;
+    QString tle;
+    QString stle;
+    NodeList gr;
+};
+
+#ifdef QDOC_QML
+class QmlClassNode : public FakeNode
+{
+ public:
+    QmlClassNode(InnerNode *parent, 
+                 const QString& name, 
+                 const ClassNode* cn);
+    virtual ~QmlClassNode() { }
+
+    const ClassNode* classNode() const { return cnode; }
+    virtual QString fileBase() const;
+
+ private:
+    const ClassNode* cnode;
+};
+
+class QmlPropGroupNode : public FakeNode
+{
+ public:
+    QmlPropGroupNode(QmlClassNode* parent, 
+                     const QString& name,
+                     bool attached);
+    virtual ~QmlPropGroupNode() { }
+
+    const QString& element() const { return name(); }
+    void setDefault() { isdefault = true; }
+    bool isDefault() const { return isdefault; }
+    bool isAttached() const { return att; }
+
+ private:
+    bool    isdefault;
+    bool    att;
+};
+
+class QmlPropertyNode : public LeafNode
+{
+ public:
+    QmlPropertyNode(QmlPropGroupNode* parent, 
+                    const QString& name,
+                    const QString& type,
+                    bool attached);
+    virtual ~QmlPropertyNode() { }
+
+    void setDataType(const QString& dataType) { dt = dataType; }
+    void setStored(bool stored) { sto = toTrool(stored); }
+    void setDesignable(bool designable) { des = toTrool(designable); }
+
+    const QString &dataType() const { return dt; }
+    QString qualifiedDataType() const { return dt; }
+    bool isStored() const { return fromTrool(sto,true); }
+    bool isDesignable() const { return fromTrool(des,false); }
+    bool isAttached() const { return att; }
+
+    const QString& element() const { return parent()->name(); }
+
+ private:
+    enum Trool { Trool_True, Trool_False, Trool_Default };
+
+    static Trool toTrool(bool boolean);
+    static bool fromTrool(Trool troolean, bool defaultValue);
+
+    QString dt;
+    Trool   sto;
+    Trool   des;
+    bool    att;
+};
+
+class QmlSignalNode : public LeafNode
+{
+ public:
+    QmlSignalNode(QmlClassNode* parent, const QString& name);
+    virtual ~QmlSignalNode() { }
+
+    const QString& element() const { return parent()->name(); }
+};
+
+class QmlMethodNode : public LeafNode
+{
+ public:
+    QmlMethodNode(QmlClassNode* parent, const QString& name);
+    virtual ~QmlMethodNode() { }
+
+    const QString& element() const { return parent()->name(); }
+};
+#endif
+
+class EnumItem
+{
+ public:
+    EnumItem() { }
+    EnumItem(const QString& name, const QString& value)
+	: nam(name), val(value) { }
+    EnumItem(const QString& name, const QString& value, const Text &txt)
+	: nam(name), val(value), txt(txt) { }
+
+    const QString& name() const { return nam; }
+    const QString& value() const { return val; }
+    const Text &text() const { return txt; }
+
+ private:
+    QString nam;
+    QString val;
+    Text txt;
+};
+
+class TypedefNode;
+
+class EnumNode : public LeafNode
+{
+ public:
+    EnumNode(InnerNode *parent, const QString& name);
+    virtual ~EnumNode() { }
+
+    void addItem(const EnumItem& item);
+    void setFlagsType(TypedefNode *typedeff);
+    bool hasItem(const QString &name) const { return names.contains(name); }
+
+    const QList<EnumItem>& items() const { return itms; }
+    Access itemAccess(const QString& name) const;
+    const TypedefNode *flagsType() const { return ft; }
+    QString itemValue(const QString &name) const;
+
+ private:
+    QList<EnumItem> itms;
+    QSet<QString> names;
+    const TypedefNode *ft;
+};
+
+class TypedefNode : public LeafNode
+{
+ public:
+    TypedefNode(InnerNode *parent, const QString& name);
+    virtual ~TypedefNode() { }
+
+    const EnumNode *associatedEnum() const { return ae; }
+
+ private:
+    void setAssociatedEnum(const EnumNode *enume);
+
+    friend class EnumNode;
+
+    const EnumNode *ae;
+};
+
+inline void EnumNode::setFlagsType(TypedefNode *typedeff)
+{
+    ft = typedeff;
+    typedeff->setAssociatedEnum(this);
+}
+
+
+class Parameter
+{
+ public:
+    Parameter() {}
+    Parameter(const QString& leftType, 
+              const QString& rightType = "",
+              const QString& name = "", 
+              const QString& defaultValue = "");
+    Parameter(const Parameter& p);
+
+    Parameter& operator=(const Parameter& p);
+
+    void setName(const QString& name) { nam = name; }
+
+    bool hasType() const { return lef.length() + rig.length() > 0; }
+    const QString& leftType() const { return lef; }
+    const QString& rightType() const { return rig; }
+    const QString& name() const { return nam; }
+    const QString& defaultValue() const { return def; }
+
+    QString reconstruct(bool value = false) const;
+
+ private:
+    QString lef;
+    QString rig;
+    QString nam;
+    QString def;
+};
+
+class PropertyNode;
+
+class FunctionNode : public LeafNode
+{
+ public:
+    enum Metaness { 
+        Plain, 
+        Signal, 
+        Slot,
+        Ctor,
+        Dtor, 
+        MacroWithParams,
+        MacroWithoutParams, 
+        Native };
+    enum Virtualness { NonVirtual, ImpureVirtual, PureVirtual };
+
+    FunctionNode(InnerNode *parent, const QString &name);
+    virtual ~FunctionNode() { }
+
+    void setReturnType(const QString& returnType) { rt = returnType; }
+    void setParentPath(const QStringList& parentPath) { pp = parentPath; }
+    void setMetaness(Metaness metaness) { met = metaness; }
+    void setVirtualness(Virtualness virtualness) { vir = virtualness; }
+    void setConst(bool conste) { con = conste; }
+    void setStatic(bool statique) { sta = statique; }
+    void setOverload(bool overlode);
+    void setReimp(bool r);
+    void addParameter(const Parameter& parameter);
+    inline void setParameters(const QList<Parameter>& parameters);
+    void borrowParameterNames(const FunctionNode *source);
+    void setReimplementedFrom(FunctionNode *from);
+
+    const QString& returnType() const { return rt; }
+    Metaness metaness() const { return met; }
+    bool isMacro() const { 
+        return met == MacroWithParams || met == MacroWithoutParams; 
+    }
+    Virtualness virtualness() const { return vir; }
+    bool isConst() const { return con; }
+    bool isStatic() const { return sta; }
+    bool isOverload() const { return ove; }
+    bool isReimp() const { return reimp; }
+    int overloadNumber() const;
+    int numOverloads() const;
+    const QList<Parameter>& parameters() const { return params; }
+    QStringList parameterNames() const;
+    const FunctionNode *reimplementedFrom() const { return rf; }
+    const QList<FunctionNode *> &reimplementedBy() const { return rb; }
+    const PropertyNode *associatedProperty() const { return ap; }
+    const QStringList& parentPath() const { return pp; }
+
+    QStringList reconstructParams(bool values = false) const;
+    QString signature(bool values = false) const;
+
+ private:
+    void setAssociatedProperty(PropertyNode *property);
+
+    friend class InnerNode;
+    friend class PropertyNode;
+
+    QString     rt;
+    QStringList pp;
+#ifdef Q_WS_WIN
+    Metaness    met;
+    Virtualness vir;
+#else
+    Metaness met : 4;
+    Virtualness vir : 2;
+#endif
+    bool con : 1;
+    bool sta : 1;
+    bool ove : 1;
+    bool reimp: 1; 
+    QList<Parameter> params;
+    const FunctionNode *rf;
+    const PropertyNode *ap;
+    QList<FunctionNode *> rb;
+};
+
+class PropertyNode : public LeafNode
+{
+ public:
+    enum FunctionRole { Getter, Setter, Resetter, Notifier };
+    enum { NumFunctionRoles = Notifier + 1 };
+
+    PropertyNode(InnerNode *parent, const QString& name);
+    virtual ~PropertyNode() { }
+
+    void setDataType(const QString& dataType) { dt = dataType; }
+    void addFunction(FunctionNode *function, FunctionRole role);
+    void addSignal(FunctionNode *function, FunctionRole role);
+    void setStored(bool stored) { sto = toTrool(stored); }
+    void setDesignable(bool designable) { des = toTrool(designable); }
+    void setOverriddenFrom(const PropertyNode *baseProperty);
+
+    const QString &dataType() const { return dt; }
+    QString qualifiedDataType() const;
+    NodeList functions() const;
+    NodeList functions(FunctionRole role) const { return funcs[(int)role]; }
+    NodeList getters() const { return functions(Getter); }
+    NodeList setters() const { return functions(Setter); }
+    NodeList resetters() const { return functions(Resetter); }
+    NodeList notifiers() const { return functions(Notifier); }
+    bool isStored() const { return fromTrool(sto, storedDefault()); }
+    bool isDesignable() const { return fromTrool(des, designableDefault()); }
+    const PropertyNode *overriddenFrom() const { return overrides; }
+
+ private:
+    enum Trool { Trool_True, Trool_False, Trool_Default };
+
+    static Trool toTrool(bool boolean);
+    static bool fromTrool(Trool troolean, bool defaultValue);
+
+    bool storedDefault() const { return true; }
+    bool designableDefault() const { return !setters().isEmpty(); }
+
+    QString dt;
+    NodeList funcs[NumFunctionRoles];
+    Trool sto;
+    Trool des;
+    const PropertyNode *overrides;
+};
+
+inline void FunctionNode::setParameters(const QList<Parameter> &parameters)
+{
+    params = parameters;
+}
+
+inline void PropertyNode::addFunction(FunctionNode *function, FunctionRole role)
+{
+    funcs[(int)role].append(function);
+    function->setAssociatedProperty(this);
+}
+
+inline void PropertyNode::addSignal(FunctionNode *function, FunctionRole role)
+{
+    funcs[(int)role].append(function);
+}
+
+inline NodeList PropertyNode::functions() const
+{
+    NodeList list;
+    for (int i = 0; i < NumFunctionRoles; ++i)
+	list += funcs[i];
+    return list;
+}
+
+class VariableNode : public LeafNode
+{
+ public:
+    VariableNode(InnerNode *parent, const QString &name);
+    virtual ~VariableNode() { }
+
+    void setLeftType(const QString &leftType) { lt = leftType; }
+    void setRightType(const QString &rightType) { rt = rightType; }
+    void setStatic(bool statique) { sta = statique; }
+
+    const QString &leftType() const { return lt; }
+    const QString &rightType() const { return rt; }
+    QString dataType() const { return lt + rt; }
+    bool isStatic() const { return sta; }
+
+ private:
+    QString lt;
+    QString rt;
+    bool sta;
+};
+
+inline VariableNode::VariableNode(InnerNode *parent, const QString &name)
+    : LeafNode(Variable, parent, name), sta(false)
+{
+}
+
+class TargetNode : public LeafNode
+{
+ public:
+    TargetNode(InnerNode *parent, const QString& name);
+    virtual ~TargetNode() { }
+
+    virtual bool isInnerNode() const;
+};
+
+QT_END_NAMESPACE
+
+#endif