CharUnits.h revision f899af662801ee6bb82be871eb0b8d19b61503ba
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 21namespace 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 whereever 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 172inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale, 173 const clang::CharUnits &CU) { 174 return CU * Scale; 175} 176 177namespace llvm { 178 179template<> 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 205template <> struct isPodLike<clang::CharUnits> { 206 static const bool value = true; 207}; 208 209} // end namespace llvm 210 211#endif // LLVM_CLANG_AST_CHARUNITS_H 212