← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/ADT/PointerUnion.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/ADT/PointerUnion.h
 
1
//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- 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 PointerUnion class, which is a discriminated union of
 
11
// pointer types.
 
12
//
 
13
//===----------------------------------------------------------------------===//
 
14
 
 
15
#ifndef LLVM_ADT_POINTERUNION_H
 
16
#define LLVM_ADT_POINTERUNION_H
 
17
 
 
18
#include "llvm/ADT/PointerIntPair.h"
 
19
 
 
20
namespace llvm {
 
21
 
 
22
  /// getPointerUnionTypeNum - If the argument has type PT1* or PT2* return
 
23
  /// false or true respectively.
 
24
  template <typename PT1, typename PT2>
 
25
  static inline int getPointerUnionTypeNum(PT1 *P) { return 0; }
 
26
  template <typename PT1, typename PT2>
 
27
  static inline int getPointerUnionTypeNum(PT2 *P) { return 1; }
 
28
  template <typename PT1, typename PT2>
 
29
  static inline int getPointerUnionTypeNum(...) { return -1; }
 
30
  
 
31
  
 
32
  /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
 
33
  /// for the two template arguments.
 
34
  template <typename PT1, typename PT2>
 
35
  class PointerUnionUIntTraits {
 
36
  public:
 
37
    static inline void *getAsVoidPointer(void *P) { return P; }
 
38
    static inline void *getFromVoidPointer(void *P) { return P; }
 
39
    enum {
 
40
      PT1BitsAv = PointerLikeTypeTraits<PT1>::NumLowBitsAvailable,
 
41
      PT2BitsAv = PointerLikeTypeTraits<PT2>::NumLowBitsAvailable,
 
42
      NumLowBitsAvailable = PT1BitsAv < PT2BitsAv ? PT1BitsAv : PT2BitsAv
 
43
    };
 
44
  };
 
45
  
 
46
  /// PointerUnion - This implements a discriminated union of two pointer types,
 
47
  /// and keeps the discriminator bit-mangled into the low bits of the pointer.
 
48
  /// This allows the implementation to be extremely efficient in space, but
 
49
  /// permits a very natural and type-safe API.
 
50
  ///
 
51
  /// Common use patterns would be something like this:
 
52
  ///    PointerUnion<int*, float*> P;
 
53
  ///    P = (int*)0;
 
54
  ///    printf("%d %d", P.is<int*>(), P.is<float*>());  // prints "1 0"
 
55
  ///    X = P.get<int*>();     // ok.
 
56
  ///    Y = P.get<float*>();   // runtime assertion failure.
 
57
  ///    Z = P.get<double*>();  // runtime assertion failure (regardless of tag)
 
58
  ///    P = (float*)0;
 
59
  ///    Y = P.get<float*>();   // ok.
 
60
  ///    X = P.get<int*>();     // runtime assertion failure.
 
61
  template <typename PT1, typename PT2>
 
62
  class PointerUnion {
 
63
  public:
 
64
    typedef PointerIntPair<void*, 1, bool, 
 
65
                           PointerUnionUIntTraits<PT1,PT2> > ValTy;
 
66
  private:
 
67
    ValTy Val;
 
68
  public:
 
69
    PointerUnion() {}
 
70
    
 
71
    PointerUnion(PT1 V) {
 
72
      Val.setPointer(
 
73
         const_cast<void *>(PointerLikeTypeTraits<PT1>::getAsVoidPointer(V)));
 
74
      Val.setInt(0);
 
75
    }
 
76
    PointerUnion(PT2 V) {
 
77
      Val.setPointer(
 
78
         const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(V)));
 
79
      Val.setInt(1);
 
80
    }
 
81
    
 
82
    /// isNull - Return true if the pointer held in the union is null,
 
83
    /// regardless of which type it is.
 
84
    bool isNull() const { return Val.getPointer() == 0; }
 
85
    operator bool() const { return !isNull(); }
 
86
 
 
87
    /// is<T>() return true if the Union currently holds the type matching T.
 
88
    template<typename T>
 
89
    int is() const {
 
90
      int TyNo = ::llvm::getPointerUnionTypeNum<PT1, PT2>((T*)0);
 
91
      assert(TyNo != -1 && "Type query could never succeed on PointerUnion!");
 
92
      return static_cast<int>(Val.getInt()) == TyNo;
 
93
    }
 
94
    
 
95
    /// get<T>() - Return the value of the specified pointer type. If the
 
96
    /// specified pointer type is incorrect, assert.
 
97
    template<typename T>
 
98
    T get() const {
 
99
      assert(is<T>() && "Invalid accessor called");
 
100
      return PointerLikeTypeTraits<T>::getFromVoidPointer(Val.getPointer());
 
101
    }
 
102
    
 
103
    /// dyn_cast<T>() - If the current value is of the specified pointer type,
 
104
    /// return it, otherwise return null.
 
105
    template<typename T>
 
106
    T dyn_cast() const {
 
107
      if (is<T>()) return get<T>();
 
108
      return T();
 
109
    }
 
110
    
 
111
    /// Assignment operators - Allow assigning into this union from either
 
112
    /// pointer type, setting the discriminator to remember what it came from.
 
113
    const PointerUnion &operator=(const PT1 &RHS) {
 
114
      Val.setPointer(
 
115
         const_cast<void *>(PointerLikeTypeTraits<PT1>::getAsVoidPointer(RHS)));
 
116
      Val.setInt(0);
 
117
      return *this;
 
118
    }
 
119
    const PointerUnion &operator=(const PT2 &RHS) {
 
120
      Val.setPointer(
 
121
        const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(RHS)));
 
122
      Val.setInt(1);
 
123
      return *this;
 
124
    }
 
