abstractincludenavigationcontext.cpp Source File

kdevplatform/language/duchain

 /*
    Copyright 2007 David Nolden <[email protected]>
  
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
  
    This library 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
    Library General Public License for more details.
  
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
  
 #include "abstractincludenavigationcontext.h"
  
 #include <KLocalizedString>
  
 #include <language/duchain/duchain.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/duchainlock.h>
  
 namespace KDevelop {
 AbstractIncludeNavigationContext::AbstractIncludeNavigationContext(const IncludeItem& item,
                                                                    const TopDUContextPointer& topContext,
                                                                    const ParsingEnvironmentType& type)
     : AbstractNavigationContext(topContext)
     , m_type(type)
     , m_item(item)
 {}
  
 TopDUContext* pickContextWithData(const QList<TopDUContext*>& duchains, uint maxDepth,
                                   const ParsingEnvironmentType& type,
                                   bool forcePick = true)
 {
     TopDUContext* duchain = nullptr;
  
     for (TopDUContext* ctx : duchains) {
         if (!ctx->parsingEnvironmentFile() || ctx->parsingEnvironmentFile()->type() != type)
             continue;
  
         if (ctx->childContexts().count() != 0
             && (duchain == nullptr || ctx->childContexts().count() > duchain->childContexts().count())) {
             duchain = ctx;
         }
         if (ctx->localDeclarations().count() != 0
             && (duchain == nullptr || ctx->localDeclarations().count() > duchain->localDeclarations().count())) {
             duchain = ctx;
         }
     }
  
     if (!duchain && maxDepth != 0) {
         if (maxDepth != 0) {
             for (TopDUContext* ctx : duchains) {
                 QList<TopDUContext*> children;
                 const auto importedParentContexts = ctx->importedParentContexts();
                 for (const DUContext::Import& import : importedParentContexts) {
                     if (import.context(nullptr))
                         children << import.context(nullptr)->topContext();
                 }
  
                 duchain = pickContextWithData(children, maxDepth - 1, type, false);
                 if (duchain)
                     break;
             }
         }
     }
  
     if (!duchain && !duchains.isEmpty() && forcePick)
         duchain = duchains.first();
  
     return duchain;
 }
  
 QString AbstractIncludeNavigationContext::html(bool shorten)
 {
     clear();
     modifyHtml()  += QStringLiteral("<html><body><p>");
  
     QUrl u = m_item.url();
     NavigationAction action(u, KTextEditor::Cursor(0, 0));
     makeLink(u.toDisplayString(QUrl::PreferLocalFile), u.toString(), action);
     modifyHtml() += QStringLiteral("<br />");
  
     DUChainReadLocker lock;
     QList<TopDUContext*> duchains = DUChain::self()->chainsForDocument(u);
     //Pick the one duchain for this document that has the most child-contexts/declarations.
     //This prevents picking a context that is empty due to header-guards.
     TopDUContext* duchain = pickContextWithData(duchains, 2, m_type);
  
     if (duchain) {
         getFileInfo(duchain);
         if (!shorten) {
             modifyHtml() += labelHighlight(i18n("Declarations:")) + QLatin1String("<br />");
             bool first = true;
             QVector<IdentifierPair> decs;
             addDeclarationsFromContext(duchain, first, decs);
         }
     } else if (duchains.isEmpty()) {
         modifyHtml() += i18n("not parsed yet");
     }
  
     modifyHtml() += QStringLiteral("</p></body></html>");
     return currentHtml();
 }
  
 void AbstractIncludeNavigationContext::getFileInfo(TopDUContext* duchain)
 {
     modifyHtml() +=
         QStringLiteral("%1: %2 %3: %4").arg(labelHighlight(i18nc("Files included into this file", "Includes"))).arg(
             duchain->importedParentContexts().count()).arg(labelHighlight(i18nc(
                                                                               "Count of files this file was included into",
                                                                               "Included by"))).arg(
             duchain->importers().count());
     modifyHtml() += QStringLiteral("<br />");
 }
  
 QString AbstractIncludeNavigationContext::name() const
 {
     return m_item.name;
 }
  
 bool AbstractIncludeNavigationContext::filterDeclaration(Declaration* /*decl*/)
 {
     return true;
 }
  
 void AbstractIncludeNavigationContext::addDeclarationsFromContext(KDevelop::DUContext* ctx, bool& first,
                                                                   QVector<IdentifierPair>& addedDeclarations,
                                                                   const QString& indent)
 {
     //modifyHtml() += indent + ctx->localScopeIdentifier().toString() + "{<br />";
     QVector<DUContext*> children = ctx->childContexts();
     QVector<Declaration*> declarations = ctx->localDeclarations();
  
     QVector<DUContext*>::const_iterator childIterator = children.constBegin();
     QVector<Declaration*>::const_iterator declarationIterator = declarations.constBegin();
  
     while (childIterator != children.constEnd() || declarationIterator != declarations.constEnd()) {
         //Show declarations/contexts in the order they appear in the file
         int currentDeclarationLine = -1;
         int currentContextLine = -1;
         if (declarationIterator != declarations.constEnd())
             currentDeclarationLine = (*declarationIterator)->rangeInCurrentRevision().start().line();
  
         if (childIterator != children.constEnd())
             currentDeclarationLine = (*childIterator)->rangeInCurrentRevision().start().line();
  
         if ((currentDeclarationLine <= currentContextLine || currentContextLine == -1 ||
              childIterator == children.constEnd()) && declarationIterator != declarations.constEnd()) {
             IdentifierPair id = qMakePair(static_cast<int>((*declarationIterator)->kind()),
                                           (*declarationIterator)->qualifiedIdentifier().index());
             if (!addedDeclarations.contains(id) && filterDeclaration(*declarationIterator)) {
                 //Show the declaration
                 if (!first)
                     modifyHtml() += QStringLiteral(", ");
                 else
                     first = false;
  
                 modifyHtml() += QString(indent + declarationKind(DeclarationPointer(
                                                                      *declarationIterator)) +
                                         QLatin1Char(' ')).toHtmlEscaped();
                 makeLink((*declarationIterator)->qualifiedIdentifier().toString(),
                          DeclarationPointer(*declarationIterator), NavigationAction::NavigateDeclaration);
  
                 addedDeclarations << id;
             }
             ++declarationIterator;
         } else {
             //Eventually Recurse into the context
             if ((*childIterator)->type() == DUContext::Global ||
                 (*childIterator)->type() == DUContext::Namespace /*|| (*childIterator)->type() == DUContext::Class*/)
                 addDeclarationsFromContext(*childIterator, first, addedDeclarations, indent + QLatin1Char(' '));
             ++childIterator;
         }
     }
     //modifyHtml() += "}<br />";
 }
 }

