• Skip to content
• Skip to link menu

KDE 4.4 API Reference

• KDE API Reference
• KDevelop Platform Libraries

• Sitemap
• Contact Us

 

language/duchain

abstractcontextbuilder.h

/***************************************************************************
 *   This file is part of KDevelop                                         *
 *   Copyright 2008 Andreas Pakulat <apaku@gmx.de>                         *
 *   Copyright 2006 Roberto Raggi <roberto@kdevelop.org>                   *
 *   Copyright 2006-2008 Hamish Rodda <rodda@kde.org>                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
 ***************************************************************************/

#ifndef ABSTRACTABSTRACTCONTEXTBUILDER_H
#define ABSTRACTABSTRACTCONTEXTBUILDER_H

#include <climits>

#include <QtCore/QMutexLocker>

#include <ktexteditor/smartinterface.h>
#include <ktexteditor/range.h>
#include <ktexteditor/smartrange.h>
#include <ktexteditor/document.h>

#include "../../editor/editorintegrator.h"
#include "../topducontext.h"
#include "../duchainpointer.h"
#include "../duchainlock.h"
#include "../duchain.h"
#include "../ducontext.h"
#include "../identifier.h"
#include "../indexedstring.h"
#include "../parsingenvironment.h"
#include "../smartconverter.h"

namespace KDevelop
{
template<typename T, typename NameT>
class AbstractContextBuilder
{
public:
  AbstractContextBuilder()
    : m_editor( 0 )
    , m_ownsEditorIntegrator(false)
    , m_compilingContexts( false )
    , m_recompiling( false )
    , m_lastContext( 0 )
  {
  }

  virtual ~AbstractContextBuilder()
  {
    if (m_ownsEditorIntegrator)
      delete m_editor;
  }

  void setEditor(EditorIntegrator* editor, bool ownsEditorIntegrator)
  {
    m_editor = editor;
    m_ownsEditorIntegrator = ownsEditorIntegrator;
  }

  virtual ReferencedTopDUContext build( const IndexedString& url, T* node,
                              ReferencedTopDUContext updateContext
                                    = ReferencedTopDUContext(), bool useSmart = true )
  {
    m_compilingContexts = true;
    m_editor->setCurrentUrl( url, useSmart );

    ReferencedTopDUContext top;
    {
      DUChainWriteLocker lock( DUChain::lock() );
      top = updateContext.data();

      if( top && top->smartRange() )
      {
        if( top && top->smartRange()->parentRange() )
        {
          //somethings wrong, a top level range can't have a parent
          Q_ASSERT(false);
        }
      }
      if( top )
      {
//         kDebug() << "re-compiling";
        m_recompiling = true;
        if( m_compilingContexts )
        {
          LockedSmartInterface iface = m_editor->smart();
          if( iface && top->range().textRange() != iface.currentDocument()->documentRange() )
          {
            //Happens if the context wasn't smart
            top->setRange( SimpleRange( iface.currentDocument()->documentRange() ) );
          }
        }
      }else
      {
//         kDebug() << "compiling";
        LockedSmartInterface iface = m_editor->smart();
        top = newTopContext( iface.currentDocument()
                                    ? SimpleRange( iface.currentDocument()->documentRange() )
                                    : SimpleRange( SimpleCursor( 0, 0 ), SimpleCursor( INT_MAX, INT_MAX ) ) );
        top->setSmartRange( m_editor->topRange( iface, EditorIntegrator::DefinitionUseChain ), DocumentRangeObject::Own );
        top->setType( DUContext::Global );
        DUChain::self()->addDocumentChain( top );
      }
      setEncountered( top );
      setContextOnNode( node, top );
    }

    supportBuild( node, top );

    {
      LockedSmartInterface iface = m_editor->smart();
      if( iface && top->range().textRange() != iface.currentDocument()->documentRange() )
      {
        kDebug() << "WARNING: top level context has wrong size:" << top->range().textRange() << "should be:" << iface.currentDocument()->documentRange();
        top->setRange( iface.currentDocument()->documentRange() );
      }
    }
    {
      /*DUChainReadLocker lock( DUChain::lock() );
      //foreach(DUContext* context, topLevelContext->childContexts());
      kDebug() << "built top-level context with" << top->localDeclarations().count() << "declarations," << top->localDeclarations().count() << " Definitions and" << top->childContexts().size() << "Child-Contexts";

      foreach( DUContext* contexts, top->childContexts() )
      {
        kDebug() << "CHILD:" << contexts->scopeIdentifier( true ) << "Parent:" << ( dynamic_cast<TopDUContext*>( contexts->parentContext() ) ? "top-context" : "" );
      }*/
    }
    m_compilingContexts = false;
    return top;
  }

protected:
  virtual void supportBuild( T* node, DUContext* context = 0 )
  {
    if (!context)
      context = contextFromNode(node);

    openContext( context );

    //The url must be set before supportBuild is called, together with the decision
    //whether smart-ranges shold be created
    if(m_editor->currentUrl() != currentContext()->url())
      m_editor->setCurrentUrl(currentContext()->url(), true);

    {
      LockedSmartInterface iface = m_editor->smart();
      m_editor->setCurrentRange(iface, currentContext()->smartRange());
    }

    startVisiting(node);

    closeContext();

    Q_ASSERT(m_contextStack.isEmpty());
  }

  virtual void startVisiting( T* node ) = 0;

  virtual void setContextOnNode( T* node, DUContext* context ) = 0;

  virtual DUContext* contextFromNode( T* node ) = 0;

  virtual KTextEditor::Range editorFindRange( T* fromNode, T* toNode ) = 0;

  virtual KTextEditor::Range editorFindRangeForContext( T* fromNode, T* toNode )
  {
    return editorFindRange(fromNode, toNode);
  }

  virtual QualifiedIdentifier identifierForNode( NameT* node ) = 0;

  virtual DUContext* newContext(const SimpleRange& range)
  {
    return new DUContext(range, currentContext());
  }

  virtual TopDUContext* newTopContext(const SimpleRange& range, ParsingEnvironmentFile* file = 0)
  {
    return new TopDUContext(m_editor->currentUrl(), range, file);
  }

  inline DUContext* currentContext() const { return m_contextStack.top(); }
  inline DUContext* lastContext() const { return m_lastContext; }
  inline void clearLastContext() { m_lastContext = 0; }

  inline void setLastContext(DUContext* context) { m_lastContext = context; }

  inline bool recompiling() const { return m_recompiling; }

  inline void setRecompiling(bool recomp) { m_recompiling = recomp; }

  inline bool compilingContexts() const { return m_compilingContexts; }

  inline void setCompilingContexts(bool compilingContexts) { m_compilingContexts = compilingContexts; }

  DUContext* buildSubContexts( const KUrl& url, T *node,
                                         DUContext* parent )
  {
  //     m_compilingContexts = true;
  //     m_recompiling = false;
      {
        DUChainReadLocker lock( DUChain::lock() );
        m_editor->setCurrentUrl( IndexedString( url.pathOrUrl() ), (bool)parent->smartRange() );
      }
      setContextOnNode( node, parent );
      {
          openContext( contextFromNode( node ) );
          {
            LockedSmartInterface iface = m_editor->smart();
            m_editor->setCurrentRange( iface, m_editor->topRange( iface, EditorIntegrator::DefinitionUseChain ) );
          }
          startVisiting( node );
          closeContext();
      }

      m_compilingContexts = false;

      if ( contextFromNode( node ) == parent )
      {
          kDebug() << "Error in AbstractContextBuilder::buildSubContexts(...): du-context was not replaced with new one";
          DUChainWriteLocker lock( DUChain::lock() );
          deleteContextOnNode( node );
      }

      return contextFromNode( node );
  }

  void deleteContextOnNode( T* node )
  {
    delete contextFromNode( node );
    setContextOnNode( node, 0 );
  }

  DUContext* openContext( T* rangeNode, DUContext::ContextType type, NameT* identifier = 0)
  {
    if ( m_compilingContexts )
    {
#ifdef DEBUG_UPDATE_MATCHING
    //kDebug() << "opening context with text" << editor()->tokensToStrings( rangeNode->start_token, rangeNode->end_token );
#endif
      DUContext* ret = openContextInternal( editorFindRangeForContext( rangeNode, rangeNode ), type, identifier ? identifierForNode( identifier ) : QualifiedIdentifier() );
      setContextOnNode( rangeNode, ret );
      return ret;
    }
    else
    {
      openContext( contextFromNode(rangeNode) );
      {
        LockedSmartInterface iface = editor()->smart();
        editor()->setCurrentRange(iface, currentContext()->smartRange());
      }
      return currentContext();
    }
  }

  DUContext* openContext(T* node, const KDevelop::SimpleRange& range, DUContext::ContextType type, NameT* identifier = 0)
  {
    if (m_compilingContexts) {
#ifdef DEBUG_UPDATE_MATCHING
      kDebug() << "opening custom context";
#endif
      DUContext* ret = openContextInternal(range, type, identifier ? identifierForNode(identifier) : QualifiedIdentifier());
      setContextOnNode( node, ret );
      return ret;

    } else {
      openContext( contextFromNode(node) );
      {
        LockedSmartInterface iface = editor()->smart();
        editor()->setCurrentRange(iface, currentContext()->smartRange());
      }
      return currentContext();
    }
  }

  DUContext* openContext(T* node, const KDevelop::SimpleRange& range, DUContext::ContextType type, QualifiedIdentifier id)
  {
    if (m_compilingContexts) {
#ifdef DEBUG_UPDATE_MATCHING
      kDebug() << "opening custom context";
#endif
      DUContext* ret = openContextInternal(range, type, id);
      setContextOnNode( node, ret );
      return ret;

    } else {
      openContext( contextFromNode(node) );
      {
        LockedSmartInterface iface = editor()->smart();
        editor()->setCurrentRange(iface, currentContext()->smartRange());
      }
      return currentContext();
    }
  }

  DUContext* openContext( T* rangeNode, DUContext::ContextType type, const QualifiedIdentifier& identifier )
  {
    if ( m_compilingContexts )
    {
#ifdef DEBUG_UPDATE_MATCHING
    //kDebug() << "opening context with text" << editor()->tokensToStrings( rangeNode->start_token, rangeNode->end_token );
#endif
      DUContext* ret = openContextInternal( editorFindRangeForContext( rangeNode, rangeNode ), type, identifier );
      setContextOnNode( rangeNode, ret );
      return ret;
    }
    else
    {
      //kDebug() << "Opening Context associated with node";
      openContext( contextFromNode(rangeNode) );
      {
        LockedSmartInterface iface = editor()->smart();
        editor()->setCurrentRange(iface, currentContext()->smartRange());
      }
      return currentContext();
    }
  }

  DUContext* openContext( T* fromRange, T* toRange, DUContext::ContextType type, const QualifiedIdentifier& identifier = QualifiedIdentifier() )
  {
    if ( m_compilingContexts )
    {
#ifdef DEBUG_UPDATE_MATCHING
      //kDebug() << "opening context with text" << editor()->tokensToStrings( fromRange->start_token, toRange->end_token );
#endif
      DUContext* ret = openContextInternal( editorFindRangeForContext( fromRange, toRange ), type, identifier );
      setContextOnNode( fromRange, ret );
      return ret;
    }
    else
    {
      openContext( contextFromNode(fromRange) );
      {
        LockedSmartInterface iface = editor()->smart();
        editor()->setCurrentRange(iface, currentContext()->smartRange());
      }
      return currentContext();
    }
  }

  virtual void openContext( DUContext* newContext )
  {
    m_contextStack.push( newContext );
    m_nextContextStack.push( 0 );
  }

  void injectContext( const LockedSmartInterface& iface, DUContext* ctx, KTextEditor::SmartRange* range = 0 ) {
    openContext( ctx );
    m_editor->setCurrentRange( iface, range ? range : ctx->smartRange() );
  }

  void closeInjectedContext(const LockedSmartInterface& iface) {
    m_contextStack.pop();
    m_nextContextStack.pop();
    if(m_editor->smart())
      m_editor->exitCurrentRange(iface);
  }

  virtual void closeContext()
  {
    {
      DUChainWriteLocker lock( DUChain::lock() );
      //Remove all slaves that were not encountered while parsing
      if(m_compilingContexts)
        currentContext()->cleanIfNotEncountered( m_encountered );
      setEncountered( currentContext() );

      m_lastContext = currentContext();
    }

    m_contextStack.pop();
    m_nextContextStack.pop();
    if(LockedSmartInterface iface = m_editor->smart())
      m_editor->exitCurrentRange(iface);
  }

  void setEncountered( DUChainBase* item )
  {
    m_encountered.insert( item );
  }

  bool wasEncountered( DUChainBase* item )
  {
    return m_encountered.contains( item );
  }

  void setIdentifier( const QString& id )
  {
    m_identifier = Identifier( id );
    m_qIdentifier.push( m_identifier );
  }

  QualifiedIdentifier qualifiedIdentifier() const
  {
    return m_qIdentifier;
  }

  void clearQualifiedIdentifier()
  {
    m_qIdentifier.clear();
  }

  EditorIntegrator* editor() const
  {
    return m_editor;
  }

  const QStack<DUContext*>& contextStack() const
  {
    return m_contextStack;
  }

  int& nextContextIndex()
  {
    return m_nextContextStack.top();
  }

