Line data Source code
1 : //===- FormatVariadic.cpp - Format string parsing and analysis ----*-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 : #include "llvm/Support/FormatVariadic.h"
10 :
11 : using namespace llvm;
12 :
13 : static Optional<AlignStyle> translateLocChar(char C) {
14 2284 : switch (C) {
15 : case '-':
16 : return AlignStyle::Left;
17 150 : case '=':
18 : return AlignStyle::Center;
19 450 : case '+':
20 : return AlignStyle::Right;
21 : default:
22 : return None;
23 : }
24 : LLVM_BUILTIN_UNREACHABLE;
25 : }
26 :
27 1405 : bool formatv_object_base::consumeFieldLayout(StringRef &Spec, AlignStyle &Where,
28 : size_t &Align, char &Pad) {
29 1405 : Where = AlignStyle::Right;
30 1405 : Align = 0;
31 1405 : Pad = ' ';
32 1405 : if (Spec.empty())
33 : return true;
34 :
35 1405 : if (Spec.size() > 1) {
36 : // A maximum of 2 characters at the beginning can be used for something
37 : // other
38 : // than the width.
39 : // If Spec[1] is a loc char, then Spec[0] is a pad char and Spec[2:...]
40 : // contains the width.
41 : // Otherwise, if Spec[0] is a loc char, then Spec[1:...] contains the width.
42 : // Otherwise, Spec[0:...] contains the width.
43 2297 : if (auto Loc = translateLocChar(Spec[1])) {
44 16 : Pad = Spec[0];
45 16 : Where = *Loc;
46 16 : Spec = Spec.drop_front(2);
47 1134 : } else if (auto Loc = translateLocChar(Spec[0])) {
48 894 : Where = *Loc;
49 894 : Spec = Spec.drop_front(1);
50 : }
51 : }
52 :
53 : bool Failed = Spec.consumeInteger(0, Align);
54 1405 : return !Failed;
55 : }
56 :
57 : Optional<ReplacementItem>
58 116406 : formatv_object_base::parseReplacementItem(StringRef Spec) {
59 116406 : StringRef RepString = Spec.trim("{}");
60 :
61 : // If the replacement sequence does not start with a non-negative integer,
62 : // this is an error.
63 116406 : char Pad = ' ';
64 116406 : std::size_t Align = 0;
65 116406 : AlignStyle Where = AlignStyle::Right;
66 : StringRef Options;
67 : size_t Index = 0;
68 116406 : RepString = RepString.trim();
69 : if (RepString.consumeInteger(0, Index)) {
70 : assert(false && "Invalid replacement sequence index!");
71 : return ReplacementItem{};
72 : }
73 116406 : RepString = RepString.trim();
74 116406 : if (!RepString.empty() && RepString.front() == ',') {
75 1405 : RepString = RepString.drop_front();
76 1405 : if (!consumeFieldLayout(RepString, Where, Align, Pad))
77 : assert(false && "Invalid replacement field layout specification!");
78 : }
79 116406 : RepString = RepString.trim();
80 116406 : if (!RepString.empty() && RepString.front() == ':') {
81 8461 : Options = RepString.drop_front().trim();
82 8461 : RepString = StringRef();
83 : }
84 116406 : RepString = RepString.trim();
85 : if (!RepString.empty()) {
86 : assert(false && "Unexpected characters found in replacement string!");
87 : }
88 :
89 116406 : return ReplacementItem{Spec, Index, Align, Where, Pad, Options};
90 : }
91 :
92 : std::pair<ReplacementItem, StringRef>
93 212122 : formatv_object_base::splitLiteralAndReplacement(StringRef Fmt) {
94 : std::size_t From = 0;
95 212122 : while (From < Fmt.size() && From != StringRef::npos) {
96 212122 : std::size_t BO = Fmt.find_first_of('{', From);
97 : // Everything up until the first brace is a literal.
98 212122 : if (BO != 0)
99 125816 : return std::make_pair(ReplacementItem{Fmt.substr(0, BO)}, Fmt.substr(BO));
100 :
101 : StringRef Braces =
102 116516 : Fmt.drop_front(BO).take_while([](char C) { return C == '{'; });
103 : // If there is more than one brace, then some of them are escaped. Treat
104 : // these as replacements.
105 116516 : if (Braces.size() > 1) {
106 107 : size_t NumEscapedBraces = Braces.size() / 2;
107 107 : StringRef Middle = Fmt.substr(BO, NumEscapedBraces);
108 107 : StringRef Right = Fmt.drop_front(BO + NumEscapedBraces * 2);
109 : return std::make_pair(ReplacementItem{Middle}, Right);
110 : }
111 : // An unterminated open brace is undefined. We treat the rest of the string
112 : // as a literal replacement, but we assert to indicate that this is
113 : // undefined and that we consider it an error.
114 116409 : std::size_t BC = Fmt.find_first_of('}', BO);
115 116409 : if (BC == StringRef::npos) {
116 : assert(
117 : false &&
118 : "Unterminated brace sequence. Escape with {{ for a literal brace.");
119 : return std::make_pair(ReplacementItem{Fmt}, StringRef());
120 : }
121 :
122 : // Even if there is a closing brace, if there is another open brace before
123 : // this closing brace, treat this portion as literal, and try again with the
124 : // next one.
125 116409 : std::size_t BO2 = Fmt.find_first_of('{', BO + 1);
126 116409 : if (BO2 < BC)
127 3 : return std::make_pair(ReplacementItem{Fmt.substr(0, BO2)},
128 3 : Fmt.substr(BO2));
129 :
130 116406 : StringRef Spec = Fmt.slice(BO + 1, BC);
131 116406 : StringRef Right = Fmt.substr(BC + 1);
132 :
133 116406 : auto RI = parseReplacementItem(Spec);
134 116406 : if (RI.hasValue())
135 : return std::make_pair(*RI, Right);
136 :
137 : // If there was an error parsing the replacement item, treat it as an
138 : // invalid replacement spec, and just continue.
139 : From = BC + 1;
140 : }
141 : return std::make_pair(ReplacementItem{Fmt}, StringRef());
142 : }
143 :
144 : std::vector<ReplacementItem>
145 87695 : formatv_object_base::parseFormatString(StringRef Fmt) {
146 : std::vector<ReplacementItem> Replacements;
147 : ReplacementItem I;
148 299817 : while (!Fmt.empty()) {
149 212122 : std::tie(I, Fmt) = splitLiteralAndReplacement(Fmt);
150 212122 : if (I.Type != ReplacementType::Empty)
151 212122 : Replacements.push_back(I);
152 : }
153 87695 : return Replacements;
154 : }
|
