llvm::yaml::Output::paddedKey unconditionally outputs spaces, which
are superfluous if the value to be dumped is a sequence or map.
Change `bool NeedsNewLine` to `StringRef Padding` so that it can be
overridden to `\n` if the value is a sequence or map.
An empty map/sequence is special. It is printed as `{}` or `[]` without
a newline, while a non-empty map/sequence follows a newline. To handle
this distinction, add another variable `PaddingBeforeContainer` and does
the special handling in endMapping/endSequence.
Reviewed By: grimar, jhenderson
Differential Revision: https://reviews.llvm.org/D64566
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@365869
91177308-0d34-0410-b5e6-
96231b3b80d8
bool NeedBitValueComma = false;
bool NeedFlowSequenceComma = false;
bool EnumerationMatchFound = false;
- bool NeedsNewLine = false;
bool WriteDefaultValues = false;
+ StringRef Padding;
+ StringRef PaddingBeforeContainer;
};
/// YAML I/O does conversion based on types. But often native data types
void Output::beginMapping() {
StateStack.push_back(inMapFirstKey);
- NeedsNewLine = true;
+ PaddingBeforeContainer = Padding;
+ Padding = "\n";
}
bool Output::mapTag(StringRef Tag, bool Use) {
}
// Tags inside maps in sequences should act as keys in the map from a
// formatting perspective, so we always want a newline in a sequence.
- NeedsNewLine = true;
+ Padding = "\n";
}
}
return Use;
void Output::endMapping() {
// If we did not map anything, we should explicitly emit an empty map
- if (StateStack.back() == inMapFirstKey)
+ if (StateStack.back() == inMapFirstKey) {
+ Padding = PaddingBeforeContainer;
+ newLineCheck();
output("{}");
+ Padding = "\n";
+ }
StateStack.pop_back();
}
unsigned Output::beginSequence() {
StateStack.push_back(inSeqFirstElement);
- NeedsNewLine = true;
+ PaddingBeforeContainer = Padding;
+ Padding = "\n";
return 0;
}
void Output::endSequence() {
// If we did not emit anything, we should explicitly emit an empty sequence
- if (StateStack.back() == inSeqFirstElement)
+ if (StateStack.back() == inSeqFirstElement) {
+ Padding = PaddingBeforeContainer;
+ newLineCheck();
output("[]");
+ Padding = "\n";
+ }
StateStack.pop_back();
}
output(s);
if (StateStack.empty() || (!inFlowSeqAnyElement(StateStack.back()) &&
!inFlowMapAnyKey(StateStack.back())))
- NeedsNewLine = true;
+ Padding = "\n";
}
void Output::outputNewLine() {
//
void Output::newLineCheck() {
- if (!NeedsNewLine)
+ if (Padding != "\n") {
+ output(Padding);
+ Padding = {};
return;
- NeedsNewLine = false;
-
+ }
outputNewLine();
+ Padding = {};
if (StateStack.size() == 0)
return;
output(":");
const char *spaces = " ";
if (key.size() < strlen(spaces))
- output(&spaces[key.size()]);
+ Padding = &spaces[key.size()];
else
- output(" ");
+ Padding = " ";
}
void Output::flowKey(StringRef Key) {
ASSERT_EQ(OStream.str(), "---\n"
"bar: 2\n"
"foo: 1\n"
- "qux: \n"
+ "qux:\n"
" baz: true\n"
"...\n");
}
ASSERT_EQ(OStream.str(), "---\n"
"bar: 0x2\n"
"foo: 1\n"
- "qux: \n"
+ "qux:\n"
" baz: true\n"
"...\n");
}
ostr.flush();
EXPECT_EQ(1, Context.A);
EXPECT_EQ("---\n"
- "Simple: \n"
+ "Simple:\n"
" B: 0\n"
" C: 0\n"
" Context: 1\n"
ostr.flush();
EXPECT_EQ(2, Context.A);
EXPECT_EQ("---\n"
- "Simple: \n"
+ "Simple:\n"
" B: 2\n"
" C: 3\n"
" Context: 2\n"
TEST(YAMLIO, TestCustomMapping) {
std::map<std::string, int> x;
- x["foo"] = 1;
- x["bar"] = 2;
std::string out;
llvm::raw_string_ostream ostr(out);
Output xout(ostr, nullptr, 0);
+ xout << x;
+ ostr.flush();
+ EXPECT_EQ("---\n"
+ "{}\n"
+ "...\n",
+ out);
+
+ x["foo"] = 1;
+ x["bar"] = 2;
+
+ out.clear();
xout << x;
ostr.flush();
EXPECT_EQ("---\n"
xout << x;
ostr.flush();
EXPECT_EQ("---\n"
- "bar: \n"
+ "bar:\n"
" foo: 3\n"
" bar: 4\n"
- "foo: \n"
+ "foo:\n"
" foo: 1\n"
" bar: 2\n"
"...\n",
EXPECT_EQ(4, y["bar"].bar);
}
+struct FooBarMapMap {
+ std::map<std::string, FooBar> fbm;
+};
+
+template <> struct MappingTraits<FooBarMapMap> {
+ static void mapping(IO &io, FooBarMapMap &x) {
+ io.mapRequired("fbm", x.fbm);
+ }
+};
+
+TEST(YAMLIO, TestEmptyMapWrite) {
+ FooBarMapMap cont;
+ std::string str;
+ llvm::raw_string_ostream OS(str);
+ Output yout(OS);
+ yout << cont;
+ EXPECT_EQ(OS.str(), "---\nfbm: {}\n...\n");
+}
+
+TEST(YAMLIO, TestEmptySequenceWrite) {
+ FooBarContainer cont;
+ std::string str;
+ llvm::raw_string_ostream OS(str);
+ Output yout(OS);
+ yout << cont;
+ EXPECT_EQ(OS.str(), "---\nfbs: []\n...\n");
+}
+
static void TestEscaped(llvm::StringRef Input, llvm::StringRef Expected) {
std::string out;
llvm::raw_string_ostream ostr(out);
"--- !tapi-tbe\n"
"TbeVersion: 1.0\n"
"Arch: AArch64\n"
- "Symbols: \n"
+ "Symbols:\n"
" bar: { Type: Func, Weak: true }\n"
" foo: { Type: NoType, Size: 99, Warning: Does nothing }\n"
" nor: { Type: Func, Undefined: true }\n"
"TbeVersion: 1.0\n"
"SoName: nosyms.so\n"
"Arch: x86_64\n"
- "NeededLibs: \n"
+ "NeededLibs:\n"
" - libc.so\n"
" - libfoo.so\n"
" - libbar.so\n"
"compatibility-version: 0\n"
"swift-version: 5\n"
"objc-constraint: retain_release\n"
- "exports: \n"
+ "exports:\n"
" - archs: [ i386 ]\n"
" symbols: [ _sym1 ]\n"
" weak-def-symbols: [ _sym2 ]\n"
"current-version: 1.2.3\n"
"compatibility-version: 0\n"
"swift-version: 5\n"
- "exports: \n"
+ "exports:\n"
" - archs: [ i386 ]\n"
" symbols: [ _sym1 ]\n"
" weak-def-symbols: [ _sym2 ]\n"