duchainlock.h

KDevelop::DUChainReadLocker

Customized read locker for the definition-use chain.

Definition: duchainlock.h:114

KDevelop::DUContext::Global

A context that declares functions, namespaces or classes.

Definition: ducontext.h:103

KDevelop::AbstractNavigationContext::currentHtml

QString currentHtml() const

Returns the html text being built in its current state.

Definition: abstractnavigationcontext.cpp:587

QUrl

KDevelop::AbstractNavigationContext::declarationKind

virtual QString declarationKind(const DeclarationPointer &decl)

Definition: abstractnavigationcontext.cpp:497

KDevelop::AbstractNavigationContext::labelHighlight

static const Colorizer labelHighlight

Definition: abstractnavigationcontext.h:164

KDevelop::TopDUContext::importedParentContexts

QVector< Import > importedParentContexts() const override

Returns the list of imported parent contexts for this context.

Definition: topducontext.cpp:1024

QVector::constEnd

const_iterator constEnd() const

KDevelop::DUChainPointer< TopDUContext >

KDevelop::pickContextWithData

TopDUContext * pickContextWithData(const QList< TopDUContext * > &duchains, uint maxDepth, const ParsingEnvironmentType &type, bool forcePick=true)

Definition: abstractincludenavigationcontext.cpp:37

QList

KDevelop::Declaration

Represents a single declaration in a definition-use chain.

Definition: declaration.h:51

QUrl::toString

QString toString(QFlags< QUrl::FormattingOption > options) const

