• Skip to content
• Skip to link menu

KDE 4.4 API Reference

• KDE API Reference
• KDevelop Platform Libraries

• Sitemap
• Contact Us

 

language/duchain

abstractdeclarationbuilder.h

/* This file is part of KDevelop
    Copyright 2006-2008 Hamish Rodda <rodda@kde.org>

   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.
*/

#ifndef ABSTRACTDECLARATIONBUILDER_H
#define ABSTRACTDECLARATIONBUILDER_H

#include <typeinfo>

#include "../classfunctiondeclaration.h"
#include "../forwarddeclaration.h"
#include "../types/identifiedtype.h"
#include "../functiondeclaration.h"
#include "../../editor/editorintegrator.h"

namespace KDevelop
{
class Declaration;

template<typename T, typename NameT, typename LanguageSpecificDeclarationBuilderBase>
class AbstractDeclarationBuilder : public LanguageSpecificDeclarationBuilderBase
{
protected:
  inline bool hasCurrentDeclaration() const { return !m_declarationStack.isEmpty(); }
  inline Declaration* currentDeclaration() const { return m_declarationStack.isEmpty() ? 0 : m_declarationStack.top(); }
  template<class DeclarationType>
  inline DeclarationType* currentDeclaration() const { return m_declarationStack.isEmpty() ? 0 : dynamic_cast<DeclarationType*>(m_declarationStack.top()); }

  inline const QByteArray& comment() const { return m_lastComment; }
  inline void setComment(const QByteArray& comment) { m_lastComment = comment; }
  inline void clearComment() { m_lastComment.clear(); }

  enum DeclarationFlags {
    NoFlags    = 0x0,
    DeclarationIsDefinition = 0x1
  };

  template<class DeclarationT>
  DeclarationT* openDeclaration(NameT* name, T* range, DeclarationFlags flags = NoFlags)
  {
    DUChainWriteLocker lock(DUChain::lock());

    SimpleRange newRange = editorFindRange(name ? name : range, name ? name : range);

    if (newRange.start >= newRange.end)
      kWarning() << "Range collapsed";

    QualifiedIdentifier id = identifierForNode(name);

    return openDeclaration<DeclarationT>(id, newRange, flags);
  }

  template<class DeclarationT>
  DeclarationT* openDeclaration(const QualifiedIdentifier& id, const SimpleRange& newRange, DeclarationFlags flags = NoFlags)
  {
    Identifier localId;

    if(!id.isEmpty()) {
      localId = id.last();
    }

    DeclarationT* declaration = 0;

    if (LanguageSpecificDeclarationBuilderBase::recompiling()) {
      // Seek a matching declaration

      // Translate cursor to take into account any changes the user may have made since the text was retrieved
      LockedSmartInterface iface = LanguageSpecificDeclarationBuilderBase::editor()->smart();
      SimpleRange translated = LanguageSpecificDeclarationBuilderBase::editor()->translate(iface, newRange);

      QList<Declaration*> declarations = LanguageSpecificDeclarationBuilderBase::currentContext()->allLocalDeclarations(localId);
      foreach( Declaration* dec, declarations ) {

        if( LanguageSpecificDeclarationBuilderBase::wasEncountered(dec) )
          continue;

        //This works because dec->textRange() is taken from a smart-range. This means that now both ranges are translated to the current document-revision.
        if (dec->range() == translated &&
            (localId == dec->identifier() || (localId.isUnique() && dec->identifier().isUnique())) &&
            typeid(*dec) == typeid(DeclarationT)
            //&& extraDeclarationComparisons()
          )
        {
          // Match
          declaration = dynamic_cast<DeclarationT*>(dec);
          break;
        }
      }
    }

    if (!declaration) {
      declaration = new DeclarationT(newRange, LanguageSpecificDeclarationBuilderBase::currentContext());

      LockedSmartInterface iface = LanguageSpecificDeclarationBuilderBase::editor()->smart();
      KTextEditor::SmartRange* range = LanguageSpecificDeclarationBuilderBase::editor()->createRange(iface, newRange.textRange());
      declaration->setSmartRange(range);
      if (flags & DeclarationIsDefinition)
        declaration->setDeclarationIsDefinition(true);
      declaration->setIdentifier(localId);

      LanguageSpecificDeclarationBuilderBase::editor()->exitCurrentRange(iface);
    }

    declaration->setComment(m_lastComment);
    m_lastComment.clear();

    LanguageSpecificDeclarationBuilderBase::setEncountered(declaration);

    openDeclarationInternal(declaration);

    return declaration;
  }

  template<class DeclarationT>
  DeclarationT* openDefinition(NameT* name, T* range)
  {
    return openDeclaration<DeclarationT>(name, range, DeclarationIsDefinition);
  }

  template<class DeclarationT>
  DeclarationT* openDefinition(const QualifiedIdentifier& id, const SimpleRange& newRange)
  {
    return openDeclaration<DeclarationT>(id, newRange, DeclarationIsDefinition);
  }

  void openDeclarationInternal(Declaration* declaration)
  {
    m_declarationStack.push(declaration);
  }

  ForwardDeclaration* openForwardDeclaration(NameT* name, T* range)
  {
    return openDeclaration<ForwardDeclaration*>(name, range);
  }

  void eventuallyAssignInternalContext()
  {
    if (LanguageSpecificDeclarationBuilderBase::lastContext()) {
      DUChainWriteLocker lock(DUChain::lock());

      if( dynamic_cast<ClassFunctionDeclaration*>(currentDeclaration()) )
        Q_ASSERT( !static_cast<ClassFunctionDeclaration*>(currentDeclaration())->isConstructor() || currentDeclaration()->context()->type() == DUContext::Class );

      if(LanguageSpecificDeclarationBuilderBase::lastContext() && 
        (LanguageSpecificDeclarationBuilderBase::lastContext()->type() == DUContext::Class || 
         LanguageSpecificDeclarationBuilderBase::lastContext()->type() == DUContext::Other || 
         LanguageSpecificDeclarationBuilderBase::lastContext()->type() == DUContext::Function || 
         LanguageSpecificDeclarationBuilderBase::lastContext()->type() == DUContext::Template || 
         LanguageSpecificDeclarationBuilderBase::lastContext()->type() == DUContext::Enum ||
         (LanguageSpecificDeclarationBuilderBase::lastContext()->type() == DUContext::Namespace && currentDeclaration()->kind() == Declaration::Namespace)
         ) )
      {
        if( !LanguageSpecificDeclarationBuilderBase::lastContext()->owner() || !LanguageSpecificDeclarationBuilderBase::wasEncountered(LanguageSpecificDeclarationBuilderBase::lastContext()->owner()) ) { //if the context is already internalContext of another declaration, leave it alone
          currentDeclaration()->setInternalContext(LanguageSpecificDeclarationBuilderBase::lastContext());

          LanguageSpecificDeclarationBuilderBase::clearLastContext();
        }
      }
    }
  }

  virtual void closeDeclaration()
  {
    m_declarationStack.pop();
  }

  void abortDeclaration()
  {
    delete m_declarationStack.pop();
  }

private:
  QStack<Declaration*> m_declarationStack;
  QByteArray m_lastComment;
};

}

#endif // ABSTRACTDECLARATIONBUILDER_H

language/duchain

Skip menu "language/duchain"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

KDevelop Platform Libraries

Skip menu "KDevelop Platform Libraries"

• interfaces
• language
•   codegen
•   duchain
•   editor
• outputview
• project
• shell
• sublime
• util
• vcs

Generated for KDevelop Platform Libraries by doxygen 1.5.9-20090814
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal