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 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-= (const CharUnits &Other) {
  74         Quantity -= Other.Quantity;
  75         return *this;
  76       }
  77
  78       // Comparison operators.
  79       bool operator== (const CharUnits &Other) const {
  80         return Quantity == Other.Quantity;
  81       }
  82       bool operator!= (const CharUnits &Other) const {
  83         return Quantity != Other.Quantity;
  84       }
  85
  86       // Relational operators.
  87       bool operator<  (const CharUnits &Other) const {
  88         return Quantity <  Other.Quantity;
  89       }
  90       bool operator<= (const CharUnits &Other) const {
  91         return Quantity <= Other.Quantity;
  92       }
  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       // Other predicates.
 101
 102       /// isZero - Test whether the quantity equals zero.
 103       bool isZero() const     { return Quantity == 0; }
 104
 105       /// isOne - Test whether the quantity equals one.
 106       bool isOne() const      { return Quantity == 1; }
 107
 108       /// isPositive - Test whether the quantity is greater than zero.
 109       bool isPositive() const { return Quantity  > 0; }
 110
 111       /// isNegative - Test whether the quantity is less than zero.
 112       bool isNegative() const { return Quantity  < 0; }
 113
 114       // Arithmetic operators.
 115       CharUnits operator* (QuantityType N) const {
 116         return CharUnits(Quantity * N);
 117       }
 118       CharUnits operator/ (QuantityType N) const {
 119         return CharUnits(Quantity / N);
 120       }
 121       QuantityType operator/ (const CharUnits &Other) const {
 122         return Quantity / Other.Quantity;
 123       }
 124       CharUnits operator% (QuantityType N) const {
 125         return CharUnits(Quantity % N);
 126       }
 127       QuantityType operator% (const CharUnits &Other) const {
 128         return Quantity % Other.Quantity;
 129       }
 130       CharUnits operator+ (const CharUnits &Other) const {
 131         return CharUnits(Quantity + Other.Quantity);
 132       }
 133       CharUnits operator- (const CharUnits &Other) const {
 134         return CharUnits(Quantity - Other.Quantity);
 135       }
 136       CharUnits operator- () const {
 137         return CharUnits(-Quantity);
 138       }
 139
 140
 141       // Conversions.
 142
 143       /// getQuantity - Get the raw integer representation of this quantity.
 144       QuantityType getQuantity() const { return Quantity; }
 145
 146       /// RoundUpToAlignment - Returns the next integer (mod 2**64) that is
 147       /// greater than or equal to this quantity and is a multiple of \arg
 148       /// Align. Align must be non-zero.
 149       CharUnits RoundUpToAlignment(const CharUnits &Align) {
 150         return CharUnits(llvm::RoundUpToAlignment(Quantity,
 151                                                   Align.Quantity));
 152       }
 153
 154
 155   }; // class CharUnit
 156 } // namespace clang
 157
 158 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale,
 159                                    const clang::CharUnits &CU) {
 160   return CU * Scale;
 161 }
 162
 163 namespace llvm {
 164
 165 template<> struct DenseMapInfo<clang::CharUnits> {
 166   static clang::CharUnits getEmptyKey() {
 167     clang::CharUnits::QuantityType Quantity =
 168       DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey();
 169
 170     return clang::CharUnits::fromQuantity(Quantity);
 171   }
 172
 173   static clang::CharUnits getTombstoneKey() {
 174     clang::CharUnits::QuantityType Quantity =
 175       DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey();
 176
 177     return clang::CharUnits::fromQuantity(Quantity);
 178   }
 179
 180   static unsigned getHashValue(const clang::CharUnits &CU) {
 181     clang::CharUnits::QuantityType Quantity = CU.getQuantity();
 182     return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity);
 183   }
 184
 185   static bool isEqual(const clang::CharUnits &LHS,
 186                       const clang::CharUnits &RHS) {
 187     return LHS == RHS;
 188   }
 189 };
 190
 191 template <> struct isPodLike<clang::CharUnits> {
 192   static const bool value = true;
 193 };
 194
 195 } // end namespace llvm
 196
 197 #endif // LLVM_CLANG_AST_CHARUNITS_H