1 //===--- CharUnits.h - Character units for sizes and offsets ----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the CharUnits class
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_AST_CHARUNITS_H
15 #define LLVM_CLANG_AST_CHARUNITS_H
17 #include "llvm/ADT/DenseMapInfo.h"
18 #include "llvm/Support/DataTypes.h"
19 #include "llvm/Support/MathExtras.h"
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.
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.
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.
41 typedef int64_t QuantityType;
44 QuantityType Quantity;
46 explicit CharUnits(QuantityType C) : Quantity(C) {}
50 /// CharUnits - A default constructor.
51 CharUnits() : Quantity(0) {}
53 /// Zero - Construct a CharUnits quantity of zero.
54 static CharUnits Zero() {
58 /// One - Construct a CharUnits quantity of one.
59 static CharUnits One() {
63 /// fromQuantity - Construct a CharUnits quantity from a raw integer type.
64 static CharUnits fromQuantity(QuantityType Quantity) {
65 return CharUnits(Quantity);
68 // Compound assignment.
69 CharUnits& operator+= (const CharUnits &Other) {
70 Quantity += Other.Quantity;
73 CharUnits& operator++ () {
77 CharUnits operator++ (int) {
78 return CharUnits(Quantity++);
80 CharUnits& operator-= (const CharUnits &Other) {
81 Quantity -= Other.Quantity;
84 CharUnits& operator-- () {
88 CharUnits operator-- (int) {
89 return CharUnits(Quantity--);
92 // Comparison operators.
93 bool operator== (const CharUnits &Other) const {
94 return Quantity == Other.Quantity;
96 bool operator!= (const CharUnits &Other) const {
97 return Quantity != Other.Quantity;
100 // Relational operators.
101 bool operator< (const CharUnits &Other) const {
102 return Quantity < Other.Quantity;
104 bool operator<= (const CharUnits &Other) const {
105 return Quantity <= Other.Quantity;
107 bool operator> (const CharUnits &Other) const {
108 return Quantity > Other.Quantity;
110 bool operator>= (const CharUnits &Other) const {
111 return Quantity >= Other.Quantity;
116 /// isZero - Test whether the quantity equals zero.
117 bool isZero() const { return Quantity == 0; }
119 /// isOne - Test whether the quantity equals one.
120 bool isOne() const { return Quantity == 1; }
122 /// isPositive - Test whether the quantity is greater than zero.
123 bool isPositive() const { return Quantity > 0; }
125 /// isNegative - Test whether the quantity is less than zero.
126 bool isNegative() const { return Quantity < 0; }
128 // Arithmetic operators.
129 CharUnits operator* (QuantityType N) const {
130 return CharUnits(Quantity * N);
132 CharUnits operator/ (QuantityType N) const {
133 return CharUnits(Quantity / N);
135 QuantityType operator/ (const CharUnits &Other) const {
136 return Quantity / Other.Quantity;
138 CharUnits operator% (QuantityType N) const {
139 return CharUnits(Quantity % N);
141 QuantityType operator% (const CharUnits &Other) const {
142 return Quantity % Other.Quantity;
144 CharUnits operator+ (const CharUnits &Other) const {
145 return CharUnits(Quantity + Other.Quantity);
147 CharUnits operator- (const CharUnits &Other) const {
148 return CharUnits(Quantity - Other.Quantity);
150 CharUnits operator- () const {
151 return CharUnits(-Quantity);
157 /// getQuantity - Get the raw integer representation of this quantity.
158 QuantityType getQuantity() const { return Quantity; }
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,
172 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale,
173 const clang::CharUnits &CU) {
179 template<> struct DenseMapInfo<clang::CharUnits> {
180 static clang::CharUnits getEmptyKey() {
181 clang::CharUnits::QuantityType Quantity =
182 DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey();
184 return clang::CharUnits::fromQuantity(Quantity);
187 static clang::CharUnits getTombstoneKey() {
188 clang::CharUnits::QuantityType Quantity =
189 DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey();
191 return clang::CharUnits::fromQuantity(Quantity);
194 static unsigned getHashValue(const clang::CharUnits &CU) {
195 clang::CharUnits::QuantityType Quantity = CU.getQuantity();
196 return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity);
199 static bool isEqual(const clang::CharUnits &LHS,
200 const clang::CharUnits &RHS) {
205 template <> struct isPodLike<clang::CharUnits> {
206 static const bool value = true;
209 } // end namespace llvm
211 #endif // LLVM_CLANG_AST_CHARUNITS_H