15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===-- Twine.h - Fast Temporary String Concatenation -----------*- C++ -*-===// 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// The LLVM Compiler Infrastructure 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 59ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch// This file is distributed under the University of Illinois Open Source 65821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// License. See LICENSE.TXT for details. 75821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 85821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===----------------------------------------------------------------------===// 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#ifndef LLVM_ADT_TWINE_H 115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define LLVM_ADT_TWINE_H 125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/StringRef.h" 145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/DataTypes.h" 155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/ErrorHandling.h" 165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <cassert> 175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <string> 185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)namespace llvm { 205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) template <typename T> 215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) class SmallVectorImpl; 225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) class StringRef; 235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) class raw_ostream; 245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Twine - A lightweight data structure for efficiently representing the 265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// concatenation of temporary values as strings. 275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A Twine is a kind of rope, it represents a concatenated string using a 295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// binary-tree, where the string is the preorder of the nodes. Since the 305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Twine can be efficiently rendered into a buffer when its result is used, 315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// it avoids the cost of generating temporary values for intermediate string 325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// results -- particularly in cases when the Twine result is never 33e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch /// required. By explicitly tracking the type of leaf nodes, we can also avoid 345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the creation of temporary strings for conversions operations (such as 35e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch /// appending an integer to a string). 365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A Twine is not intended for use directly and should not be stored, its 385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// implementation relies on the ability to store pointers to temporary stack 395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// objects which may be deallocated at the end of a statement. Twines should 405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// only be used accepted as const references in arguments, when an API wishes 415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// to accept possibly-concatenated strings. 425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Twines support a special 'null' value, which always concatenates to form 445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// itself, and renders as an empty string. This can be returned from APIs to 455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// effectively nullify any concatenations performed on the result. 465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \b Implementation 485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Given the nature of a Twine, it is not possible for the Twine's 505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// concatenation method to construct interior nodes; the result must be 515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// represented inside the returned value. For this reason a Twine object 525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// actually holds two values, the left- and right-hand sides of a 535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// concatenation. We also have nullary Twine objects, which are effectively 545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// sentinel values that represent empty strings. 555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Thus, a Twine can effectively have zero, one, or two children. The \see 575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// isNullary(), \see isUnary(), and \see isBinary() predicates exist for 585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// testing the number of children. 595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// We maintain a number of invariants on Twine objects (FIXME: Why): 615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// - Nullary twines are always represented with their Kind on the left-hand 625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// side, and the Empty kind on the right-hand side. 635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// - Unary twines are always represented with the value on the left-hand 6490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) /// side, and the Empty kind on the right-hand side. 655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// - If a Twine has another Twine as a child, that child should always be 665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// binary (otherwise it could have been folded into the parent). 675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// These invariants are check by \see isValid(). 695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \b Efficiency Considerations 715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// The Twine is designed to yield efficient and small code for common 735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// situations. For this reason, the concat() method is inlined so that 745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// concatenations of leaf nodes can be optimized into stores directly into a 755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// single stack allocated object. 765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// In practice, not all compilers can be trusted to optimize concat() fully, 785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// so we provide two additional methods (and accompanying operator+ 795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// overloads) to guarantee that particularly important cases (cstring plus 805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// StringRef) codegen as desired. 815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) class Twine { 825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// NodeKind - Represent the type of an argument. 835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) enum NodeKind { 845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// An empty string; the result of concatenating anything with it is also 855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// empty. 865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) NullKind, 875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// The empty string. 895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EmptyKind, 905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A pointer to a Twine instance. 9290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) TwineKind, 935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A pointer to a C string instance. 955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CStringKind, 965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A pointer to an std::string instance. 985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StdStringKind, 995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A pointer to a StringRef instance. 1015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StringRefKind, 1025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A char value reinterpreted as a pointer, to render as a character. 1045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CharKind, 1055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// An unsigned int value reinterpreted as a pointer, to render as an 1075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// unsigned decimal integer. 1085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DecUIKind, 1095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// An int value reinterpreted as a pointer, to render as a signed 1115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// decimal integer. 1125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DecIKind, 1135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A pointer to an unsigned long value, to render as an unsigned decimal 11590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) /// integer. 1165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DecULKind, 1175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A pointer to a long value, to render as a signed decimal integer. 1195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DecLKind, 1205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A pointer to an unsigned long long value, to render as an unsigned 1225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// decimal integer. 1235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DecULLKind, 1245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A pointer to a long long value, to render as a signed decimal integer. 1265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DecLLKind, 1275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// A pointer to a uint64_t value, to render as an unsigned hexadecimal 1295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// integer. 1305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UHexKind 1315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) }; 1325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) union Child 1345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 13590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) const Twine *twine; 1365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const char *cString; 1375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const std::string *stdString; 1385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const StringRef *stringRef; 1395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) char character; 1405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned int decUI; 1415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int decI; 1425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const unsigned long *decUL; 1435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const long *decL; 1445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const unsigned long long *decULL; 1455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const long long *decLL; 1465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const uint64_t *uHex; 1475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) }; 1485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 1505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// LHS - The prefix in the concatenation, which may be uninitialized for 1515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Null or Empty kinds. 1525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Child LHS; 1535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// RHS - The suffix in the concatenation, which may be uninitialized for 1545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Null or Empty kinds. 1555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Child RHS; 1565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // enums stored as unsigned chars to save on space while some compilers 15790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // don't support specifying the backing type for an enum 1585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// LHSKind - The NodeKind of the left hand side, \see getLHSKind(). 1595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned char LHSKind; 1605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// RHSKind - The NodeKind of the left hand side, \see getLHSKind(). 1615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned char RHSKind; 1625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 1645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Construct a nullary twine; the kind must be NullKind or EmptyKind. 1655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) explicit Twine(NodeKind Kind) 1665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) : LHSKind(Kind), RHSKind(EmptyKind) { 1675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(isNullary() && "Invalid kind!"); 16890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) } 16990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 17090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) /// Construct a binary twine. 1715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) explicit Twine(const Twine &_LHS, const Twine &_RHS) 17290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) : LHSKind(TwineKind), RHSKind(TwineKind) { 1735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) LHS.twine = &_LHS; 17490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) RHS.twine = &_RHS; 1755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(isValid() && "Invalid twine!"); 1765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Construct a twine from explicit values. 1795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) explicit Twine(Child _LHS, NodeKind _LHSKind, 1805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Child _RHS, NodeKind _RHSKind) 1815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) : LHS(_LHS), RHS(_RHS), LHSKind(_LHSKind), RHSKind(_RHSKind) { 1825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(isValid() && "Invalid twine!"); 1835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Since the intended use of twines is as temporary objects, assignments 1865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// when concatenating might cause undefined behavior or stack corruptions 1875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Twine &operator=(const Twine &Other) LLVM_DELETED_FUNCTION; 1885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// isNull - Check for the null twine. 1905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isNull() const { 1915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return getLHSKind() == NullKind; 1925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// isEmpty - Check for the empty twine. 1955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isEmpty() const { 1965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return getLHSKind() == EmptyKind; 1975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 19890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 1995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// isNullary - Check if this is a nullary twine (null or empty). 2005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isNullary() const { 2015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return isNull() || isEmpty(); 2025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// isUnary - Check if this is a unary twine. 2055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isUnary() const { 20690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) return getRHSKind() == EmptyKind && !isNullary(); 2075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// isBinary - Check if this is a binary twine. 2105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isBinary() const { 2115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return getLHSKind() != NullKind && getRHSKind() != EmptyKind; 2125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// isValid - Check if this is a valid twine (satisfying the invariants on 2155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// order and number of arguments). 2165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isValid() const { 2175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Nullary twines always have Empty on the RHS. 2185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (isNullary() && getRHSKind() != EmptyKind) 2195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return false; 2205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Null should never appear on the RHS. 2225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (getRHSKind() == NullKind) 2235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return false; 2245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The RHS cannot be non-empty if the LHS is empty. 2265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (getRHSKind() != EmptyKind && getLHSKind() == EmptyKind) 2275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return false; 2285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // A twine child should always be binary. 2305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (getLHSKind() == TwineKind && 231effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch !LHS.twine->isBinary()) 232effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch return false; 2335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (getRHSKind() == TwineKind && 2345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) !RHS.twine->isBinary()) 2355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return false; 2365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 237effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch return true; 238effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch } 2395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// getLHSKind - Get the NodeKind of the left-hand side. 2415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) NodeKind getLHSKind() const { return (NodeKind) LHSKind; } 2425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// getRHSKind - Get the NodeKind of the right-hand side. 2445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) NodeKind getRHSKind() const { return (NodeKind) RHSKind; } 2455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// printOneChild - Print one child from a twine. 2475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void printOneChild(raw_ostream &OS, Child Ptr, NodeKind Kind) const; 2485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 249effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch /// printOneChildRepr - Print the representation of one child from a twine. 250effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch void printOneChildRepr(raw_ostream &OS, Child Ptr, 2515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) NodeKind Kind) const; 2525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 2545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// @name Constructors 2555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// @{ 256effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch 257effb81e5f8246d0db0270817048dc992db66e9fbBen Murdoch /// Construct from an empty string. 2585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /*implicit*/ Twine() : LHSKind(EmptyKind), RHSKind(EmptyKind) { 2595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(isValid() && "Invalid twine!"); 2605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Construct from a C string. 2635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 2645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// We take care here to optimize "" into the empty twine -- this will be 265 /// optimized out for string constants. This allows Twine arguments have 266 /// default "" values, without introducing unnecessary string constants. 267 /*implicit*/ Twine(const char *Str) 268 : RHSKind(EmptyKind) { 269 if (Str[0] != '\0') { 270 LHS.cString = Str; 271 LHSKind = CStringKind; 272 } else 273 LHSKind = EmptyKind; 274 275 assert(isValid() && "Invalid twine!"); 276 } 277 278 /// Construct from an std::string. 279 /*implicit*/ Twine(const std::string &Str) 280 : LHSKind(StdStringKind), RHSKind(EmptyKind) { 281 LHS.stdString = &Str; 282 assert(isValid() && "Invalid twine!"); 283 } 284 285 /// Construct from a StringRef. 286 /*implicit*/ Twine(const StringRef &Str) 287 : LHSKind(StringRefKind), RHSKind(EmptyKind) { 288 LHS.stringRef = &Str; 289 assert(isValid() && "Invalid twine!"); 290 } 291 292 /// Construct from a char. 293 explicit Twine(char Val) 294 : LHSKind(CharKind), RHSKind(EmptyKind) { 295 LHS.character = Val; 296 } 297 298 /// Construct from a signed char. 299 explicit Twine(signed char Val) 300 : LHSKind(CharKind), RHSKind(EmptyKind) { 301 LHS.character = static_cast<char>(Val); 302 } 303 304 /// Construct from an unsigned char. 305 explicit Twine(unsigned char Val) 306 : LHSKind(CharKind), RHSKind(EmptyKind) { 307 LHS.character = static_cast<char>(Val); 308 } 309 310 /// Construct a twine to print \p Val as an unsigned decimal integer. 311 explicit Twine(unsigned Val) 312 : LHSKind(DecUIKind), RHSKind(EmptyKind) { 313 LHS.decUI = Val; 314 } 315 316 /// Construct a twine to print \p Val as a signed decimal integer. 317 explicit Twine(int Val) 318 : LHSKind(DecIKind), RHSKind(EmptyKind) { 319 LHS.decI = Val; 320 } 321 322 /// Construct a twine to print \p Val as an unsigned decimal integer. 323 explicit Twine(const unsigned long &Val) 324 : LHSKind(DecULKind), RHSKind(EmptyKind) { 325 LHS.decUL = &Val; 326 } 327 328 /// Construct a twine to print \p Val as a signed decimal integer. 329 explicit Twine(const long &Val) 330 : LHSKind(DecLKind), RHSKind(EmptyKind) { 331 LHS.decL = &Val; 332 } 333 334 /// Construct a twine to print \p Val as an unsigned decimal integer. 335 explicit Twine(const unsigned long long &Val) 336 : LHSKind(DecULLKind), RHSKind(EmptyKind) { 337 LHS.decULL = &Val; 338 } 339 340 /// Construct a twine to print \p Val as a signed decimal integer. 341 explicit Twine(const long long &Val) 342 : LHSKind(DecLLKind), RHSKind(EmptyKind) { 343 LHS.decLL = &Val; 344 } 345 346 // FIXME: Unfortunately, to make sure this is as efficient as possible we 347 // need extra binary constructors from particular types. We can't rely on 348 // the compiler to be smart enough to fold operator+()/concat() down to the 349 // right thing. Yet. 350 351 /// Construct as the concatenation of a C string and a StringRef. 352 /*implicit*/ Twine(const char *_LHS, const StringRef &_RHS) 353 : LHSKind(CStringKind), RHSKind(StringRefKind) { 354 LHS.cString = _LHS; 355 RHS.stringRef = &_RHS; 356 assert(isValid() && "Invalid twine!"); 357 } 358 359 /// Construct as the concatenation of a StringRef and a C string. 360 /*implicit*/ Twine(const StringRef &_LHS, const char *_RHS) 361 : LHSKind(StringRefKind), RHSKind(CStringKind) { 362 LHS.stringRef = &_LHS; 363 RHS.cString = _RHS; 364 assert(isValid() && "Invalid twine!"); 365 } 366 367 /// Create a 'null' string, which is an empty string that always 368 /// concatenates to form another empty string. 369 static Twine createNull() { 370 return Twine(NullKind); 371 } 372 373 /// @} 374 /// @name Numeric Conversions 375 /// @{ 376 377 // Construct a twine to print \p Val as an unsigned hexadecimal integer. 378 static Twine utohexstr(const uint64_t &Val) { 379 Child LHS, RHS; 380 LHS.uHex = &Val; 381 RHS.twine = nullptr; 382 return Twine(LHS, UHexKind, RHS, EmptyKind); 383 } 384 385 /// @} 386 /// @name Predicate Operations 387 /// @{ 388 389 /// isTriviallyEmpty - Check if this twine is trivially empty; a false 390 /// return value does not necessarily mean the twine is empty. 391 bool isTriviallyEmpty() const { 392 return isNullary(); 393 } 394 395 /// isSingleStringRef - Return true if this twine can be dynamically 396 /// accessed as a single StringRef value with getSingleStringRef(). 397 bool isSingleStringRef() const { 398 if (getRHSKind() != EmptyKind) return false; 399 400 switch (getLHSKind()) { 401 case EmptyKind: 402 case CStringKind: 403 case StdStringKind: 404 case StringRefKind: 405 return true; 406 default: 407 return false; 408 } 409 } 410 411 /// @} 412 /// @name String Operations 413 /// @{ 414 415 Twine concat(const Twine &Suffix) const; 416 417 /// @} 418 /// @name Output & Conversion. 419 /// @{ 420 421 /// str - Return the twine contents as a std::string. 422 std::string str() const; 423 424 /// toVector - Write the concatenated string into the given SmallString or 425 /// SmallVector. 426 void toVector(SmallVectorImpl<char> &Out) const; 427 428 /// getSingleStringRef - This returns the twine as a single StringRef. This 429 /// method is only valid if isSingleStringRef() is true. 430 StringRef getSingleStringRef() const { 431 assert(isSingleStringRef() &&"This cannot be had as a single stringref!"); 432 switch (getLHSKind()) { 433 default: llvm_unreachable("Out of sync with isSingleStringRef"); 434 case EmptyKind: return StringRef(); 435 case CStringKind: return StringRef(LHS.cString); 436 case StdStringKind: return StringRef(*LHS.stdString); 437 case StringRefKind: return *LHS.stringRef; 438 } 439 } 440 441 /// toStringRef - This returns the twine as a single StringRef if it can be 442 /// represented as such. Otherwise the twine is written into the given 443 /// SmallVector and a StringRef to the SmallVector's data is returned. 444 StringRef toStringRef(SmallVectorImpl<char> &Out) const; 445 446 /// toNullTerminatedStringRef - This returns the twine as a single null 447 /// terminated StringRef if it can be represented as such. Otherwise the 448 /// twine is written into the given SmallVector and a StringRef to the 449 /// SmallVector's data is returned. 450 /// 451 /// The returned StringRef's size does not include the null terminator. 452 StringRef toNullTerminatedStringRef(SmallVectorImpl<char> &Out) const; 453 454 /// Write the concatenated string represented by this twine to the 455 /// stream \p OS. 456 void print(raw_ostream &OS) const; 457 458 /// Dump the concatenated string represented by this twine to stderr. 459 void dump() const; 460 461 /// Write the representation of this twine to the stream \p OS. 462 void printRepr(raw_ostream &OS) const; 463 464 /// Dump the representation of this twine to stderr. 465 void dumpRepr() const; 466 467 /// @} 468 }; 469 470 /// @name Twine Inline Implementations 471 /// @{ 472 473 inline Twine Twine::concat(const Twine &Suffix) const { 474 // Concatenation with null is null. 475 if (isNull() || Suffix.isNull()) 476 return Twine(NullKind); 477 478 // Concatenation with empty yields the other side. 479 if (isEmpty()) 480 return Suffix; 481 if (Suffix.isEmpty()) 482 return *this; 483 484 // Otherwise we need to create a new node, taking care to fold in unary 485 // twines. 486 Child NewLHS, NewRHS; 487 NewLHS.twine = this; 488 NewRHS.twine = &Suffix; 489 NodeKind NewLHSKind = TwineKind, NewRHSKind = TwineKind; 490 if (isUnary()) { 491 NewLHS = LHS; 492 NewLHSKind = getLHSKind(); 493 } 494 if (Suffix.isUnary()) { 495 NewRHS = Suffix.LHS; 496 NewRHSKind = Suffix.getLHSKind(); 497 } 498 499 return Twine(NewLHS, NewLHSKind, NewRHS, NewRHSKind); 500 } 501 502 inline Twine operator+(const Twine &LHS, const Twine &RHS) { 503 return LHS.concat(RHS); 504 } 505 506 /// Additional overload to guarantee simplified codegen; this is equivalent to 507 /// concat(). 508 509 inline Twine operator+(const char *LHS, const StringRef &RHS) { 510 return Twine(LHS, RHS); 511 } 512 513 /// Additional overload to guarantee simplified codegen; this is equivalent to 514 /// concat(). 515 516 inline Twine operator+(const StringRef &LHS, const char *RHS) { 517 return Twine(LHS, RHS); 518 } 519 520 inline raw_ostream &operator<<(raw_ostream &OS, const Twine &RHS) { 521 RHS.print(OS); 522 return OS; 523 } 524 525 /// @} 526} 527 528#endif 529