KDevelop::AbstractNavigationContext::makeLink

virtual void makeLink(const QString &name, const DeclarationPointer &declaration, NavigationAction::Type actionType)

Creates and registers a link to the given declaration, labeled by the given name.

Definition: abstractnavigationcontext.cpp:93

KDevelop::AbstractIncludeNavigationContext::html

QString html(bool shorten) override

Here the context can return html to be displayed.

Definition: abstractincludenavigationcontext.cpp:80

declaration.h

KDevelop::AbstractIncludeNavigationContext::AbstractIncludeNavigationContext

AbstractIncludeNavigationContext(const IncludeItem &item, const TopDUContextPointer &topContext, const ParsingEnvironmentType &type)

Definition: abstractincludenavigationcontext.cpp:29

KDevelop::NavigationAction

Definition: navigationaction.h:31

KDevelop::TopDUContext::importers

QVector< DUContext * > importers() const override

Returns the list of contexts importing this context.

Definition: topducontext.cpp:1007

KDevelop::AbstractIncludeNavigationContext::name

QString name() const override

Definition: abstractincludenavigationcontext.cpp:123

QString

KDevelop::AbstractIncludeNavigationContext::filterDeclaration

virtual bool filterDeclaration(Declaration *decl)

Should return true if this declaration should be shown, and false if not The duchain is locked when t...

Definition: abstractincludenavigationcontext.cpp:128

KDevelop::AbstractNavigationContext::clear

void clear()

Definition: abstractnavigationcontext.cpp:146

KDevelop::AbstractNavigationContext::modifyHtml

TextHandler modifyHtml()

Returns a convenience object that allows writing "modifyHtml() += "Hallo";".

Definition: abstractnavigationcontext.h:139

KDevelop::TopDUContext

The top context in a definition-use chain for one source file.

Definition: topducontext.h:113

QVector::contains

bool contains(const T &value) const

QList::isEmpty

bool isEmpty() const

QLatin1String

KDevelop::DUContext::childContexts

QVector< DUContext * > childContexts() const

Returns the list of immediate child contexts for this context.

Definition: ducontext.cpp:479

KDevelop::NavigationAction::NavigateDeclaration

Definition: navigationaction.h:35

KDevelop::AbstractNavigationContext

Definition: abstractnavigationcontext.h:64

abstractincludenavigationcontext.h

QLatin1Char

duchain.h

KDevelop

Definition: abstractfunctiondeclaration.cpp:27

KDevelop::DUContext

A single context in source code, represented as a node in a directed acyclic graph.

Definition: ducontext.h:72

KDevelop::DUContext::Namespace

A context that declares namespace members.

Definition: ducontext.h:104

parsingenvironment.h

QVector

KDevelop::AbstractIncludeNavigationContext::getFileInfo

virtual void getFileInfo(KDevelop::TopDUContext *duchain)

Overwrite this to add language dependent information for a given file.

Definition: abstractincludenavigationcontext.cpp:112

QVector::constBegin

const_iterator constBegin() const

KDevelop::DUContext::localDeclarations

virtual QVector< Declaration * > localDeclarations(const TopDUContext *source=nullptr) const

Returns all local declarations.

Definition: ducontext.cpp:967

KDevelop::DeclarationPointer

DUChainPointer< Declaration > DeclarationPointer

Definition: duchainpointer.h:200

KDevelop::DUChain::chainsForDocument

QList< TopDUContext * > chainsForDocument(const QUrl &document) const

Return all chains for the given document that are currently in memory.

Definition: duchain.cpp:1459

QObject::children

const QObjectList & children() const

KDevelop::ParsingEnvironmentType

ParsingEnvironmentType

Just an enumeration of a few parsing-environment types.

Definition: parsingenvironment.h:43

KDevelop::DUChain::self

static DUChain * self()

Returns the global static instance.

Definition: duchain.cpp:1230

KDevelop::DUContext::Import

Represents an imported parent context.

Definition: ducontext.h:256

KDE's Doxygen guidelines are available online.

kdevplatform/language/duchain

kdevplatform/language/duchain

kdevelop API Reference

Search