]> CyberLeo.Net >> Repos - FreeBSD/stable/9.git/blob - contrib/llvm/tools/clang/include/clang/AST/CharUnits.h
Copy head to stable/9 as part of 9.0-RELEASE release cycle.
[FreeBSD/stable/9.git] / contrib / llvm / tools / clang / include / clang / AST / CharUnits.h
1 //===--- CharUnits.h - Character units for sizes and offsets ----*- 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 CharUnits class
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_CLANG_AST_CHARUNITS_H
15 #define LLVM_CLANG_AST_CHARUNITS_H
16
17 #include "llvm/ADT/DenseMapInfo.h"
18 #include "llvm/Support/DataTypes.h"
19 #include "llvm/Support/MathExtras.h"
20
21 namespace clang {
22   
23   /// CharUnits - This is an opaque type for sizes expressed in character units.
24   /// Instances of this type represent a quantity as a multiple of the size 
25   /// of the standard C type, char, on the target architecture. As an opaque
26   /// type, CharUnits protects you from accidentally combining operations on
27   /// quantities in bit units and character units. 
28   ///
29   /// It should be noted that characters and bytes are distinct concepts. Bytes
30   /// refer to addressable units of data storage on the target machine, and
31   /// characters are members of a set of elements used for the organization,
32   /// control, or representation of data. According to C99, bytes are allowed
33   /// to exceed characters in size, although currently, clang only supports
34   /// architectures where the two are the same size.
35   /// 
36   /// For portability, never assume that a target character is 8 bits wide. Use 
37   /// CharUnit values wherever you calculate sizes, offsets, or alignments
38   /// in character units.
39   class CharUnits {
40     public:
41       typedef int64_t QuantityType;
42
43     private:
44       QuantityType Quantity;
45
46       explicit CharUnits(QuantityType C) : Quantity(C) {}
47
48     public:
49
50       /// CharUnits - A default constructor.
51       CharUnits() : Quantity(0) {}
52
53       /// Zero - Construct a CharUnits quantity of zero.
54       static CharUnits Zero() {
55         return CharUnits(0);
56       }
57
58       /// One - Construct a CharUnits quantity of one.
59       static CharUnits One() {
60         return CharUnits(1);
61       }
62
63       /// fromQuantity - Construct a CharUnits quantity from a raw integer type.
64       static CharUnits fromQuantity(QuantityType Quantity) {
65         return CharUnits(Quantity); 
66       }
67
68       // Compound assignment.
69       CharUnits& operator+= (const CharUnits &Other) {
70         Quantity += Other.Quantity;
71         return *this;
72       }
73       CharUnits& operator++ () {
74         ++Quantity;
75         return *this;
76       }
77       CharUnits operator++ (int) {
78         return CharUnits(Quantity++);
79       }
80       CharUnits& operator-= (const CharUnits &Other) {
81         Quantity -= Other.Quantity;
82         return *this;
83       }
84       CharUnits& operator-- () {
85         --Quantity;
86         return *this;
87       }
88       CharUnits operator-- (int) {
89         return CharUnits(Quantity--);
90       }
91        
92       // Comparison operators.
93       bool operator== (const CharUnits &Other) const {
94         return Quantity == Other.Quantity;
95       }
96       bool operator!= (const CharUnits &Other) const {
97         return Quantity != Other.Quantity;
98       }
99
100       // Relational operators.
101       bool operator<  (const CharUnits &Other) const { 
102         return Quantity <  Other.Quantity; 
103       }
104       bool operator<= (const CharUnits &Other) const { 
105         return Quantity <= Other.Quantity;
106       }
107       bool operator>  (const CharUnits &Other) const { 
108         return Quantity >  Other.Quantity; 
109       }
110       bool operator>= (const CharUnits &Other) const { 
111         return Quantity >= Other.Quantity; 
112       }
113
114       // Other predicates.
115       
116       /// isZero - Test whether the quantity equals zero.
117       bool isZero() const     { return Quantity == 0; }
118
119       /// isOne - Test whether the quantity equals one.
120       bool isOne() const      { return Quantity == 1; }
121
122       /// isPositive - Test whether the quantity is greater than zero.
123       bool isPositive() const { return Quantity  > 0; }
124
125       /// isNegative - Test whether the quantity is less than zero.
126       bool isNegative() const { return Quantity  < 0; }
127
128       // Arithmetic operators.
129       CharUnits operator* (QuantityType N) const {
130         return CharUnits(Quantity * N);
131       }
132       CharUnits operator/ (QuantityType N) const {
133         return CharUnits(Quantity / N);
134       }
135       QuantityType operator/ (const CharUnits &Other) const {
136         return Quantity / Other.Quantity;
137       }
138       CharUnits operator% (QuantityType N) const {
139         return CharUnits(Quantity % N);
140       }
141       QuantityType operator% (const CharUnits &Other) const {
142         return Quantity % Other.Quantity;
143       }
144       CharUnits operator+ (const CharUnits &Other) const {
145         return CharUnits(Quantity + Other.Quantity);
146       }
147       CharUnits operator- (const CharUnits &Other) const {
148         return CharUnits(Quantity - Other.Quantity);
149       }
150       CharUnits operator- () const {
151         return CharUnits(-Quantity);
152       }
153
154       
155       // Conversions.
156
157       /// getQuantity - Get the raw integer representation of this quantity.
158       QuantityType getQuantity() const { return Quantity; }
159
160       /// RoundUpToAlignment - Returns the next integer (mod 2**64) that is
161       /// greater than or equal to this quantity and is a multiple of \arg
162       /// Align. Align must be non-zero.
163       CharUnits RoundUpToAlignment(const CharUnits &Align) {
164         return CharUnits(llvm::RoundUpToAlignment(Quantity, 
165                                                   Align.Quantity));
166       }
167
168
169   }; // class CharUnit
170 } // namespace clang
171
172 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale, 
173                                    const clang::CharUnits &CU) {
174   return CU * Scale;
175 }
176
177 namespace llvm {
178
179 template<> struct DenseMapInfo<clang::CharUnits> {
180   static clang::CharUnits getEmptyKey() {
181     clang::CharUnits::QuantityType Quantity =
182       DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey();
183
184     return clang::CharUnits::fromQuantity(Quantity);
185   }
186
187   static clang::CharUnits getTombstoneKey() {
188     clang::CharUnits::QuantityType Quantity =
189       DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey();
190     
191     return clang::CharUnits::fromQuantity(Quantity);    
192   }
193
194   static unsigned getHashValue(const clang::CharUnits &CU) {
195     clang::CharUnits::QuantityType Quantity = CU.getQuantity();
196     return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity);
197   }
198
199   static bool isEqual(const clang::CharUnits &LHS, 
200                       const clang::CharUnits &RHS) {
201     return LHS == RHS;
202   }
203 };
204
205 template <> struct isPodLike<clang::CharUnits> {
206   static const bool value = true;
207 };
208   
209 } // end namespace llvm
210
211 #endif // LLVM_CLANG_AST_CHARUNITS_H