KDevelop Namespace Reference

When this is uncommented, a 64-bit test-value is written behind the area an item is allowed to write into before createItem(. More...

Namespaces
namespace	DUChainUtils
Classes
class	AbstractContextBuilder
	Abstract definition-use chain context builder class. More...
class	AbstractDeclarationBuilder
	A class which iterates the AST to extract definitions of types. More...
class	AbstractFunctionDeclaration
	Provides an interface to declarations which represent functions in a definition-use chain. More...
class	AbstractIncludeNavigationContext
	Abstract navigation context for file includes. More...
class	AbstractNavigationWidget
	This class deleted itself when its part is deleted, so always use a QPointer when referencing it. More...
class	AbstractRepositoryManager
	Internal helper class that wraps around a repository object and manages its lifetime. More...
class	AbstractType
	Base class for all types. More...
class	AbstractTypeBuilder
	Abstract definition-use chain type builder class. More...
class	AbstractTypeFactory
	A factory class for type data. More...
class	AbstractUseBuilder
	Abstract definition-use chain use builder class. More...
class	AliasDeclaration
	An alias declaration maps one declaration to another. More...
class	AppendedListItemRequest
	This is a class that allows you easily putting instances of your class into an ItemRepository as seen in itemrepository.h. More...
class	ArrayTypeData
	Private data structure for ArrayType. More...
class	ClassDeclaration
	Represents a single template-parameter definition. More...
class	ClassMemberDeclaration
	Represents a single class member definition in a definition-use chain. More...
class	CodeModel
	Persistent store that efficiently holds a list of identifiers and their kind for each declaration-string. More...
struct	Colorizer
	A helper-class for elegant colorization of html-strings . More...
struct	ConstantIntegralTypeData
	Private data structure for ConstantIntegralType. More...
class	Declaration
	Represents a single declaration in a definition-use chain. More...
class	DeclarationId
	Allows clearly identifying a Declaration. More...
class	Definitions
	Global mapping of one Declaration-Ids to multiple Definitions, protected through DUChainLock. More...
class	DelayedType
	A type which has not yet been resolved. More...
class	DelayedTypeData
	Private data structure for DelayedType. More...
class	DocumentCursor
class	DocumentCursorObject
class	DocumentRange
class	DocumentRangeObject
class	DocumentRangeObjectData
class	DUChain
	Holds references to all top level source file contexts. More...
class	DUChainBase
	Base class for definition-use chain objects. More...
class	DUChainBaseData
class	DUChainBaseFactory
	This class is purely internal and doesn't need to be documented. More...
class	DUChainItemFactory
	Never use this directly, use the REGISTER_DUCHAIN_ITEM macro instead. More...
struct	DUChainItemRegistrator
	Helper class to register an DUChainBase subclass. More...
class	DUChainItemSystem
	A class which registers data types and creates factories for them. More...
class	DUChainLock
	Customized read/write locker for the definition-use chain. More...
class	DUChainObserver
	Abstract class for observers of the definition-use chain to receive feedback on changes. More...
class	DUChainPointer
	A smart-pointer similar class that conveniently wraps around DUChainPointerData without too many dynamic casts. More...
class	DUChainPointerData
	Whenever the du-chain is unlocked and locked again, any du-chain item may have been deleted in between. More...
class	DUChainReadLocker
	Customized read locker for the definition-use chain. More...
class	DUChainWriteLocker
	Customized write locker for the definition-use chain. More...
class	DUContext
	A single context in source code, represented as a node in a directed acyclic graph. More...
class	DUContextDynamicData
	This class contains data that is only runtime-dependant and does not need to be stored to disk. More...
class	DumpDotGraph
	A helper-class for debugging, that nicely visualizes the whole structure of a du-context. More...
class	DynamicItem
	This object needs to be kept alive as long as you change the contents of an item stored in the repository. More...
class	EditorIntegrator
class	EditorRevisionTracker
class	ExampleItem
	This is the actual data that is stored in the repository. More...
class	ForwardDeclaration
	Represents a forward declaration. More...
class	FunctionDefinition
	A FunctionDefinition represents a function-definition that is assigned to a separate function-declaration. More...
class	FunctionType
	A type representing function types. More...
class	HashedString
class	IdentifiedType
	An IdentifiedType is a type that has a declaration. More...
class	IdentifiedTypeData
	Data structure for identified types. More...
class	Identifier
	Represents a single unqualified identifier. More...
class	Importers
	Global mapping of Declaration-Ids to contexts that import the associated context, protected through DUChainLock. More...
class	ImportTraceItem
	This class is used to trace imports while findDeclarationsInternal. The back-tracing may be needed for correctly resolving delayed types(templates). More...
class	IndexedDeclaration
	Represents a declaration only by its global indices. More...
class	IndexedDeclarationHandler
class	IndexedDUContext
	Represents a context only by its global indices. More...
struct	IndexedIdentifier
	A helper-class to store an identifier by index in a type-safe way. More...
class	IndexedQualifiedIdentifier
	A helper-class to store an identifier by index in a type-safe way. More...
class	IndexedString
	This string does "disk reference-counting", which means that reference-counts are maintainted, but only when the string is in a disk-stored location. More...
class	IndexedTopDUContext
	Allows simple indirect access to top-contexts with on-demand loading. More...
class	IndexedType
	Indexed type pointer. More...
class	IndexedTypeIdentifier
	Extends IndexedQualifiedIdentifier by: Arbitrary count of pointer-poperators with cv-qualifiers Reference operator All the properties set here are respected in the hash value. More...
class	IntegralType
	A type representing inbuilt data types. More...
class	IntegralTypeData
	Private data structure for IntegralType. More...
class	ItemRepository
class	ItemRepositoryRegistry
	Manages a set of item-repositores and allows loading/storing them all at once from/to disk. More...
class	LocalIndexedDeclaration
	Represents a declaration only by its index within the top-context. More...
class	LocalIndexedDUContext
	Represents a DUContext within a TopDUContext, without storing the TopDUContext(It must be given to data()). More...
class	LockedSmartInterface
class	MergeAbstractFunctionDeclaration
	Use this to merge AbstractFunctionDeclaration into the class hierarchy. More...
class	MergeIdentifiedType
	Implements everything necessary to merge the given Parent class with IdentifiedType Your used Data class must be based on the Data member class. More...
class	ModificationRevision
class	NamespaceAliasDeclaration
	A class which represents a "using namespace" statement, or a "namespace A = B" statement. More...
class	OneUseWidget
	A widget representing one use of a Declaration in a speicific context. More...
class	ParamIterator
	Can be used to iterate through different kinds of parameters, for example template-parameters(By giving it "<>:"). More...
class	ParsingEnvironment
	Use this as base-class to define new parsing-environments. More...
class	ParsingEnvironmentFile
	This represents all information about a specific parsed file that is needed to match the file to a parsing-environment. More...
class	ParsingEnvironmentFileData
	The data class used for storing. More...
class	PersistentSetMap
	This class allows easily implement a very efficient persistent map from a key, to a set of data items. More...
class	PersistentSymbolTable
	Global symbol-table that is stored to disk, and allows retrieving declarations that currently are not loaded to memory. More...
class	PointerType
	A type representing pointer types. More...
class	PointerTypeData
	Private data structure for PointerType. More...
class	QualifiedIdentifier
	Represents a qualified identifier. More...
struct	ReferenceCountManager
	Use this as local variable within the object that maintains the reference-count, and use. More...
class	ReferencedTopDUContext
	KDevelop can unload unused top-context at any time. More...
class	ReferenceType
	A type representing reference types. More...
class	ReferenceTypeData
	Private data structure for ReferenceType. More...
struct	RepositoryManager
	This class helps managing the lifetime of a global item repository, and protecting the consistency. More...
class	SimpleTypeExchanger
	A simple type-exchanger that replaces one type with another. More...
class	SpecializationStore
	This class allows dynamic management of "current" specializations for declarations. More...
class	StructureType
	A type representing structure types. More...
class	StructureTypeData
	Private data structure for StructureType. More...
class	TemporaryDataManager
	Manages a repository of items for temporary usage. More...
class	TopContextUsesWidget
	Represents the uses of a declaration within one top-context. More...
class	TopDUContext
	The top context in a definition-use chain for one source file. More...
class	TopDUContextDynamicData
	This class contains dynamic data of a top-context, and also the repository that contains all the data within this top-context. More...
class	TypeAliasTypeData
	Private data structure for ReferenceType. More...
class	TypeExchanger
	A class that can be used to walk through all types that are references from one type, and exchange them with other types. More...
class	TypeFactory
	Template class to implement factories for each AbstractType subclass you want to instantiate. More...
class	TypeSystem
	A class which registers data types and creates factories for them. More...
struct	TypeSystemRegistrator
	Helper class to register an AbstractType subclass. More...
class	Use
	Represents a position in a document where a specific declaration is used. More...
class	Uses
	Global mapping of Declaration-Ids to top-contexts, protected through DUChainLock. More...
class	UsesCollector
	A helper base-class for collecting the top-contexts that contain all uses of a declaration The most important part is that this also updates the duchain if it's not up-to-date or doesn't contain the required features. More...
class	UsesWidget
	A widget that allows browsing through all the uses of a declaration, and also through all declarations of it. More...
Typedefs
typedef QPair< QByteArray, uint >	ArrayWithPosition
typedef MergeAbstractFunctionDeclaration < ClassMemberDeclaration, ClassFunctionDeclarationData >	ClassFunctionDeclarationBase
typedef IdentifierPrivate< false >	ConstantIdentifierPrivate
typedef QualifiedIdentifierPrivate < false >	ConstantQualifiedIdentifierPrivate
typedef DUChainPointer < Declaration >	DeclarationPointer
typedef DUChainPointer < DUChainBase >	DUChainBasePointer
typedef DUChainPointer< DUContext >	DUContextPointer
typedef IdentifierPrivate< true >	DynamicIdentifierPrivate
typedef QualifiedIdentifierPrivate < true >	DynamicQualifiedIdentifierPrivate
typedef KDevelop::MergeIdentifiedType < IntegralType >	EnumerationTypeBase
typedef EnumerationTypeBase::Data	EnumerationTypeData
typedef KDevelop::MergeIdentifiedType < ConstantIntegralType >	EnumeratorTypeBase
typedef EnumeratorTypeBase::Data	EnumeratorTypeData
typedef MergeAbstractFunctionDeclaration < Declaration, FunctionDeclarationData >	FunctionDeclarationBase
typedef DUChainPointer < AbstractFunctionDeclaration >	FunctionDeclarationPointer
typedef KSharedPtr < AbstractNavigationContext >	NavigationContextPointer
typedef KSharedPtr < ParsingEnvironmentFile >	ParsingEnvironmentFilePointer
typedef KSharedPtr< Problem >	ProblemPointer
typedef QHash< const TopDUContext *, QPair< int, const TopDUContext * > >	RecursiveImports
typedef MergeIdentifiedType < AbstractType >	StructureTypeBase
typedef DUChainPointer < TopDUContext >	TopDUContextPointer
typedef MergeIdentifiedType < AbstractType >	TypeAliasTypeBase
Enumerations
enum	{ DynamicAppendedListMask = 1 << 31 }
enum	{ DynamicAppendedListRevertMask = ~DynamicAppendedListMask }
enum	{ ItemRepositoryBucketSize = 1<<16 }
enum	ClassFunctionFlags {   FunctionFlagNormal = 0, FunctionSignalFlag = 1 << 1, FunctionSlotFlag = 1 << 2, AbstractFunctionFlag = 1 << 3,   FinalFunctionFlag = 1 << 4 }
enum	ParsingEnvironmentType {   StandardParsingEnvironment, CppParsingEnvironment, PythonParsingEnvironment, CMakeParsingEnvironment,   CSharpParsingEnvironment, JavaParsingEnvironment, RubyParsingEnvironment, PhpParsingEnvironment }
Functions
ItemRepositoryRegistry &	allocateGlobalItemRepositoryRegistry ()
QPair< QString, KLockFile::Ptr >	allocateRepository ()
QList< KTextEditor::SmartRange * >	allSmartUses (TopDUContext *context, Declaration *declaration)
QList< KTextEditor::SmartRange * >	allSmartUses (DUContext *context, int declarationIndex)
QList< SimpleRange >	allUses (TopDUContext *context, Declaration *declaration, bool noEmptyRanges=false)
QList< SimpleRange >	allUses (DUContext *context, int declarationIndex, bool noEmptyRanges=false)
template<class Container , class Type >
bool	arrayContains (Container &container, const Type &value)
template<class T , int num>
QList< T >	arrayToList (const KDevVarLengthArray< T, num > &array)
template<class T , int num>
QList< T >	arrayToVector (const KDevVarLengthArray< T, num > &array)
QString	clearComments (QString str, QChar replacement= ' ')
QString	clearStrings (QString str, QChar replacement= ' ')
template<typename T >
T	constant_value (const qint64 *realval)
bool	contextIsChildOrEqual (const DUContext *childContext, const DUContext *context)
Identifier	conversionIdentifier ("operator{...cast...}")
	DECLARE_LIST_MEMBER_HASH (FunctionTypeData, m_arguments, IndexedType) class AbstractTypeData
	DECLARE_LIST_MEMBER_HASH (TopDUContextData, m_usedDeclarationIds, DeclarationId) class TopDUContextData
	DECLARE_LIST_MEMBER_HASH (InstantiationInformation, templateParameters, IndexedType) class IndexedInstantiationInformation
	DECLARE_LIST_MEMBER_HASH (FunctionDeclarationData, m_defaultParameters, IndexedString) class FunctionDeclarationData
IndexedDUContext LocalIndexedDeclaration	DECLARE_LIST_MEMBER_HASH (DUContextData, m_uses, Use) class DUContextData
IndexedDUContext	DECLARE_LIST_MEMBER_HASH (DUContextData, m_importedContexts, DUContext::Import) DECLARE_LIST_MEMBER_HASH(DUContextData
	DECLARE_LIST_MEMBER_HASH (DUContextData, m_childContexts, LocalIndexedDUContext) DECLARE_LIST_MEMBER_HASH(DUContextData
	DECLARE_LIST_MEMBER_HASH (ClassFunctionDeclarationData, m_defaultParameters, IndexedString) class ClassFunctionDeclarationData
	DECLARE_LIST_MEMBER_HASH (ClassDeclarationData, baseClasses, BaseClassInstance) class ClassDeclarationData
static void	deconvertDUChainInternal (DUContext *context)
void	disableDUChainReferenceCounting (void *start)
const ConstantIdentifierPrivate *	emptyConstantIdentifierPrivate ()
uint	emptyConstantIdentifierPrivateIndex ()
const ConstantQualifiedIdentifierPrivate *	emptyConstantQualifiedIdentifierPrivate ()
uint	emptyConstantQualifiedIdentifierPrivateIndex ()
void	enableDUChainReferenceCounting (void *start, unsigned int size)
QString	escapeForBracketMatching (QString str)
QString	escapeFromBracketMatching (QString str)
template<class To >
const To	fastCast (const AbstractType *from)
template<class To >
To	fastCast (AbstractType *from)
template<>
ArrayType *	fastCast< ArrayType * > (AbstractType *from)
template<>
ConstantIntegralType *	fastCast< ConstantIntegralType * > (AbstractType *from)
template<>
DelayedType *	fastCast< DelayedType * > (AbstractType *from)
template<>
EnumerationType *	fastCast< EnumerationType * > (AbstractType *from)
template<>
EnumeratorType *	fastCast< EnumeratorType * > (AbstractType *from)
template<>
FunctionType *	fastCast< FunctionType * > (AbstractType *from)
template<>
IntegralType *	fastCast< IntegralType * > (AbstractType *from)
template<>
PointerType *	fastCast< PointerType * > (AbstractType *from)
template<>
ReferenceType *	fastCast< ReferenceType * > (AbstractType *from)
template<>
StructureType *	fastCast< StructureType * > (AbstractType *from)
template<>
TypeAliasType *	fastCast< TypeAliasType * > (AbstractType *from)
static bool	featuresMatch (ParsingEnvironmentFilePointer file, TopDUContext::Features minimumFeatures, QSet< ParsingEnvironmentFilePointer > &checked)
void	fillString (QString &str, int start, int end, QChar replacement)
int	findClose (const QString &str, int pos)
int	findCommaOrEnd (const QString &str, int pos, QChar validEnd= ' ')
QByteArray	formatComment (const QByteArray &comment)
QString	formatComment (const QString &comment)
ItemRepositoryRegistry &	globalItemRepositoryRegistry ()
template<class Container , class Type >
void	insertToArray (Container &array, const Type &item, int position)
static bool	isWhite (char c)
static bool	isWhite (QChar c)
CodeModelItem::Kind	kindForDeclaration (Declaration *decl)
const Identifier &globalImportIdentifier *	new ("{...import...}")
bool	parenFits (QChar c1, QChar c2)
TopDUContext *	pickContextWithData (QList< TopDUContext * > duchains, uint maxDepth, const ParsingEnvironmentType &type, bool forcePick=true)
bool	processExists (int pid)
template<class T >
uint	qHash (const TypePtr< T > &type)
uint	qHash (const IndexedTopDUContext &ctx)
uint	qHash (const ReferencedTopDUContext &ctx)
uint	qHash (const InstantiationInformation &info)
uint	qHash (const IndexedInstantiationInformation &info)
uint	qHash (const KDevelop::IndexedString &str)
uint	qHash (const Identifier &id)
uint	qHash (const QualifiedIdentifier &id)
uint	qHash (const IndexedTypeIdentifier &id)
uint	qHash (const KDevelop::DeclarationId &id)
uint	qHash (const IndexedDeclaration &decl)
QString	rangeToString (const KTextEditor::Range &r)
Utils::BasicSetRepository	recursiveImportCacheRepository ("Recursive Imports Cache", 0, false)
Utils::BasicSetRepository	recursiveImportRepository ("Recursive Imports",&KDevelop::globalItemRepositoryRegistry())
QString	reduceWhiteSpace (QString str)
	REGISTER_DUCHAIN_ITEM (TopDUContext)
	REGISTER_DUCHAIN_ITEM (ParsingEnvironmentFile)
	REGISTER_DUCHAIN_ITEM (NamespaceAliasDeclaration)
	REGISTER_DUCHAIN_ITEM (FunctionDefinition)
	REGISTER_DUCHAIN_ITEM (FunctionDeclaration)
	REGISTER_DUCHAIN_ITEM (ForwardDeclaration)
	REGISTER_DUCHAIN_ITEM (DUContext)
	REGISTER_DUCHAIN_ITEM (DUChainBase)
	REGISTER_DUCHAIN_ITEM (Declaration)
	REGISTER_DUCHAIN_ITEM (ClassMemberDeclaration)
	REGISTER_DUCHAIN_ITEM (ClassFunctionDeclaration)
	REGISTER_DUCHAIN_ITEM (ClassDeclaration)
	REGISTER_DUCHAIN_ITEM (AliasDeclaration)
	REGISTER_TYPE (UnsureType)
	REGISTER_TYPE (TypeAliasType)
	REGISTER_TYPE (StructureType)
	REGISTER_TYPE (ReferenceType)
	REGISTER_TYPE (PointerType)
	REGISTER_TYPE (IntegralType)
	REGISTER_TYPE (FunctionType)
	REGISTER_TYPE (EnumeratorType)
	REGISTER_TYPE (EnumerationType)
	REGISTER_TYPE (DelayedType)
	REGISTER_TYPE (ConstantIntegralType)
	REGISTER_TYPE (ArrayType)
bool	removeDirectory (const QDir &aDir)
template<class Container >
void	removeFromArray (Container &array, int position)
template<class T >
void	removeFromVector (QVector< T > &vec, const T &t)
template<class Container , class Type >
bool	removeOne (Container &container, const Type &value)
template<class Container >
bool	removeOneImport (Container &container, const DUContext *value)
AbstractRepositoryManager *	returnIdentifierRepository ()
AbstractRepositoryManager *	returnTypeRepository ()
QString	reverse (const QString &str)
void	rStrip (const QByteArray &str, QByteArray &from)
void	rStrip (const QString &str, QString &from)
uint	setFlag (bool enable, uint flag, uint flags)
QString	shortLabel (KDevelop::Declaration *declaration)
QString	shortLabel (KDevelop::DUContext *context)
bool	shouldDoDUChainReferenceCounting (void *item)
bool	shouldDoDUChainReferenceCountingInternal (void *item)
void	skipFunctionArguments (QString str, QStringList &skippedArguments, int &argumentsStart)
static QStringList	splitAndKeep (QString str, QRegExp regExp)
uint	staticItemRepositoryVersion ()
void	strip (const QByteArray &str, QByteArray &from)
void	strip (const QString &str, QString &from)
QString	stripFinalWhitespace (QString str)
uint	toMilliSeconds (timeval v)
AbstractRepositoryManager *	typeRepositoryManager ()
RepositoryManager < ItemRepository < AbstractTypeData, AbstractTypeDataRequest > , false > &	typeRepositoryObject ()
Variables
int	cnt = 0
Repositories::StringRepository	commentRepository ("Comment Repository")
const int	crashesBeforeCleanup = 2
bool	doReferenceCounting = false
static DUChainPrivate *	duChainPrivateSelf = 0
static Importers	globalImporters
const Identifier &	globalImportIdentifier
RepositoryManager < ItemRepository < ConstantIdentifierPrivate, IdentifierItemRequest >, false >	identifierRepository ("Identifier Repository")
QMutex	importStructureMutex (QMutex::Recursive)
KDevelop::RepositoryManager < KDevelop::ItemRepository < InstantiationInformation, AppendedListItemRequest < InstantiationInformation > > >	instantiationInformationRepository ("Instantiation Information Repository", 1,&returnTypeRepository)
const int	lineJump = 3
	m_importers
IndexedDUContext	m_localDeclarations
const int	maxNavigationWidgetWidth = 580
RepositoryManager < ItemRepository < ConstantQualifiedIdentifierPrivate, QualifiedIdentifierItemRequest > , false >	qualifiedidentifierRepository ("Qualified Identifier Repository", 1,&returnIdentifierRepository)
Utils::BasicSetRepository	recursiveImportCacheRepository
Utils::BasicSetRepository	recursiveImportRepository
QSet< Qt::HANDLE >	shouldCreateConstantDataStorage
QMutex	shouldCreateConstantDataStorageMutex
const uint	standardInstantiationInformationIndex = instantiationInformationRepository->index( InstantiationInformation() )
RepositoryManager < ItemRepository < AbstractTypeData, AbstractTypeDataRequest > , false > &	typeRepository = typeRepositoryObject()

---

Detailed Description

When this is uncommented, a 64-bit test-value is written behind the area an item is allowed to write into before createItem(.

.) is called, and an assertion triggers when it was changed during createItem(), which means createItem wrote too long. The problem: This temporarily overwrites valid data in the following item, so it will cause serious problems if that data is accessed during the call to createItem().

---

Typedef Documentation

typedef MergeAbstractFunctionDeclaration<ClassMemberDeclaration, ClassFunctionDeclarationData> KDevelop::ClassFunctionDeclarationBase

Represents a single variable definition in a definition-use chain.

Definition at line 64 of file classfunctiondeclaration.h.

typedef MergeAbstractFunctionDeclaration<Declaration, FunctionDeclarationData> KDevelop::FunctionDeclarationBase

Represents a single variable definition in a definition-use chain.

Definition at line 54 of file functiondeclaration.h.

typedef QHash<const TopDUContext*, QPair<int, const TopDUContext*> > KDevelop::RecursiveImports

Maps an imported top-context to a pair: 1.

The distance to the top-context, and 2. The next step towards the top-context in the chain.

Definition at line 57 of file topducontext.h.

---

Enumeration Type Documentation

anonymous enum

This file contains macros and classes that can be used to conveniently implement classes that store the data of an arbitrary count of additional lists within the same memory block directly behind the class data, in a way that one the whole data can be stored by one copy-operation to another place, like needed in ItemRepository.

These macros simplify having two versions of a class: One that has its lists attached in memory, and one version that has them contained as a directly accessible KDevVarLengthArray. Both versions have their lists accessible through access-functions, have a completeSize() function that computes the size of the one-block version, and a copyListsFrom(..) function which can copy the lists from one version to the other.

Warning:

Always follow these rules: You must call initalizeAppendedLists(bool) on construction, also in any copy-constructor, but before calling copyFrom(..). The parameter to that function should be whether the lists in the items should be dynamic, and thus most times "true". You must call freeAppendedLists() on destruction, our you will be leaking memory(only when dynamic)

For each embedded list, you must use macros to define a global hash that will be used to allocate the temporary lists, example fir identifier.cpp: DEFINE_LIST_MEMBER_HASH(IdentifierPrivate, templateIdentifiers, uint);

See identifier.cpp for an example how to use these classes.

Todo:

Document this a bit more

Definition at line 53 of file appendedlist.h.

anonymous enum

A request represents the information that is searched in the repository.

It must be able to compare itself to items stored in the repository, and it must be able to create items in the. The item-types can also be basic data-types, with additional information stored behind. It must have a static destroy() member, that does any action that needs to be done before the item is removed from the repository again.

Definition at line 268 of file itemrepository.h.

enum KDevelop::ParsingEnvironmentType

Just an enumeration of a few parsing-environment types.

Enumerate a few possible future parsing-environment types. A parsing-environment could also have a type not in this enumeration, the only important thing is that it's unique for the type.

The type is needed to match ParsingEnvironment, ParsingEnvironmentFile, and ParsingEnvironmentManager together so they fit. For example the c++-versions would have their specific type.

The type must be unique(no other language may have the same type), and the type must be persistent.(it must be same after restarting kdevelop)

Enumerator:

StandardParsingEnvironment	a basic standard parsing environment
CppParsingEnvironment	a C++ parsing environment
PythonParsingEnvironment	a python parsing environment
CMakeParsingEnvironment	a CMake parsing environment
CSharpParsingEnvironment	a CSharp parsing environment
JavaParsingEnvironment	a JAva parsing environment
RubyParsingEnvironment	a Ruby parsing environment
PhpParsingEnvironment	a PHP parsing environment

Definition at line 54 of file parsingenvironment.h.

---

Function Documentation

ItemRepositoryRegistry& KDevelop::allocateGlobalItemRepositoryRegistry

(

)

The global item-repository registry that is used by default.

We intentionally leak the registry, to prevent problems in the destruction order, where the actual repositories might get deleted later than the repository registry.

Definition at line 118 of file itemrepository.cpp.

QList< KTextEditor::SmartRange * > KDevelop::allSmartUses	(	TopDUContext *	context,
		Declaration *	declaration
	)

Returns the smart-ranges of all uses.

QList< KTextEditor::SmartRange * > KDevelop::allSmartUses	(	DUContext *	context,
		int	declarationIndex
	)

Collects the smart-ranges of all uses of the given.

Parameters:

declarationIndex

QList< SimpleRange > KDevelop::allUses	(	TopDUContext *	context,
		Declaration *	declaration,
		bool	noEmptyRanges
	)

Returns all uses of the given declaration within this top-context and all sub-contexts.

QList< SimpleRange > KDevelop::allUses	(	DUContext *	context,
		int	declarationIndex,
		bool	noEmptyRanges = false
	)

Collects all uses of the given.

Parameters:

declarationIndex

QString KDevelop::clearComments	(	QString	str,
		QChar	replacement
	)

Fills all c++-style comments within the given code with the given 'replacement' character Newlines are preserved.

QString KDevelop::clearStrings	(	QString	str,
		QChar	replacement
	)

Fills all c++-strings within the given code with the given 'replacement' character Comments should have been removed before.

KDevelop::DECLARE_LIST_MEMBER_HASH	(	FunctionTypeData	,
		m_arguments	,
		IndexedType
	)

Private data structure for AbstractType.

Private data structure for FunctionType.

Inherit from this for custom type private data.

Within your inherited data types, you can use the mechanisms described in appendedlist.h

You must explicitly implement the copy constructor, see appendedlist.h for more information on copying dynamic data. When calling initalizeAppendedLists() as described there, you should always use m_dynamic as parameter.

Constructor.

Copy constructor.

While cloning, the dynamic/constant attribute alternates(The copy of dynamic data is constant, and the copy of constant data is dynamic) This means that when copying dynamic data, the size of the allocated buffer must be big enough to hold the appended lists. the AbstractType::copyData function cares about that.

Parameters:

rhs

data to copy.

Destructor.

Internal setup for the data structure.

This must be called from actual class that belongs to this data(not parent classes), and the class must have the "Identity" enumerator with a unique identity. Do NOT call this in copy-constructors!

Remember which type this data was created for.

See also:

setTypeClassId()

Type modifier flags

Remember whether this type is in a TypeRepository. Not used for comparison or hashes.

Reference-count for this type within the repository. Not used for comparison or hashes.

Returns the pure data size of this class(not including anything dynamic).

Returns the complete size of this item in memory, including derived class data and derived class appended list data

Expensive

Constructor

Copy constructor.

Parameters:

rhs

data to copy

Destructor

Function return type

Constructor

Copy constructor.

Parameters:

rhs

data to copy

Destructor

Function return type

Definition at line 139 of file typesystemdata.h.

KDevelop::DECLARE_LIST_MEMBER_HASH	(	TopDUContextData	,
		m_usedDeclarationIds	,
		DeclarationId
	)

Todo:

remove

If this is not empty, it means that the cache is used instead of the implicit structure.

Is used to count up the used declarations while building uses

Maps a declarationIndex to a DeclarationId, which is used when the entry in m_usedDeclaration is zero.

Definition at line 31 of file topducontextdata.h.

IndexedDUContext LocalIndexedDeclaration KDevelop::DECLARE_LIST_MEMBER_HASH	(	DUContextData	,
		m_uses	,
		Use
	)

This class contains data that needs to be stored to disk.

Todo:

Create an additional structure for importing to/from "temporary" contexts and classes in a way that it persists while saving/loading, and doesn't require changing a top-contexts data only because a class was derived from.

Warning:

: Whenever m_localDeclarations is read or written, DUContextDynamicData::m_localDeclarationsMutex must be locked.

Vector of all uses in this context Mutable for range synchronization

Type Constraints

Definition at line 51 of file ducontextdata.h.

KDevelop::DECLARE_LIST_MEMBER_HASH	(	ClassDeclarationData	,
		baseClasses	,
		BaseClassInstance
	)

Type of the class (struct, class, etc.)

Modifier of the class (final, abstract, etc.)

Definition at line 46 of file classdeclaration.h.

void KDevelop::disableDUChainReferenceCounting

(

void *

start

)

Must be called as often as enableDUChainReferenceCounting, with the same ranges Must never be called for the same range twice, and not for overlapping ranges.

Parameters:

	start	Position where to start the reference-counting
	size	Size of the area in bytes

Definition at line 71 of file referencecounting.cpp.

uint KDevelop::emptyConstantIdentifierPrivateIndex

(

)

This has to be initialized now, else we will get a crash when multiple threads try accessing it for the first time in the same moment.

Just so the function is instantiated right now

Definition at line 134 of file identifier.cpp.

uint KDevelop::emptyConstantQualifiedIdentifierPrivateIndex

(

)

Just so the function is instantiated right now

Definition at line 277 of file identifier.cpp.

void KDevelop::enableDUChainReferenceCounting	(	void *	start,
		unsigned int	size
	)

Enable reference-counting for the given range You should only enable the reference-counting for the time it's really needed, and it always has to be enabled too when the items are deleted again, else it will lead to inconsistencies in the repository.

Warning:

If you are not working on the duchain internal storage mechanism, you should not care about this stuff at all.

Parameters:

	start	Position where to start the reference-counting
	size	Size of the area in bytes

Definition at line 95 of file referencecounting.cpp.

QString KDevelop::escapeForBracketMatching

(

QString

str

)

Todo:

this hackery sucks

Definition at line 183 of file stringhelpers.cpp.

template<class To >

To KDevelop::fastCast

(

AbstractType *

from

)

[inline]

You can use these instead of dynamic_cast, for basic types it has better performance because it checks the whichType() member.

Definition at line 294 of file abstracttype.h.

static bool KDevelop::featuresMatch	(	ParsingEnvironmentFilePointer	file,
		TopDUContext::Features	minimumFeatures,
		QSet< ParsingEnvironmentFilePointer > &	checked
	)			[static]

Makes sure the the file has the correct features attached, and if minimumFeatures contains AllDeclarationsContextsAndUsesForRecursive, then also checks all imports.

Remove all features that are not attached to the AST

Todo:

Before recursing, do a fast check whether one of the imports has special rules stored. Else it's not neede.

Definition at line 193 of file parsingenvironment.cpp.

int KDevelop::findClose	(	const QString &	str,
		int	pos
	)

searches a fitting closing brace from left to right: a ')' for '(', ']' for '[', .

..

int KDevelop::findCommaOrEnd	(	const QString &	str,
		int	pos,
		QChar	validEnd = ' '
	)

Searches in the given string for a ',' or closing brace, while skipping everything between opened braces.

Parameters:

	str	string to search
	pos	position where to start searching
	validEnd	when this is set differently, the function will stop when it finds a comma or the given character, and not at closing-braces.

Returns:

On fail, str.length() is returned, else the position of the closing character.

QByteArray KDevelop::formatComment

(

const QByteArray &

comment

)

Extracts the interesting information out of a comment.

For example it removes all the stars at the beginning, and re-indents the text.

QString KDevelop::formatComment

(

const QString &

comment

)

Extracts the interesting information out of a comment.

For example it removes all the stars at the beginning, and re-indents the text.

ItemRepositoryRegistry & KDevelop::globalItemRepositoryRegistry

(

)

The global item-repository registry that is used by default.

bool KDevelop::processExists

(

int

pid

)

Todo:

Find a cross-platform way of doing this!

Definition at line 61 of file itemrepository.cpp.

QString KDevelop::reduceWhiteSpace

(

QString

str

)

Removes white space at the beginning and end, and replaces contiguous inner white-spaces with single white-spaces.

Newlines are treated as whitespaces, the returned text will have no more newlines.

void KDevelop::rStrip	(	const QByteArray &	str,
		QByteArray &	from
	)

Todo:

Check whether this can cause problems in utf-8, as only one real character is treated!

Definition at line 428 of file stringhelpers.cpp.

bool KDevelop::shouldDoDUChainReferenceCounting

(

void *

item

)

[inline]

This is used by indexed items to decide whether they should do reference-counting.

Definition at line 34 of file referencecounting.h.

void KDevelop::skipFunctionArguments	(	QString	str,
		QStringList &	skippedArguments,
		int &	argumentsStart
	)

Skips in the string backwards over function-arguments, and stops at the right side of a "(".

Parameters:

	skippedArguments	Will contain all skipped arguments
	argumentsStart	Should be set to the position where the seeking should start, will be changed to the right side of a "(" when found. Should be at the right side of a '(', and may be max. str.length()

static QStringList KDevelop::splitAndKeep	(	QString	str,
		QRegExp	regExp
	)			[static]

Splits the string by the given regular expression, but keeps the split-matches at the end of each line.

Definition at line 412 of file abstractnavigationcontext.cpp.

uint KDevelop::staticItemRepositoryVersion

(

)

This file implements a generic bucket-based indexing repository, that can be used for example to index strings.

All you need to do is define your item type that you want to store into the repository, and create a request item similar to ExampleItemRequest that compares and fills the defined item type.

For example the string repository uses "unsigned short" as item-type, uses that actual value to store the length of the string, and uses the space behind to store the actual string content.

See also:

ItemRepository

stringrepository.h

indexedstring.hReturns a version-number that is used to reset the item-repository after incompatible layout changes

void KDevelop::strip	(	const QByteArray &	str,
		QByteArray &	from
	)

Todo:

Check whether this can cause problems in utf-8, as only one real character is treated!

Definition at line 452 of file stringhelpers.cpp.

---

Variable Documentation

Repositories::StringRepository KDevelop::commentRepository("Comment Repository")

Todo:

Use reference counting

const Identifier& KDevelop::globalImportIdentifier

This is the identifier that can be used to search namespace-import declarations, and should be used to store namespace-imports.

It is stored statically for performance-reasons, so it doesn't need to be constructed every time it is used.

See also:

NamespaceAliasDeclaration.