/usr/include/clang/AST/UnresolvedSet.h is in libclang-dev 3.0-6ubuntu3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 | //===-- UnresolvedSet.h - Unresolved sets of declarations ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the UnresolvedSet class, which is used to store
// collections of declarations in the AST.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_UNRESOLVEDSET_H
#define LLVM_CLANG_AST_UNRESOLVEDSET_H
#include <iterator>
#include "llvm/ADT/SmallVector.h"
#include "clang/AST/DeclAccessPair.h"
namespace clang {
/// The iterator over UnresolvedSets. Serves as both the const and
/// non-const iterator.
class UnresolvedSetIterator {
private:
typedef SmallVectorImpl<DeclAccessPair> DeclsTy;
typedef DeclsTy::iterator IteratorTy;
IteratorTy ir;
friend class UnresolvedSetImpl;
friend class OverloadExpr;
explicit UnresolvedSetIterator(DeclsTy::iterator ir) : ir(ir) {}
explicit UnresolvedSetIterator(DeclsTy::const_iterator ir) :
ir(const_cast<DeclsTy::iterator>(ir)) {}
IteratorTy getIterator() const { return ir; }
public:
UnresolvedSetIterator() {}
typedef std::iterator_traits<IteratorTy>::difference_type difference_type;
typedef NamedDecl *value_type;
typedef NamedDecl **pointer;
typedef NamedDecl *reference;
typedef std::iterator_traits<IteratorTy>::iterator_category iterator_category;
NamedDecl *getDecl() const { return ir->getDecl(); }
AccessSpecifier getAccess() const { return ir->getAccess(); }
void setAccess(AccessSpecifier AS) { ir->setAccess(AS); }
DeclAccessPair getPair() const { return *ir; }
NamedDecl *operator*() const { return getDecl(); }
UnresolvedSetIterator &operator++() { ++ir; return *this; }
UnresolvedSetIterator operator++(int) { return UnresolvedSetIterator(ir++); }
UnresolvedSetIterator &operator--() { --ir; return *this; }
UnresolvedSetIterator operator--(int) { return UnresolvedSetIterator(ir--); }
UnresolvedSetIterator &operator+=(difference_type d) {
ir += d; return *this;
}
UnresolvedSetIterator operator+(difference_type d) const {
return UnresolvedSetIterator(ir + d);
}
UnresolvedSetIterator &operator-=(difference_type d) {
ir -= d; return *this;
}
UnresolvedSetIterator operator-(difference_type d) const {
return UnresolvedSetIterator(ir - d);
}
value_type operator[](difference_type d) const { return *(*this + d); }
difference_type operator-(const UnresolvedSetIterator &o) const {
return ir - o.ir;
}
bool operator==(const UnresolvedSetIterator &o) const { return ir == o.ir; }
bool operator!=(const UnresolvedSetIterator &o) const { return ir != o.ir; }
bool operator<(const UnresolvedSetIterator &o) const { return ir < o.ir; }
bool operator<=(const UnresolvedSetIterator &o) const { return ir <= o.ir; }
bool operator>=(const UnresolvedSetIterator &o) const { return ir >= o.ir; }
bool operator>(const UnresolvedSetIterator &o) const { return ir > o.ir; }
};
/// UnresolvedSet - A set of unresolved declarations.
class UnresolvedSetImpl {
typedef UnresolvedSetIterator::DeclsTy DeclsTy;
// Don't allow direct construction, and only permit subclassing by
// UnresolvedSet.
private:
template <unsigned N> friend class UnresolvedSet;
UnresolvedSetImpl() {}
UnresolvedSetImpl(const UnresolvedSetImpl &) {}
public:
// We don't currently support assignment through this iterator, so we might
// as well use the same implementation twice.
typedef UnresolvedSetIterator iterator;
typedef UnresolvedSetIterator const_iterator;
iterator begin() { return iterator(decls().begin()); }
iterator end() { return iterator(decls().end()); }
const_iterator begin() const { return const_iterator(decls().begin()); }
const_iterator end() const { return const_iterator(decls().end()); }
void addDecl(NamedDecl *D) {
addDecl(D, AS_none);
}
void addDecl(NamedDecl *D, AccessSpecifier AS) {
decls().push_back(DeclAccessPair::make(D, AS));
}
/// Replaces the given declaration with the new one, once.
///
/// \return true if the set changed
bool replace(const NamedDecl* Old, NamedDecl *New) {
for (DeclsTy::iterator I = decls().begin(), E = decls().end(); I != E; ++I)
if (I->getDecl() == Old)
return (I->setDecl(New), true);
return false;
}
/// Replaces the declaration at the given iterator with the new one,
/// preserving the original access bits.
void replace(iterator I, NamedDecl *New) {
I.ir->setDecl(New);
}
void replace(iterator I, NamedDecl *New, AccessSpecifier AS) {
I.ir->set(New, AS);
}
void erase(unsigned I) {
decls()[I] = decls().back();
decls().pop_back();
}
void erase(iterator I) {
*I.ir = decls().back();
decls().pop_back();
}
void setAccess(iterator I, AccessSpecifier AS) {
I.ir->setAccess(AS);
}
void clear() { decls().clear(); }
void set_size(unsigned N) { decls().set_size(N); }
bool empty() const { return decls().empty(); }
unsigned size() const { return decls().size(); }
void append(iterator I, iterator E) {
decls().append(I.ir, E.ir);
}
DeclAccessPair &operator[](unsigned I) { return decls()[I]; }
const DeclAccessPair &operator[](unsigned I) const { return decls()[I]; }
private:
// These work because the only permitted subclass is UnresolvedSetImpl
DeclsTy &decls() {
return *reinterpret_cast<DeclsTy*>(this);
}
const DeclsTy &decls() const {
return *reinterpret_cast<const DeclsTy*>(this);
}
};
/// A set of unresolved declarations
template <unsigned InlineCapacity> class UnresolvedSet :
public UnresolvedSetImpl {
SmallVector<DeclAccessPair, InlineCapacity> Decls;
};
} // namespace clang
#endif
|