  virtual DUContext* openContextInternal( const SimpleRange& range, DUContext::ContextType type, const QualifiedIdentifier& identifier )
  {
    Q_ASSERT( m_compilingContexts );
    DUContext* ret = 0L;
    if(range.start > range.end)
    {
      kDebug() << "Bad context-range" << range.textRange();
    }

    {
      if ( recompiling() )
      {
        DUChainReadLocker readLock( DUChain::lock() );
        const QVector<DUContext*>& childContexts = currentContext()->childContexts();

        LockedSmartInterface iface = m_editor->smart();
        // translated is now in sync with the current state of the document, with whatever changes
        // have occurred since the text was fetched.
        SimpleRange translated = m_editor->translate(iface, range);

//         if(iface)
//           kDebug() << "translated by" << (translated.start.textCursor() - range.start.textCursor()) << (translated.end.textCursor() - range.end.textCursor()) << "to revision" << iface->currentRevision();

        int currentIndex = nextContextIndex();
        int lookingAhead = 0;

        for ( ; currentIndex < childContexts.count(); ++currentIndex )
        {
          DUContext* child = childContexts.at( currentIndex );

//           if ( child->range().start > translated.end && child->smartRange() ) {
// #ifdef DEBUG_UPDATE_MATCHING
//               kDebug() << "While searching" << identifier << translated.textRange() << "(from" << range.textRange() << ") stopping because found" << child->localScopeIdentifier() << child->range().textRange();
// #endif
//               break;
//           }

      //For unnamed child-ranges, we still do range-comparison, because we cannot distinguish them in other ways
          if ( child->type() == type && child->localScopeIdentifier() == identifier && (!identifier.isEmpty() || child->range() == translated) )
          {
            if(child->range() != translated && child->smartRange()) {
              kDebug() << "range mismatch while updating context. Range:" << child->range().textRange() << "should be:" << translated.textRange();
              break;
            }
            // No need to have the translated range accurate any more
            // Also we can't unlock after the duchain lock is unlocked
            iface.unlock();

            // Match
            ret = child;
            readLock.unlock();
            DUChainWriteLocker writeLock( DUChain::lock() );

            ret->clearImportedParentContexts();
            m_editor->setCurrentRange( iface, ret->smartRange() );
            ++currentIndex;
            break;
          }else{
#ifdef DEBUG_UPDATE_MATCHING
          if(child->type() != type)
            kDebug() << "type mismatch" << child->type() << type;
          if(child->localScopeIdentifier() != identifier)
            kDebug() << "identifier mismatch" << child->localScopeIdentifier() << identifier;
          if(translated != child->range())
            kDebug() << "range mismatch" << child->range().textRange() << translated.textRange();

            kDebug() << "skipping range" << childContexts.at(currentIndex)->localScopeIdentifier() << childContexts.at(currentIndex)->range().textRange();
#endif
          if ( child->range().start > translated.end && child->smartRange() && (currentIndex+1 == childContexts.count() || (childContexts.at(currentIndex+1)->localScopeIdentifier() != identifier || childContexts.at(currentIndex+1)->type() != type)) ) {
            ++lookingAhead;
            const int maxLookahead = 5;
            if(lookingAhead > maxLookahead)
              break; //Don't move the currentIndex too far
          }
          }
        }
        if(ret)
          nextContextIndex() = currentIndex; //If we had a match, jump forward to that position
        else
          ++nextContextIndex();   //If we did not have a match, just increment by 1
      }

      if ( !ret )
      {
        DUChainWriteLocker writeLock( DUChain::lock() );

        ret = newContext( SimpleRange( range ) );
        {
          LockedSmartInterface iface = m_editor->smart();
          ret->setSmartRange( m_editor->createRange( iface, range.textRange() ), DocumentRangeObject::Own );
        }
        ret->setType( type );

        if (!identifier.isEmpty())
          ret->setLocalScopeIdentifier(identifier);

        setInSymbolTable(ret);

//         if( recompiling() )
//           kDebug() << "created new context while recompiling for " << identifier.toString() << "(" << ret->range().textRange() << ")";
      }
    }

    m_encountered.insert( ret );
    openContext( ret );
    return ret;
  }

  virtual void setInSymbolTable(DUContext* context) {
    if(!context->parentContext()->inSymbolTable()) {
      context->setInSymbolTable(false);
      return;
    }
    DUContext::ContextType type = context->type();
    context->setInSymbolTable(type == DUContext::Class || type == DUContext::Namespace || type == DUContext::Global || type == DUContext::Helper || type == DUContext::Enum);
  }

private:

  Identifier m_identifier;
  QualifiedIdentifier m_qIdentifier;
  EditorIntegrator* m_editor;
  bool m_ownsEditorIntegrator: 1;
  bool m_compilingContexts : 1;
  bool m_recompiling : 1;
  QStack<int> m_nextContextStack;
  DUContext* m_lastContext;
  //Here all valid declarations/uses/... will be collected
  QSet<DUChainBase*> m_encountered;
  QStack<DUContext*> m_contextStack;
};

}

#endif

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