cpp.h - mozsearch

Enable keyboard shortcuts

// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

#ifndef CPP_H

#define CPP_H

#include <translator.h>

#include <QtCore/QSet>

#include <QtCore/QStack>

QT_BEGIN_NAMESPACE

struct HashString

    HashString() : m_hash(0x80000000) {}

    explicit HashString(const QString &str) : m_str(str), m_hash(0x80000000) {}

    void setValue(const QString &str) { m_str = str; m_hash = 0x80000000; }

    const QString &value() const { return m_str; }

    bool operator==(const HashString &other) const { return m_str == other.m_str; }

    QString m_str;

    mutable uint m_hash; // We use the highest bit as a validity indicator (set => invalid)

};

QDebug operator<<(QDebug debug, const HashString &s);

size_t qHash(const HashString &str, size_t seed = 0);

struct HashStringList {

    explicit HashStringList(const QList<HashString> &list) : m_list(list), m_hash(0x80000000) {}

    const QList<HashString> &value() const { return m_list; }

    bool operator==(const HashStringList &other) const { return m_list == other.m_list; }

    QList<HashString> m_list;

    mutable uint m_hash; // We use the highest bit as a validity indicator (set => invalid)

};

QDebug operator<<(QDebug debug, const HashStringList &lst);

size_t qHash(const HashStringList &list, size_t seed = 0);

typedef QList<HashString> NamespaceList;

struct Namespace {

    Namespace() : classDef(this) { }

    ~Namespace()

        qDeleteAll(children);

    Namespace *parent = nullptr;

    QHash<HashString, Namespace *> children;

    QHash<HashString, NamespaceList> aliases;

    QList<HashStringList> usings;

    // Class declarations set no flags and create no namespaces, so they are ignored.

    // Class definitions may appear multiple times - but only because we are trying to

    // "compile" all sources irrespective of build configuration.

    // Nested classes may be forward-declared inside a definition, and defined in another file.

    // The latter will detach the class' child list, so clones need a backlink to the original

    // definition (either one in case of multiple definitions).

    // Namespaces can have tr() functions as well, so we need to track parent definitions for

    // them as well. The complication is that we may have to deal with a forrest instead of

    // a tree - in that case the parent will be arbitrary. However, it seem likely that

    // Q_DECLARE_TR_FUNCTIONS would be used either in "class-like" namespaces with a central

    // header or only locally in a file.

    Namespace *classDef;

    QString trQualification;

    bool hasTrFunctions = false;

    bool complained = false; // ... that tr functions are missing.

    bool isClass = false; // True if this represents a class, false for namespace

};

struct ParseResults {

    int fileId;

    Namespace rootNamespace;

    QSet<const ParseResults *> includes;

};

struct IncludeCycle {

    QSet<QString> fileNames;

    QSet<const ParseResults *> results;

};

struct CppParserState

    NamespaceList namespaces;

    QStack<qsizetype> namespaceDepths;

    NamespaceList functionContext;

    QString functionContextUnresolved;

    QString pendingContext;

    bool operator==(const CppParserState &other) const

        return namespaces == other.namespaces

            && namespaceDepths == other.namespaceDepths

            && functionContext == other.functionContext

            && functionContextUnresolved == other.functionContextUnresolved

            && pendingContext == other.pendingContext;

};

size_t qHash(const CppParserState &s, size_t seed);

struct ResultsCacheKey

    const QString cleanFile;

    const CppParserState parserState;

    ResultsCacheKey(const QString &filePath)

        : cleanFile(filePath)

    ResultsCacheKey(const QString &filePath, const CppParserState &state)

        : cleanFile(filePath),

          parserState(state)

    bool operator==(const ResultsCacheKey &other) const

        return cleanFile == other.cleanFile

            && parserState == other.parserState;

};

size_t qHash(const ResultsCacheKey &key, size_t seed);

typedef QHash<ResultsCacheKey, IncludeCycle *> IncludeCycleHash;

typedef QHash<QString, const Translator *> TranslatorHash;

class CppFiles {

public:

    static QSet<const ParseResults *> getResults(const ResultsCacheKey &key);

    static void setResults(const ResultsCacheKey &key, const ParseResults *results);

    static const Translator *getTranslator(const QString &cleanFile);

    static void setTranslator(const QString &cleanFile, const Translator *results);

    static bool isBlacklisted(const QString &cleanFile);

    static void setBlacklisted(const QString &cleanFile);

    static void addIncludeCycle(const QSet<QString> &fileNames, const CppParserState &parserState);

private:

    static IncludeCycleHash &includeCycles();

    static TranslatorHash &translatedFiles();

    static QSet<QString> &blacklistedFiles();

};

QT_END_NAMESPACE

#endif // CPP_H