]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
1 | //===-- Twine.cpp - Fast Temporary String Concatenation -------------------===// |
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 | #include "llvm/ADT/Twine.h" | |
11 | #include "llvm/ADT/SmallString.h" | |
12 | #include "llvm/Support/Debug.h" | |
13 | #include "llvm/Support/raw_ostream.h" | |
14 | using namespace llvm; | |
15 | ||
16 | std::string Twine::str() const { | |
17 | // If we're storing only a std::string, just return it. | |
18 | if (LHSKind == StdStringKind && RHSKind == EmptyKind) | |
19 | return *LHS.stdString; | |
20 | ||
21 | // Otherwise, flatten and copy the contents first. | |
22 | SmallString<256> Vec; | |
23 | return toStringRef(Vec).str(); | |
24 | } | |
25 | ||
26 | void Twine::toVector(SmallVectorImpl<char> &Out) const { | |
27 | raw_svector_ostream OS(Out); | |
28 | print(OS); | |
29 | } | |
30 | ||
31 | StringRef Twine::toStringRef(SmallVectorImpl<char> &Out) const { | |
32 | if (isSingleStringRef()) | |
33 | return getSingleStringRef(); | |
34 | toVector(Out); | |
35 | return StringRef(Out.data(), Out.size()); | |
36 | } | |
37 | ||
38 | StringRef Twine::toNullTerminatedStringRef(SmallVectorImpl<char> &Out) const { | |
39 | if (isUnary()) { | |
40 | switch (getLHSKind()) { | |
41 | case CStringKind: | |
42 | // Already null terminated, yay! | |
43 | return StringRef(LHS.cString); | |
44 | case StdStringKind: { | |
45 | const std::string *str = LHS.stdString; | |
46 | return StringRef(str->c_str(), str->size()); | |
47 | } | |
48 | default: | |
49 | break; | |
50 | } | |
51 | } | |
52 | toVector(Out); | |
53 | Out.push_back(0); | |
54 | Out.pop_back(); | |
55 | return StringRef(Out.data(), Out.size()); | |
56 | } | |
57 | ||
58 | void Twine::printOneChild(raw_ostream &OS, Child Ptr, | |
59 | NodeKind Kind) const { | |
60 | switch (Kind) { | |
61 | case Twine::NullKind: break; | |
62 | case Twine::EmptyKind: break; | |
63 | case Twine::TwineKind: | |
64 | Ptr.twine->print(OS); | |
65 | break; | |
66 | case Twine::CStringKind: | |
67 | OS << Ptr.cString; | |
68 | break; | |
69 | case Twine::StdStringKind: | |
70 | OS << *Ptr.stdString; | |
71 | break; | |
72 | case Twine::StringRefKind: | |
73 | OS << *Ptr.stringRef; | |
74 | break; | |
75 | case Twine::CharKind: | |
76 | OS << Ptr.character; | |
77 | break; | |
78 | case Twine::DecUIKind: | |
79 | OS << Ptr.decUI; | |
80 | break; | |
81 | case Twine::DecIKind: | |
82 | OS << Ptr.decI; | |
83 | break; | |
84 | case Twine::DecULKind: | |
85 | OS << *Ptr.decUL; | |
86 | break; | |
87 | case Twine::DecLKind: | |
88 | OS << *Ptr.decL; | |
89 | break; | |
90 | case Twine::DecULLKind: | |
91 | OS << *Ptr.decULL; | |
92 | break; | |
93 | case Twine::DecLLKind: | |
94 | OS << *Ptr.decLL; | |
95 | break; | |
96 | case Twine::UHexKind: | |
97 | OS.write_hex(*Ptr.uHex); | |
98 | break; | |
99 | } | |
100 | } | |
101 | ||
102 | void Twine::printOneChildRepr(raw_ostream &OS, Child Ptr, | |
103 | NodeKind Kind) const { | |
104 | switch (Kind) { | |
105 | case Twine::NullKind: | |
106 | OS << "null"; break; | |
107 | case Twine::EmptyKind: | |
108 | OS << "empty"; break; | |
109 | case Twine::TwineKind: | |
110 | OS << "rope:"; | |
111 | Ptr.twine->printRepr(OS); | |
112 | break; | |
113 | case Twine::CStringKind: | |
114 | OS << "cstring:\"" | |
115 | << Ptr.cString << "\""; | |
116 | break; | |
117 | case Twine::StdStringKind: | |
118 | OS << "std::string:\"" | |
119 | << Ptr.stdString << "\""; | |
120 | break; | |
121 | case Twine::StringRefKind: | |
122 | OS << "stringref:\"" | |
123 | << Ptr.stringRef << "\""; | |
124 | break; | |
125 | case Twine::CharKind: | |
126 | OS << "char:\"" << Ptr.character << "\""; | |
127 | break; | |
128 | case Twine::DecUIKind: | |
129 | OS << "decUI:\"" << Ptr.decUI << "\""; | |
130 | break; | |
131 | case Twine::DecIKind: | |
132 | OS << "decI:\"" << Ptr.decI << "\""; | |
133 | break; | |
134 | case Twine::DecULKind: | |
135 | OS << "decUL:\"" << *Ptr.decUL << "\""; | |
136 | break; | |
137 | case Twine::DecLKind: | |
138 | OS << "decL:\"" << *Ptr.decL << "\""; | |
139 | break; | |
140 | case Twine::DecULLKind: | |
141 | OS << "decULL:\"" << *Ptr.decULL << "\""; | |
142 | break; | |
143 | case Twine::DecLLKind: | |
144 | OS << "decLL:\"" << *Ptr.decLL << "\""; | |
145 | break; | |
146 | case Twine::UHexKind: | |
147 | OS << "uhex:\"" << Ptr.uHex << "\""; | |
148 | break; | |
149 | } | |
150 | } | |
151 | ||
152 | void Twine::print(raw_ostream &OS) const { | |
153 | printOneChild(OS, LHS, getLHSKind()); | |
154 | printOneChild(OS, RHS, getRHSKind()); | |
155 | } | |
156 | ||
157 | void Twine::printRepr(raw_ostream &OS) const { | |
158 | OS << "(Twine "; | |
159 | printOneChildRepr(OS, LHS, getLHSKind()); | |
160 | OS << " "; | |
161 | printOneChildRepr(OS, RHS, getRHSKind()); | |
162 | OS << ")"; | |
163 | } | |
164 | ||
165 | void Twine::dump() const { | |
1a4d82fc | 166 | print(dbgs()); |
223e47cc LB |
167 | } |
168 | ||
169 | void Twine::dumpRepr() const { | |
1a4d82fc | 170 | printRepr(dbgs()); |
223e47cc | 171 | } |