~ubuntu-branches/debian/sid/kdevelop/sid

KDevelop::TopDUContext* buildProxyContextFromContent(Cpp::EnvironmentFilePointer file, const TopDUContextPointer& content, const TopDUContextPointer& updateContext);

106

107

/**

108

* Compile either a context-definition chain, or add uses to an existing

109

* chain.

110

111

* \param includes contexts to reference from the top context. The list may be changed by this function.

112

* \param removeOldImports Should old imports that are not in the includes-list be removed?

113

114

KDevelop::ReferencedTopDUContext buildContexts(Cpp::EnvironmentFilePointer file, AST *node, IncludeFileList* includes = 0, const ReferencedTopDUContext& updateContext = ReferencedTopDUContext(), bool removeOldImports = true);

115

116

/**

117

* Build.an independent du-context based on a given parent-context. Such a context may be used for expression-parsing,

118

* but should be deleted as fast as possible because it keeps a reference to an independent context.

119

120

* Warning: the resulting context should be deleted some time. Before deleting it, the du-chain must be locked.

121

* Warning: The new context is added as a child to the parent-context.

122

* \param url A temporary url that can be used to identify this context @todo remove this

123

124

* \param parent Context that will be used as parent for this context

125

126

// KDevelop::DUContext* buildSubContexts(const HashedString& url, AST *node, KDevelop::DUContext* parent = 0);

127

128

inline CppEditorIntegrator* editor() const { return static_cast<CppEditorIntegrator*>(ContextBuilderBase::editor()); }

129

130

//If this flag is enabled, only publically visible declarations/contexts are computed

131

void setOnlyComputeVisible(bool onlyVisible);

132

//If this flag is enabled, declarations and contexts are computed in a very simplified form (without types, without template- or function-contexts, etc.)

133

void setComputeSimplified(bool simplified);

134

//If this flag is set, the top-context will be empty, without any contexts or declarations

135

void setComputeEmpty(bool empty);

136

137

void setMapAst(bool mapAst);

138

139

protected:

140

QualifiedIdentifier identifierForNode(NameAST* id);

141

void identifierForNode(NameAST* id, QualifiedIdentifier& target);

142

virtual void startVisiting( AST* node );

143

virtual void setContextOnNode( AST* node, DUContext* ctx );

144

virtual DUContext* contextFromNode( AST* node );

145

virtual KTextEditor::Range editorFindRange( AST* fromRange, AST* toRange );

146

virtual KTextEditor::Range editorFindRangeForContext( AST* fromRange, AST* toRange );

147

virtual DUContext* newContext(const SimpleRange& range);

148

149

/**

150

* Compile an identifier for the specified NameAST \a id.

151

152

* \note this reference will only be valid until the next time the function

153

* is called, so you need to create a copy (store as non-reference).

154

* @param typeSpecifier a pointer that will eventually be filled with a type-specifier that can be found in the name(for example the return-type of a cast-operator)

155

* @param target Place where the identifier will be written.

156

157

void identifierForNode(NameAST* id, TypeSpecifierAST** typeSpecifier, QualifiedIdentifier& target);

158

159

virtual void addBaseType( KDevelop::BaseClassInstance base, BaseSpecifierAST *node );

160

161

///Open/close prefix contexts around the class specifier that make the qualified identifier

162

///of the class Declaration match, because Declarations have only unqualified names.

163

///The prefix-context will also import the context of the specific class-declaration, so the visibility matches.

164

///@param id should be the whole identifier. A prefix-context will only be created if it

165

///has more than 1 element.

166

void openPrefixContext(AST* ast, const QualifiedIdentifier& id, const SimpleCursor& pos);

167

void closePrefixContext(const QualifiedIdentifier& id);

168

169

//The returned context may be zero, while the identifier valid

170

QPair<DUContext*, QualifiedIdentifier> findPrefixContext(const QualifiedIdentifier& id, KDevelop::SimpleCursor pos);

171

172

// Split up visitors created for subclasses to use

173

/// Visits the type specifier and init declarator for a function.

174

virtual void visitFunctionDeclaration (FunctionDefinitionAST *);

175

virtual void visitPostSimpleDeclaration(SimpleDeclarationAST*);

176

177

virtual void visitTemplateDeclaration(TemplateDeclarationAST *);

178

179

// Normal overridden visitors

180

virtual void visitInitDeclarator(InitDeclaratorAST *node);

181

virtual void visitDeclarator(DeclaratorAST *node);

182

virtual void visitNamespace(NamespaceAST *);

183

virtual void visitEnumSpecifier(EnumSpecifierAST* node);

184

virtual void visitClassSpecifier(ClassSpecifierAST *);

185

virtual void visitTypedef(TypedefAST *);

186

virtual void visitFunctionDefinition(FunctionDefinitionAST *);

187

virtual void visitCompoundStatement(CompoundStatementAST *);

188

virtual void visitSimpleDeclaration(SimpleDeclarationAST *);

189

virtual void visitName(NameAST *);

190

virtual void visitUsing(UsingAST*);

191

virtual void visitExpressionOrDeclarationStatement(ExpressionOrDeclarationStatementAST*);

192

virtual void visitForStatement(ForStatementAST*);

193

virtual void visitIfStatement(IfStatementAST*);

194

virtual void visitDoStatement(DoStatementAST*);

195

virtual void visitTryBlockStatement(TryBlockStatementAST*);

196

virtual void visitCatchStatement(CatchStatementAST*);

197

virtual void createTypeForDeclarator(DeclaratorAST *node);

198

virtual void createTypeForInitializer(InitializerAST *node);

199

virtual void closeTypeForInitializer(InitializerAST *node);

200

virtual void closeTypeForDeclarator(DeclaratorAST *node);

201

virtual void visitParameterDeclarationClause(ParameterDeclarationClauseAST* node);

202

203

void queueImportedContext(DUContext* context) {

204

DUChainReadLocker lock(DUChain::lock());

205

m_importedParentContexts << DUContext::Import(context, currentContext());

206

}

207

208

virtual void setInSymbolTable(DUContext* context);

209

210

virtual void classContextOpened(ClassSpecifierAST *node, DUContext* context);

211

212

virtual void preVisitSimpleDeclaration(SimpleDeclarationAST *);

213

214

//DUChain must not be locked

215

void createUserProblem(AST* node, QString problem);

216

217

//Opens a context of size 0, starting at the given node

218

KDevelop::DUContext* openContextEmpty(AST* range, KDevelop::DUContext::ContextType type);

219

220

KDevelop::DUContext* openContextInternal(const KDevelop::SimpleRange& range, KDevelop::DUContext::ContextType type, const KDevelop::QualifiedIdentifier& identifier);

221

222

bool createContextIfNeeded(AST* node, const QVector<KDevelop::DUContext::Import>& importedParentContexts);

223

bool createContextIfNeeded(AST* node, KDevelop::DUContext* importedParentContext);

224

void addImportedContexts();

225

226

int templateDeclarationDepth() const {

227

return m_templateDeclarationDepth;

228

}

229

230

// Variables

231

NameCompiler* m_nameCompiler;

232

233

bool m_inFunctionDefinition;

234

bool smart() const;

235

236

int m_templateDeclarationDepth;

237

uint m_typeSpecifierWithoutInitDeclarators; //Start-token of the last opened type-specifier without init-declarators (Only filled in specific cases)

238

239

QualifiedIdentifier m_openingFunctionBody; //Identifier of the currently opened function body, or empty.

240

241

bool m_onlyComputeVisible;

242

bool m_onlyComputeSimplified;

243

bool m_computeEmpty;

244

245

#ifdef DEBUG_CONTEXT_RANGES

246

void checkRanges();

247

QHash<KDevelop::DUContext*, KDevelop::SimpleRange> m_contextRanges;

248

#endif

249

250

QVector<KDevelop::DUContext::Import> m_importedParentContexts;

251

QStack< QVector<KDevelop::DUContext::Import> > m_tryParentContexts;

252

InitializerAST* m_currentInitializer;

253

254

/// AST - DUChain/Uses mapping variables

255

bool m_mapAst;

256

};

257

258

#endif // CONTEXTBUILDER_H

259

Older »