mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-10-07 05:55:44 +00:00
283b399377
behavior based on other files defining DEBUG_TYPE, which means it cannot define DEBUG_TYPE at all. This is actually better IMO as it forces folks to define relevant DEBUG_TYPEs for their files. However, it requires all files that currently use DEBUG(...) to define a DEBUG_TYPE if they don't already. I've updated all such files in LLVM and will do the same for other upstream projects. This still leaves one important change in how LLVM uses the DEBUG_TYPE macro going forward: we need to only define the macro *after* header files have been #include-ed. Previously, this wasn't possible because Debug.h required the macro to be pre-defined. This commit removes that. By defining DEBUG_TYPE after the includes two things are fixed: - Header files that need to provide a DEBUG_TYPE for some inline code can do so by defining the macro before their inline code and undef-ing it afterward so the macro does not escape. - We no longer have rampant ODR violations due to including headers with different DEBUG_TYPE definitions. This may be mostly an academic violation today, but with modules these types of violations are easy to check for and potentially very relevant. Where necessary to suppor headers with DEBUG_TYPE, I have moved the definitions below the includes in this commit. I plan to move the rest of the DEBUG_TYPE macros in LLVM in subsequent commits; this one is big enough. The comments in Debug.h, which were hilariously out of date already, have been updated to reflect the recommended practice going forward. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@206822 91177308-0d34-0410-b5e6-96231b3b80d8
100 lines
3.0 KiB
C++
100 lines
3.0 KiB
C++
//===--- UnicodeCharRanges.h - Types and functions for character ranges ---===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#ifndef LLVM_SUPPORT_UNICODECHARRANGES_H
|
|
#define LLVM_SUPPORT_UNICODECHARRANGES_H
|
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/Mutex.h"
|
|
#include "llvm/Support/MutexGuard.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <algorithm>
|
|
|
|
namespace llvm {
|
|
namespace sys {
|
|
|
|
#define DEBUG_TYPE "unicode"
|
|
|
|
/// \brief Represents a closed range of Unicode code points [Lower, Upper].
|
|
struct UnicodeCharRange {
|
|
uint32_t Lower;
|
|
uint32_t Upper;
|
|
};
|
|
|
|
inline bool operator<(uint32_t Value, UnicodeCharRange Range) {
|
|
return Value < Range.Lower;
|
|
}
|
|
inline bool operator<(UnicodeCharRange Range, uint32_t Value) {
|
|
return Range.Upper < Value;
|
|
}
|
|
|
|
/// \brief Holds a reference to an ordered array of UnicodeCharRange and allows
|
|
/// to quickly check if a code point is contained in the set represented by this
|
|
/// array.
|
|
class UnicodeCharSet {
|
|
public:
|
|
typedef ArrayRef<UnicodeCharRange> CharRanges;
|
|
|
|
/// \brief Constructs a UnicodeCharSet instance from an array of
|
|
/// UnicodeCharRanges.
|
|
///
|
|
/// Array pointed by \p Ranges should have the lifetime at least as long as
|
|
/// the UnicodeCharSet instance, and should not change. Array is validated by
|
|
/// the constructor, so it makes sense to create as few UnicodeCharSet
|
|
/// instances per each array of ranges, as possible.
|
|
UnicodeCharSet(CharRanges Ranges) : Ranges(Ranges) {
|
|
assert(rangesAreValid());
|
|
}
|
|
|
|
/// \brief Returns true if the character set contains the Unicode code point
|
|
/// \p C.
|
|
bool contains(uint32_t C) const {
|
|
return std::binary_search(Ranges.begin(), Ranges.end(), C);
|
|
}
|
|
|
|
private:
|
|
/// \brief Returns true if each of the ranges is a proper closed range
|
|
/// [min, max], and if the ranges themselves are ordered and non-overlapping.
|
|
bool rangesAreValid() const {
|
|
uint32_t Prev = 0;
|
|
for (CharRanges::const_iterator I = Ranges.begin(), E = Ranges.end();
|
|
I != E; ++I) {
|
|
if (I != Ranges.begin() && Prev >= I->Lower) {
|
|
DEBUG(dbgs() << "Upper bound 0x");
|
|
DEBUG(dbgs().write_hex(Prev));
|
|
DEBUG(dbgs() << " should be less than succeeding lower bound 0x");
|
|
DEBUG(dbgs().write_hex(I->Lower) << "\n");
|
|
return false;
|
|
}
|
|
if (I->Upper < I->Lower) {
|
|
DEBUG(dbgs() << "Upper bound 0x");
|
|
DEBUG(dbgs().write_hex(I->Lower));
|
|
DEBUG(dbgs() << " should not be less than lower bound 0x");
|
|
DEBUG(dbgs().write_hex(I->Upper) << "\n");
|
|
return false;
|
|
}
|
|
Prev = I->Upper;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
const CharRanges Ranges;
|
|
};
|
|
|
|
#undef DEBUG_TYPE // "unicode"
|
|
|
|
} // namespace sys
|
|
} // namespace llvm
|
|
|
|
|
|
#endif // LLVM_SUPPORT_UNICODECHARRANGES_H
|