125
    
 
126
    void *getOpaqueValue() const { return Val.getOpaqueValue(); }
 
127
    static PointerUnion getFromOpaqueValue(void *VP) {
 
128
      PointerUnion V;
 
129
      V.Val = ValTy::getFromOpaqueValue(VP);
 
130
      return V;
 
131
    }
 
132
  };
 
133
  
 
134
  // Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
 
135
  // # low bits available = min(PT1bits,PT2bits)-1.
 
136
  template<typename PT1, typename PT2>
 
137
  class PointerLikeTypeTraits<PointerUnion<PT1, PT2> > {
 
138
  public:
 
139
    static inline void *
 
140
    getAsVoidPointer(const PointerUnion<PT1, PT2> &P) {
 
141
      return P.getOpaqueValue();
 
142
    }
 
143
    static inline PointerUnion<PT1, PT2>
 
144
    getFromVoidPointer(void *P) {
 
145
      return PointerUnion<PT1, PT2>::getFromOpaqueValue(P);
 
146
    }
 
147
    
 
148
    // The number of bits available are the min of the two pointer types.
 
149
    enum {
 
150
      NumLowBitsAvailable = 
 
151
        PointerLikeTypeTraits<typename PointerUnion<PT1,PT2>::ValTy>
 
152
          ::NumLowBitsAvailable
 
153
    };
 
154
  };
 
155
  
 
156
  
 
157
  /// PointerUnion3 - This is a pointer union of three pointer types.  See
 
158
  /// documentation for PointerUnion for usage.
 
159
  template <typename PT1, typename PT2, typename PT3>
 
