<html><head><meta http-equiv="Content-Type" content="text/html; charset=us-ascii"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; line-break: after-white-space;" class="">Looks like you forgot to update the module map?<div class=""><br class=""></div><div class=""><div style="margin: 0px; font-stretch: normal; line-height: normal; font-family: Menlo;" class=""><span style="font-variant-ligatures: no-common-ligatures" class="">[53/1303] Building CXX object lib/Bina...LVMBinaryFormat.dir/MsgPackTypes.cpp.o</span></div><div style="margin: 0px; font-stretch: normal; line-height: normal; font-family: Menlo;" class=""><span style="font-variant-ligatures: no-common-ligatures" class=""><b class="">../lib/BinaryFormat/MsgPackTypes.cpp:15:2: </b></span><span style="font-variant-ligatures: no-common-ligatures; color: #db27da" class=""><b class="">warning: </b></span><span style="font-variant-ligatures: no-common-ligatures" class=""><b class="">missing submodule 'LLVM_BinaryFormat.MsgPackTypes' [-Wincomplete-umbrella]</b></span></div><div style="margin: 0px; font-stretch: normal; line-height: normal; font-family: Menlo;" class=""><span style="font-variant-ligatures: no-common-ligatures" class="">#include "llvm/BinaryFormat/MsgPackTypes.h"</span></div><div style="margin: 0px; font-stretch: normal; line-height: normal; font-family: Menlo; color: rgb(57, 192, 38);" class=""><span style="font-variant-ligatures: no-common-ligatures" class=""><b class=""> ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~</b></span></div><div style="margin: 0px; font-stretch: normal; line-height: normal; font-family: Menlo;" class=""><span style="font-variant-ligatures: no-common-ligatures" class="">1 warning generated.</span></div><div class=""><span style="font-variant-ligatures: no-common-ligatures" class=""><br class=""></span></div><div class=""><span style="font-variant-ligatures: no-common-ligatures" class="">-- adrian</span></div><div><br class=""><blockquote type="cite" class=""><div class="">On Nov 15, 2018, at 10:50 AM, Scott Linder via llvm-commits <<a href="mailto:llvm-commits@lists.llvm.org" class="">llvm-commits@lists.llvm.org</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><div class="">Author: scott.linder<br class="">Date: Thu Nov 15 10:50:01 2018<br class="">New Revision: 346978<br class=""><br class="">URL: <a href="http://llvm.org/viewvc/llvm-project?rev=346978&view=rev" class="">http://llvm.org/viewvc/llvm-project?rev=346978&view=rev</a><br class="">Log:<br class="">[BinaryFormat] Add MsgPackTypes<br class=""><br class="">Add data structure to represent MessagePack "documents" and convert<br class="">to/from both MessagePack and YAML encodings.<br class=""><br class="">Differential Revision: <a href="https://reviews.llvm.org/D48175" class="">https://reviews.llvm.org/D48175</a><br class=""><br class="">Added:<br class=""> llvm/trunk/include/llvm/BinaryFormat/MsgPackTypes.h<br class=""> llvm/trunk/lib/BinaryFormat/MsgPackTypes.cpp<br class=""> llvm/trunk/unittests/BinaryFormat/MsgPackTypesTest.cpp<br class="">Modified:<br class=""> llvm/trunk/lib/BinaryFormat/CMakeLists.txt<br class=""> llvm/trunk/unittests/BinaryFormat/CMakeLists.txt<br class=""><br class="">Added: llvm/trunk/include/llvm/BinaryFormat/MsgPackTypes.h<br class="">URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/BinaryFormat/MsgPackTypes.h?rev=346978&view=auto" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/BinaryFormat/MsgPackTypes.h?rev=346978&view=auto</a><br class="">==============================================================================<br class="">--- llvm/trunk/include/llvm/BinaryFormat/MsgPackTypes.h (added)<br class="">+++ llvm/trunk/include/llvm/BinaryFormat/MsgPackTypes.h Thu Nov 15 10:50:01 2018<br class="">@@ -0,0 +1,372 @@<br class="">+//===- MsgPackTypes.h - MsgPack Types ---------------------------*- C++ -*-===//<br class="">+//<br class="">+// The LLVM Compiler Infrastructure<br class="">+//<br class="">+// This file is distributed under the University of Illinois Open Source<br class="">+// License. See LICENSE.TXT for details.<br class="">+//<br class="">+//===----------------------------------------------------------------------===//<br class="">+//<br class="">+/// \file<br class="">+/// This is a data structure for representing MessagePack "documents", with<br class="">+/// methods to go to and from MessagePack. The types also specialize YAMLIO<br class="">+/// traits in order to go to and from YAML.<br class="">+//<br class="">+//===----------------------------------------------------------------------===//<br class="">+<br class="">+#include "llvm/ADT/Optional.h"<br class="">+#include "llvm/BinaryFormat/MsgPackReader.h"<br class="">+#include "llvm/BinaryFormat/MsgPackWriter.h"<br class="">+#include "llvm/Support/Casting.h"<br class="">+#include "llvm/Support/YAMLTraits.h"<br class="">+#include <vector><br class="">+<br class="">+#ifndef LLVM_BINARYFORMAT_MSGPACKTYPES_H<br class="">+#define LLVM_BINARYFORMAT_MSGPACKTYPES_H<br class="">+<br class="">+namespace llvm {<br class="">+namespace msgpack {<br class="">+<br class="">+class Node;<br class="">+<br class="">+/// Short-hand for a Node pointer.<br class="">+using NodePtr = std::shared_ptr<Node>;<br class="">+<br class="">+/// Short-hand for an Optional Node pointer.<br class="">+using OptNodePtr = Optional<NodePtr>;<br class="">+<br class="">+/// Abstract base-class which can be any MessagePack type.<br class="">+class Node {<br class="">+public:<br class="">+ enum NodeKind {<br class="">+ NK_Scalar,<br class="">+ NK_Array,<br class="">+ NK_Map,<br class="">+ };<br class="">+<br class="">+private:<br class="">+ virtual void anchor() = 0;<br class="">+ const NodeKind Kind;<br class="">+<br class="">+ static Expected<OptNodePtr> readArray(Reader &MPReader, size_t Length);<br class="">+ static Expected<OptNodePtr> readMap(Reader &MPReader, size_t Length);<br class="">+<br class="">+public:<br class="">+ NodeKind getKind() const { return Kind; }<br class="">+<br class="">+ /// Construct a Node. Used by derived classes to track kind information.<br class="">+ Node(NodeKind Kind) : Kind(Kind) {}<br class="">+<br class="">+ virtual ~Node() = default;<br class="">+<br class="">+ /// Read from a MessagePack reader \p MPReader, returning an error if one is<br class="">+ /// encountered, or None if \p MPReader is at the end of stream, or some Node<br class="">+ /// pointer if some type is read.<br class="">+ static Expected<OptNodePtr> read(Reader &MPReader);<br class="">+<br class="">+ /// Write to a MessagePack writer \p MPWriter.<br class="">+ virtual void write(Writer &MPWriter) = 0;<br class="">+};<br class="">+<br class="">+/// A MessagePack scalar.<br class="">+class ScalarNode : public Node {<br class="">+public:<br class="">+ enum ScalarKind {<br class="">+ SK_Int,<br class="">+ SK_UInt,<br class="">+ SK_Nil,<br class="">+ SK_Boolean,<br class="">+ SK_Float,<br class="">+ SK_String,<br class="">+ SK_Binary,<br class="">+ };<br class="">+<br class="">+private:<br class="">+ void anchor() override;<br class="">+<br class="">+ void destroy();<br class="">+<br class="">+ ScalarKind SKind;<br class="">+<br class="">+ union {<br class="">+ int64_t IntValue;<br class="">+ uint64_t UIntValue;<br class="">+ bool BoolValue;<br class="">+ double FloatValue;<br class="">+ std::string StringValue;<br class="">+ };<br class="">+<br class="">+public:<br class="">+ /// Construct an Int ScalarNode.<br class="">+ ScalarNode(int64_t IntValue);<br class="">+ /// Construct an Int ScalarNode.<br class="">+ ScalarNode(int32_t IntValue);<br class="">+ /// Construct an UInt ScalarNode.<br class="">+ ScalarNode(uint64_t UIntValue);<br class="">+ /// Construct an UInt ScalarNode.<br class="">+ ScalarNode(uint32_t UIntValue);<br class="">+ /// Construct a Nil ScalarNode.<br class="">+ ScalarNode();<br class="">+ /// Construct a Boolean ScalarNode.<br class="">+ ScalarNode(bool BoolValue);<br class="">+ /// Construct a Float ScalarNode.<br class="">+ ScalarNode(double FloatValue);<br class="">+ /// Construct a String ScalarNode.<br class="">+ ScalarNode(StringRef StringValue);<br class="">+ /// Construct a String ScalarNode.<br class="">+ ScalarNode(const char *StringValue);<br class="">+ /// Construct a String ScalarNode.<br class="">+ ScalarNode(std::string &&StringValue);<br class="">+ /// Construct a Binary ScalarNode.<br class="">+ ScalarNode(MemoryBufferRef BinaryValue);<br class="">+<br class="">+ ~ScalarNode();<br class="">+<br class="">+ ScalarNode &operator=(const ScalarNode &RHS) = delete;<br class="">+ /// A ScalarNode can only be move assigned.<br class="">+ ScalarNode &operator=(ScalarNode &&RHS);<br class="">+<br class="">+ /// Change the kind of this ScalarNode, zero initializing it to the new type.<br class="">+ void setScalarKind(ScalarKind SKind) {<br class="">+ switch (SKind) {<br class="">+ case SK_Int:<br class="">+ *this = int64_t(0);<br class="">+ break;<br class="">+ case SK_UInt:<br class="">+ *this = uint64_t(0);<br class="">+ break;<br class="">+ case SK_Boolean:<br class="">+ *this = false;<br class="">+ break;<br class="">+ case SK_Float:<br class="">+ *this = 0.0;<br class="">+ break;<br class="">+ case SK_String:<br class="">+ *this = StringRef();<br class="">+ break;<br class="">+ case SK_Binary:<br class="">+ *this = MemoryBufferRef("", "");<br class="">+ break;<br class="">+ case SK_Nil:<br class="">+ *this = ScalarNode();<br class="">+ break;<br class="">+ }<br class="">+ }<br class="">+<br class="">+ /// Get the current kind of ScalarNode.<br class="">+ ScalarKind getScalarKind() { return SKind; }<br class="">+<br class="">+ /// Get the value of an Int scalar.<br class="">+ ///<br class="">+ /// \warning Assumes getScalarKind() == SK_Int<br class="">+ int64_t getInt() {<br class="">+ assert(SKind == SK_Int);<br class="">+ return IntValue;<br class="">+ }<br class="">+<br class="">+ /// Get the value of a UInt scalar.<br class="">+ ///<br class="">+ /// \warning Assumes getScalarKind() == SK_UInt<br class="">+ uint64_t getUInt() {<br class="">+ assert(SKind == SK_UInt);<br class="">+ return UIntValue;<br class="">+ }<br class="">+<br class="">+ /// Get the value of an Boolean scalar.<br class="">+ ///<br class="">+ /// \warning Assumes getScalarKind() == SK_Boolean<br class="">+ bool getBool() {<br class="">+ assert(SKind == SK_Boolean);<br class="">+ return BoolValue;<br class="">+ }<br class="">+<br class="">+ /// Get the value of an Float scalar.<br class="">+ ///<br class="">+ /// \warning Assumes getScalarKind() == SK_Float<br class="">+ double getFloat() {<br class="">+ assert(SKind == SK_Float);<br class="">+ return FloatValue;<br class="">+ }<br class="">+<br class="">+ /// Get the value of a String scalar.<br class="">+ ///<br class="">+ /// \warning Assumes getScalarKind() == SK_String<br class="">+ StringRef getString() {<br class="">+ assert(SKind == SK_String);<br class="">+ return StringValue;<br class="">+ }<br class="">+<br class="">+ /// Get the value of a Binary scalar.<br class="">+ ///<br class="">+ /// \warning Assumes getScalarKind() == SK_Binary<br class="">+ StringRef getBinary() {<br class="">+ assert(SKind == SK_Binary);<br class="">+ return StringValue;<br class="">+ }<br class="">+<br class="">+ static bool classof(const Node *N) { return N->getKind() == NK_Scalar; }<br class="">+<br class="">+ void write(Writer &MPWriter) override;<br class="">+<br class="">+ /// Parse a YAML scalar of the current ScalarKind from \p ScalarStr.<br class="">+ ///<br class="">+ /// \returns An empty string on success, otherwise an error message.<br class="">+ StringRef inputYAML(StringRef ScalarStr);<br class="">+<br class="">+ /// Output a YAML scalar of the current ScalarKind into \p OS.<br class="">+ void outputYAML(raw_ostream &OS) const;<br class="">+<br class="">+ /// Determine which YAML quoting type the current value would need when<br class="">+ /// output.<br class="">+ yaml::QuotingType mustQuoteYAML(StringRef ScalarStr) const;<br class="">+<br class="">+ /// Get the YAML tag for the current ScalarKind.<br class="">+ StringRef getYAMLTag() const;<br class="">+<br class="">+ /// Flag which affects how the type handles YAML tags when reading and<br class="">+ /// writing.<br class="">+ ///<br class="">+ /// When false, tags are used when reading and writing. When reading, the tag<br class="">+ /// is used to decide the ScalarKind before parsing. When writing, the tag is<br class="">+ /// output along with the value.<br class="">+ ///<br class="">+ /// When true, tags are ignored when reading and writing. When reading, the<br class="">+ /// ScalarKind is always assumed to be String. When writing, the tag is not<br class="">+ /// output.<br class="">+ bool IgnoreTag = false;<br class="">+<br class="">+ static const char *IntTag;<br class="">+ static const char *NilTag;<br class="">+ static const char *BooleanTag;<br class="">+ static const char *FloatTag;<br class="">+ static const char *StringTag;<br class="">+ static const char *BinaryTag;<br class="">+};<br class="">+<br class="">+class ArrayNode : public Node, public std::vector<NodePtr> {<br class="">+ void anchor() override;<br class="">+<br class="">+public:<br class="">+ ArrayNode() : Node(NK_Array) {}<br class="">+ static bool classof(const Node *N) { return N->getKind() == NK_Array; }<br class="">+<br class="">+ void write(Writer &MPWriter) override {<br class="">+ MPWriter.writeArraySize(this->size());<br class="">+ for (auto &N : *this)<br class="">+ N->write(MPWriter);<br class="">+ }<br class="">+};<br class="">+<br class="">+class MapNode : public Node, public StringMap<NodePtr> {<br class="">+ void anchor() override;<br class="">+<br class="">+public:<br class="">+ MapNode() : Node(NK_Map) {}<br class="">+ static bool classof(const Node *N) { return N->getKind() == NK_Map; }<br class="">+<br class="">+ void write(Writer &MPWriter) override {<br class="">+ MPWriter.writeMapSize(this->size());<br class="">+ for (auto &N : *this) {<br class="">+ MPWriter.write(N.first());<br class="">+ N.second->write(MPWriter);<br class="">+ }<br class="">+ }<br class="">+};<br class="">+<br class="">+} // end namespace msgpack<br class="">+<br class="">+namespace yaml {<br class="">+<br class="">+template <> struct PolymorphicTraits<msgpack::NodePtr> {<br class="">+ static NodeKind getKind(const msgpack::NodePtr &N) {<br class="">+ if (isa<msgpack::ScalarNode>(*N))<br class="">+ return NodeKind::Scalar;<br class="">+ if (isa<msgpack::MapNode>(*N))<br class="">+ return NodeKind::Map;<br class="">+ if (isa<msgpack::ArrayNode>(*N))<br class="">+ return NodeKind::Sequence;<br class="">+ llvm_unreachable("NodeKind not supported");<br class="">+ }<br class="">+ static msgpack::ScalarNode &getAsScalar(msgpack::NodePtr &N) {<br class="">+ if (!N || !isa<msgpack::ScalarNode>(*N))<br class="">+ N.reset(new msgpack::ScalarNode());<br class="">+ return *cast<msgpack::ScalarNode>(N.get());<br class="">+ }<br class="">+ static msgpack::MapNode &getAsMap(msgpack::NodePtr &N) {<br class="">+ if (!N || !isa<msgpack::MapNode>(*N))<br class="">+ N.reset(new msgpack::MapNode());<br class="">+ return *cast<msgpack::MapNode>(N.get());<br class="">+ }<br class="">+ static msgpack::ArrayNode &getAsSequence(msgpack::NodePtr &N) {<br class="">+ if (!N || !isa<msgpack::ArrayNode>(*N))<br class="">+ N.reset(new msgpack::ArrayNode());<br class="">+ return *cast<msgpack::ArrayNode>(N.get());<br class="">+ }<br class="">+};<br class="">+<br class="">+template <> struct TaggedScalarTraits<msgpack::ScalarNode> {<br class="">+ static void output(const msgpack::ScalarNode &S, void *Ctxt,<br class="">+ raw_ostream &ScalarOS, raw_ostream &TagOS) {<br class="">+ if (!S.IgnoreTag)<br class="">+ TagOS << S.getYAMLTag();<br class="">+ S.outputYAML(ScalarOS);<br class="">+ }<br class="">+<br class="">+ static StringRef input(StringRef ScalarStr, StringRef Tag, void *Ctxt,<br class="">+ msgpack::ScalarNode &S) {<br class="">+ if (Tag == msgpack::ScalarNode::IntTag) {<br class="">+ S.setScalarKind(msgpack::ScalarNode::SK_UInt);<br class="">+ if (S.inputYAML(ScalarStr) == StringRef())<br class="">+ return StringRef();<br class="">+ S.setScalarKind(msgpack::ScalarNode::SK_Int);<br class="">+ return S.inputYAML(ScalarStr);<br class="">+ }<br class="">+<br class="">+ if (S.IgnoreTag || Tag == msgpack::ScalarNode::StringTag ||<br class="">+ Tag == "tag:<a href="http://yaml.org" class="">yaml.org</a>,2002:str")<br class="">+ S.setScalarKind(msgpack::ScalarNode::SK_String);<br class="">+ else if (Tag == msgpack::ScalarNode::NilTag)<br class="">+ S.setScalarKind(msgpack::ScalarNode::SK_Nil);<br class="">+ else if (Tag == msgpack::ScalarNode::BooleanTag)<br class="">+ S.setScalarKind(msgpack::ScalarNode::SK_Boolean);<br class="">+ else if (Tag == msgpack::ScalarNode::FloatTag)<br class="">+ S.setScalarKind(msgpack::ScalarNode::SK_Float);<br class="">+ else if (Tag == msgpack::ScalarNode::StringTag)<br class="">+ S.setScalarKind(msgpack::ScalarNode::SK_String);<br class="">+ else if (Tag == msgpack::ScalarNode::BinaryTag)<br class="">+ S.setScalarKind(msgpack::ScalarNode::SK_Binary);<br class="">+ else<br class="">+ return "Unsupported messagepack tag";<br class="">+<br class="">+ return S.inputYAML(ScalarStr);<br class="">+ }<br class="">+<br class="">+ static QuotingType mustQuote(const msgpack::ScalarNode &S, StringRef Str) {<br class="">+ return S.mustQuoteYAML(Str);<br class="">+ }<br class="">+};<br class="">+<br class="">+template <> struct CustomMappingTraits<msgpack::MapNode> {<br class="">+ static void inputOne(IO &IO, StringRef Key, msgpack::MapNode &M) {<br class="">+ IO.mapRequired(Key.str().c_str(), M[Key]);<br class="">+ }<br class="">+ static void output(IO &IO, msgpack::MapNode &M) {<br class="">+ for (auto &N : M)<br class="">+ IO.mapRequired(N.getKey().str().c_str(), N.getValue());<br class="">+ }<br class="">+};<br class="">+<br class="">+template <> struct SequenceTraits<msgpack::ArrayNode> {<br class="">+ static size_t size(IO &IO, msgpack::ArrayNode &A) { return A.size(); }<br class="">+ static msgpack::NodePtr &element(IO &IO, msgpack::ArrayNode &A,<br class="">+ size_t Index) {<br class="">+ if (Index >= A.size())<br class="">+ A.resize(Index + 1);<br class="">+ return A[Index];<br class="">+ }<br class="">+};<br class="">+<br class="">+} // end namespace yaml<br class="">+} // end namespace llvm<br class="">+<br class="">+#endif // LLVM_BINARYFORMAT_MSGPACKTYPES_H<br class=""><br class="">Modified: llvm/trunk/lib/BinaryFormat/CMakeLists.txt<br class="">URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/BinaryFormat/CMakeLists.txt?rev=346978&r1=346977&r2=346978&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/BinaryFormat/CMakeLists.txt?rev=346978&r1=346977&r2=346978&view=diff</a><br class="">==============================================================================<br class="">--- llvm/trunk/lib/BinaryFormat/CMakeLists.txt (original)<br class="">+++ llvm/trunk/lib/BinaryFormat/CMakeLists.txt Thu Nov 15 10:50:01 2018<br class="">@@ -2,6 +2,7 @@ add_llvm_library(LLVMBinaryFormat<br class=""> Dwarf.cpp<br class=""> Magic.cpp<br class=""> MsgPackReader.cpp<br class="">+ MsgPackTypes.cpp<br class=""> MsgPackWriter.cpp<br class=""> Wasm.cpp<br class=""><br class=""><br class="">Added: llvm/trunk/lib/BinaryFormat/MsgPackTypes.cpp<br class="">URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/BinaryFormat/MsgPackTypes.cpp?rev=346978&view=auto" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/BinaryFormat/MsgPackTypes.cpp?rev=346978&view=auto</a><br class="">==============================================================================<br class="">--- llvm/trunk/lib/BinaryFormat/MsgPackTypes.cpp (added)<br class="">+++ llvm/trunk/lib/BinaryFormat/MsgPackTypes.cpp Thu Nov 15 10:50:01 2018<br class="">@@ -0,0 +1,303 @@<br class="">+//===- MsgPackTypes.cpp - MsgPack Types -------------------------*- C++ -*-===//<br class="">+//<br class="">+// The LLVM Compiler Infrastructure<br class="">+//<br class="">+// This file is distributed under the University of Illinois Open Source<br class="">+// License. See LICENSE.TXT for details.<br class="">+//<br class="">+//===----------------------------------------------------------------------===//<br class="">+//<br class="">+/// \file<br class="">+/// Implementation of types representing MessagePack "documents".<br class="">+//<br class="">+//===----------------------------------------------------------------------===//<br class="">+<br class="">+#include "llvm/BinaryFormat/MsgPackTypes.h"<br class="">+#include "llvm/Support/Error.h"<br class="">+<br class="">+using namespace llvm;<br class="">+using namespace msgpack;<br class="">+<br class="">+namespace llvm {<br class="">+namespace msgpack {<br class="">+void ScalarNode::anchor() {}<br class="">+void ArrayNode::anchor() {}<br class="">+void MapNode::anchor() {}<br class="">+}<br class="">+}<br class="">+<br class="">+Expected<OptNodePtr> Node::readArray(Reader &MPReader, size_t Length) {<br class="">+ auto A = std::make_shared<ArrayNode>();<br class="">+ for (size_t I = 0; I < Length; ++I) {<br class="">+ auto OptNodeOrErr = Node::read(MPReader);<br class="">+ if (auto Err = OptNodeOrErr.takeError())<br class="">+ return std::move(Err);<br class="">+ if (!*OptNodeOrErr)<br class="">+ return make_error<StringError>(<br class="">+ "Insufficient array elements",<br class="">+ std::make_error_code(std::errc::invalid_argument));<br class="">+ A->push_back(std::move(**OptNodeOrErr));<br class="">+ }<br class="">+ return OptNodePtr(std::move(A));<br class="">+}<br class="">+<br class="">+Expected<OptNodePtr> Node::readMap(Reader &MPReader, size_t Length) {<br class="">+ auto M = std::make_shared<MapNode>();<br class="">+ for (size_t I = 0; I < Length; ++I) {<br class="">+ auto OptKeyOrErr = Node::read(MPReader);<br class="">+ if (auto Err = OptKeyOrErr.takeError())<br class="">+ return std::move(Err);<br class="">+ if (!*OptKeyOrErr)<br class="">+ return make_error<StringError>(<br class="">+ "Insufficient map elements",<br class="">+ std::make_error_code(std::errc::invalid_argument));<br class="">+ auto OptValOrErr = Node::read(MPReader);<br class="">+ if (auto Err = OptValOrErr.takeError())<br class="">+ return std::move(Err);<br class="">+ if (!*OptValOrErr)<br class="">+ return make_error<StringError>(<br class="">+ "Insufficient map elements",<br class="">+ std::make_error_code(std::errc::invalid_argument));<br class="">+ auto *Key = dyn_cast<ScalarNode>((*OptKeyOrErr)->get());<br class="">+ if (!Key)<br class="">+ return make_error<StringError>(<br class="">+ "Only string map keys are supported",<br class="">+ std::make_error_code(std::errc::invalid_argument));<br class="">+ if (Key->getScalarKind() != ScalarNode::SK_String)<br class="">+ return make_error<StringError>(<br class="">+ "Only string map keys are supported",<br class="">+ std::make_error_code(std::errc::invalid_argument));<br class="">+ M->try_emplace(Key->getString(), std::move(**OptValOrErr));<br class="">+ }<br class="">+ return OptNodePtr(std::move(M));<br class="">+}<br class="">+<br class="">+Expected<OptNodePtr> Node::read(Reader &MPReader) {<br class="">+ Object Obj;<br class="">+<br class="">+ auto ContinueOrErr = MPReader.read(Obj);<br class="">+ if (auto Err = ContinueOrErr.takeError())<br class="">+ return std::move(Err);<br class="">+ if (!*ContinueOrErr)<br class="">+ return None;<br class="">+<br class="">+ switch (Obj.Kind) {<br class="">+ case Type::Int:<br class="">+ return OptNodePtr(std::make_shared<ScalarNode>(Obj.Int));<br class="">+ case Type::UInt:<br class="">+ return OptNodePtr(std::make_shared<ScalarNode>(Obj.UInt));<br class="">+ case Type::Nil:<br class="">+ return OptNodePtr(std::make_shared<ScalarNode>());<br class="">+ case Type::Boolean:<br class="">+ return OptNodePtr(std::make_shared<ScalarNode>(Obj.Bool));<br class="">+ case Type::Float:<br class="">+ return OptNodePtr(std::make_shared<ScalarNode>(Obj.Float));<br class="">+ case Type::String:<br class="">+ return OptNodePtr(std::make_shared<ScalarNode>(Obj.Raw));<br class="">+ case Type::Binary:<br class="">+ return OptNodePtr(std::make_shared<ScalarNode>(Obj.Raw));<br class="">+ case Type::Array:<br class="">+ return Node::readArray(MPReader, Obj.Length);<br class="">+ case Type::Map:<br class="">+ return Node::readMap(MPReader, Obj.Length);<br class="">+ case Type::Extension:<br class="">+ return make_error<StringError>(<br class="">+ "Extension types are not supported",<br class="">+ std::make_error_code(std::errc::invalid_argument));<br class="">+ }<br class="">+ llvm_unreachable("msgpack::Type not handled");<br class="">+}<br class="">+<br class="">+void ScalarNode::destroy() {<br class="">+ switch (SKind) {<br class="">+ case SK_String:<br class="">+ case SK_Binary:<br class="">+ StringValue.~basic_string();<br class="">+ break;<br class="">+ default:<br class="">+ // POD types do not require destruction<br class="">+ break;<br class="">+ }<br class="">+}<br class="">+<br class="">+ScalarNode::ScalarNode(int64_t IntValue)<br class="">+ : Node(NK_Scalar), SKind(SK_Int), IntValue(IntValue) {}<br class="">+<br class="">+ScalarNode::ScalarNode(int32_t IntValue)<br class="">+ : ScalarNode(static_cast<int64_t>(IntValue)) {}<br class="">+<br class="">+ScalarNode::ScalarNode(uint64_t UIntValue)<br class="">+ : Node(NK_Scalar), SKind(SK_UInt), UIntValue(UIntValue) {}<br class="">+<br class="">+ScalarNode::ScalarNode(uint32_t IntValue)<br class="">+ : ScalarNode(static_cast<uint64_t>(IntValue)) {}<br class="">+<br class="">+ScalarNode::ScalarNode() : Node(NK_Scalar), SKind(SK_Nil) {}<br class="">+<br class="">+ScalarNode::ScalarNode(bool BoolValue)<br class="">+ : Node(NK_Scalar), SKind(SK_Boolean), BoolValue(BoolValue) {}<br class="">+<br class="">+ScalarNode::ScalarNode(double FloatValue)<br class="">+ : Node(NK_Scalar), SKind(SK_Float), BoolValue(FloatValue) {}<br class="">+<br class="">+ScalarNode::ScalarNode(StringRef StringValue)<br class="">+ : Node(NK_Scalar), SKind(SK_String) {<br class="">+ new (&this->StringValue) std::string(StringValue);<br class="">+}<br class="">+<br class="">+ScalarNode::ScalarNode(const char *StringValue)<br class="">+ : ScalarNode(StringRef(StringValue)) {}<br class="">+<br class="">+ScalarNode::ScalarNode(std::string &&StringValue)<br class="">+ : Node(NK_Scalar), SKind(SK_String) {<br class="">+ new (&this->StringValue) std::string(StringValue);<br class="">+}<br class="">+<br class="">+ScalarNode::ScalarNode(MemoryBufferRef BinaryValue)<br class="">+ : Node(NK_Scalar), SKind(SK_Binary) {<br class="">+ new (&StringValue) std::string(BinaryValue.getBuffer());<br class="">+}<br class="">+<br class="">+ScalarNode::~ScalarNode() { destroy(); }<br class="">+<br class="">+ScalarNode &ScalarNode::operator=(ScalarNode &&RHS) {<br class="">+ destroy();<br class="">+ switch (SKind = RHS.SKind) {<br class="">+ case SK_Int:<br class="">+ IntValue = RHS.IntValue;<br class="">+ break;<br class="">+ case SK_UInt:<br class="">+ UIntValue = RHS.UIntValue;<br class="">+ break;<br class="">+ case SK_Boolean:<br class="">+ BoolValue = RHS.BoolValue;<br class="">+ break;<br class="">+ case SK_Float:<br class="">+ FloatValue = RHS.FloatValue;<br class="">+ break;<br class="">+ case SK_String:<br class="">+ case SK_Binary:<br class="">+ new (&StringValue) std::string(std::move(RHS.StringValue));<br class="">+ break;<br class="">+ case SK_Nil:<br class="">+ // pass<br class="">+ break;<br class="">+ }<br class="">+ return *this;<br class="">+}<br class="">+<br class="">+StringRef ScalarNode::inputYAML(StringRef ScalarStr) {<br class="">+ switch (SKind) {<br class="">+ case SK_Int:<br class="">+ return yaml::ScalarTraits<int64_t>::input(ScalarStr, nullptr, IntValue);<br class="">+ case SK_UInt:<br class="">+ return yaml::ScalarTraits<uint64_t>::input(ScalarStr, nullptr, UIntValue);<br class="">+ case SK_Nil:<br class="">+ return StringRef();<br class="">+ case SK_Boolean:<br class="">+ return yaml::ScalarTraits<bool>::input(ScalarStr, nullptr, BoolValue);<br class="">+ case SK_Float:<br class="">+ return yaml::ScalarTraits<double>::input(ScalarStr, nullptr, FloatValue);<br class="">+ case SK_Binary:<br class="">+ case SK_String:<br class="">+ return yaml::ScalarTraits<std::string>::input(ScalarStr, nullptr,<br class="">+ StringValue);<br class="">+ }<br class="">+ llvm_unreachable("unrecognized ScalarKind");<br class="">+}<br class="">+<br class="">+void ScalarNode::outputYAML(raw_ostream &OS) const {<br class="">+ switch (SKind) {<br class="">+ case SK_Int:<br class="">+ yaml::ScalarTraits<int64_t>::output(IntValue, nullptr, OS);<br class="">+ break;<br class="">+ case SK_UInt:<br class="">+ yaml::ScalarTraits<uint64_t>::output(UIntValue, nullptr, OS);<br class="">+ break;<br class="">+ case SK_Nil:<br class="">+ yaml::ScalarTraits<StringRef>::output("", nullptr, OS);<br class="">+ break;<br class="">+ case SK_Boolean:<br class="">+ yaml::ScalarTraits<bool>::output(BoolValue, nullptr, OS);<br class="">+ break;<br class="">+ case SK_Float:<br class="">+ yaml::ScalarTraits<double>::output(FloatValue, nullptr, OS);<br class="">+ break;<br class="">+ case SK_Binary:<br class="">+ case SK_String:<br class="">+ yaml::ScalarTraits<std::string>::output(StringValue, nullptr, OS);<br class="">+ break;<br class="">+ }<br class="">+}<br class="">+<br class="">+yaml::QuotingType ScalarNode::mustQuoteYAML(StringRef ScalarStr) const {<br class="">+ switch (SKind) {<br class="">+ case SK_Int:<br class="">+ return yaml::ScalarTraits<int64_t>::mustQuote(ScalarStr);<br class="">+ case SK_UInt:<br class="">+ return yaml::ScalarTraits<uint64_t>::mustQuote(ScalarStr);<br class="">+ case SK_Nil:<br class="">+ return yaml::ScalarTraits<StringRef>::mustQuote(ScalarStr);<br class="">+ case SK_Boolean:<br class="">+ return yaml::ScalarTraits<bool>::mustQuote(ScalarStr);<br class="">+ case SK_Float:<br class="">+ return yaml::ScalarTraits<double>::mustQuote(ScalarStr);<br class="">+ case SK_Binary:<br class="">+ case SK_String:<br class="">+ return yaml::ScalarTraits<std::string>::mustQuote(ScalarStr);<br class="">+ }<br class="">+ llvm_unreachable("unrecognized ScalarKind");<br class="">+}<br class="">+<br class="">+const char *ScalarNode::IntTag = "!int";<br class="">+const char *ScalarNode::NilTag = "!nil";<br class="">+const char *ScalarNode::BooleanTag = "!bool";<br class="">+const char *ScalarNode::FloatTag = "!float";<br class="">+const char *ScalarNode::StringTag = "!str";<br class="">+const char *ScalarNode::BinaryTag = "!bin";<br class="">+<br class="">+StringRef ScalarNode::getYAMLTag() const {<br class="">+ switch (SKind) {<br class="">+ case SK_Int:<br class="">+ return IntTag;<br class="">+ case SK_UInt:<br class="">+ return IntTag;<br class="">+ case SK_Nil:<br class="">+ return NilTag;<br class="">+ case SK_Boolean:<br class="">+ return BooleanTag;<br class="">+ case SK_Float:<br class="">+ return FloatTag;<br class="">+ case SK_String:<br class="">+ return StringTag;<br class="">+ case SK_Binary:<br class="">+ return BinaryTag;<br class="">+ }<br class="">+ llvm_unreachable("unrecognized ScalarKind");<br class="">+}<br class="">+<br class="">+void ScalarNode::write(Writer &MPWriter) {<br class="">+ switch (SKind) {<br class="">+ case SK_Int:<br class="">+ MPWriter.write(IntValue);<br class="">+ break;<br class="">+ case SK_UInt:<br class="">+ MPWriter.write(UIntValue);<br class="">+ break;<br class="">+ case SK_Nil:<br class="">+ MPWriter.writeNil();<br class="">+ break;<br class="">+ case SK_Boolean:<br class="">+ MPWriter.write(BoolValue);<br class="">+ break;<br class="">+ case SK_Float:<br class="">+ MPWriter.write(FloatValue);<br class="">+ break;<br class="">+ case SK_String:<br class="">+ MPWriter.write(StringValue);<br class="">+ break;<br class="">+ case SK_Binary:<br class="">+ MPWriter.write(MemoryBufferRef(StringValue, ""));<br class="">+ break;<br class="">+ }<br class="">+}<br class=""><br class="">Modified: llvm/trunk/unittests/BinaryFormat/CMakeLists.txt<br class="">URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/BinaryFormat/CMakeLists.txt?rev=346978&r1=346977&r2=346978&view=diff" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/BinaryFormat/CMakeLists.txt?rev=346978&r1=346977&r2=346978&view=diff</a><br class="">==============================================================================<br class="">--- llvm/trunk/unittests/BinaryFormat/CMakeLists.txt (original)<br class="">+++ llvm/trunk/unittests/BinaryFormat/CMakeLists.txt Thu Nov 15 10:50:01 2018<br class="">@@ -6,6 +6,7 @@ add_llvm_unittest(BinaryFormatTests<br class=""> DwarfTest.cpp<br class=""> MachOTest.cpp<br class=""> MsgPackReaderTest.cpp<br class="">+ MsgPackTypesTest.cpp<br class=""> MsgPackWriterTest.cpp<br class=""> TestFileMagic.cpp<br class=""> )<br class=""><br class="">Added: llvm/trunk/unittests/BinaryFormat/MsgPackTypesTest.cpp<br class="">URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/BinaryFormat/MsgPackTypesTest.cpp?rev=346978&view=auto" class="">http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/BinaryFormat/MsgPackTypesTest.cpp?rev=346978&view=auto</a><br class="">==============================================================================<br class="">--- llvm/trunk/unittests/BinaryFormat/MsgPackTypesTest.cpp (added)<br class="">+++ llvm/trunk/unittests/BinaryFormat/MsgPackTypesTest.cpp Thu Nov 15 10:50:01 2018<br class="">@@ -0,0 +1,188 @@<br class="">+//===- MsgPackTypesTest.cpp -------------------------------------*- C++ -*-===//<br class="">+//<br class="">+// The LLVM Compiler Infrastructure<br class="">+//<br class="">+// This file is distributed under the University of Illinois Open Source<br class="">+// License. See LICENSE.TXT for details.<br class="">+//<br class="">+//===----------------------------------------------------------------------===//<br class="">+<br class="">+#include "llvm/BinaryFormat/MsgPackTypes.h"<br class="">+#include "gtest/gtest.h"<br class="">+<br class="">+using namespace llvm;<br class="">+using namespace msgpack;<br class="">+<br class="">+TEST(MsgPackTypes, TestReadInt) {<br class="">+ Reader MPReader(StringRef("\xd0\x00", 2));<br class="">+ auto OptNodeOrErr = Node::read(MPReader);<br class="">+ ASSERT_TRUE(static_cast<bool>(OptNodeOrErr));<br class="">+ ASSERT_TRUE(*OptNodeOrErr);<br class="">+ auto *S = dyn_cast<ScalarNode>((*OptNodeOrErr)->get());<br class="">+ ASSERT_TRUE(S);<br class="">+ ASSERT_EQ(S->getScalarKind(), ScalarNode::SK_Int);<br class="">+ ASSERT_EQ(S->getInt(), 0);<br class="">+}<br class="">+<br class="">+TEST(MsgPackTypes, TestReadArray) {<br class="">+ Reader MPReader(StringRef("\x92\xd0\x01\xc0"));<br class="">+ auto OptNodeOrErr = Node::read(MPReader);<br class="">+ ASSERT_TRUE(static_cast<bool>(OptNodeOrErr));<br class="">+ ASSERT_TRUE(*OptNodeOrErr);<br class="">+ auto *A = dyn_cast<ArrayNode>((*OptNodeOrErr)->get());<br class="">+ ASSERT_TRUE(A);<br class="">+ ASSERT_EQ(A->size(), 2u);<br class="">+ auto *SI = dyn_cast<ScalarNode>((*A)[0].get());<br class="">+ ASSERT_TRUE(SI);<br class="">+ ASSERT_EQ(SI->getScalarKind(), ScalarNode::SK_Int);<br class="">+ ASSERT_EQ(SI->getInt(), 1);<br class="">+ auto *SN = dyn_cast<ScalarNode>((*A)[1].get());<br class="">+ ASSERT_TRUE(SN);<br class="">+ ASSERT_EQ(SN->getScalarKind(), ScalarNode::SK_Nil);<br class="">+}<br class="">+<br class="">+TEST(MsgPackTypes, TestReadMap) {<br class="">+ Reader MPReader(StringRef("\x82\xa3"<br class="">+ "foo"<br class="">+ "\xd0\x01\xa3"<br class="">+ "bar"<br class="">+ "\xd0\x02"));<br class="">+ auto OptNodeOrErr = Node::read(MPReader);<br class="">+ ASSERT_TRUE(static_cast<bool>(OptNodeOrErr));<br class="">+ ASSERT_TRUE(*OptNodeOrErr);<br class="">+ auto *A = dyn_cast<MapNode>((*OptNodeOrErr)->get());<br class="">+ ASSERT_TRUE(A);<br class="">+ ASSERT_EQ(A->size(), 2u);<br class="">+ auto *FooS = dyn_cast<ScalarNode>((*A)["foo"].get());<br class="">+ ASSERT_TRUE(FooS);<br class="">+ ASSERT_EQ(FooS->getScalarKind(), ScalarNode::SK_Int);<br class="">+ ASSERT_EQ(FooS->getInt(), 1);<br class="">+ auto *BarS = dyn_cast<ScalarNode>((*A)["bar"].get());<br class="">+ ASSERT_TRUE(BarS);<br class="">+ ASSERT_EQ(BarS->getScalarKind(), ScalarNode::SK_Int);<br class="">+ ASSERT_EQ(BarS->getInt(), 2);<br class="">+}<br class="">+<br class="">+TEST(MsgPackTypes, TestWriteInt) {<br class="">+ std::string Buffer;<br class="">+ raw_string_ostream OStream(Buffer);<br class="">+ Writer MPWriter(OStream);<br class="">+ ScalarNode I(int64_t(1));<br class="">+ I.write(MPWriter);<br class="">+ ASSERT_EQ(OStream.str(), "\x01");<br class="">+}<br class="">+<br class="">+TEST(MsgPackTypes, TestWriteArray) {<br class="">+ std::string Buffer;<br class="">+ raw_string_ostream OStream(Buffer);<br class="">+ Writer MPWriter(OStream);<br class="">+ ArrayNode A;<br class="">+ A.push_back(std::make_shared<ScalarNode>(int64_t(1)));<br class="">+ A.push_back(std::make_shared<ScalarNode>());<br class="">+ A.write(MPWriter);<br class="">+ ASSERT_EQ(OStream.str(), "\x92\x01\xc0");<br class="">+}<br class="">+<br class="">+TEST(MsgPackTypes, TestWriteMap) {<br class="">+ std::string Buffer;<br class="">+ raw_string_ostream OStream(Buffer);<br class="">+ Writer MPWriter(OStream);<br class="">+ MapNode M;<br class="">+ M["foo"] = std::make_shared<ScalarNode>(int64_t(1));<br class="">+ M["bar"] = std::make_shared<ScalarNode>(int64_t(2));<br class="">+ M.write(MPWriter);<br class="">+ ASSERT_EQ(OStream.str(), "\x82\xa3"<br class="">+ "foo"<br class="">+ "\x01\xa3"<br class="">+ "bar"<br class="">+ "\x02");<br class="">+}<br class="">+<br class="">+TEST(MsgPackTypes, TestOutputYAMLArray) {<br class="">+ std::string Buffer;<br class="">+ raw_string_ostream OStream(Buffer);<br class="">+ yaml::Output yout(OStream);<br class="">+ ArrayNode A;<br class="">+ A.push_back(std::make_shared<ScalarNode>(int64_t(1)));<br class="">+ A.push_back(std::make_shared<ScalarNode>(int64_t(2)));<br class="">+ yout << A;<br class="">+ ASSERT_EQ(OStream.str(), "---\n- !int 1\n- !int 2\n...\n");<br class="">+}<br class="">+<br class="">+TEST(MsgPackTypes, TestInputYAMLArray) {<br class="">+ NodePtr RootNode;<br class="">+ yaml::Input yin("---\n- !int 1\n- !str 2\n...\n");<br class="">+ yin >> RootNode;<br class="">+ auto *A = dyn_cast<ArrayNode>(RootNode.get());<br class="">+ ASSERT_TRUE(A);<br class="">+ ASSERT_EQ(A->size(), 2u);<br class="">+ auto *SI = dyn_cast<ScalarNode>((*A)[0].get());<br class="">+ ASSERT_TRUE(SI);<br class="">+ ASSERT_EQ(SI->getScalarKind(), ScalarNode::SK_UInt);<br class="">+ ASSERT_EQ(SI->getUInt(), 1u);<br class="">+ auto *SS = dyn_cast<ScalarNode>((*A)[1].get());<br class="">+ ASSERT_TRUE(SS);<br class="">+ ASSERT_EQ(SS->getScalarKind(), ScalarNode::SK_String);<br class="">+ ASSERT_EQ(SS->getString(), "2");<br class="">+}<br class="">+<br class="">+TEST(MsgPackTypes, TestOutputYAMLMap) {<br class="">+ std::string Buffer;<br class="">+ raw_string_ostream OStream(Buffer);<br class="">+ yaml::Output yout(OStream);<br class="">+ MapNode M;<br class="">+ M["foo"] = std::make_shared<ScalarNode>(int64_t(1));<br class="">+ M["bar"] = std::make_shared<ScalarNode>(uint64_t(2));<br class="">+ auto N = std::make_shared<MapNode>();<br class="">+ (*N)["baz"] = std::make_shared<ScalarNode>(true);<br class="">+ M["qux"] = std::move(N);<br class="">+ yout << M;<br class="">+ ASSERT_EQ(OStream.str(), "---\nfoo: !int 1\nbar: "<br class="">+ "!int 2\nqux: \n baz: "<br class="">+ "!bool true\n...\n");<br class="">+}<br class="">+<br class="">+TEST(MsgPackTypes, TestInputYAMLMap) {<br class="">+ NodePtr RootNode;<br class="">+ yaml::Input yin("---\nfoo: !int 1\nbaz: !str 2\n...\n");<br class="">+ yin >> RootNode;<br class="">+ auto *M = dyn_cast<MapNode>(RootNode.get());<br class="">+ ASSERT_TRUE(M);<br class="">+ ASSERT_EQ(M->size(), 2u);<br class="">+ auto *SI = dyn_cast<ScalarNode>((*M)["foo"].get());<br class="">+ ASSERT_TRUE(SI);<br class="">+ ASSERT_EQ(SI->getScalarKind(), ScalarNode::SK_UInt);<br class="">+ ASSERT_EQ(SI->getUInt(), 1u);<br class="">+ auto *SS = dyn_cast<ScalarNode>((*M)["baz"].get());<br class="">+ ASSERT_TRUE(SS);<br class="">+ ASSERT_EQ(SS->getScalarKind(), ScalarNode::SK_String);<br class="">+ ASSERT_EQ(SS->getString(), "2");<br class="">+}<br class="">+<br class="">+// Test that the document is parsed into a tree of shared_ptr where each node<br class="">+// can have multiple owners.<br class="">+TEST(MsgPackTypes, TestInputShared) {<br class="">+ yaml::Input yin("---\nfoo:\n bar: !int 1\n...\n");<br class="">+ NodePtr InnerMap;<br class="">+ NodePtr IntNode;<br class="">+ {<br class="">+ {<br class="">+ {<br class="">+ NodePtr RootNode;<br class="">+ yin >> RootNode;<br class="">+ auto *M = dyn_cast<MapNode>(RootNode.get());<br class="">+ ASSERT_TRUE(M);<br class="">+ ASSERT_EQ(M->size(), 1u);<br class="">+ InnerMap = (*M)["foo"];<br class="">+ }<br class="">+ auto *N = dyn_cast<MapNode>(InnerMap.get());<br class="">+ ASSERT_TRUE(N);<br class="">+ ASSERT_EQ(N->size(), 1u);<br class="">+ IntNode = (*N)["bar"];<br class="">+ }<br class="">+ auto *S = dyn_cast<ScalarNode>(IntNode.get());<br class="">+ ASSERT_TRUE(S);<br class="">+ ASSERT_EQ(S->getScalarKind(), ScalarNode::SK_UInt);<br class="">+ ASSERT_EQ(S->getUInt(), 1u);<br class="">+ }<br class="">+}<br class=""><br class=""><br class="">_______________________________________________<br class="">llvm-commits mailing list<br class=""><a href="mailto:llvm-commits@lists.llvm.org" class="">llvm-commits@lists.llvm.org</a><br class="">http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits<br class=""></div></div></blockquote></div><br class=""></div></body></html>