/// Twines support a special 'null' value, which always concatenates to form
/// itself, and renders as an empty string. This can be returned from APIs to
/// effectively nullify any concatenations performed on the result.
- ///
+ ///
/// \b Implementation \n
///
/// Given the nature of a Twine, it is not possible for the Twine's
/// A pointer to a StringRef instance.
StringRefKind,
- /// A pointer to a uint64_t value, to render as an unsigned decimal
- /// integer.
- UDec32Kind,
+ /// An unsigned int value reinterpreted as a pointer, to render as an
+ /// unsigned decimal integer.
+ DecUIKind,
- /// A pointer to a uint64_t value, to render as a signed decimal integer.
- SDec32Kind,
+ /// An int value reinterpreted as a pointer, to render as a signed
+ /// decimal integer.
+ DecIKind,
- /// A pointer to a uint64_t value, to render as an unsigned decimal
+ /// A pointer to an unsigned long value, to render as an unsigned decimal
/// integer.
- UDec64Kind,
+ DecULKind,
+
+ /// A pointer to a long value, to render as a signed decimal integer.
+ DecLKind,
- /// A pointer to a uint64_t value, to render as a signed decimal integer.
- SDec64Kind,
+ /// A pointer to an unsigned long long value, to render as an unsigned
+ /// decimal integer.
+ DecULLKind,
+
+ /// A pointer to a long long value, to render as a signed decimal integer.
+ DecLLKind,
/// A pointer to a uint64_t value, to render as an unsigned hexadecimal
/// integer.
/// Null or Empty kinds.
const void *RHS;
/// LHSKind - The NodeKind of the left hand side, \see getLHSKind().
- NodeKind LHSKind : 8;
+ unsigned char LHSKind;
/// RHSKind - The NodeKind of the left hand side, \see getLHSKind().
- NodeKind RHSKind : 8;
+ unsigned char RHSKind;
private:
/// Construct a nullary twine; the kind must be NullKind or EmptyKind.
}
/// getLHSKind - Get the NodeKind of the left-hand side.
- NodeKind getLHSKind() const { return LHSKind; }
+ NodeKind getLHSKind() const { return (NodeKind) LHSKind; }
/// getRHSKind - Get the NodeKind of the left-hand side.
- NodeKind getRHSKind() const { return RHSKind; }
+ NodeKind getRHSKind() const { return (NodeKind) RHSKind; }
/// printOneChild - Print one child from a twine.
void printOneChild(raw_ostream &OS, const void *Ptr, NodeKind Kind) const;
}
/// Construct a twine to print \arg Val as an unsigned decimal integer.
- explicit Twine(const uint32_t &Val)
- : LHS(&Val), LHSKind(UDec32Kind), RHSKind(EmptyKind) {
+ explicit Twine(unsigned Val)
+ : LHS((void*)(intptr_t)Val), LHSKind(DecUIKind), RHSKind(EmptyKind) {
+ }
+
+ /// Construct a twine to print \arg Val as a signed decimal integer.
+ explicit Twine(int Val)
+ : LHS((void*)(intptr_t)Val), LHSKind(DecIKind), RHSKind(EmptyKind) {
+ }
+
+ /// Construct a twine to print \arg Val as an unsigned decimal integer.
+ explicit Twine(const unsigned long &Val)
+ : LHS(&Val), LHSKind(DecULKind), RHSKind(EmptyKind) {
}
/// Construct a twine to print \arg Val as a signed decimal integer.
- explicit Twine(const int32_t &Val)
- : LHS(&Val), LHSKind(SDec32Kind), RHSKind(EmptyKind) {
+ explicit Twine(const long &Val)
+ : LHS(&Val), LHSKind(DecLKind), RHSKind(EmptyKind) {
}
/// Construct a twine to print \arg Val as an unsigned decimal integer.
- explicit Twine(const uint64_t &Val)
- : LHS(&Val), LHSKind(UDec64Kind), RHSKind(EmptyKind) {
+ explicit Twine(const unsigned long long &Val)
+ : LHS(&Val), LHSKind(DecULLKind), RHSKind(EmptyKind) {
}
/// Construct a twine to print \arg Val as a signed decimal integer.
- explicit Twine(const int64_t &Val)
- : LHS(&Val), LHSKind(SDec64Kind), RHSKind(EmptyKind) {
+ explicit Twine(const long long &Val)
+ : LHS(&Val), LHSKind(DecLLKind), RHSKind(EmptyKind) {
}
// FIXME: Unfortunately, to make sure this is as efficient as possible we
return Twine(&Val, UHexKind, 0, EmptyKind);
}
+ /// @}
+ /// @name Predicate Operations
+ /// @{
+
+ /// isTriviallyEmpty - Check if this twine is trivially empty; a false
+ /// return value does not necessarily mean the twine is empty.
+ bool isTriviallyEmpty() const {
+ return isNullary();
+ }
+
+ /// isSingleStringRef - Return true if this twine can be dynamically
+ /// accessed as a single StringRef value with getSingleStringRef().
+ bool isSingleStringRef() const {
+ if (getRHSKind() != EmptyKind) return false;
+
+ switch (getLHSKind()) {
+ case EmptyKind:
+ case CStringKind:
+ case StdStringKind:
+ case StringRefKind:
+ return true;
+ default:
+ return false;
+ }
+ }
+
/// @}
/// @name String Operations
/// @{
/// SmallVector.
void toVector(SmallVectorImpl<char> &Out) const;
+ /// getSingleStringRef - This returns the twine as a single StringRef. This
+ /// method is only valid if isSingleStringRef() is true.
+ StringRef getSingleStringRef() const {
+ assert(isSingleStringRef() &&"This cannot be had as a single stringref!");
+ switch (getLHSKind()) {
+ default: assert(0 && "Out of sync with isSingleStringRef");
+ case EmptyKind: return StringRef();
+ case CStringKind: return StringRef((const char*)LHS);
+ case StdStringKind: return StringRef(*(const std::string*)LHS);
+ case StringRefKind: return *(const StringRef*)LHS;
+ }
+ }
+
+ /// toStringRef - This returns the twine as a single StringRef if it can be
+ /// represented as such. Otherwise the twine is written into the given
+ /// SmallVector and a StringRef to the SmallVector's data is returned.
+ StringRef toStringRef(SmallVectorImpl<char> &Out) const;
+
+ /// toNullTerminatedStringRef - This returns the twine as a single null
+ /// terminated StringRef if it can be represented as such. Otherwise the
+ /// twine is written into the given SmallVector and a StringRef to the
+ /// SmallVector's data is returned.
+ ///
+ /// The returned StringRef's size does not include the null terminator.
+ StringRef toNullTerminatedStringRef(SmallVectorImpl<char> &Out) const;
+
/// print - Write the concatenated string represented by this twine to the
/// stream \arg OS.
void print(raw_ostream &OS) const;
projects / oota-llvm.git / blobdiff