160
  class PointerUnion3 {
 
161
  public:
 
162
    typedef PointerUnion<PT1, PT2> InnerUnion;
 
163
    typedef PointerUnion<InnerUnion, PT3> ValTy;
 
164
  private:
 
165
    ValTy Val;
 
166
  public:
 
167
    PointerUnion3() {}
 
168
    
 
169
    PointerUnion3(PT1 V) {
 
170
      Val = InnerUnion(V);
 
171
    }
 
172
    PointerUnion3(PT2 V) {
 
173
      Val = InnerUnion(V);
 
174
    }
 
175
    PointerUnion3(PT3 V) {
 
176
      Val = V;
 
177
    }
 
178
    
 
179
    /// isNull - Return true if the pointer held in the union is null,
 
180
    /// regardless of which type it is.
 
181
    bool isNull() const { return Val.isNull(); }
 
182
    operator bool() const { return !isNull(); }
 
183
    
 
184
    /// is<T>() return true if the Union currently holds the type matching T.
 
185
    template<typename T>
 
186
    int is() const {
 
187
      // Is it PT1/PT2?
 
188
      if (::llvm::getPointerUnionTypeNum<PT1, PT2>((T*)0) != -1)
 
189
        return Val.template is<InnerUnion>() && 
 
190
               Val.template get<InnerUnion>().template is<T>();
 
191
      return Val.template is<T>();
 
192
    }
 
193
    
 
194
    /// get<T>() - Return the value of the specified pointer type. If the
 
195
    /// specified pointer type is incorrect, assert.
 
196
    template<typename T>
 
197
    T get() const {
 
198
      assert(is<T>() && "Invalid accessor called");
 
199
      // Is it PT1/PT2?
 
200
      if (::llvm::getPointerUnionTypeNum<PT1, PT2>((T*)0) != -1)
 
201
        return Val.template get<InnerUnion>().template get<T>();
 
202
      
 
203
      return Val.template get<T>();
 
204
    }
 
205
    
 
206
    /// dyn_cast<T>() - If the current value is of the specified pointer type,
 
207
    /// return it, otherwise return null.
 
208
    template<typename T>
 
209
    T dyn_cast() const {
 
210
      if (is<T>()) return get<T>();
 
211
      return T();
 
212
    }
 
213
    
 
214
    /// Assignment operators - Allow assigning into this union from either
 
215
    /// pointer type, setting the discriminator to remember what it came from.
 
216
    const PointerUnion3 &operator=(const PT1 &RHS) {
 
217
      Val = InnerUnion(RHS);
 
218
      return *this;
 
219
    }
 
220
    const PointerUnion3 &operator=(const PT2 &RHS) {
 
221
      Val = InnerUnion(RHS);
 
222
      return *this;
 
223
    }
 
224
    const PointerUnion3 &operator=(const PT3 &RHS) {
 
225
      Val = RHS;
 
226
      return *this;
 
227
    }
 
228
    
 
229
    void *getOpaqueValue() const { return Val.getOpaqueValue(); }
 
230
    static PointerUnion3 getFromOpaqueValue(void *VP) {
 
231
      PointerUnion3 V;
 
232
      V.Val = ValTy::getFromOpaqueValue(VP);
 
233
      return V;
 
234
    }
 
235
  };
 
236
 
 
237
  // Teach SmallPtrSet that PointerUnion3 is "basically a pointer", that has
 
238
  // # low bits available = min(PT1bits,PT2bits,PT2bits)-2.
 
239
  template<typename PT1, typename PT2, typename PT3>
 
240
  class PointerLikeTypeTraits<PointerUnion3<PT1, PT2, PT3> > {
 
241
  public:
 
242
    static inline void *
 
243
    getAsVoidPointer(const PointerUnion3<PT1, PT2, PT3> &P) {
 
244
      return P.getOpaqueValue();
 
245
    }
 
246
    static inline PointerUnion3<PT1, PT2, PT3>
 
247
    getFromVoidPointer(void *P) {
 
248
      return PointerUnion3<PT1, PT2, PT3>::getFromOpaqueValue(P);
 
249
    }
 
250
    
 
251
    // The number of bits available are the min of the two pointer types.
 
252
    enum {
 
253
      NumLowBitsAvailable = 
 
254
        PointerLikeTypeTraits<typename PointerUnion3<PT1, PT2, PT3>::ValTy>
 
255
          ::NumLowBitsAvailable
 
256
    };
 
257
  };
 
258
 
 
259
  /// PointerUnion4 - This is a pointer union of four pointer types.  See
 
260
  /// documentation for PointerUnion for usage.
 
261
  template <typename PT1, typename PT2, typename PT3, typename PT4>
 
