LLVM  13.0.0git
FormatVariadic.cpp
Go to the documentation of this file.
1 //===- FormatVariadic.cpp - Format string parsing and analysis ----*-C++-*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //===----------------------------------------------------------------------===//
7 
9 #include <cassert>
10 
11 using namespace llvm;
12 
14  switch (C) {
15  case '-':
16  return AlignStyle::Left;
17  case '=':
18  return AlignStyle::Center;
19  case '+':
20  return AlignStyle::Right;
21  default:
22  return None;
23  }
24  LLVM_BUILTIN_UNREACHABLE;
25 }
26 
28  size_t &Align, char &Pad) {
29  Where = AlignStyle::Right;
30  Align = 0;
31  Pad = ' ';
32  if (Spec.empty())
33  return true;
34 
35  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  if (auto Loc = translateLocChar(Spec[1])) {
44  Pad = Spec[0];
45  Where = *Loc;
46  Spec = Spec.drop_front(2);
47  } else if (auto Loc = translateLocChar(Spec[0])) {
48  Where = *Loc;
49  Spec = Spec.drop_front(1);
50  }
51  }
52 
53  bool Failed = Spec.consumeInteger(0, Align);
54  return !Failed;
55 }
56 
59  StringRef RepString = Spec.trim("{}");
60 
61  // If the replacement sequence does not start with a non-negative integer,
62  // this is an error.
63  char Pad = ' ';
64  std::size_t Align = 0;
67  size_t Index = 0;
68  RepString = RepString.trim();
69  if (RepString.consumeInteger(0, Index)) {
70  assert(false && "Invalid replacement sequence index!");
71  return ReplacementItem{};
72  }
73  RepString = RepString.trim();
74  if (!RepString.empty() && RepString.front() == ',') {
75  RepString = RepString.drop_front();
76  if (!consumeFieldLayout(RepString, Where, Align, Pad))
77  assert(false && "Invalid replacement field layout specification!");
78  }
79  RepString = RepString.trim();
80  if (!RepString.empty() && RepString.front() == ':') {
81  Options = RepString.drop_front().trim();
82  RepString = StringRef();
83  }
84  RepString = RepString.trim();
85  if (!RepString.empty()) {
86  assert(false && "Unexpected characters found in replacement string!");
87  }
88 
89  return ReplacementItem{Spec, Index, Align, Where, Pad, Options};
90 }
91 
92 std::pair<ReplacementItem, StringRef>
94  while (!Fmt.empty()) {
95  // Everything up until the first brace is a literal.
96  if (Fmt.front() != '{') {
97  std::size_t BO = Fmt.find_first_of('{');
98  return std::make_pair(ReplacementItem{Fmt.substr(0, BO)}, Fmt.substr(BO));
99  }
100 
101  StringRef Braces = Fmt.take_while([](char C) { return C == '{'; });
102  // If there is more than one brace, then some of them are escaped. Treat
103  // these as replacements.
104  if (Braces.size() > 1) {
105  size_t NumEscapedBraces = Braces.size() / 2;
106  StringRef Middle = Fmt.take_front(NumEscapedBraces);
107  StringRef Right = Fmt.drop_front(NumEscapedBraces * 2);
108  return std::make_pair(ReplacementItem{Middle}, Right);
109  }
110  // An unterminated open brace is undefined. We treat the rest of the string
111  // as a literal replacement, but we assert to indicate that this is
112  // undefined and that we consider it an error.
113  std::size_t BC = Fmt.find_first_of('}');
114  if (BC == StringRef::npos) {
115  assert(
116  false &&
117  "Unterminated brace sequence. Escape with {{ for a literal brace.");
118  return std::make_pair(ReplacementItem{Fmt}, StringRef());
119  }
120 
121  // Even if there is a closing brace, if there is another open brace before
122  // this closing brace, treat this portion as literal, and try again with the
123  // next one.
124  std::size_t BO2 = Fmt.find_first_of('{', 1);
125  if (BO2 < BC)
126  return std::make_pair(ReplacementItem{Fmt.substr(0, BO2)},
127  Fmt.substr(BO2));
128 
129  StringRef Spec = Fmt.slice(1, BC);
130  StringRef Right = Fmt.substr(BC + 1);
131 
132  auto RI = parseReplacementItem(Spec);
133  if (RI.hasValue())
134  return std::make_pair(*RI, Right);
135 
136  // If there was an error parsing the replacement item, treat it as an
137  // invalid replacement spec, and just continue.
138  Fmt = Fmt.drop_front(BC + 1);
139  }
140  return std::make_pair(ReplacementItem{Fmt}, StringRef());
141 }
142 
145  SmallVector<ReplacementItem, 2> Replacements;
147  while (!Fmt.empty()) {
148  std::tie(I, Fmt) = splitLiteralAndReplacement(Fmt);
149  if (I.Type != ReplacementType::Empty)
150  Replacements.push_back(I);
151  }
152  return Replacements;
153 }
154 
155 void detail::format_adapter::anchor() { }
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::formatv_object_base::consumeFieldLayout
static bool consumeFieldLayout(StringRef &Spec, AlignStyle &Where, size_t &Align, char &Pad)
Definition: FormatVariadic.cpp:27
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:60
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::StringRef::take_while
LLVM_NODISCARD StringRef take_while(function_ref< bool(char)> F) const
Return the longest prefix of 'this' such that every character in the prefix satisfies the given predi...
Definition: StringRef.h:639
Right
Vector Shift Left Right
Definition: README_P9.txt:118
llvm::formatv_object_base::parseFormatString
static SmallVector< ReplacementItem, 2 > parseFormatString(StringRef Fmt)
Definition: FormatVariadic.cpp:144
translateLocChar
static Optional< AlignStyle > translateLocChar(char C)
Definition: FormatVariadic.cpp:13
llvm::Optional
Definition: APInt.h:33
llvm::StringRef::slice
LLVM_NODISCARD StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:732
llvm::StringRef::substr
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:611
llvm::AlignStyle::Left
@ Left
llvm::Failed
testing::Matcher< const detail::ErrorHolder & > Failed()
Definition: Error.h:198
llvm::StringRef::take_front
LLVM_NODISCARD StringRef take_front(size_t N=1) const
Return a StringRef equal to 'this' but with only the first N elements remaining.
Definition: StringRef.h:620
llvm::AlignStyle
AlignStyle
Definition: FormatCommon.h:17
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::formatv_object_base::Fmt
StringRef Fmt
Definition: FormatVariadic.h:67
llvm::formatv_object_base::splitLiteralAndReplacement
static std::pair< ReplacementItem, StringRef > splitLiteralAndReplacement(StringRef Fmt)
Definition: FormatVariadic.cpp:93
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
FormatVariadic.h
llvm::None
const NoneType None
Definition: None.h:23
llvm::ReplacementItem
Definition: FormatVariadic.h:47
llvm::StringRef::trim
LLVM_NODISCARD StringRef trim(char Char) const
Return string with consecutive Char characters starting from the left and right removed.
Definition: StringRef.h:870
llvm::AlignStyle::Center
@ Center
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::StringRef::front
LLVM_NODISCARD char front() const
front - Get the first character in the string.
Definition: StringRef.h:161
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::ReplacementType::Empty
@ Empty
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::StringRef::consumeInteger
std::enable_if_t< std::numeric_limits< T >::is_signed, bool > consumeInteger(unsigned Radix, T &Result)
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:544
llvm::StringRef::drop_front
LLVM_NODISCARD StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
Definition: StringRef.h:653
llvm::formatv_object_base::parseReplacementItem
static Optional< ReplacementItem > parseReplacementItem(StringRef Spec)
Definition: FormatVariadic.cpp:58
llvm::StringRef::find_first_of
LLVM_NODISCARD size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
Definition: StringRef.h:410
llvm::AlignStyle::Right
@ Right
llvm::StringRef::size
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:157