Casting.h revision 589df88ba03a81b2b3dc9d084c191a3a74724ecd 
1//===-- Support/Casting.h - Allow flexible, checked, casts -------*- C++ -*--=//
2//
3// This file defines the isa<X>(), cast<X>(), dyn_cast<X>(), cast_or_null<X>(),
4// and dyn_cast_or_null<X>() templates.
5//
6//===----------------------------------------------------------------------===//
7
8#ifndef SUPPORT_CASTING_H
9#define SUPPORT_CASTING_H
10
11// real_type - Provide a macro to get the real type of a value that might be
12// a use.  This provides a typedef 'Type' that is the argument type for all
13// non UseTy types, and is the contained pointer type of the use if it is a
14// UseTy.
15//
16template <class X> class real_type { typedef X Type; };
17
18//===----------------------------------------------------------------------===//
19//                          Type Checking Templates
20//===----------------------------------------------------------------------===//
21
22// isa<X> - Return true if the parameter to the template is an instance of the
23// template type argument.  Used like this:
24//
25//  if (isa<Type>(myVal)) { ... }
26//
27template <class X, class Y>
28inline bool isa(Y Val) {
29  assert(Val && "isa<Ty>(NULL) invoked!");
30  return X::classof(Val);
31}
32
33
34// cast<X> - Return the argument parameter cast to the specified type.  This
35// casting operator asserts that the type is correct, so it does not return null
36// on failure.  But it will correctly return NULL when the input is NULL.
37// Used Like this:
38//
39//  cast<      Instruction>(myVal)->getParent()
40//  cast<const Instruction>(myVal)->getParent()
41//
42template <class X, class Y>
43inline X *cast(Y Val) {
44  assert(isa<X>(Val) && "cast<Ty>() argument of uncompatible type!");
45  return (X*)(real_type<Y>::Type)Val;
46}
47
48// cast_or_null<X> - Functionally identical to cast, except that a null value is
49// accepted.
50//
51template <class X, class Y>
52inline X *cast_or_null(Y Val) {
53  assert((Val == 0 || isa<X>(Val)) &&
54         "cast_or_null<Ty>() argument of uncompatible type!");
55  return (X*)(real_type<Y>::Type)Val;
56}
57
58
59// dyn_cast<X> - Return the argument parameter cast to the specified type.  This
60// casting operator returns null if the argument is of the wrong type, so it can
61// be used to test for a type as well as cast if successful.  This should be
62// used in the context of an if statement like this:
63//
64//  if (const Instruction *I = dyn_cast<const Instruction>(myVal)) { ... }
65//
66
67template <class X, class Y>
68inline X *dyn_cast(Y Val) {
69  return isa<X>(Val) ? cast<X>(Val) : 0;
70}
71
72// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
73// value is accepted.
74//
75template <class X, class Y>
76inline X *dyn_cast_or_null(Y Val) {
77  return (Val && isa<X>(Val)) ? cast<X>(Val) : 0;
78}
79
80#endif
81