262
  class PointerUnion4 {
 
263
  public:
 
264
    typedef PointerUnion<PT1, PT2> InnerUnion1;
 
265
    typedef PointerUnion<PT3, PT4> InnerUnion2;
 
266
    typedef PointerUnion<InnerUnion1, InnerUnion2> ValTy;
 
267
  private:
 
268
    ValTy Val;
 
269
  public:
 
270
    PointerUnion4() {}
 
271
    
 
272
    PointerUnion4(PT1 V) {
 
273
      Val = InnerUnion1(V);
 
274
    }
 
275
    PointerUnion4(PT2 V) {
 
276
      Val = InnerUnion1(V);
 
277
    }
 
278
    PointerUnion4(PT3 V) {
 
279
      Val = InnerUnion2(V);
 
280
    }
 
281
    PointerUnion4(PT4 V) {
 
282
      Val = InnerUnion2(V);
 
283
    }
 
284
    
 
285
    /// isNull - Return true if the pointer held in the union is null,
 
286
    /// regardless of which type it is.
 
287
    bool isNull() const { return Val.isNull(); }
 
288
    operator bool() const { return !isNull(); }
 
289
    
 
290
    /// is<T>() return true if the Union currently holds the type matching T.
 
291
    template<typename T>
 
292
    int is() const {
 
293
      // Is it PT1/PT2?
 
294
      if (::llvm::getPointerUnionTypeNum<PT1, PT2>((T*)0) != -1)
 
295
        return Val.template is<InnerUnion1>() && 
 
296
               Val.template get<InnerUnion1>().template is<T>();
 
297
      return Val.template is<InnerUnion2>() && 
 
298
             Val.template get<InnerUnion2>().template is<T>();
 
299
    }
 
300
    
 
301
    /// get<T>() - Return the value of the specified pointer type. If the
 
302
    /// specified pointer type is incorrect, assert.
 
303
    template<typename T>
 
304
    T get() const {
 
305
      assert(is<T>() && "Invalid accessor called");
 
306
      // Is it PT1/PT2?
 
307
      if (::llvm::getPointerUnionTypeNum<PT1, PT2>((T*)0) != -1)
 
308
        return Val.template get<InnerUnion1>().template get<T>();
 
309
      
 
310
      return Val.template get<InnerUnion2>().template get<T>();
 
311
    }
 
312
    
 
313
    /// dyn_cast<T>() - If the current value is of the specified pointer type,
 
314
    /// return it, otherwise return null.
 
315
    template<typename T>
 
316
    T dyn_cast() const {
 
317
      if (is<T>()) return get<T>();
 
318
      return T();
 
319
    }
 
320
    
 
321
    /// Assignment operators - Allow assigning into this union from either
 
322
    /// pointer type, setting the discriminator to remember what it came from.
 
323
    const PointerUnion4 &operator=(const PT1 &RHS) {
 
324
      Val = InnerUnion1(RHS);
 
325
      return *this;
 
326
    }
 
327
    const PointerUnion4 &operator=(const PT2 &RHS) {
 
328
      Val = InnerUnion1(RHS);
 
329
      return *this;
 
330
    }
 
331
    const PointerUnion4 &operator=(const PT3 &RHS) {
 
332
      Val = InnerUnion2(RHS);
 
333
      return *this;
 
334
    }
 
335
    const PointerUnion4 &operator=(const PT4 &RHS) {
 
336
      Val = InnerUnion2(RHS);
 
337
      return *this;
 
338
    }
 
339
    
 
340
    void *getOpaqueValue() const { return Val.getOpaqueValue(); }
 
341
    static PointerUnion4 getFromOpaqueValue(void *VP) {
 
342
      PointerUnion4 V;
 
343
      V.Val = ValTy::getFromOpaqueValue(VP);
 
344
      return V;
 
345
    }
 
346
  };
 
347
  
 
348
  // Teach SmallPtrSet that PointerUnion4 is "basically a pointer", that has
 
349
  // # low bits available = min(PT1bits,PT2bits,PT2bits)-2.
 
350
  template<typename PT1, typename PT2, typename PT3, typename PT4>
 
351
  class PointerLikeTypeTraits<PointerUnion4<PT1, PT2, PT3, PT4> > {
 
352
  public:
 
353
    static inline void *
 
354
    getAsVoidPointer(const PointerUnion4<PT1, PT2, PT3, PT4> &P) {
 
355
      return P.getOpaqueValue();
 
356
    }
 
357
    static inline PointerUnion4<PT1, PT2, PT3, PT4>
 
358
    getFromVoidPointer(void *P) {
 
359
      return PointerUnion4<PT1, PT2, PT3, PT4>::getFromOpaqueValue(P);
 
360
    }
 
361
    
 
362
    // The number of bits available are the min of the two pointer types.
 
363
    enum {
 
364
      NumLowBitsAvailable = 
 
365
        PointerLikeTypeTraits<typename PointerUnion4<PT1, PT2, PT3, PT4>::ValTy>
 
366
          ::NumLowBitsAvailable
 
367
    };
 
368
  };
 
369
}
 
370
 
 
371
#endif