7a51313d8a
lib dir and move all the libraries into it. This follows the main llvm tree, and allows the libraries to be built in parallel. The top level now enforces that all the libs are built before Driver, but we don't care what order the libs are built in. This speeds up parallel builds, particularly incremental ones. llvm-svn: 48402
119 lines
2.8 KiB
C++
119 lines
2.8 KiB
C++
//===--- StmtIterator.cpp - Iterators for Statements ------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines internal methods for StmtIterator.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/StmtIterator.h"
|
|
#include "clang/AST/Expr.h"
|
|
#include "clang/AST/Decl.h"
|
|
|
|
using namespace clang;
|
|
|
|
static inline VariableArrayType* FindVA(Type* t) {
|
|
while (ArrayType* vt = dyn_cast<ArrayType>(t)) {
|
|
if (VariableArrayType* vat = dyn_cast<VariableArrayType>(vt))
|
|
if (vat->getSizeExpr())
|
|
return vat;
|
|
|
|
t = vt->getElementType().getTypePtr();
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void StmtIteratorBase::NextVA() {
|
|
assert (getVAPtr());
|
|
|
|
VariableArrayType* p = getVAPtr();
|
|
p = FindVA(p->getElementType().getTypePtr());
|
|
setVAPtr(p);
|
|
|
|
if (!p && decl) {
|
|
if (VarDecl* VD = dyn_cast<VarDecl>(decl))
|
|
if (VD->Init)
|
|
return;
|
|
|
|
NextDecl();
|
|
}
|
|
else {
|
|
RawVAPtr = 0;
|
|
}
|
|
}
|
|
|
|
void StmtIteratorBase::NextDecl(bool ImmediateAdvance) {
|
|
assert (inDecl());
|
|
assert (getVAPtr() == NULL);
|
|
assert (decl);
|
|
|
|
if (ImmediateAdvance) {
|
|
decl = decl->getNextDeclarator();
|
|
|
|
if (!decl) {
|
|
RawVAPtr = 0;
|
|
return;
|
|
}
|
|
}
|
|
|
|
for ( ; decl ; decl = decl->getNextDeclarator()) {
|
|
if (VarDecl* VD = dyn_cast<VarDecl>(decl)) {
|
|
if (VariableArrayType* VAPtr = FindVA(VD->getType().getTypePtr())) {
|
|
setVAPtr(VAPtr);
|
|
return;
|
|
}
|
|
|
|
if (VD->getInit())
|
|
return;
|
|
}
|
|
else if (TypedefDecl* TD = dyn_cast<TypedefDecl>(decl)) {
|
|
if (VariableArrayType* VAPtr =
|
|
FindVA(TD->getUnderlyingType().getTypePtr())) {
|
|
setVAPtr(VAPtr);
|
|
return;
|
|
}
|
|
}
|
|
else if (EnumConstantDecl* ECD = dyn_cast<EnumConstantDecl>(decl))
|
|
if (ECD->getInitExpr())
|
|
return;
|
|
}
|
|
|
|
if (!decl) {
|
|
RawVAPtr = 0;
|
|
return;
|
|
}
|
|
}
|
|
|
|
StmtIteratorBase::StmtIteratorBase(ScopedDecl* d)
|
|
: decl(d), RawVAPtr(DeclMode) {
|
|
assert (decl);
|
|
NextDecl(false);
|
|
}
|
|
|
|
StmtIteratorBase::StmtIteratorBase(VariableArrayType* t)
|
|
: decl(NULL), RawVAPtr(SizeOfTypeVAMode) {
|
|
RawVAPtr |= reinterpret_cast<uintptr_t>(t);
|
|
}
|
|
|
|
|
|
Stmt*& StmtIteratorBase::GetDeclExpr() const {
|
|
if (VariableArrayType* VAPtr = getVAPtr()) {
|
|
assert (VAPtr->SizeExpr);
|
|
return reinterpret_cast<Stmt*&>(VAPtr->SizeExpr);
|
|
}
|
|
|
|
if (VarDecl* VD = dyn_cast<VarDecl>(decl)) {
|
|
assert (VD->Init);
|
|
return reinterpret_cast<Stmt*&>(VD->Init);
|
|
}
|
|
|
|
EnumConstantDecl* ECD = cast<EnumConstantDecl>(decl);
|
|
return reinterpret_cast<Stmt*&>(ECD->Init);
|
|
}
|