diff options
Diffstat (limited to 'src/libs/3rdparty/yaml-cpp/src')
47 files changed, 703 insertions, 482 deletions
diff --git a/src/libs/3rdparty/yaml-cpp/src/binary.cpp b/src/libs/3rdparty/yaml-cpp/src/binary.cpp index a7e51301b8..d27762a243 100644 --- a/src/libs/3rdparty/yaml-cpp/src/binary.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/binary.cpp @@ -1,5 +1,7 @@ #include "yaml-cpp/binary.h" +#include <cctype> + namespace YAML { static const char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; @@ -64,7 +66,7 @@ static const unsigned char decoding[] = { }; std::vector<unsigned char> DecodeBase64(const std::string &input) { - typedef std::vector<unsigned char> ret_type; + using ret_type = std::vector<unsigned char>; if (input.empty()) return ret_type(); @@ -72,22 +74,27 @@ std::vector<unsigned char> DecodeBase64(const std::string &input) { unsigned char *out = &ret[0]; unsigned value = 0; - for (std::size_t i = 0; i < input.size(); i++) { - unsigned char d = decoding[static_cast<unsigned>(input[i])]; + for (std::size_t i = 0, cnt = 0; i < input.size(); i++) { + if (std::isspace(static_cast<unsigned char>(input[i]))) { + // skip newlines + continue; + } + unsigned char d = decoding[static_cast<unsigned char>(input[i])]; if (d == 255) return ret_type(); value = (value << 6) | d; - if (i % 4 == 3) { + if (cnt % 4 == 3) { *out++ = value >> 16; if (i > 0 && input[i - 1] != '=') *out++ = value >> 8; if (input[i] != '=') *out++ = value; } + ++cnt; } ret.resize(out - &ret[0]); return ret; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/collectionstack.h b/src/libs/3rdparty/yaml-cpp/src/collectionstack.h index 2302786e03..9feba96795 100644 --- a/src/libs/3rdparty/yaml-cpp/src/collectionstack.h +++ b/src/libs/3rdparty/yaml-cpp/src/collectionstack.h @@ -7,8 +7,8 @@ #pragma once #endif -#include <stack> #include <cassert> +#include <stack> namespace YAML { struct CollectionType { @@ -17,6 +17,7 @@ struct CollectionType { class CollectionStack { public: + CollectionStack() : collectionStack{} {} CollectionType::value GetCurCollectionType() const { if (collectionStack.empty()) return CollectionType::NoCollection; @@ -28,12 +29,13 @@ class CollectionStack { } void PopCollectionType(CollectionType::value type) { assert(type == GetCurCollectionType()); + (void)type; collectionStack.pop(); } private: std::stack<CollectionType::value> collectionStack; }; -} +} // namespace YAML #endif // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/convert.cpp b/src/libs/3rdparty/yaml-cpp/src/convert.cpp index ec05b77826..9658b36035 100644 --- a/src/libs/3rdparty/yaml-cpp/src/convert.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/convert.cpp @@ -16,11 +16,7 @@ std::string tolower(const std::string& str) { template <typename T> bool IsEntirely(const std::string& str, T func) { - for (std::size_t i = 0; i < str.size(); i++) - if (!func(str[i])) - return false; - - return true; + return std::all_of(str.begin(), str.end(), [=](char ch) { return func(ch); }); } // IsFlexibleCase @@ -39,7 +35,7 @@ bool IsFlexibleCase(const std::string& str) { std::string rest = str.substr(1); return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper)); } -} +} // namespace namespace YAML { bool convert<bool>::decode(const Node& node, bool& rhs) { @@ -52,19 +48,22 @@ bool convert<bool>::decode(const Node& node, bool& rhs) { static const struct { std::string truename, falsename; } names[] = { - {"y", "n"}, {"yes", "no"}, {"true", "false"}, {"on", "off"}, + {"y", "n"}, + {"yes", "no"}, + {"true", "false"}, + {"on", "off"}, }; if (!IsFlexibleCase(node.Scalar())) return false; - for (unsigned i = 0; i < sizeof(names) / sizeof(names[0]); i++) { - if (names[i].truename == tolower(node.Scalar())) { + for (const auto& name : names) { + if (name.truename == tolower(node.Scalar())) { rhs = true; return true; } - if (names[i].falsename == tolower(node.Scalar())) { + if (name.falsename == tolower(node.Scalar())) { rhs = false; return true; } @@ -72,4 +71,4 @@ bool convert<bool>::decode(const Node& node, bool& rhs) { return false; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/depthguard.cpp b/src/libs/3rdparty/yaml-cpp/src/depthguard.cpp new file mode 100644 index 0000000000..5bf6cdf03b --- /dev/null +++ b/src/libs/3rdparty/yaml-cpp/src/depthguard.cpp @@ -0,0 +1,9 @@ +#include "yaml-cpp/depthguard.h" + +namespace YAML { + +DeepRecursion::DeepRecursion(int depth, const Mark& mark_, + const std::string& msg_) + : ParserException(mark_, msg_), m_depth(depth) {} + +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/directives.cpp b/src/libs/3rdparty/yaml-cpp/src/directives.cpp index 963bd2cd37..4c1dc201d7 100644 --- a/src/libs/3rdparty/yaml-cpp/src/directives.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/directives.cpp @@ -1,16 +1,11 @@ #include "directives.h" namespace YAML { -Directives::Directives() { - // version - version.isDefault = true; - version.major = 1; - version.minor = 2; -} +Directives::Directives() : version{true, 1, 2}, tags{} {} -const std::string Directives::TranslateTagHandle( +std::string Directives::TranslateTagHandle( const std::string& handle) const { - std::map<std::string, std::string>::const_iterator it = tags.find(handle); + auto it = tags.find(handle); if (it == tags.end()) { if (handle == "!!") return "tag:yaml.org,2002:"; @@ -19,4 +14,4 @@ const std::string Directives::TranslateTagHandle( return it->second; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/directives.h b/src/libs/3rdparty/yaml-cpp/src/directives.h index 333af26e37..18d14c9c0b 100644 --- a/src/libs/3rdparty/yaml-cpp/src/directives.h +++ b/src/libs/3rdparty/yaml-cpp/src/directives.h @@ -19,7 +19,7 @@ struct Version { struct Directives { Directives(); - const std::string TranslateTagHandle(const std::string& handle) const; + std::string TranslateTagHandle(const std::string& handle) const; Version version; std::map<std::string, std::string> tags; diff --git a/src/libs/3rdparty/yaml-cpp/src/emit.cpp b/src/libs/3rdparty/yaml-cpp/src/emit.cpp index 51bc791533..b0efb8401c 100644 --- a/src/libs/3rdparty/yaml-cpp/src/emit.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/emit.cpp @@ -1,7 +1,7 @@ #include "yaml-cpp/node/emit.h" +#include "nodeevents.h" #include "yaml-cpp/emitfromevents.h" #include "yaml-cpp/emitter.h" -#include "nodeevents.h" namespace YAML { Emitter& operator<<(Emitter& out, const Node& node) { diff --git a/src/libs/3rdparty/yaml-cpp/src/emitfromevents.cpp b/src/libs/3rdparty/yaml-cpp/src/emitfromevents.cpp index 4832649f3c..2e97187b90 100644 --- a/src/libs/3rdparty/yaml-cpp/src/emitfromevents.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/emitfromevents.cpp @@ -16,10 +16,11 @@ std::string ToString(YAML::anchor_t anchor) { stream << anchor; return stream.str(); } -} +} // namespace namespace YAML { -EmitFromEvents::EmitFromEvents(Emitter& emitter) : m_emitter(emitter) {} +EmitFromEvents::EmitFromEvents(Emitter& emitter) + : m_emitter(emitter), m_stateStack{} {} void EmitFromEvents::OnDocumentStart(const Mark&) {} @@ -58,6 +59,8 @@ void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag, default: break; } + // Restore the global settings to eliminate the override from node style + m_emitter.RestoreGlobalModifiedSettings(); m_emitter << BeginSeq; m_stateStack.push(State::WaitingForSequenceEntry); } @@ -82,6 +85,8 @@ void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag, default: break; } + // Restore the global settings to eliminate the override from node style + m_emitter.RestoreGlobalModifiedSettings(); m_emitter << BeginMap; m_stateStack.push(State::WaitingForKey); } @@ -116,4 +121,4 @@ void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) { if (anchor) m_emitter << Anchor(ToString(anchor)); } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/emitter.cpp b/src/libs/3rdparty/yaml-cpp/src/emitter.cpp index ebeb059554..4d483075bd 100644 --- a/src/libs/3rdparty/yaml-cpp/src/emitter.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/emitter.cpp @@ -11,12 +11,12 @@ namespace YAML { class Binary; struct _Null; -Emitter::Emitter() : m_pState(new EmitterState) {} +Emitter::Emitter() : m_pState(new EmitterState), m_stream{} {} Emitter::Emitter(std::ostream& stream) : m_pState(new EmitterState), m_stream(stream) {} -Emitter::~Emitter() {} +Emitter::~Emitter() = default; const char* Emitter::c_str() const { return m_stream.str(); } @@ -49,6 +49,10 @@ bool Emitter::SetBoolFormat(EMITTER_MANIP value) { return ok; } +bool Emitter::SetNullFormat(EMITTER_MANIP value) { + return m_pState->SetNullFormat(value, FmtScope::Global); +} + bool Emitter::SetIntBase(EMITTER_MANIP value) { return m_pState->SetIntFormat(value, FmtScope::Global); } @@ -86,6 +90,10 @@ bool Emitter::SetDoublePrecision(std::size_t n) { return m_pState->SetDoublePrecision(n, FmtScope::Global); } +void Emitter::RestoreGlobalModifiedSettings() { + m_pState->RestoreGlobalModifiedSettings(); +} + // SetLocalValue // . Either start/end a group, or set a modifier locally Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) { @@ -197,6 +205,7 @@ void Emitter::EmitBeginSeq() { void Emitter::EmitEndSeq() { if (!good()) return; + FlowType::value originalType = m_pState->CurGroupFlowType(); if (m_pState->CurGroupChildCount() == 0) m_pState->ForceFlow(); @@ -205,8 +214,12 @@ void Emitter::EmitEndSeq() { if (m_stream.comment()) m_stream << "\n"; m_stream << IndentTo(m_pState->CurIndent()); - if (m_pState->CurGroupChildCount() == 0) + if (originalType == FlowType::Block) { m_stream << "["; + } else { + if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode()) + m_stream << "["; + } m_stream << "]"; } @@ -227,6 +240,7 @@ void Emitter::EmitBeginMap() { void Emitter::EmitEndMap() { if (!good()) return; + FlowType::value originalType = m_pState->CurGroupFlowType(); if (m_pState->CurGroupChildCount() == 0) m_pState->ForceFlow(); @@ -235,8 +249,12 @@ void Emitter::EmitEndMap() { if (m_stream.comment()) m_stream << "\n"; m_stream << IndentTo(m_pState->CurIndent()); - if (m_pState->CurGroupChildCount() == 0) + if (originalType == FlowType::Block) { m_stream << "{"; + } else { + if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode()) + m_stream << "{"; + } m_stream << "}"; } @@ -285,10 +303,8 @@ void Emitter::PrepareTopNode(EmitterNodeType::value child) { if (child == EmitterNodeType::NoType) return; - if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) { - if (child != EmitterNodeType::NoType) - EmitBeginDoc(); - } + if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) + EmitBeginDoc(); switch (child) { case EmitterNodeType::NoType: @@ -488,6 +504,9 @@ void Emitter::FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child) { if (m_stream.comment()) m_stream << "\n"; m_stream << IndentTo(lastIndent); + if (m_pState->HasAlias()) { + m_stream << " "; + } m_stream << ":"; } @@ -514,7 +533,8 @@ void Emitter::BlockMapPrepareNode(EmitterNodeType::value child) { if (m_pState->GetMapKeyFormat() == LongKey) m_pState->SetLongKey(); if (child == EmitterNodeType::BlockSeq || - child == EmitterNodeType::BlockMap) + child == EmitterNodeType::BlockMap || + child == EmitterNodeType::Property) m_pState->SetLongKey(); if (m_pState->CurGroupLongKey()) @@ -558,6 +578,8 @@ void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) { break; case EmitterNodeType::BlockSeq: case EmitterNodeType::BlockMap: + if (m_pState->HasBegunContent()) + m_stream << "\n"; break; } } @@ -581,8 +603,12 @@ void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child) { case EmitterNodeType::Scalar: case EmitterNodeType::FlowSeq: case EmitterNodeType::FlowMap: + SpaceOrIndentTo(true, curIndent + 1); + break; case EmitterNodeType::BlockSeq: case EmitterNodeType::BlockMap: + if (m_pState->HasBegunContent()) + m_stream << "\n"; SpaceOrIndentTo(true, curIndent + 1); break; } @@ -621,6 +647,9 @@ void Emitter::BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child) { const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent(); if (!m_pState->HasBegunNode()) { + if (m_pState->HasAlias()) { + m_stream << " "; + } m_stream << ":"; } @@ -674,16 +703,29 @@ void Emitter::StartedScalar() { m_pState->StartedScalar(); } // ******************************************************************************************* // overloads of Write +StringEscaping::value GetStringEscapingStyle(const EMITTER_MANIP emitterManip) { + switch (emitterManip) { + case EscapeNonAscii: + return StringEscaping::NonAscii; + case EscapeAsJson: + return StringEscaping::JSON; + default: + return StringEscaping::None; + break; + } +} + Emitter& Emitter::Write(const std::string& str) { if (!good()) return *this; - const bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii; + StringEscaping::value stringEscaping = GetStringEscapingStyle(m_pState->GetOutputCharset()); + const StringFormat::value strFormat = Utils::ComputeStringFormat(str, m_pState->GetStringFormat(), - m_pState->CurGroupFlowType(), escapeNonAscii); + m_pState->CurGroupFlowType(), stringEscaping == StringEscaping::NonAscii); - if (strFormat == StringFormat::Literal) + if (strFormat == StringFormat::Literal || str.size() > 1024) m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local); PrepareNode(EmitterNodeType::Scalar); @@ -696,7 +738,7 @@ Emitter& Emitter::Write(const std::string& str) { Utils::WriteSingleQuotedString(m_stream, str); break; case StringFormat::DoubleQuoted: - Utils::WriteDoubleQuotedString(m_stream, str, escapeNonAscii); + Utils::WriteDoubleQuotedString(m_stream, str, stringEscaping); break; case StringFormat::Literal: Utils::WriteLiteralString(m_stream, str, @@ -766,6 +808,21 @@ const char* Emitter::ComputeFullBoolName(bool b) const { // these answers } +const char* Emitter::ComputeNullName() const { + switch (m_pState->GetNullFormat()) { + case LowerNull: + return "null"; + case UpperNull: + return "NULL"; + case CamelNull: + return "Null"; + case TildeNull: + // fallthrough + default: + return "~"; + } +} + Emitter& Emitter::Write(bool b) { if (!good()) return *this; @@ -787,8 +844,10 @@ Emitter& Emitter::Write(char ch) { if (!good()) return *this; + + PrepareNode(EmitterNodeType::Scalar); - Utils::WriteChar(m_stream, ch); + Utils::WriteChar(m_stream, ch, GetStringEscapingStyle(m_pState->GetOutputCharset())); StartedScalar(); return *this; @@ -812,6 +871,8 @@ Emitter& Emitter::Write(const _Alias& alias) { StartedScalar(); + m_pState->SetAlias(); + return *this; } @@ -889,7 +950,7 @@ Emitter& Emitter::Write(const _Null& /*null*/) { PrepareNode(EmitterNodeType::Scalar); - m_stream << "~"; + m_stream << ComputeNullName(); StartedScalar(); @@ -908,4 +969,4 @@ Emitter& Emitter::Write(const Binary& binary) { return *this; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/emitterstate.cpp b/src/libs/3rdparty/yaml-cpp/src/emitterstate.cpp index 3542aaf507..3dbe401108 100644 --- a/src/libs/3rdparty/yaml-cpp/src/emitterstate.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/emitterstate.cpp @@ -6,29 +6,35 @@ namespace YAML { EmitterState::EmitterState() : m_isGood(true), + m_lastError{}, + // default global manipulators + m_charset(EmitNonAscii), + m_strFmt(Auto), + m_boolFmt(TrueFalseBool), + m_boolLengthFmt(LongBool), + m_boolCaseFmt(LowerCase), + m_nullFmt(TildeNull), + m_intFmt(Dec), + m_indent(2), + m_preCommentIndent(2), + m_postCommentIndent(1), + m_seqFmt(Block), + m_mapFmt(Block), + m_mapKeyFmt(Auto), + m_floatPrecision(std::numeric_limits<float>::max_digits10), + m_doublePrecision(std::numeric_limits<double>::max_digits10), + // + m_modifiedSettings{}, + m_globalModifiedSettings{}, + m_groups{}, m_curIndent(0), m_hasAnchor(false), + m_hasAlias(false), m_hasTag(false), m_hasNonContent(false), - m_docCount(0) { - // set default global manipulators - m_charset.set(EmitNonAscii); - m_strFmt.set(Auto); - m_boolFmt.set(TrueFalseBool); - m_boolLengthFmt.set(LongBool); - m_boolCaseFmt.set(LowerCase); - m_intFmt.set(Dec); - m_indent.set(2); - m_preCommentIndent.set(2); - m_postCommentIndent.set(1); - m_seqFmt.set(Block); - m_mapFmt.set(Block); - m_mapKeyFmt.set(Auto); - m_floatPrecision.set(std::numeric_limits<float>::digits10 + 1); - m_doublePrecision.set(std::numeric_limits<double>::digits10 + 1); -} - -EmitterState::~EmitterState() {} + m_docCount(0) {} + +EmitterState::~EmitterState() = default; // SetLocalValue // . We blindly tries to set all possible formatters to this value @@ -39,6 +45,7 @@ void EmitterState::SetLocalValue(EMITTER_MANIP value) { SetBoolFormat(value, FmtScope::Local); SetBoolCaseFormat(value, FmtScope::Local); SetBoolLengthFormat(value, FmtScope::Local); + SetNullFormat(value, FmtScope::Local); SetIntFormat(value, FmtScope::Local); SetFlowType(GroupType::Seq, value, FmtScope::Local); SetFlowType(GroupType::Map, value, FmtScope::Local); @@ -47,6 +54,8 @@ void EmitterState::SetLocalValue(EMITTER_MANIP value) { void EmitterState::SetAnchor() { m_hasAnchor = true; } +void EmitterState::SetAlias() { m_hasAlias = true; } + void EmitterState::SetTag() { m_hasTag = true; } void EmitterState::SetNonContent() { m_hasNonContent = true; } @@ -81,6 +90,7 @@ void EmitterState::StartedNode() { } m_hasAnchor = false; + m_hasAlias = false; m_hasTag = false; m_hasNonContent = false; } @@ -90,15 +100,13 @@ EmitterNodeType::value EmitterState::NextGroupType( if (type == GroupType::Seq) { if (GetFlowType(type) == Block) return EmitterNodeType::BlockSeq; - else - return EmitterNodeType::FlowSeq; - } else { - if (GetFlowType(type) == Block) - return EmitterNodeType::BlockMap; - else - return EmitterNodeType::FlowMap; + return EmitterNodeType::FlowSeq; } + if (GetFlowType(type) == Block) + return EmitterNodeType::BlockMap; + return EmitterNodeType::FlowMap; + // can't happen assert(false); return EmitterNodeType::NoType; @@ -152,9 +160,15 @@ void EmitterState::EndedGroup(GroupType::value type) { if (m_groups.empty()) { if (type == GroupType::Seq) { return SetError(ErrorMsg::UNEXPECTED_END_SEQ); - } else { - return SetError(ErrorMsg::UNEXPECTED_END_MAP); } + return SetError(ErrorMsg::UNEXPECTED_END_MAP); + } + + if (m_hasTag) { + SetError(ErrorMsg::INVALID_TAG); + } + if (m_hasAnchor) { + SetError(ErrorMsg::INVALID_ANCHOR); } // get rid of the current group @@ -176,6 +190,9 @@ void EmitterState::EndedGroup(GroupType::value type) { m_globalModifiedSettings.restore(); ClearModifiedSettings(); + m_hasAnchor = false; + m_hasTag = false; + m_hasNonContent = false; } EmitterNodeType::value EmitterState::CurGroupNodeType() const { @@ -216,11 +233,16 @@ std::size_t EmitterState::LastIndent() const { void EmitterState::ClearModifiedSettings() { m_modifiedSettings.clear(); } +void EmitterState::RestoreGlobalModifiedSettings() { + m_globalModifiedSettings.restore(); +} + bool EmitterState::SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope) { switch (value) { case EmitNonAscii: case EscapeNonAscii: + case EscapeAsJson: _Set(m_charset, value, scope); return true; default: @@ -278,6 +300,19 @@ bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, } } +bool EmitterState::SetNullFormat(EMITTER_MANIP value, FmtScope::value scope) { + switch (value) { + case LowerNull: + case UpperNull: + case CamelNull: + case TildeNull: + _Set(m_nullFmt, value, scope); + return true; + default: + return false; + } +} + bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) { switch (value) { case Dec: @@ -349,7 +384,7 @@ bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) { } bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) { - if (value > std::numeric_limits<float>::digits10 + 1) + if (value > std::numeric_limits<float>::max_digits10) return false; _Set(m_floatPrecision, value, scope); return true; @@ -357,9 +392,9 @@ bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) { bool EmitterState::SetDoublePrecision(std::size_t value, FmtScope::value scope) { - if (value > std::numeric_limits<double>::digits10 + 1) + if (value > std::numeric_limits<double>::max_digits10) return false; _Set(m_doublePrecision, value, scope); return true; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/emitterstate.h b/src/libs/3rdparty/yaml-cpp/src/emitterstate.h index 0937f000d9..8f379ca952 100644 --- a/src/libs/3rdparty/yaml-cpp/src/emitterstate.h +++ b/src/libs/3rdparty/yaml-cpp/src/emitterstate.h @@ -43,6 +43,7 @@ class EmitterState { // node handling void SetAnchor(); + void SetAlias(); void SetTag(); void SetNonContent(); void SetLongKey(); @@ -65,6 +66,7 @@ class EmitterState { std::size_t LastIndent() const; std::size_t CurIndent() const { return m_curIndent; } bool HasAnchor() const { return m_hasAnchor; } + bool HasAlias() const { return m_hasAlias; } bool HasTag() const { return m_hasTag; } bool HasBegunNode() const { return m_hasAnchor || m_hasTag || m_hasNonContent; @@ -72,6 +74,7 @@ class EmitterState { bool HasBegunContent() const { return m_hasAnchor || m_hasTag; } void ClearModifiedSettings(); + void RestoreGlobalModifiedSettings(); // formatters void SetLocalValue(EMITTER_MANIP value); @@ -91,6 +94,9 @@ class EmitterState { bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope); EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); } + bool SetNullFormat(EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetNullFormat() const { return m_nullFmt.get(); } + bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope); EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); } @@ -131,6 +137,7 @@ class EmitterState { Setting<EMITTER_MANIP> m_boolFmt; Setting<EMITTER_MANIP> m_boolLengthFmt; Setting<EMITTER_MANIP> m_boolCaseFmt; + Setting<EMITTER_MANIP> m_nullFmt; Setting<EMITTER_MANIP> m_intFmt; Setting<std::size_t> m_indent; Setting<std::size_t> m_preCommentIndent, m_postCommentIndent; @@ -145,7 +152,12 @@ class EmitterState { struct Group { explicit Group(GroupType::value type_) - : type(type_), indent(0), childCount(0), longKey(false) {} + : type(type_), + flowType{}, + indent(0), + childCount(0), + longKey(false), + modifiedSettings{} {} GroupType::value type; FlowType::value flowType; @@ -177,6 +189,7 @@ class EmitterState { std::vector<std::unique_ptr<Group>> m_groups; std::size_t m_curIndent; bool m_hasAnchor; + bool m_hasAlias; bool m_hasTag; bool m_hasNonContent; std::size_t m_docCount; @@ -198,6 +211,6 @@ void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) { assert(false); } } -} +} // namespace YAML #endif // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/emitterutils.cpp b/src/libs/3rdparty/yaml-cpp/src/emitterutils.cpp index 147738ad8a..6cdf6de7e2 100644 --- a/src/libs/3rdparty/yaml-cpp/src/emitterutils.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/emitterutils.cpp @@ -1,3 +1,4 @@ +#include <algorithm> #include <iomanip> #include <sstream> @@ -8,8 +9,8 @@ #include "regeximpl.h" #include "stringsource.h" #include "yaml-cpp/binary.h" // IWYU pragma: keep -#include "yaml-cpp/ostream_wrapper.h" #include "yaml-cpp/null.h" +#include "yaml-cpp/ostream_wrapper.h" namespace YAML { namespace Utils { @@ -134,12 +135,12 @@ void WriteCodePoint(ostream_wrapper& out, int codePoint) { if (codePoint < 0 || codePoint > 0x10FFFF) { codePoint = REPLACEMENT_CHARACTER; } - if (codePoint < 0x7F) { + if (codePoint <= 0x7F) { out << static_cast<char>(codePoint); - } else if (codePoint < 0x7FF) { + } else if (codePoint <= 0x7FF) { out << static_cast<char>(0xC0 | (codePoint >> 6)) << static_cast<char>(0x80 | (codePoint & 0x3F)); - } else if (codePoint < 0xFFFF) { + } else if (codePoint <= 0xFFFF) { out << static_cast<char>(0xE0 | (codePoint >> 12)) << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)) << static_cast<char>(0x80 | (codePoint & 0x3F)); @@ -173,13 +174,13 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType, // then check until something is disallowed static const RegEx& disallowed_flow = - Exp::EndScalarInFlow() || (Exp::BlankOrBreak() + Exp::Comment()) || - Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() || - Exp::Tab(); + Exp::EndScalarInFlow() | (Exp::BlankOrBreak() + Exp::Comment()) | + Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() | + Exp::Tab() | Exp::Ampersand(); static const RegEx& disallowed_block = - Exp::EndScalar() || (Exp::BlankOrBreak() + Exp::Comment()) || - Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() || - Exp::Tab(); + Exp::EndScalar() | (Exp::BlankOrBreak() + Exp::Comment()) | + Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() | + Exp::Tab() | Exp::Ampersand(); const RegEx& disallowed = flowType == FlowType::Flow ? disallowed_flow : disallowed_block; @@ -199,15 +200,10 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType, bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) { // TODO: check for non-printable characters? - for (std::size_t i = 0; i < str.size(); i++) { - if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) { - return false; - } - if (str[i] == '\n') { - return false; - } - } - return true; + return std::none_of(str.begin(), str.end(), [=](char ch) { + return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) || + (ch == '\n'); + }); } bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType, @@ -217,28 +213,39 @@ bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType, } // TODO: check for non-printable characters? - for (std::size_t i = 0; i < str.size(); i++) { - if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) { - return false; - } - } - return true; + return std::none_of(str.begin(), str.end(), [=](char ch) { + return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))); + }); +} + +std::pair<uint16_t, uint16_t> EncodeUTF16SurrogatePair(int codePoint) { + const uint32_t leadOffset = 0xD800 - (0x10000 >> 10); + + return { + leadOffset | (codePoint >> 10), + 0xDC00 | (codePoint & 0x3FF), + }; } -void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint) { +void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint, StringEscaping::value stringEscapingStyle) { static const char hexDigits[] = "0123456789abcdef"; out << "\\"; int digits = 8; - if (codePoint < 0xFF) { + if (codePoint < 0xFF && stringEscapingStyle != StringEscaping::JSON) { out << "x"; digits = 2; } else if (codePoint < 0xFFFF) { out << "u"; digits = 4; - } else { + } else if (stringEscapingStyle != StringEscaping::JSON) { out << "U"; digits = 8; + } else { + auto surrogatePair = EncodeUTF16SurrogatePair(codePoint); + WriteDoubleQuoteEscapeSequence(out, surrogatePair.first, stringEscapingStyle); + WriteDoubleQuoteEscapeSequence(out, surrogatePair.second, stringEscapingStyle); + return; } // Write digits into the escape sequence @@ -258,7 +265,7 @@ bool WriteAliasName(ostream_wrapper& out, const std::string& str) { } return true; } -} +} // namespace StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, @@ -310,7 +317,7 @@ bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) { } bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, - bool escapeNonAscii) { + StringEscaping::value stringEscaping) { out << "\""; int codePoint; for (std::string::const_iterator i = str.begin(); @@ -334,16 +341,19 @@ bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, case '\b': out << "\\b"; break; + case '\f': + out << "\\f"; + break; default: if (codePoint < 0x20 || (codePoint >= 0x80 && codePoint <= 0xA0)) { // Control characters and non-breaking space - WriteDoubleQuoteEscapeSequence(out, codePoint); + WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping); } else if (codePoint == 0xFEFF) { // Byte order marks (ZWNS) should be // escaped (YAML 1.2, sec. 5.2) - WriteDoubleQuoteEscapeSequence(out, codePoint); - } else if (escapeNonAscii && codePoint > 0x7E) { - WriteDoubleQuoteEscapeSequence(out, codePoint); + WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping); + } else if (stringEscaping == StringEscaping::NonAscii && codePoint > 0x7E) { + WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping); } else { WriteCodePoint(out, codePoint); } @@ -356,37 +366,41 @@ bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, bool WriteLiteralString(ostream_wrapper& out, const std::string& str, std::size_t indent) { out << "|\n"; - out << IndentTo(indent); int codePoint; for (std::string::const_iterator i = str.begin(); GetNextCodePointAndAdvance(codePoint, i, str.end());) { if (codePoint == '\n') { - out << "\n" << IndentTo(indent); + out << "\n"; } else { + out<< IndentTo(indent); WriteCodePoint(out, codePoint); } } return true; } -bool WriteChar(ostream_wrapper& out, char ch) { +bool WriteChar(ostream_wrapper& out, char ch, StringEscaping::value stringEscapingStyle) { if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) { out << ch; } else if (ch == '\"') { - out << "\"\\\"\""; + out << R"("\"")"; } else if (ch == '\t') { - out << "\"\\t\""; + out << R"("\t")"; } else if (ch == '\n') { - out << "\"\\n\""; + out << R"("\n")"; } else if (ch == '\b') { - out << "\"\\b\""; + out << R"("\b")"; + } else if (ch == '\r') { + out << R"("\r")"; + } else if (ch == '\f') { + out << R"("\f")"; } else if (ch == '\\') { - out << "\"\\\\\""; - } else if ((0x20 <= ch && ch <= 0x7e) || ch == ' ') { + out << R"("\\")"; + } else if (0x20 <= ch && ch <= 0x7e) { out << "\"" << ch << "\""; } else { out << "\""; - WriteDoubleQuoteEscapeSequence(out, ch); + WriteDoubleQuoteEscapeSequence(out, ch, stringEscapingStyle); out << "\""; } return true; @@ -401,8 +415,8 @@ bool WriteComment(ostream_wrapper& out, const std::string& str, for (std::string::const_iterator i = str.begin(); GetNextCodePointAndAdvance(codePoint, i, str.end());) { if (codePoint == '\n') { - out << "\n" << IndentTo(curIndent) << "#" - << Indentation(postCommentIndent); + out << "\n" + << IndentTo(curIndent) << "#" << Indentation(postCommentIndent); out.set_comment(); } else { WriteCodePoint(out, codePoint); @@ -476,8 +490,8 @@ bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, bool WriteBinary(ostream_wrapper& out, const Binary& binary) { WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()), - false); + StringEscaping::None); return true; } -} -} +} // namespace Utils +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/emitterutils.h b/src/libs/3rdparty/yaml-cpp/src/emitterutils.h index 6cc7319147..3a7d598252 100644 --- a/src/libs/3rdparty/yaml-cpp/src/emitterutils.h +++ b/src/libs/3rdparty/yaml-cpp/src/emitterutils.h @@ -24,6 +24,10 @@ struct StringFormat { enum value { Plain, SingleQuoted, DoubleQuoted, Literal }; }; +struct StringEscaping { + enum value { None, NonAscii, JSON }; +}; + namespace Utils { StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, @@ -32,10 +36,11 @@ StringFormat::value ComputeStringFormat(const std::string& str, bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str); bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, - bool escapeNonAscii); + StringEscaping::value stringEscaping); bool WriteLiteralString(ostream_wrapper& out, const std::string& str, std::size_t indent); -bool WriteChar(ostream_wrapper& out, char ch); +bool WriteChar(ostream_wrapper& out, char ch, + StringEscaping::value stringEscapingStyle); bool WriteComment(ostream_wrapper& out, const std::string& str, std::size_t postCommentIndent); bool WriteAlias(ostream_wrapper& out, const std::string& str); diff --git a/src/libs/3rdparty/yaml-cpp/src/exceptions.cpp b/src/libs/3rdparty/yaml-cpp/src/exceptions.cpp index d5e10b23c1..43a7976e90 100644 --- a/src/libs/3rdparty/yaml-cpp/src/exceptions.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/exceptions.cpp @@ -1,25 +1,20 @@ #include "yaml-cpp/exceptions.h" - -#define YAML_CPP_NOEXCEPT noexcept +#include "yaml-cpp/noexcept.h" namespace YAML { // These destructors are defined out-of-line so the vtable is only emitted once. -Exception::~Exception() YAML_CPP_NOEXCEPT {} -ParserException::~ParserException() YAML_CPP_NOEXCEPT {} -RepresentationException::~RepresentationException() YAML_CPP_NOEXCEPT {} -InvalidScalar::~InvalidScalar() YAML_CPP_NOEXCEPT {} -KeyNotFound::~KeyNotFound() YAML_CPP_NOEXCEPT {} -InvalidNode::~InvalidNode() YAML_CPP_NOEXCEPT {} -BadConversion::~BadConversion() YAML_CPP_NOEXCEPT {} -BadDereference::~BadDereference() YAML_CPP_NOEXCEPT {} -BadSubscript::~BadSubscript() YAML_CPP_NOEXCEPT {} -BadPushback::~BadPushback() YAML_CPP_NOEXCEPT {} -BadInsert::~BadInsert() YAML_CPP_NOEXCEPT {} -EmitterException::~EmitterException() YAML_CPP_NOEXCEPT {} -BadFile::~BadFile() YAML_CPP_NOEXCEPT {} -} - -#undef YAML_CPP_NOEXCEPT - - +Exception::~Exception() YAML_CPP_NOEXCEPT = default; +ParserException::~ParserException() YAML_CPP_NOEXCEPT = default; +RepresentationException::~RepresentationException() YAML_CPP_NOEXCEPT = default; +InvalidScalar::~InvalidScalar() YAML_CPP_NOEXCEPT = default; +KeyNotFound::~KeyNotFound() YAML_CPP_NOEXCEPT = default; +InvalidNode::~InvalidNode() YAML_CPP_NOEXCEPT = default; +BadConversion::~BadConversion() YAML_CPP_NOEXCEPT = default; +BadDereference::~BadDereference() YAML_CPP_NOEXCEPT = default; +BadSubscript::~BadSubscript() YAML_CPP_NOEXCEPT = default; +BadPushback::~BadPushback() YAML_CPP_NOEXCEPT = default; +BadInsert::~BadInsert() YAML_CPP_NOEXCEPT = default; +EmitterException::~EmitterException() YAML_CPP_NOEXCEPT = default; +BadFile::~BadFile() YAML_CPP_NOEXCEPT = default; +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/exp.cpp b/src/libs/3rdparty/yaml-cpp/src/exp.cpp index 695440aec0..992620ff94 100644 --- a/src/libs/3rdparty/yaml-cpp/src/exp.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/exp.cpp @@ -12,8 +12,7 @@ namespace YAML { namespace Exp { unsigned ParseHex(const std::string& str, const Mark& mark) { unsigned value = 0; - for (std::size_t i = 0; i < str.size(); i++) { - char ch = str[i]; + for (char ch : str) { int digit = 0; if ('a' <= ch && ch <= 'f') digit = ch - 'a' + 10; @@ -55,14 +54,16 @@ std::string Escape(Stream& in, int codeLength) { // now break it up into chars if (value <= 0x7F) return Str(value); - else if (value <= 0x7FF) + + if (value <= 0x7FF) return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F)); - else if (value <= 0xFFFF) + + if (value <= 0xFFFF) return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F)); - else - return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) + - Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F)); + + return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) + + Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F)); } // Escape @@ -104,7 +105,7 @@ std::string Escape(Stream& in) { case 'e': return "\x1B"; case ' ': - return "\x20"; + return R"( )"; case '\"': return "\""; case '\'': @@ -132,5 +133,5 @@ std::string Escape(Stream& in) { std::stringstream msg; throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch); } -} -} +} // namespace Exp +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/exp.h b/src/libs/3rdparty/yaml-cpp/src/exp.h index 7c02cf6e45..c8837f0f82 100644 --- a/src/libs/3rdparty/yaml-cpp/src/exp.h +++ b/src/libs/3rdparty/yaml-cpp/src/exp.h @@ -33,15 +33,15 @@ inline const RegEx& Tab() { return e; } inline const RegEx& Blank() { - static const RegEx e = Space() || Tab(); + static const RegEx e = Space() | Tab(); return e; } inline const RegEx& Break() { - static const RegEx e = RegEx('\n') || RegEx("\r\n"); + static const RegEx e = RegEx('\n') | RegEx("\r\n") | RegEx('\r'); return e; } inline const RegEx& BlankOrBreak() { - static const RegEx e = Blank() || Break(); + static const RegEx e = Blank() | Break(); return e; } inline const RegEx& Digit() { @@ -49,29 +49,29 @@ inline const RegEx& Digit() { return e; } inline const RegEx& Alpha() { - static const RegEx e = RegEx('a', 'z') || RegEx('A', 'Z'); + static const RegEx e = RegEx('a', 'z') | RegEx('A', 'Z'); return e; } inline const RegEx& AlphaNumeric() { - static const RegEx e = Alpha() || Digit(); + static const RegEx e = Alpha() | Digit(); return e; } inline const RegEx& Word() { - static const RegEx e = AlphaNumeric() || RegEx('-'); + static const RegEx e = AlphaNumeric() | RegEx('-'); return e; } inline const RegEx& Hex() { - static const RegEx e = Digit() || RegEx('A', 'F') || RegEx('a', 'f'); + static const RegEx e = Digit() | RegEx('A', 'F') | RegEx('a', 'f'); return e; } // Valid Unicode code points that are not part of c-printable (YAML 1.2, sec. // 5.1) inline const RegEx& NotPrintable() { static const RegEx e = - RegEx(0) || - RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) || - RegEx(0x0E, 0x1F) || - (RegEx('\xC2') + (RegEx('\x80', '\x84') || RegEx('\x86', '\x9F'))); + RegEx(0) | + RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) | + RegEx(0x0E, 0x1F) | + (RegEx('\xC2') + (RegEx('\x80', '\x84') | RegEx('\x86', '\x9F'))); return e; } inline const RegEx& Utf8_ByteOrderMark() { @@ -82,19 +82,19 @@ inline const RegEx& Utf8_ByteOrderMark() { // actual tags inline const RegEx& DocStart() { - static const RegEx e = RegEx("---") + (BlankOrBreak() || RegEx()); + static const RegEx e = RegEx("---") + (BlankOrBreak() | RegEx()); return e; } inline const RegEx& DocEnd() { - static const RegEx e = RegEx("...") + (BlankOrBreak() || RegEx()); + static const RegEx e = RegEx("...") + (BlankOrBreak() | RegEx()); return e; } inline const RegEx& DocIndicator() { - static const RegEx e = DocStart() || DocEnd(); + static const RegEx e = DocStart() | DocEnd(); return e; } inline const RegEx& BlockEntry() { - static const RegEx e = RegEx('-') + (BlankOrBreak() || RegEx()); + static const RegEx e = RegEx('-') + (BlankOrBreak() | RegEx()); return e; } inline const RegEx& Key() { @@ -106,36 +106,40 @@ inline const RegEx& KeyInFlow() { return e; } inline const RegEx& Value() { - static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx()); + static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx()); return e; } inline const RegEx& ValueInFlow() { - static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx(",}", REGEX_OR)); + static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx(",]}", REGEX_OR)); return e; } inline const RegEx& ValueInJSONFlow() { static const RegEx e = RegEx(':'); return e; } +inline const RegEx& Ampersand() { + static const RegEx e = RegEx('&'); + return e; +} inline const RegEx Comment() { static const RegEx e = RegEx('#'); return e; } inline const RegEx& Anchor() { - static const RegEx e = !(RegEx("[]{},", REGEX_OR) || BlankOrBreak()); + static const RegEx e = !(RegEx("[]{},", REGEX_OR) | BlankOrBreak()); return e; } inline const RegEx& AnchorEnd() { - static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) || BlankOrBreak(); + static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) | BlankOrBreak(); return e; } inline const RegEx& URI() { - static const RegEx e = Word() || RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) || + static const RegEx e = Word() | RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) | (RegEx('%') + Hex() + Hex()); return e; } inline const RegEx& Tag() { - static const RegEx e = Word() || RegEx("#;/?:@&=+$_.~*'()", REGEX_OR) || + static const RegEx e = Word() | RegEx("#;/?:@&=+$_.~*'()", REGEX_OR) | (RegEx('%') + Hex() + Hex()); return e; } @@ -148,34 +152,34 @@ inline const RegEx& Tag() { // space. inline const RegEx& PlainScalar() { static const RegEx e = - !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) || - (RegEx("-?:", REGEX_OR) + (BlankOrBreak() || RegEx()))); + !(BlankOrBreak() | RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) | + (RegEx("-?:", REGEX_OR) + (BlankOrBreak() | RegEx()))); return e; } inline const RegEx& PlainScalarInFlow() { static const RegEx e = - !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) || - (RegEx("-:", REGEX_OR) + Blank())); + !(BlankOrBreak() | RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) | + (RegEx("-:", REGEX_OR) + (Blank() | RegEx()))); return e; } inline const RegEx& EndScalar() { - static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx()); + static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx()); return e; } inline const RegEx& EndScalarInFlow() { static const RegEx e = - (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) || + (RegEx(':') + (BlankOrBreak() | RegEx() | RegEx(",]}", REGEX_OR))) | RegEx(",?[]{}", REGEX_OR); return e; } inline const RegEx& ScanScalarEndInFlow() { - static const RegEx e = (EndScalarInFlow() || (BlankOrBreak() + Comment())); + static const RegEx e = (EndScalarInFlow() | (BlankOrBreak() + Comment())); return e; } inline const RegEx& ScanScalarEnd() { - static const RegEx e = EndScalar() || (BlankOrBreak() + Comment()); + static const RegEx e = EndScalar() | (BlankOrBreak() + Comment()); return e; } inline const RegEx& EscSingleQuote() { @@ -192,8 +196,8 @@ inline const RegEx& ChompIndicator() { return e; } inline const RegEx& Chomp() { - static const RegEx e = (ChompIndicator() + Digit()) || - (Digit() + ChompIndicator()) || ChompIndicator() || + static const RegEx e = (ChompIndicator() + Digit()) | + (Digit() + ChompIndicator()) | ChompIndicator() | Digit(); return e; } diff --git a/src/libs/3rdparty/yaml-cpp/src/memory.cpp b/src/libs/3rdparty/yaml-cpp/src/memory.cpp index e5f8a9d3f8..676e4c7f15 100644 --- a/src/libs/3rdparty/yaml-cpp/src/memory.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/memory.cpp @@ -22,5 +22,5 @@ node& memory::create_node() { void memory::merge(const memory& rhs) { m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end()); } -} -} +} // namespace detail +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/node.cpp b/src/libs/3rdparty/yaml-cpp/src/node.cpp index 2088e13c9a..badc3110ec 100644 --- a/src/libs/3rdparty/yaml-cpp/src/node.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/node.cpp @@ -9,4 +9,4 @@ Node Clone(const Node& node) { events.Emit(builder); return builder.Root(); } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/node_data.cpp b/src/libs/3rdparty/yaml-cpp/src/node_data.cpp index 77cd465780..8f5422ae6e 100644 --- a/src/libs/3rdparty/yaml-cpp/src/node_data.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/node_data.cpp @@ -1,4 +1,5 @@ -#include <assert.h> +#include <algorithm> +#include <cassert> #include <iterator> #include <sstream> @@ -12,15 +13,24 @@ namespace YAML { namespace detail { +YAML_CPP_API std::atomic<size_t> node::m_amount{0}; -std::string node_data::empty_scalar; +const std::string& node_data::empty_scalar() { + static const std::string svalue; + return svalue; +} node_data::node_data() : m_isDefined(false), m_mark(Mark::null_mark()), m_type(NodeType::Null), + m_tag{}, m_style(EmitterStyle::Default), - m_seqSize(0) {} + m_scalar{}, + m_sequence{}, + m_seqSize(0), + m_map{}, + m_undefinedPairs{} {} void node_data::mark_defined() { if (m_type == NodeType::Undefined) @@ -100,9 +110,9 @@ void node_data::compute_seq_size() const { } void node_data::compute_map_size() const { - kv_pairs::iterator it = m_undefinedPairs.begin(); + auto it = m_undefinedPairs.begin(); while (it != m_undefinedPairs.end()) { - kv_pairs::iterator jt = std::next(it); + auto jt = std::next(it); if (it->first->is_defined() && it->second->is_defined()) m_undefinedPairs.erase(it); it = jt; @@ -111,7 +121,7 @@ void node_data::compute_map_size() const { const_node_iterator node_data::begin() const { if (!m_isDefined) - return const_node_iterator(); + return {}; switch (m_type) { case NodeType::Sequence: @@ -119,13 +129,13 @@ const_node_iterator node_data::begin() const { case NodeType::Map: return const_node_iterator(m_map.begin(), m_map.end()); default: - return const_node_iterator(); + return {}; } } node_iterator node_data::begin() { if (!m_isDefined) - return node_iterator(); + return {}; switch (m_type) { case NodeType::Sequence: @@ -133,13 +143,13 @@ node_iterator node_data::begin() { case NodeType::Map: return node_iterator(m_map.begin(), m_map.end()); default: - return node_iterator(); + return {}; } } const_node_iterator node_data::end() const { if (!m_isDefined) - return const_node_iterator(); + return {}; switch (m_type) { case NodeType::Sequence: @@ -147,13 +157,13 @@ const_node_iterator node_data::end() const { case NodeType::Map: return const_node_iterator(m_map.end(), m_map.end()); default: - return const_node_iterator(); + return {}; } } node_iterator node_data::end() { if (!m_isDefined) - return node_iterator(); + return {}; switch (m_type) { case NodeType::Sequence: @@ -161,12 +171,13 @@ node_iterator node_data::end() { case NodeType::Map: return node_iterator(m_map.end(), m_map.end()); default: - return node_iterator(); + return {}; } } // sequence -void node_data::push_back(node& node, shared_memory_holder /* pMemory */) { +void node_data::push_back(node& node, + const shared_memory_holder& /* pMemory */) { if (m_type == NodeType::Undefined || m_type == NodeType::Null) { m_type = NodeType::Sequence; reset_sequence(); @@ -178,7 +189,8 @@ void node_data::push_back(node& node, shared_memory_holder /* pMemory */) { m_sequence.push_back(&node); } -void node_data::insert(node& key, node& value, shared_memory_holder pMemory) { +void node_data::insert(node& key, node& value, + const shared_memory_holder& pMemory) { switch (m_type) { case NodeType::Map: break; @@ -188,27 +200,28 @@ void node_data::insert(node& key, node& value, shared_memory_holder pMemory) { convert_to_map(pMemory); break; case NodeType::Scalar: - throw BadSubscript(); + throw BadSubscript(m_mark, key); } insert_map_pair(key, value); } // indexing -node* node_data::get(node& key, shared_memory_holder /* pMemory */) const { +node* node_data::get(node& key, + const shared_memory_holder& /* pMemory */) const { if (m_type != NodeType::Map) { - return NULL; + return nullptr; } - for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) { - if (it->first->is(key)) - return it->second; + for (const auto& it : m_map) { + if (it.first->is(key)) + return it.second; } - return NULL; + return nullptr; } -node& node_data::get(node& key, shared_memory_holder pMemory) { +node& node_data::get(node& key, const shared_memory_holder& pMemory) { switch (m_type) { case NodeType::Map: break; @@ -218,12 +231,12 @@ node& node_data::get(node& key, shared_memory_holder pMemory) { convert_to_map(pMemory); break; case NodeType::Scalar: - throw BadSubscript(); + throw BadSubscript(m_mark, key); } - for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) { - if (it->first->is(key)) - return *it->second; + for (const auto& it : m_map) { + if (it.first->is(key)) + return *it.second; } node& value = pMemory->create_node(); @@ -231,15 +244,26 @@ node& node_data::get(node& key, shared_memory_holder pMemory) { return value; } -bool node_data::remove(node& key, shared_memory_holder /* pMemory */) { +bool node_data::remove(node& key, const shared_memory_holder& /* pMemory */) { if (m_type != NodeType::Map) return false; - for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) { - if (it->first->is(key)) { - m_map.erase(it); - return true; - } + for (auto it = m_undefinedPairs.begin(); it != m_undefinedPairs.end();) { + auto jt = std::next(it); + if (it->first->is(key)) + m_undefinedPairs.erase(it); + it = jt; + } + + auto it = + std::find_if(m_map.begin(), m_map.end(), + [&](std::pair<YAML::detail::node*, YAML::detail::node*> j) { + return (j.first->is(key)); + }); + + if (it != m_map.end()) { + m_map.erase(it); + return true; } return false; @@ -262,7 +286,7 @@ void node_data::insert_map_pair(node& key, node& value) { m_undefinedPairs.emplace_back(&key, &value); } -void node_data::convert_to_map(shared_memory_holder pMemory) { +void node_data::convert_to_map(const shared_memory_holder& pMemory) { switch (m_type) { case NodeType::Undefined: case NodeType::Null: @@ -280,7 +304,7 @@ void node_data::convert_to_map(shared_memory_holder pMemory) { } } -void node_data::convert_sequence_to_map(shared_memory_holder pMemory) { +void node_data::convert_sequence_to_map(const shared_memory_holder& pMemory) { assert(m_type == NodeType::Sequence); reset_map(); @@ -296,5 +320,5 @@ void node_data::convert_sequence_to_map(shared_memory_holder pMemory) { reset_sequence(); m_type = NodeType::Map; } -} -} +} // namespace detail +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/nodebuilder.cpp b/src/libs/3rdparty/yaml-cpp/src/nodebuilder.cpp index 093d2efeb7..bbaefac8a6 100644 --- a/src/libs/3rdparty/yaml-cpp/src/nodebuilder.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/nodebuilder.cpp @@ -1,4 +1,3 @@ -#include <assert.h> #include <cassert> #include "nodebuilder.h" @@ -11,11 +10,16 @@ namespace YAML { struct Mark; NodeBuilder::NodeBuilder() - : m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0) { - m_anchors.push_back(0); // since the anchors start at 1 + : m_pMemory(new detail::memory_holder), + m_pRoot(nullptr), + m_stack{}, + m_anchors{}, + m_keys{}, + m_mapDepth(0) { + m_anchors.push_back(nullptr); // since the anchors start at 1 } -NodeBuilder::~NodeBuilder() {} +NodeBuilder::~NodeBuilder() = default; Node NodeBuilder::Root() { if (!m_pRoot) @@ -88,7 +92,7 @@ void NodeBuilder::Push(detail::node& node) { m_stack.push_back(&node); if (needsKey) - m_keys.push_back(PushedKey(&node, false)); + m_keys.emplace_back(&node, false); } void NodeBuilder::Pop() { @@ -127,4 +131,4 @@ void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) { m_anchors.push_back(&node); } } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/nodebuilder.h b/src/libs/3rdparty/yaml-cpp/src/nodebuilder.h index a6a47f007b..c580d40e29 100644 --- a/src/libs/3rdparty/yaml-cpp/src/nodebuilder.h +++ b/src/libs/3rdparty/yaml-cpp/src/nodebuilder.h @@ -27,25 +27,29 @@ class Node; class NodeBuilder : public EventHandler { public: NodeBuilder(); - virtual ~NodeBuilder(); + NodeBuilder(const NodeBuilder&) = delete; + NodeBuilder(NodeBuilder&&) = delete; + NodeBuilder& operator=(const NodeBuilder&) = delete; + NodeBuilder& operator=(NodeBuilder&&) = delete; + ~NodeBuilder() override; Node Root(); - virtual void OnDocumentStart(const Mark& mark); - virtual void OnDocumentEnd(); + void OnDocumentStart(const Mark& mark) override; + void OnDocumentEnd() override; - virtual void OnNull(const Mark& mark, anchor_t anchor); - virtual void OnAlias(const Mark& mark, anchor_t anchor); - virtual void OnScalar(const Mark& mark, const std::string& tag, - anchor_t anchor, const std::string& value); + void OnNull(const Mark& mark, anchor_t anchor) override; + void OnAlias(const Mark& mark, anchor_t anchor) override; + void OnScalar(const Mark& mark, const std::string& tag, + anchor_t anchor, const std::string& value) override; - virtual void OnSequenceStart(const Mark& mark, const std::string& tag, - anchor_t anchor, EmitterStyle::value style); - virtual void OnSequenceEnd(); + void OnSequenceStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle::value style) override; + void OnSequenceEnd() override; - virtual void OnMapStart(const Mark& mark, const std::string& tag, - anchor_t anchor, EmitterStyle::value style); - virtual void OnMapEnd(); + void OnMapStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle::value style) override; + void OnMapEnd() override; private: detail::node& Push(const Mark& mark, anchor_t anchor); @@ -57,14 +61,14 @@ class NodeBuilder : public EventHandler { detail::shared_memory_holder m_pMemory; detail::node* m_pRoot; - typedef std::vector<detail::node*> Nodes; + using Nodes = std::vector<detail::node *>; Nodes m_stack; Nodes m_anchors; - typedef std::pair<detail::node*, bool> PushedKey; + using PushedKey = std::pair<detail::node*, bool>; std::vector<PushedKey> m_keys; std::size_t m_mapDepth; }; -} +} // namespace YAML #endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/nodeevents.cpp b/src/libs/3rdparty/yaml-cpp/src/nodeevents.cpp index 82261feb05..b1774fef3e 100644 --- a/src/libs/3rdparty/yaml-cpp/src/nodeevents.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/nodeevents.cpp @@ -13,14 +13,14 @@ void NodeEvents::AliasManager::RegisterReference(const detail::node& node) { anchor_t NodeEvents::AliasManager::LookupAnchor( const detail::node& node) const { - AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref()); + auto it = m_anchorByIdentity.find(node.ref()); if (it == m_anchorByIdentity.end()) return 0; return it->second; } NodeEvents::NodeEvents(const Node& node) - : m_pMemory(node.m_pMemory), m_root(node.m_pNode) { + : m_pMemory(node.m_pMemory), m_root(node.m_pNode), m_refCount{} { if (m_root) Setup(*m_root); } @@ -32,13 +32,12 @@ void NodeEvents::Setup(const detail::node& node) { return; if (node.type() == NodeType::Sequence) { - for (detail::const_node_iterator it = node.begin(); it != node.end(); ++it) - Setup(**it); + for (auto element : node) + Setup(*element); } else if (node.type() == NodeType::Map) { - for (detail::const_node_iterator it = node.begin(); it != node.end(); - ++it) { - Setup(*it->first); - Setup(*it->second); + for (auto element : node) { + Setup(*element.first); + Setup(*element.second); } } } @@ -77,17 +76,15 @@ void NodeEvents::Emit(const detail::node& node, EventHandler& handler, break; case NodeType::Sequence: handler.OnSequenceStart(Mark(), node.tag(), anchor, node.style()); - for (detail::const_node_iterator it = node.begin(); it != node.end(); - ++it) - Emit(**it, handler, am); + for (auto element : node) + Emit(*element, handler, am); handler.OnSequenceEnd(); break; case NodeType::Map: handler.OnMapStart(Mark(), node.tag(), anchor, node.style()); - for (detail::const_node_iterator it = node.begin(); it != node.end(); - ++it) { - Emit(*it->first, handler, am); - Emit(*it->second, handler, am); + for (auto element : node) { + Emit(*element.first, handler, am); + Emit(*element.second, handler, am); } handler.OnMapEnd(); break; @@ -95,7 +92,7 @@ void NodeEvents::Emit(const detail::node& node, EventHandler& handler, } bool NodeEvents::IsAliased(const detail::node& node) const { - RefCount::const_iterator it = m_refCount.find(node.ref()); + auto it = m_refCount.find(node.ref()); return it != m_refCount.end() && it->second > 1; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/nodeevents.h b/src/libs/3rdparty/yaml-cpp/src/nodeevents.h index 49c18eb854..efca9149ed 100644 --- a/src/libs/3rdparty/yaml-cpp/src/nodeevents.h +++ b/src/libs/3rdparty/yaml-cpp/src/nodeevents.h @@ -26,13 +26,17 @@ class Node; class NodeEvents { public: explicit NodeEvents(const Node& node); + NodeEvents(const NodeEvents&) = delete; + NodeEvents(NodeEvents&&) = delete; + NodeEvents& operator=(const NodeEvents&) = delete; + NodeEvents& operator=(NodeEvents&&) = delete; void Emit(EventHandler& handler); private: class AliasManager { public: - AliasManager() : m_curAnchor(0) {} + AliasManager() : m_anchorByIdentity{}, m_curAnchor(0) {} void RegisterReference(const detail::node& node); anchor_t LookupAnchor(const detail::node& node) const; @@ -41,7 +45,7 @@ class NodeEvents { anchor_t _CreateNewAnchor() { return ++m_curAnchor; } private: - typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity; + using AnchorByIdentity = std::map<const detail::node_ref*, anchor_t>; AnchorByIdentity m_anchorByIdentity; anchor_t m_curAnchor; @@ -56,9 +60,9 @@ class NodeEvents { detail::shared_memory_holder m_pMemory; detail::node* m_root; - typedef std::map<const detail::node_ref*, int> RefCount; + using RefCount = std::map<const detail::node_ref*, int>; RefCount m_refCount; }; -} +} // namespace YAML #endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/null.cpp b/src/libs/3rdparty/yaml-cpp/src/null.cpp index d12dd08ce4..db7daebf1d 100644 --- a/src/libs/3rdparty/yaml-cpp/src/null.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/null.cpp @@ -7,4 +7,4 @@ bool IsNullString(const std::string& str) { return str.empty() || str == "~" || str == "null" || str == "Null" || str == "NULL"; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/ostream_wrapper.cpp b/src/libs/3rdparty/yaml-cpp/src/ostream_wrapper.cpp index 357fc0094c..047a9f7c8e 100644 --- a/src/libs/3rdparty/yaml-cpp/src/ostream_wrapper.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/ostream_wrapper.cpp @@ -7,16 +7,21 @@ namespace YAML { ostream_wrapper::ostream_wrapper() : m_buffer(1, '\0'), - m_pStream(0), + m_pStream(nullptr), m_pos(0), m_row(0), m_col(0), m_comment(false) {} ostream_wrapper::ostream_wrapper(std::ostream& stream) - : m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) {} + : m_buffer{}, + m_pStream(&stream), + m_pos(0), + m_row(0), + m_col(0), + m_comment(false) {} -ostream_wrapper::~ostream_wrapper() {} +ostream_wrapper::~ostream_wrapper() = default; void ostream_wrapper::write(const std::string& str) { if (m_pStream) { @@ -26,8 +31,8 @@ void ostream_wrapper::write(const std::string& str) { std::copy(str.begin(), str.end(), m_buffer.begin() + m_pos); } - for (std::size_t i = 0; i < str.size(); i++) { - update_pos(str[i]); + for (char ch : str) { + update_pos(ch); } } @@ -54,4 +59,4 @@ void ostream_wrapper::update_pos(char ch) { m_comment = false; } } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/parse.cpp b/src/libs/3rdparty/yaml-cpp/src/parse.cpp index 0b2ae4a4f6..262536b85a 100644 --- a/src/libs/3rdparty/yaml-cpp/src/parse.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/parse.cpp @@ -3,10 +3,10 @@ #include <fstream> #include <sstream> -#include "yaml-cpp/node/node.h" +#include "nodebuilder.h" #include "yaml-cpp/node/impl.h" +#include "yaml-cpp/node/node.h" #include "yaml-cpp/parser.h" -#include "nodebuilder.h" namespace YAML { Node Load(const std::string& input) { @@ -30,9 +30,9 @@ Node Load(std::istream& input) { } Node LoadFile(const std::string& filename) { - std::ifstream fin(filename.c_str()); + std::ifstream fin(filename); if (!fin) { - throw BadFile(); + throw BadFile(filename); } return Load(fin); } @@ -51,7 +51,7 @@ std::vector<Node> LoadAll(std::istream& input) { std::vector<Node> docs; Parser parser(input); - while (1) { + while (true) { NodeBuilder builder; if (!parser.HandleNextDocument(builder)) { break; @@ -63,9 +63,9 @@ std::vector<Node> LoadAll(std::istream& input) { } std::vector<Node> LoadAllFromFile(const std::string& filename) { - std::ifstream fin(filename.c_str()); + std::ifstream fin(filename); if (!fin) { - throw BadFile(); + throw BadFile(filename); } return LoadAll(fin); } diff --git a/src/libs/3rdparty/yaml-cpp/src/parser.cpp b/src/libs/3rdparty/yaml-cpp/src/parser.cpp index cd69f39fce..b8b78ebabc 100644 --- a/src/libs/3rdparty/yaml-cpp/src/parser.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/parser.cpp @@ -11,15 +11,13 @@ namespace YAML { class EventHandler; -Parser::Parser() {} +Parser::Parser() : m_pScanner{}, m_pDirectives{} {} -Parser::Parser(std::istream& in) { Load(in); } +Parser::Parser(std::istream& in) : Parser() { Load(in); } -Parser::~Parser() {} +Parser::~Parser() = default; -Parser::operator bool() const { - return m_pScanner.get() && !m_pScanner->empty(); -} +Parser::operator bool() const { return m_pScanner && !m_pScanner->empty(); } void Parser::Load(std::istream& in) { m_pScanner.reset(new Scanner(in)); @@ -27,7 +25,7 @@ void Parser::Load(std::istream& in) { } bool Parser::HandleNextDocument(EventHandler& eventHandler) { - if (!m_pScanner.get()) + if (!m_pScanner) return false; ParseDirectives(); @@ -43,11 +41,7 @@ bool Parser::HandleNextDocument(EventHandler& eventHandler) { void Parser::ParseDirectives() { bool readDirective = false; - while (1) { - if (m_pScanner->empty()) { - break; - } - + while (!m_pScanner->empty()) { Token& token = m_pScanner->peek(); if (token.type != Token::DIRECTIVE) { break; @@ -113,17 +107,13 @@ void Parser::HandleTagDirective(const Token& token) { } void Parser::PrintTokens(std::ostream& out) { - if (!m_pScanner.get()) { + if (!m_pScanner) { return; } - while (1) { - if (m_pScanner->empty()) { - break; - } - + while (!m_pScanner->empty()) { out << m_pScanner->peek() << "\n"; m_pScanner->pop(); } } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/ptr_vector.h b/src/libs/3rdparty/yaml-cpp/src/ptr_vector.h index 955aebd8d5..d58de04cb6 100644 --- a/src/libs/3rdparty/yaml-cpp/src/ptr_vector.h +++ b/src/libs/3rdparty/yaml-cpp/src/ptr_vector.h @@ -12,15 +12,17 @@ #include <memory> #include <vector> -#include "yaml-cpp/noncopyable.h" - namespace YAML { // TODO: This class is no longer needed template <typename T> -class ptr_vector : private YAML::noncopyable { +class ptr_vector { public: - ptr_vector() {} + ptr_vector() : m_data{} {} + ptr_vector(const ptr_vector&) = delete; + ptr_vector(ptr_vector&&) = default; + ptr_vector& operator=(const ptr_vector&) = delete; + ptr_vector& operator=(ptr_vector&&) = default; void clear() { m_data.clear(); } @@ -38,6 +40,6 @@ class ptr_vector : private YAML::noncopyable { private: std::vector<std::unique_ptr<T>> m_data; }; -} +} // namespace YAML #endif // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/regex_yaml.cpp b/src/libs/3rdparty/yaml-cpp/src/regex_yaml.cpp index 20b772051d..bf1784b41d 100644 --- a/src/libs/3rdparty/yaml-cpp/src/regex_yaml.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/regex_yaml.cpp @@ -2,18 +2,16 @@ namespace YAML { // constructors -RegEx::RegEx() : m_op(REGEX_EMPTY) {} -RegEx::RegEx(REGEX_OP op) : m_op(op) {} +RegEx::RegEx(REGEX_OP op) : m_op(op), m_a(0), m_z(0), m_params{} {} +RegEx::RegEx() : RegEx(REGEX_EMPTY) {} -RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch) {} +RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch), m_z(0), m_params{} {} -RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z) {} +RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z), m_params{} {} -RegEx::RegEx(const std::string& str, REGEX_OP op) : m_op(op) { - for (std::size_t i = 0; i < str.size(); i++) - m_params.push_back(RegEx(str[i])); -} +RegEx::RegEx(const std::string& str, REGEX_OP op) + : m_op(op), m_a(0), m_z(0), m_params(str.begin(), str.end()) {} // combination constructors RegEx operator!(const RegEx& ex) { @@ -22,14 +20,14 @@ RegEx operator!(const RegEx& ex) { return ret; } -RegEx operator||(const RegEx& ex1, const RegEx& ex2) { +RegEx operator|(const RegEx& ex1, const RegEx& ex2) { RegEx ret(REGEX_OR); ret.m_params.push_back(ex1); ret.m_params.push_back(ex2); return ret; } -RegEx operator&&(const RegEx& ex1, const RegEx& ex2) { +RegEx operator&(const RegEx& ex1, const RegEx& ex2) { RegEx ret(REGEX_AND); ret.m_params.push_back(ex1); ret.m_params.push_back(ex2); @@ -42,4 +40,4 @@ RegEx operator+(const RegEx& ex1, const RegEx& ex2) { ret.m_params.push_back(ex2); return ret; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/regex_yaml.h b/src/libs/3rdparty/yaml-cpp/src/regex_yaml.h index 8f28b852a2..c70ab60dcc 100644 --- a/src/libs/3rdparty/yaml-cpp/src/regex_yaml.h +++ b/src/libs/3rdparty/yaml-cpp/src/regex_yaml.h @@ -31,14 +31,14 @@ enum REGEX_OP { class YAML_CPP_API RegEx { public: RegEx(); - RegEx(char ch); + explicit RegEx(char ch); RegEx(char a, char z); RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ); - ~RegEx() {} + ~RegEx() = default; friend YAML_CPP_API RegEx operator!(const RegEx& ex); - friend YAML_CPP_API RegEx operator||(const RegEx& ex1, const RegEx& ex2); - friend YAML_CPP_API RegEx operator&&(const RegEx& ex1, const RegEx& ex2); + friend YAML_CPP_API RegEx operator|(const RegEx& ex1, const RegEx& ex2); + friend YAML_CPP_API RegEx operator&(const RegEx& ex1, const RegEx& ex2); friend YAML_CPP_API RegEx operator+(const RegEx& ex1, const RegEx& ex2); bool Matches(char ch) const; @@ -53,7 +53,7 @@ class YAML_CPP_API RegEx { int Match(const Source& source) const; private: - RegEx(REGEX_OP op); + explicit RegEx(REGEX_OP op); template <typename Source> bool IsValidSource(const Source& source) const; @@ -77,10 +77,11 @@ class YAML_CPP_API RegEx { private: REGEX_OP m_op; - char m_a, m_z; + char m_a{}; + char m_z{}; std::vector<RegEx> m_params; }; -} +} // namespace YAML #include "regeximpl.h" diff --git a/src/libs/3rdparty/yaml-cpp/src/regeximpl.h b/src/libs/3rdparty/yaml-cpp/src/regeximpl.h index 709124f008..a742cdc305 100644 --- a/src/libs/3rdparty/yaml-cpp/src/regeximpl.h +++ b/src/libs/3rdparty/yaml-cpp/src/regeximpl.h @@ -8,8 +8,8 @@ #endif #include "stream.h" -#include "stringsource.h" #include "streamcharsource.h" +#include "stringsource.h" namespace YAML { // query matches @@ -106,9 +106,8 @@ inline int RegEx::MatchOpEmpty(const Source& source) const { template <> inline int RegEx::MatchOpEmpty<StringCharSource>( const StringCharSource& source) const { - return !source - ? 0 - : -1; // the empty regex only is successful on the empty string + return !source ? 0 : -1; // the empty regex only is successful on the empty + // string } // MatchOperator @@ -130,8 +129,8 @@ inline int RegEx::MatchOpRange(const Source& source) const { // OrOperator template <typename Source> inline int RegEx::MatchOpOr(const Source& source) const { - for (std::size_t i = 0; i < m_params.size(); i++) { - int n = m_params[i].MatchUnchecked(source); + for (const RegEx& param : m_params) { + int n = param.MatchUnchecked(source); if (n >= 0) return n; } @@ -169,11 +168,11 @@ inline int RegEx::MatchOpNot(const Source& source) const { template <typename Source> inline int RegEx::MatchOpSeq(const Source& source) const { int offset = 0; - for (std::size_t i = 0; i < m_params.size(); i++) { - int n = m_params[i].Match(source + offset); // note Match, not - // MatchUnchecked because we - // need to check validity after - // the offset + for (const RegEx& param : m_params) { + int n = param.Match(source + offset); // note Match, not + // MatchUnchecked because we + // need to check validity after + // the offset if (n == -1) return -1; offset += n; @@ -181,6 +180,6 @@ inline int RegEx::MatchOpSeq(const Source& source) const { return offset; } -} +} // namespace YAML #endif // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/scanner.cpp b/src/libs/3rdparty/yaml-cpp/src/scanner.cpp index b5cfcc12b2..ea5511a114 100644 --- a/src/libs/3rdparty/yaml-cpp/src/scanner.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/scanner.cpp @@ -9,12 +9,17 @@ namespace YAML { Scanner::Scanner(std::istream& in) : INPUT(in), + m_tokens{}, m_startedStream(false), m_endedStream(false), m_simpleKeyAllowed(false), - m_canBeJSONFlow(false) {} + m_canBeJSONFlow(false), + m_simpleKeys{}, + m_indents{}, + m_indentRefs{}, + m_flows{} {} -Scanner::~Scanner() {} +Scanner::~Scanner() = default; bool Scanner::empty() { EnsureTokensInQueue(); @@ -46,7 +51,7 @@ Token& Scanner::peek() { Mark Scanner::mark() const { return INPUT.mark(); } void Scanner::EnsureTokensInQueue() { - while (1) { + while (true) { if (!m_tokens.empty()) { Token& token = m_tokens.front(); @@ -83,7 +88,7 @@ void Scanner::ScanNextToken() { return StartStream(); } - // get rid of whitespace, etc. (in between tokens it should be irrelevent) + // get rid of whitespace, etc. (in between tokens it should be irrelevant) ScanToNextToken(); // maybe need to end some blocks @@ -169,7 +174,7 @@ void Scanner::ScanNextToken() { } void Scanner::ScanToNextToken() { - while (1) { + while (true) { // first eat whitespace while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) { if (InBlockContext() && Exp::Tab().Matches(INPUT)) { @@ -282,7 +287,7 @@ Scanner::IndentMarker* Scanner::PushIndentTo(int column, IndentMarker::INDENT_TYPE type) { // are we in flow? if (InFlowContext()) { - return 0; + return nullptr; } std::unique_ptr<IndentMarker> pIndent(new IndentMarker(column, type)); @@ -291,12 +296,12 @@ Scanner::IndentMarker* Scanner::PushIndentTo(int column, // is this actually an indentation? if (indent.column < lastIndent.column) { - return 0; + return nullptr; } if (indent.column == lastIndent.column && !(indent.type == IndentMarker::SEQ && lastIndent.type == IndentMarker::MAP)) { - return 0; + return nullptr; } // push a start token diff --git a/src/libs/3rdparty/yaml-cpp/src/scanner.h b/src/libs/3rdparty/yaml-cpp/src/scanner.h index 7bb2ccc71a..4af938e69c 100644 --- a/src/libs/3rdparty/yaml-cpp/src/scanner.h +++ b/src/libs/3rdparty/yaml-cpp/src/scanner.h @@ -9,9 +9,7 @@ #include <cstddef> #include <ios> -#include <map> #include <queue> -#include <set> #include <stack> #include <string> @@ -49,7 +47,7 @@ class Scanner { enum INDENT_TYPE { MAP, SEQ, NONE }; enum STATUS { VALID, INVALID, UNKNOWN }; IndentMarker(int column_, INDENT_TYPE type_) - : column(column_), type(type_), status(VALID), pStartToken(0) {} + : column(column_), type(type_), status(VALID), pStartToken(nullptr) {} int column; INDENT_TYPE type; diff --git a/src/libs/3rdparty/yaml-cpp/src/scanscalar.cpp b/src/libs/3rdparty/yaml-cpp/src/scanscalar.cpp index 10e359d446..be57b1cd5d 100644 --- a/src/libs/3rdparty/yaml-cpp/src/scanscalar.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/scanscalar.cpp @@ -47,7 +47,8 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) { if (INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) { if (params.onDocIndicator == BREAK) { break; - } else if (params.onDocIndicator == THROW) { + } + if (params.onDocIndicator == THROW) { throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR); } } @@ -183,7 +184,7 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) { case FOLD_FLOW: if (nextEmptyLine) { scalar += "\n"; - } else if (!emptyLine && !nextEmptyLine && !escapedNewline) { + } else if (!emptyLine && !escapedNewline) { scalar += " "; } break; @@ -203,7 +204,7 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) { // post-processing if (params.trimTrailingSpaces) { - std::size_t pos = scalar.find_last_not_of(' '); + std::size_t pos = scalar.find_last_not_of(" \t"); if (lastEscapedChar != std::string::npos) { if (pos < lastEscapedChar || pos == std::string::npos) { pos = lastEscapedChar; @@ -247,4 +248,4 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) { return scalar; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/scanscalar.h b/src/libs/3rdparty/yaml-cpp/src/scanscalar.h index c3a574ad9b..296b885a51 100644 --- a/src/libs/3rdparty/yaml-cpp/src/scanscalar.h +++ b/src/libs/3rdparty/yaml-cpp/src/scanscalar.h @@ -57,7 +57,7 @@ struct ScanScalarParams { bool leadingSpaces; }; -std::string ScanScalar(Stream& INPUT, ScanScalarParams& info); +std::string ScanScalar(Stream& INPUT, ScanScalarParams& params); } #endif // SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/scantag.cpp b/src/libs/3rdparty/yaml-cpp/src/scantag.cpp index c5b39652ad..176cc5c711 100644 --- a/src/libs/3rdparty/yaml-cpp/src/scantag.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/scantag.cpp @@ -78,4 +78,4 @@ const std::string ScanTagSuffix(Stream& INPUT) { return tag; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/scantoken.cpp b/src/libs/3rdparty/yaml-cpp/src/scantoken.cpp index fd8758d781..1a94ab1d7d 100644 --- a/src/libs/3rdparty/yaml-cpp/src/scantoken.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/scantoken.cpp @@ -37,7 +37,7 @@ void Scanner::ScanDirective() { token.value += INPUT.get(); // read parameters - while (1) { + while (true) { // first get rid of whitespace while (Exp::Blank().Matches(INPUT)) INPUT.eat(1); @@ -171,7 +171,7 @@ void Scanner::ScanBlockEntry() { // Key void Scanner::ScanKey() { - // handle keys diffently in the block context (and manage indents) + // handle keys differently in the block context (and manage indents) if (InBlockContext()) { if (!m_simpleKeyAllowed) throw ParserException(INPUT.mark(), ErrorMsg::MAP_KEY); @@ -199,7 +199,7 @@ void Scanner::ScanValue() { // seems fine) m_simpleKeyAllowed = false; } else { - // handle values diffently in the block context (and manage indents) + // handle values differently in the block context (and manage indents) if (InBlockContext()) { if (!m_simpleKeyAllowed) throw ParserException(INPUT.mark(), ErrorMsg::MAP_VALUE); @@ -338,7 +338,7 @@ void Scanner::ScanQuotedScalar() { // setup the scanning parameters ScanScalarParams params; - RegEx end = (single ? RegEx(quote) && !Exp::EscSingleQuote() : RegEx(quote)); + RegEx end = (single ? RegEx(quote) & !Exp::EscSingleQuote() : RegEx(quote)); params.end = &end; params.eatEnd = true; params.escape = (single ? '\'' : '\\'); @@ -434,4 +434,4 @@ void Scanner::ScanBlockScalar() { token.value = scalar; m_tokens.push(token); } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/setting.h b/src/libs/3rdparty/yaml-cpp/src/setting.h index b78d40e2e8..4960bbf75c 100644 --- a/src/libs/3rdparty/yaml-cpp/src/setting.h +++ b/src/libs/3rdparty/yaml-cpp/src/setting.h @@ -7,17 +7,24 @@ #pragma once #endif +#include "yaml-cpp/noexcept.h" #include <memory> +#include <utility> #include <vector> -#include "yaml-cpp/noncopyable.h" namespace YAML { -class SettingChangeBase; + +class SettingChangeBase { + public: + virtual ~SettingChangeBase() = default; + virtual void pop() = 0; +}; template <typename T> class Setting { public: Setting() : m_value() {} + Setting(const T& value) : m_value() { set(value); } const T get() const { return m_value; } std::unique_ptr<SettingChangeBase> set(const T& value); @@ -27,21 +34,19 @@ class Setting { T m_value; }; -class SettingChangeBase { - public: - virtual ~SettingChangeBase() {} - virtual void pop() = 0; -}; - template <typename T> class SettingChange : public SettingChangeBase { public: - SettingChange(Setting<T>* pSetting) : m_pCurSetting(pSetting) { - // copy old setting to save its state - m_oldSetting = *pSetting; - } + SettingChange(Setting<T>* pSetting) + : m_pCurSetting(pSetting), + m_oldSetting(*pSetting) // copy old setting to save its state + {} + SettingChange(const SettingChange&) = delete; + SettingChange(SettingChange&&) = delete; + SettingChange& operator=(const SettingChange&) = delete; + SettingChange& operator=(SettingChange&&) = delete; - virtual void pop() { m_pCurSetting->restore(m_oldSetting); } + void pop() override { m_pCurSetting->restore(m_oldSetting); } private: Setting<T>* m_pCurSetting; @@ -55,41 +60,41 @@ inline std::unique_ptr<SettingChangeBase> Setting<T>::set(const T& value) { return pChange; } -class SettingChanges : private noncopyable { +class SettingChanges { public: - SettingChanges() {} + SettingChanges() : m_settingChanges{} {} + SettingChanges(const SettingChanges&) = delete; + SettingChanges(SettingChanges&&) YAML_CPP_NOEXCEPT = default; + SettingChanges& operator=(const SettingChanges&) = delete; + SettingChanges& operator=(SettingChanges&& rhs) YAML_CPP_NOEXCEPT { + if (this == &rhs) + return *this; + + clear(); + std::swap(m_settingChanges, rhs.m_settingChanges); + + return *this; + } ~SettingChanges() { clear(); } - void clear() { + void clear() YAML_CPP_NOEXCEPT { restore(); m_settingChanges.clear(); } - void restore() { - for (setting_changes::const_iterator it = m_settingChanges.begin(); - it != m_settingChanges.end(); ++it) - (*it)->pop(); + void restore() YAML_CPP_NOEXCEPT { + for (const auto& setting : m_settingChanges) + setting->pop(); } void push(std::unique_ptr<SettingChangeBase> pSettingChange) { m_settingChanges.push_back(std::move(pSettingChange)); } - // like std::unique_ptr - assignment is transfer of ownership - SettingChanges& operator=(SettingChanges&& rhs) { - if (this == &rhs) - return *this; - - clear(); - std::swap(m_settingChanges, rhs.m_settingChanges); - - return *this; - } - private: - typedef std::vector<std::unique_ptr<SettingChangeBase>> setting_changes; + using setting_changes = std::vector<std::unique_ptr<SettingChangeBase>>; setting_changes m_settingChanges; }; -} +} // namespace YAML #endif // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/simplekey.cpp b/src/libs/3rdparty/yaml-cpp/src/simplekey.cpp index 70f56b6ae4..67c2d712ef 100644 --- a/src/libs/3rdparty/yaml-cpp/src/simplekey.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/simplekey.cpp @@ -5,7 +5,11 @@ namespace YAML { struct Mark; Scanner::SimpleKey::SimpleKey(const Mark& mark_, std::size_t flowLevel_) - : mark(mark_), flowLevel(flowLevel_), pIndent(0), pMapStart(0), pKey(0) {} + : mark(mark_), + flowLevel(flowLevel_), + pIndent(nullptr), + pMapStart(nullptr), + pKey(nullptr) {} void Scanner::SimpleKey::Validate() { // Note: pIndent will *not* be garbage here; @@ -125,4 +129,4 @@ void Scanner::PopAllSimpleKeys() { while (!m_simpleKeys.empty()) m_simpleKeys.pop(); } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/singledocparser.cpp b/src/libs/3rdparty/yaml-cpp/src/singledocparser.cpp index a27c1c3b04..22913d198c 100644 --- a/src/libs/3rdparty/yaml-cpp/src/singledocparser.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/singledocparser.cpp @@ -7,6 +7,7 @@ #include "singledocparser.h" #include "tag.h" #include "token.h" +#include "yaml-cpp/depthguard.h" #include "yaml-cpp/emitterstyle.h" #include "yaml-cpp/eventhandler.h" #include "yaml-cpp/exceptions.h" // IWYU pragma: keep @@ -18,9 +19,10 @@ SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives) : m_scanner(scanner), m_directives(directives), m_pCollectionStack(new CollectionStack), + m_anchors{}, m_curAnchor(0) {} -SingleDocParser::~SingleDocParser() {} +SingleDocParser::~SingleDocParser() = default; // HandleDocument // . Handles the next document @@ -46,6 +48,8 @@ void SingleDocParser::HandleDocument(EventHandler& eventHandler) { } void SingleDocParser::HandleNode(EventHandler& eventHandler) { + DepthGuard<500> depthguard(depth, m_scanner.mark(), ErrorMsg::BAD_FILE); + // an empty node *is* a possibility if (m_scanner.empty()) { eventHandler.OnNull(m_scanner.mark(), NullAnchor); @@ -71,20 +75,31 @@ void SingleDocParser::HandleNode(EventHandler& eventHandler) { } std::string tag; + std::string anchor_name; anchor_t anchor; - ParseProperties(tag, anchor); + ParseProperties(tag, anchor, anchor_name); - const Token& token = m_scanner.peek(); + if (!anchor_name.empty()) + eventHandler.OnAnchor(mark, anchor_name); - if (token.type == Token::PLAIN_SCALAR && IsNullString(token.value)) { + // after parsing properties, an empty node is again a possibility + if (m_scanner.empty()) { eventHandler.OnNull(mark, anchor); - m_scanner.pop(); return; } + const Token& token = m_scanner.peek(); + // add non-specific tags if (tag.empty()) tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?"); + + if (token.type == Token::PLAIN_SCALAR + && tag.compare("?") == 0 && IsNullString(token.value)) { + eventHandler.OnNull(mark, anchor); + m_scanner.pop(); + return; + } // now split based on what kind of node we should be switch (token.type) { @@ -152,7 +167,7 @@ void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) { m_scanner.pop(); m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq); - while (1) { + while (true) { if (m_scanner.empty()) throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ); @@ -166,10 +181,10 @@ void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) { // check for null if (!m_scanner.empty()) { - const Token& token = m_scanner.peek(); - if (token.type == Token::BLOCK_ENTRY || - token.type == Token::BLOCK_SEQ_END) { - eventHandler.OnNull(token.mark, NullAnchor); + const Token& nextToken = m_scanner.peek(); + if (nextToken.type == Token::BLOCK_ENTRY || + nextToken.type == Token::BLOCK_SEQ_END) { + eventHandler.OnNull(nextToken.mark, NullAnchor); continue; } } @@ -185,7 +200,7 @@ void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler) { m_scanner.pop(); m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq); - while (1) { + while (true) { if (m_scanner.empty()) throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW); @@ -238,7 +253,7 @@ void SingleDocParser::HandleBlockMap(EventHandler& eventHandler) { m_scanner.pop(); m_pCollectionStack->PushCollectionType(CollectionType::BlockMap); - while (1) { + while (true) { if (m_scanner.empty()) throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP); @@ -277,7 +292,7 @@ void SingleDocParser::HandleFlowMap(EventHandler& eventHandler) { m_scanner.pop(); m_pCollectionStack->PushCollectionType(CollectionType::FlowMap); - while (1) { + while (true) { if (m_scanner.empty()) throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW); @@ -356,11 +371,13 @@ void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler) { // ParseProperties // . Grabs any tag or anchor tokens and deals with them. -void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor) { +void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor, + std::string& anchor_name) { tag.clear(); + anchor_name.clear(); anchor = NullAnchor; - while (1) { + while (true) { if (m_scanner.empty()) return; @@ -369,7 +386,7 @@ void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor) { ParseTag(tag); break; case Token::ANCHOR: - ParseAnchor(anchor); + ParseAnchor(anchor, anchor_name); break; default: return; @@ -387,11 +404,12 @@ void SingleDocParser::ParseTag(std::string& tag) { m_scanner.pop(); } -void SingleDocParser::ParseAnchor(anchor_t& anchor) { +void SingleDocParser::ParseAnchor(anchor_t& anchor, std::string& anchor_name) { Token& token = m_scanner.peek(); if (anchor) throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS); + anchor_name = token.value; anchor = RegisterAnchor(token.value); m_scanner.pop(); } @@ -405,10 +423,13 @@ anchor_t SingleDocParser::RegisterAnchor(const std::string& name) { anchor_t SingleDocParser::LookupAnchor(const Mark& mark, const std::string& name) const { - Anchors::const_iterator it = m_anchors.find(name); - if (it == m_anchors.end()) - throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR); + auto it = m_anchors.find(name); + if (it == m_anchors.end()) { + std::stringstream ss; + ss << ErrorMsg::UNKNOWN_ANCHOR << name; + throw ParserException(mark, ss.str()); + } return it->second; } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/singledocparser.h b/src/libs/3rdparty/yaml-cpp/src/singledocparser.h index 2b92067cdd..f484eb1f95 100644 --- a/src/libs/3rdparty/yaml-cpp/src/singledocparser.h +++ b/src/libs/3rdparty/yaml-cpp/src/singledocparser.h @@ -12,10 +12,10 @@ #include <string> #include "yaml-cpp/anchor.h" -#include "yaml-cpp/noncopyable.h" namespace YAML { class CollectionStack; +template <int> class DepthGuard; // depthguard.h class EventHandler; class Node; class Scanner; @@ -23,9 +23,13 @@ struct Directives; struct Mark; struct Token; -class SingleDocParser : private noncopyable { +class SingleDocParser { public: SingleDocParser(Scanner& scanner, const Directives& directives); + SingleDocParser(const SingleDocParser&) = delete; + SingleDocParser(SingleDocParser&&) = delete; + SingleDocParser& operator=(const SingleDocParser&) = delete; + SingleDocParser& operator=(SingleDocParser&&) = delete; ~SingleDocParser(); void HandleDocument(EventHandler& eventHandler); @@ -43,23 +47,25 @@ class SingleDocParser : private noncopyable { void HandleCompactMap(EventHandler& eventHandler); void HandleCompactMapWithNoKey(EventHandler& eventHandler); - void ParseProperties(std::string& tag, anchor_t& anchor); + void ParseProperties(std::string& tag, anchor_t& anchor, + std::string& anchor_name); void ParseTag(std::string& tag); - void ParseAnchor(anchor_t& anchor); + void ParseAnchor(anchor_t& anchor, std::string& anchor_name); anchor_t RegisterAnchor(const std::string& name); anchor_t LookupAnchor(const Mark& mark, const std::string& name) const; private: + int depth = 0; Scanner& m_scanner; const Directives& m_directives; std::unique_ptr<CollectionStack> m_pCollectionStack; - typedef std::map<std::string, anchor_t> Anchors; + using Anchors = std::map<std::string, anchor_t>; Anchors m_anchors; anchor_t m_curAnchor; }; -} +} // namespace YAML #endif // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/stream.cpp b/src/libs/3rdparty/yaml-cpp/src/stream.cpp index 3b013cfa7d..b1aa092f69 100644 --- a/src/libs/3rdparty/yaml-cpp/src/stream.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/stream.cpp @@ -111,24 +111,15 @@ static UtfIntroState s_introTransitions[][uictMax] = { static char s_introUngetCount[][uictMax] = { // uict00, uictBB, uictBF, uictEF, uictFE, uictFF, uictAscii, uictOther - {0, 1, 1, 0, 0, 0, 0, 1}, - {0, 2, 2, 2, 2, 2, 2, 2}, - {3, 3, 3, 3, 0, 3, 3, 3}, - {4, 4, 4, 4, 4, 0, 4, 4}, - {1, 1, 1, 1, 1, 1, 1, 1}, - {1, 1, 1, 1, 1, 1, 1, 1}, - {2, 2, 2, 2, 2, 0, 2, 2}, - {2, 2, 2, 2, 0, 2, 2, 2}, - {0, 1, 1, 1, 1, 1, 1, 1}, - {0, 2, 2, 2, 2, 2, 2, 2}, - {1, 1, 1, 1, 1, 1, 1, 1}, - {1, 1, 1, 1, 1, 1, 1, 1}, - {0, 2, 2, 2, 2, 2, 2, 2}, - {0, 3, 3, 3, 3, 3, 3, 3}, - {4, 4, 4, 4, 4, 4, 4, 4}, - {2, 0, 2, 2, 2, 2, 2, 2}, - {3, 3, 0, 3, 3, 3, 3, 3}, - {1, 1, 1, 1, 1, 1, 1, 1}, + {0, 1, 1, 0, 0, 0, 0, 1}, {0, 2, 2, 2, 2, 2, 2, 2}, + {3, 3, 3, 3, 0, 3, 3, 3}, {4, 4, 4, 4, 4, 0, 4, 4}, + {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1}, + {2, 2, 2, 2, 2, 0, 2, 2}, {2, 2, 2, 2, 0, 2, 2, 2}, + {0, 1, 1, 1, 1, 1, 1, 1}, {0, 2, 2, 2, 2, 2, 2, 2}, + {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1}, + {0, 2, 2, 2, 2, 2, 2, 2}, {0, 3, 3, 3, 3, 3, 3, 3}, + {4, 4, 4, 4, 4, 4, 4, 4}, {2, 0, 2, 2, 2, 2, 2, 2}, + {3, 3, 0, 3, 3, 3, 3, 3}, {1, 1, 1, 1, 1, 1, 1, 1}, }; inline UtfIntroCharType IntroCharTypeOf(std::istream::int_type ch) { @@ -160,7 +151,8 @@ inline UtfIntroCharType IntroCharTypeOf(std::istream::int_type ch) { inline char Utf8Adjust(unsigned long ch, unsigned char lead_bits, unsigned char rshift) { - const unsigned char header = ((1 << lead_bits) - 1) << (8 - lead_bits); + const unsigned char header = + static_cast<unsigned char>(((1 << lead_bits) - 1) << (8 - lead_bits)); const unsigned char mask = (0xFF >> (lead_bits + 1)); return static_cast<char>( static_cast<unsigned char>(header | ((ch >> rshift) & mask))); @@ -192,17 +184,20 @@ inline void QueueUnicodeCodepoint(std::deque<char>& q, unsigned long ch) { Stream::Stream(std::istream& input) : m_input(input), + m_mark{}, + m_charSet{}, + m_readahead{}, m_pPrefetched(new unsigned char[YAML_PREFETCH_SIZE]), m_nPrefetchedAvailable(0), m_nPrefetchedUsed(0) { - typedef std::istream::traits_type char_traits; + using char_traits = std::istream::traits_type; if (!input) return; // Determine (or guess) the character-set by reading the BOM, if any. See // the YAML specification for the determination algorithm. - char_traits::int_type intro[4]; + char_traits::int_type intro[4]{}; int nIntroUsed = 0; UtfIntroState state = uis_start; for (; !s_introFinalState[state];) { @@ -279,9 +274,11 @@ char Stream::get() { // . Extracts 'n' characters from the stream and updates our position std::string Stream::get(int n) { std::string ret; - ret.reserve(n); - for (int i = 0; i < n; i++) - ret += get(); + if (n > 0) { + ret.reserve(static_cast<std::string::size_type>(n)); + for (int i = 0; i < n; i++) + ret += get(); + } return ret; } @@ -332,7 +329,7 @@ bool Stream::_ReadAheadTo(size_t i) const { void Stream::StreamInUtf8() const { unsigned char b = GetNextByte(); if (m_input.good()) { - m_readahead.push_back(b); + m_readahead.push_back(static_cast<char>(b)); } } @@ -353,7 +350,9 @@ void Stream::StreamInUtf16() const { // Trailing (low) surrogate...ugh, wrong order QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); return; - } else if (ch >= 0xD800 && ch < 0xDC00) { + } + + if (ch >= 0xD800 && ch < 0xDC00) { // ch is a leading (high) surrogate // Four byte UTF-8 code point @@ -378,11 +377,10 @@ void Stream::StreamInUtf16() const { // Easiest case: queue the codepoint and return QueueUnicodeCodepoint(m_readahead, ch); return; - } else { - // Start the loop over with the new high surrogate - ch = chLow; - continue; } + // Start the loop over with the new high surrogate + ch = chLow; + continue; } // Select the payload bits from the high surrogate @@ -445,4 +443,4 @@ void Stream::StreamInUtf32() const { QueueUnicodeCodepoint(m_readahead, ch); } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/stream.h b/src/libs/3rdparty/yaml-cpp/src/stream.h index 42d542d5b1..2bc7a15216 100644 --- a/src/libs/3rdparty/yaml-cpp/src/stream.h +++ b/src/libs/3rdparty/yaml-cpp/src/stream.h @@ -7,7 +7,6 @@ #pragma once #endif -#include "yaml-cpp/noncopyable.h" #include "yaml-cpp/mark.h" #include <cstddef> #include <deque> @@ -17,11 +16,18 @@ #include <string> namespace YAML { -class Stream : private noncopyable { + +class StreamCharSource; + +class Stream { public: friend class StreamCharSource; Stream(std::istream& input); + Stream(const Stream&) = delete; + Stream(Stream&&) = delete; + Stream& operator=(const Stream&) = delete; + Stream& operator=(Stream&&) = delete; ~Stream(); operator bool() const; @@ -71,6 +77,6 @@ inline bool Stream::ReadAheadTo(size_t i) const { return true; return _ReadAheadTo(i); } -} +} // namespace YAML #endif // STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/streamcharsource.h b/src/libs/3rdparty/yaml-cpp/src/streamcharsource.h index 624599e65d..826ba5347e 100644 --- a/src/libs/3rdparty/yaml-cpp/src/streamcharsource.h +++ b/src/libs/3rdparty/yaml-cpp/src/streamcharsource.h @@ -7,16 +7,20 @@ #pragma once #endif -#include "yaml-cpp/noncopyable.h" +#include "yaml-cpp/noexcept.h" +#include "stream.h" #include <cstddef> namespace YAML { + class StreamCharSource { public: StreamCharSource(const Stream& stream) : m_offset(0), m_stream(stream) {} - StreamCharSource(const StreamCharSource& source) - : m_offset(source.m_offset), m_stream(source.m_stream) {} - ~StreamCharSource() {} + StreamCharSource(const StreamCharSource& source) = default; + StreamCharSource(StreamCharSource&&) YAML_CPP_NOEXCEPT = default; + StreamCharSource& operator=(const StreamCharSource&) = delete; + StreamCharSource& operator=(StreamCharSource&&) = delete; + ~StreamCharSource() = default; operator bool() const; char operator[](std::size_t i) const { return m_stream.CharAt(m_offset + i); } @@ -27,8 +31,6 @@ class StreamCharSource { private: std::size_t m_offset; const Stream& m_stream; - - StreamCharSource& operator=(const StreamCharSource&); // non-assignable }; inline StreamCharSource::operator bool() const { @@ -38,11 +40,11 @@ inline StreamCharSource::operator bool() const { inline const StreamCharSource StreamCharSource::operator+(int i) const { StreamCharSource source(*this); if (static_cast<int>(source.m_offset) + i >= 0) - source.m_offset += i; + source.m_offset += static_cast<std::size_t>(i); else source.m_offset = 0; return source; } -} +} // namespace YAML #endif // STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/src/libs/3rdparty/yaml-cpp/src/tag.cpp b/src/libs/3rdparty/yaml-cpp/src/tag.cpp index 51435520e4..35a1b46560 100644 --- a/src/libs/3rdparty/yaml-cpp/src/tag.cpp +++ b/src/libs/3rdparty/yaml-cpp/src/tag.cpp @@ -6,7 +6,8 @@ #include "token.h" namespace YAML { -Tag::Tag(const Token& token) : type(static_cast<TYPE>(token.data)) { +Tag::Tag(const Token& token) + : type(static_cast<TYPE>(token.data)), handle{}, value{} { switch (type) { case VERBATIM: value = token.value; @@ -28,7 +29,7 @@ Tag::Tag(const Token& token) : type(static_cast<TYPE>(token.data)) { } } -const std::string Tag::Translate(const Directives& directives) { +std::string Tag::Translate(const Directives& directives) { switch (type) { case VERBATIM: return value; @@ -46,4 +47,4 @@ const std::string Tag::Translate(const Directives& directives) { } throw std::runtime_error("yaml-cpp: internal error, bad tag type"); } -} +} // namespace YAML diff --git a/src/libs/3rdparty/yaml-cpp/src/tag.h b/src/libs/3rdparty/yaml-cpp/src/tag.h index ac30673b9e..c811f39559 100644 --- a/src/libs/3rdparty/yaml-cpp/src/tag.h +++ b/src/libs/3rdparty/yaml-cpp/src/tag.h @@ -23,7 +23,7 @@ struct Tag { }; Tag(const Token& token); - const std::string Translate(const Directives& directives); + std::string Translate(const Directives& directives); TYPE type; std::string handle, value; diff --git a/src/libs/3rdparty/yaml-cpp/src/token.h b/src/libs/3rdparty/yaml-cpp/src/token.h index ad0b7d0a00..9c9a5b7798 100644 --- a/src/libs/3rdparty/yaml-cpp/src/token.h +++ b/src/libs/3rdparty/yaml-cpp/src/token.h @@ -14,10 +14,11 @@ namespace YAML { const std::string TokenNames[] = { - "DIRECTIVE", "DOC_START", "DOC_END", "BLOCK_SEQ_START", "BLOCK_MAP_START", - "BLOCK_SEQ_END", "BLOCK_MAP_END", "BLOCK_ENTRY", "FLOW_SEQ_START", - "FLOW_MAP_START", "FLOW_SEQ_END", "FLOW_MAP_END", "FLOW_MAP_COMPACT", - "FLOW_ENTRY", "KEY", "VALUE", "ANCHOR", "ALIAS", "TAG", "SCALAR"}; + "DIRECTIVE", "DOC_START", "DOC_END", "BLOCK_SEQ_START", + "BLOCK_MAP_START", "BLOCK_SEQ_END", "BLOCK_MAP_END", "BLOCK_ENTRY", + "FLOW_SEQ_START", "FLOW_MAP_START", "FLOW_SEQ_END", "FLOW_MAP_END", + "FLOW_MAP_COMPACT", "FLOW_ENTRY", "KEY", "VALUE", + "ANCHOR", "ALIAS", "TAG", "SCALAR"}; struct Token { // enums @@ -48,12 +49,12 @@ struct Token { // data Token(TYPE type_, const Mark& mark_) - : status(VALID), type(type_), mark(mark_), data(0) {} + : status(VALID), type(type_), mark(mark_), value{}, params{}, data(0) {} friend std::ostream& operator<<(std::ostream& out, const Token& token) { out << TokenNames[token.type] << std::string(": ") << token.value; - for (std::size_t i = 0; i < token.params.size(); i++) - out << std::string(" ") << token.params[i]; + for (const std::string& param : token.params) + out << std::string(" ") << param; return out; } @@ -64,6 +65,6 @@ struct Token { std::vector<std::string> params; int data; }; -} +} // namespace YAML #endif // TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 |