1//===- DeclGroup.h - Classes for representing groups of Decls ---*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the DeclGroup, DeclGroupRef, and OwningDeclGroup classes.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_AST_DECLGROUP_H
15#define LLVM_CLANG_AST_DECLGROUP_H
16
17#include "llvm/Support/TrailingObjects.h"
18#include <cassert>
19#include <cstdint>
20
21namespace clang {
22
23class ASTContext;
24class Decl;
25
26class DeclGroup final : private llvm::TrailingObjects<DeclGroup, Decl *> {
27 // FIXME: Include a TypeSpecifier object.
28 unsigned NumDecls = 0;
29
30private:
31 DeclGroup() = default;
32 DeclGroup(unsigned numdecls, Decl** decls);
33
34public:
35 friend TrailingObjects;
36
37 static DeclGroup *Create(ASTContext &C, Decl **Decls, unsigned NumDecls);
38
39 unsigned size() const { return NumDecls; }
40
41 Decl*& operator[](unsigned i) {
42 assert (i < NumDecls && "Out-of-bounds access.");
43 return getTrailingObjects<Decl *>()[i];
44 }
45
46 Decl* const& operator[](unsigned i) const {
47 assert (i < NumDecls && "Out-of-bounds access.");
48 return getTrailingObjects<Decl *>()[i];
49 }
50};
51
52class DeclGroupRef {
53 // Note this is not a PointerIntPair because we need the address of the
54 // non-group case to be valid as a Decl** for iteration.
55 enum Kind { SingleDeclKind=0x0, DeclGroupKind=0x1, Mask=0x1 };
56
57 Decl* D = nullptr;
58
59 Kind getKind() const {
60 return (Kind) (reinterpret_cast<uintptr_t>(D) & Mask);
61 }
62
63public:
64 DeclGroupRef() = default;
65 explicit DeclGroupRef(Decl* d) : D(d) {}
66 explicit DeclGroupRef(DeclGroup* dg)
67 : D((Decl*) (reinterpret_cast<uintptr_t>(dg) | DeclGroupKind)) {}
68
69 static DeclGroupRef Create(ASTContext &C, Decl **Decls, unsigned NumDecls) {
70 if (NumDecls == 0)
71 return DeclGroupRef();
72 if (NumDecls == 1)
73 return DeclGroupRef(Decls[0]);
74 return DeclGroupRef(DeclGroup::Create(C, Decls, NumDecls));
75 }
76
77 using iterator = Decl **;
78 using const_iterator = Decl * const *;
79
80 bool isNull() const { return D == nullptr; }
81 bool isSingleDecl() const { return getKind() == SingleDeclKind; }
82 bool isDeclGroup() const { return getKind() == DeclGroupKind; }
83
84 Decl *getSingleDecl() {
85 assert(isSingleDecl() && "Isn't a single decl");
86 return D;
87 }
88 const Decl *getSingleDecl() const {
89 return const_cast<DeclGroupRef*>(this)->getSingleDecl();
90 }
91
92 DeclGroup &getDeclGroup() {
93 assert(isDeclGroup() && "Isn't a declgroup");
94 return *((DeclGroup*)(reinterpret_cast<uintptr_t>(D) & ~Mask));
95 }
96 const DeclGroup &getDeclGroup() const {
97 return const_cast<DeclGroupRef*>(this)->getDeclGroup();
98 }
99
100 iterator begin() {
101 if (isSingleDecl())
102 return D ? &D : nullptr;
103 return &getDeclGroup()[0];
104 }
105
106 iterator end() {
107 if (isSingleDecl())
108 return D ? &D+1 : nullptr;
109 DeclGroup &G = getDeclGroup();
110 return &G[0] + G.size();
111 }
112
113 const_iterator begin() const {
114 if (isSingleDecl())
115 return D ? &D : nullptr;
116 return &getDeclGroup()[0];
117 }
118
119 const_iterator end() const {
120 if (isSingleDecl())
121 return D ? &D+1 : nullptr;
122 const DeclGroup &G = getDeclGroup();
123 return &G[0] + G.size();
124 }
125
126 void *getAsOpaquePtr() const { return D; }
127 static DeclGroupRef getFromOpaquePtr(void *Ptr) {
128 DeclGroupRef X;
129 X.D = static_cast<Decl*>(Ptr);
130 return X;
131 }
132};
133
134} // namespace clang
135
136namespace llvm {
137
138 // DeclGroupRef is "like a pointer", implement PointerLikeTypeTraits.
139 template <typename T>
140 struct PointerLikeTypeTraits;
141 template <>
142 struct PointerLikeTypeTraits<clang::DeclGroupRef> {
143 static inline void *getAsVoidPointer(clang::DeclGroupRef P) {
144 return P.getAsOpaquePtr();
145 }
146
147 static inline clang::DeclGroupRef getFromVoidPointer(void *P) {
148 return clang::DeclGroupRef::getFromOpaquePtr(P);
149 }
150
151 enum { NumLowBitsAvailable = 0 };
152 };
153
154} // namespace llvm
155
156#endif // LLVM_CLANG_AST_DECLGROUP_H
157