docs: Fix link in README

Update README.md
Bump the release note to the latest version
2026-07-27 14:13:42 -07:00 · 2025-03-13 14:45:33 -05:00 · 2025-01-24 16:01:30 -06:00 · 2024-12-30 11:27:02 -06:00 · 2024-12-22 16:22:38 -06:00 · 2024-12-22 16:16:07 -06:00
30 changed files with 4988 additions and 88 deletions
@@ -20,6 +20,9 @@ jobs:
          googletest: [build, system]
          generator: ["Default Generator", "MinGW Makefiles"]
          exclude:
+          - os: ubuntu-latest
+            cxx_standard: 11
+            googletest: system
          - os: macos-latest
            build: shared
          - os: macos-latest
@@ -17,9 +17,9 @@ Commit messages should be in the imperative mood, as described in the [Git contr

 # Tests

-Please verify the tests pass by running the target `test/yaml-cpp-tests`.
+Please verify the tests pass by configuring CMake with `-D YAML_CPP_BUILD_TESTS=ON` and running the target `test/yaml-cpp-tests`.

-If you are adding functionality, add tests accordingly.
+If you are adding functionality, add tests accordingly. Note that the "spec tests" are reserved for examples directly from the YAML spec, so if you have new examples, put them in other test files.

 # Pull request process

@@ -0,0 +1,114 @@
+{
+  "lockFileVersion": 11,
+  "registryFileHashes": {
+    "https://bcr.bazel.build/bazel_registry.json": "8a28e4aff06ee60aed2a8c281907fb8bcbf3b753c91fb5a5c57da3215d5b3497",
+    "https://bcr.bazel.build/modules/abseil-cpp/20210324.2/MODULE.bazel": "7cd0312e064fde87c8d1cd79ba06c876bd23630c83466e9500321be55c96ace2",
+    "https://bcr.bazel.build/modules/abseil-cpp/20211102.0/MODULE.bazel": "70390338f7a5106231d20620712f7cccb659cd0e9d073d1991c038eb9fc57589",
+    "https://bcr.bazel.build/modules/abseil-cpp/20230125.1/MODULE.bazel": "89047429cb0207707b2dface14ba7f8df85273d484c2572755be4bab7ce9c3a0",
+    "https://bcr.bazel.build/modules/abseil-cpp/20230125.1/source.json": "06cc0842d241da0c5edc755edb3c7d0d008d304330e57ecf2d6449fb0b633a82",
+    "https://bcr.bazel.build/modules/apple_support/1.5.0/MODULE.bazel": "50341a62efbc483e8a2a6aec30994a58749bd7b885e18dd96aa8c33031e558ef",
+    "https://bcr.bazel.build/modules/apple_support/1.5.0/source.json": "eb98a7627c0bc486b57f598ad8da50f6625d974c8f723e9ea71bd39f709c9862",
+    "https://bcr.bazel.build/modules/bazel_features/1.11.0/MODULE.bazel": "f9382337dd5a474c3b7d334c2f83e50b6eaedc284253334cf823044a26de03e8",
+    "https://bcr.bazel.build/modules/bazel_features/1.11.0/source.json": "c9320aa53cd1c441d24bd6b716da087ad7e4ff0d9742a9884587596edfe53015",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.0.3/MODULE.bazel": "bcb0fd896384802d1ad283b4e4eb4d718eebd8cb820b0a2c3a347fb971afd9d8",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.2.1/MODULE.bazel": "f35baf9da0efe45fa3da1696ae906eea3d615ad41e2e3def4aeb4e8bc0ef9a7a",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.3.0/MODULE.bazel": "20228b92868bf5cfc41bda7afc8a8ba2a543201851de39d990ec957b513579c5",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.4.1/MODULE.bazel": "a0dcb779424be33100dcae821e9e27e4f2901d9dfd5333efe5ac6a8d7ab75e1d",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.6.1/MODULE.bazel": "8fdee2dbaace6c252131c00e1de4b165dc65af02ea278476187765e1a617b917",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.6.1/source.json": "082ed5f9837901fada8c68c2f3ddc958bb22b6d654f71dd73f3df30d45d4b749",
+    "https://bcr.bazel.build/modules/buildozer/7.1.2/MODULE.bazel": "2e8dd40ede9c454042645fd8d8d0cd1527966aa5c919de86661e62953cd73d84",
+    "https://bcr.bazel.build/modules/buildozer/7.1.2/source.json": "c9028a501d2db85793a6996205c8de120944f50a0d570438fcae0457a5f9d1f8",
+    "https://bcr.bazel.build/modules/googletest/1.11.0/MODULE.bazel": "3a83f095183f66345ca86aa13c58b59f9f94a2f81999c093d4eeaa2d262d12f4",
+    "https://bcr.bazel.build/modules/googletest/1.14.0/MODULE.bazel": "cfbcbf3e6eac06ef9d85900f64424708cc08687d1b527f0ef65aa7517af8118f",
+    "https://bcr.bazel.build/modules/googletest/1.14.0/source.json": "2478949479000fdd7de9a3d0107ba2c85bb5f961c3ecb1aa448f52549ce310b5",
+    "https://bcr.bazel.build/modules/platforms/0.0.4/MODULE.bazel": "9b328e31ee156f53f3c416a64f8491f7eb731742655a47c9eec4703a71644aee",
+    "https://bcr.bazel.build/modules/platforms/0.0.5/MODULE.bazel": "5733b54ea419d5eaf7997054bb55f6a1d0b5ff8aedf0176fef9eea44f3acda37",
+    "https://bcr.bazel.build/modules/platforms/0.0.6/MODULE.bazel": "ad6eeef431dc52aefd2d77ed20a4b353f8ebf0f4ecdd26a807d2da5aa8cd0615",
+    "https://bcr.bazel.build/modules/platforms/0.0.7/MODULE.bazel": "72fd4a0ede9ee5c021f6a8dd92b503e089f46c227ba2813ff183b71616034814",
+    "https://bcr.bazel.build/modules/platforms/0.0.9/MODULE.bazel": "4a87a60c927b56ddd67db50c89acaa62f4ce2a1d2149ccb63ffd871d5ce29ebc",
+    "https://bcr.bazel.build/modules/platforms/0.0.9/source.json": "cd74d854bf16a9e002fb2ca7b1a421f4403cda29f824a765acd3a8c56f8d43e6",
+    "https://bcr.bazel.build/modules/protobuf/21.7/MODULE.bazel": "a5a29bb89544f9b97edce05642fac225a808b5b7be74038ea3640fae2f8e66a7",
+    "https://bcr.bazel.build/modules/protobuf/21.7/source.json": "bbe500720421e582ff2d18b0802464205138c06056f443184de39fbb8187b09b",
+    "https://bcr.bazel.build/modules/protobuf/3.19.0/MODULE.bazel": "6b5fbb433f760a99a22b18b6850ed5784ef0e9928a72668b66e4d7ccd47db9b0",
+    "https://bcr.bazel.build/modules/protobuf/3.19.6/MODULE.bazel": "9233edc5e1f2ee276a60de3eaa47ac4132302ef9643238f23128fea53ea12858",
+    "https://bcr.bazel.build/modules/rules_cc/0.0.1/MODULE.bazel": "cb2aa0747f84c6c3a78dad4e2049c154f08ab9d166b1273835a8174940365647",
+    "https://bcr.bazel.build/modules/rules_cc/0.0.2/MODULE.bazel": "6915987c90970493ab97393024c156ea8fb9f3bea953b2f3ec05c34f19b5695c",
+    "https://bcr.bazel.build/modules/rules_cc/0.0.6/MODULE.bazel": "abf360251023dfe3efcef65ab9d56beefa8394d4176dd29529750e1c57eaa33f",
+    "https://bcr.bazel.build/modules/rules_cc/0.0.8/MODULE.bazel": "964c85c82cfeb6f3855e6a07054fdb159aced38e99a5eecf7bce9d53990afa3e",
+    "https://bcr.bazel.build/modules/rules_cc/0.0.9/MODULE.bazel": "836e76439f354b89afe6a911a7adf59a6b2518fafb174483ad78a2a2fde7b1c5",
+    "https://bcr.bazel.build/modules/rules_cc/0.0.9/source.json": "1f1ba6fea244b616de4a554a0f4983c91a9301640c8fe0dd1d410254115c8430",
+    "https://bcr.bazel.build/modules/rules_java/4.0.0/MODULE.bazel": "5a78a7ae82cd1a33cef56dc578c7d2a46ed0dca12643ee45edbb8417899e6f74",
+    "https://bcr.bazel.build/modules/rules_java/7.6.5/MODULE.bazel": "481164be5e02e4cab6e77a36927683263be56b7e36fef918b458d7a8a1ebadb1",
+    "https://bcr.bazel.build/modules/rules_java/7.6.5/source.json": "a805b889531d1690e3c72a7a7e47a870d00323186a9904b36af83aa3d053ee8d",
+    "https://bcr.bazel.build/modules/rules_jvm_external/4.4.2/MODULE.bazel": "a56b85e418c83eb1839819f0b515c431010160383306d13ec21959ac412d2fe7",
+    "https://bcr.bazel.build/modules/rules_jvm_external/4.4.2/source.json": "a075731e1b46bc8425098512d038d416e966ab19684a10a34f4741295642fc35",
+    "https://bcr.bazel.build/modules/rules_license/0.0.3/MODULE.bazel": "627e9ab0247f7d1e05736b59dbb1b6871373de5ad31c3011880b4133cafd4bd0",
+    "https://bcr.bazel.build/modules/rules_license/0.0.7/MODULE.bazel": "088fbeb0b6a419005b89cf93fe62d9517c0a2b8bb56af3244af65ecfe37e7d5d",
+    "https://bcr.bazel.build/modules/rules_license/0.0.7/source.json": "355cc5737a0f294e560d52b1b7a6492d4fff2caf0bef1a315df5a298fca2d34a",
+    "https://bcr.bazel.build/modules/rules_pkg/0.7.0/MODULE.bazel": "df99f03fc7934a4737122518bb87e667e62d780b610910f0447665a7e2be62dc",
+    "https://bcr.bazel.build/modules/rules_pkg/0.7.0/source.json": "c2557066e0c0342223ba592510ad3d812d4963b9024831f7f66fd0584dd8c66c",
+    "https://bcr.bazel.build/modules/rules_proto/4.0.0/MODULE.bazel": "a7a7b6ce9bee418c1a760b3d84f83a299ad6952f9903c67f19e4edd964894e06",
+    "https://bcr.bazel.build/modules/rules_proto/5.3.0-21.7/MODULE.bazel": "e8dff86b0971688790ae75528fe1813f71809b5afd57facb44dad9e8eca631b7",
+    "https://bcr.bazel.build/modules/rules_proto/5.3.0-21.7/source.json": "d57902c052424dfda0e71646cb12668d39c4620ee0544294d9d941e7d12bc3a9",
+    "https://bcr.bazel.build/modules/rules_python/0.10.2/MODULE.bazel": "cc82bc96f2997baa545ab3ce73f196d040ffb8756fd2d66125a530031cd90e5f",
+    "https://bcr.bazel.build/modules/rules_python/0.22.1/MODULE.bazel": "26114f0c0b5e93018c0c066d6673f1a2c3737c7e90af95eff30cfee38d0bbac7",
+    "https://bcr.bazel.build/modules/rules_python/0.22.1/source.json": "57226905e783bae7c37c2dd662be078728e48fa28ee4324a7eabcafb5a43d014",
+    "https://bcr.bazel.build/modules/rules_python/0.4.0/MODULE.bazel": "9208ee05fd48bf09ac60ed269791cf17fb343db56c8226a720fbb1cdf467166c",
+    "https://bcr.bazel.build/modules/stardoc/0.5.1/MODULE.bazel": "1a05d92974d0c122f5ccf09291442580317cdd859f07a8655f1db9a60374f9f8",
+    "https://bcr.bazel.build/modules/stardoc/0.5.1/source.json": "a96f95e02123320aa015b956f29c00cb818fa891ef823d55148e1a362caacf29",
+    "https://bcr.bazel.build/modules/upb/0.0.0-20220923-a547704/MODULE.bazel": "7298990c00040a0e2f121f6c32544bab27d4452f80d9ce51349b1a28f3005c43",
+    "https://bcr.bazel.build/modules/upb/0.0.0-20220923-a547704/source.json": "f1ef7d3f9e0e26d4b23d1c39b5f5de71f584dd7d1b4ef83d9bbba6ec7a6a6459",
+    "https://bcr.bazel.build/modules/zlib/1.2.11/MODULE.bazel": "07b389abc85fdbca459b69e2ec656ae5622873af3f845e1c9d80fe179f3effa0",
+    "https://bcr.bazel.build/modules/zlib/1.2.12/MODULE.bazel": "3b1a8834ada2a883674be8cbd36ede1b6ec481477ada359cd2d3ddc562340b27",
+    "https://bcr.bazel.build/modules/zlib/1.3.1.bcr.3/MODULE.bazel": "af322bc08976524477c79d1e45e241b6efbeb918c497e8840b8ab116802dda79",
+    "https://bcr.bazel.build/modules/zlib/1.3.1.bcr.3/source.json": "2be409ac3c7601245958cd4fcdff4288be79ed23bd690b4b951f500d54ee6e7d"
+  },
+  "selectedYankedVersions": {},
+  "moduleExtensions": {
+    "@@apple_support~//crosstool:setup.bzl%apple_cc_configure_extension": {
+      "general": {
+        "bzlTransitiveDigest": "PjIds3feoYE8SGbbIq2SFTZy3zmxeO2tQevJZNDo7iY=",
+        "usagesDigest": "+hz7IHWN6A1oVJJWNDB6yZRG+RYhF76wAYItpAeIUIg=",
+        "recordedFileInputs": {},
+        "recordedDirentsInputs": {},
+        "envVariables": {},
+        "generatedRepoSpecs": {
+          "local_config_apple_cc_toolchains": {
+            "bzlFile": "@@apple_support~//crosstool:setup.bzl",
+            "ruleClassName": "_apple_cc_autoconf_toolchains",
+            "attributes": {}
+          },
+          "local_config_apple_cc": {
+            "bzlFile": "@@apple_support~//crosstool:setup.bzl",
+            "ruleClassName": "_apple_cc_autoconf",
+            "attributes": {}
+          }
+        },
+        "recordedRepoMappingEntries": [
+          [
+            "apple_support~",
+            "bazel_tools",
+            "bazel_tools"
+          ]
+        ]
+      }
+    },
+    "@@platforms//host:extension.bzl%host_platform": {
+      "general": {
+        "bzlTransitiveDigest": "xelQcPZH8+tmuOHVjL9vDxMnnQNMlwj0SlvgoqBkm4U=",
+        "usagesDigest": "pCYpDQmqMbmiiPI1p2Kd3VLm5T48rRAht5WdW0X2GlA=",
+        "recordedFileInputs": {},
+        "recordedDirentsInputs": {},
+        "envVariables": {},
+        "generatedRepoSpecs": {
+          "host_platform": {
+            "bzlFile": "@@platforms//host:extension.bzl",
+            "ruleClassName": "host_platform_repo",
+            "attributes": {}
+          }
+        },
+        "recordedRepoMappingEntries": []
+      }
+    }
+  }
+}
@@ -68,11 +68,11 @@ target_link_libraries(YOUR_LIBRARY PUBLIC yaml-cpp::yaml-cpp) # The library or e

 ## Recent Releases

-[yaml-cpp 0.6.0](https://github.com/jbeder/yaml-cpp/releases/tag/yaml-cpp-0.6.0) released! This release requires C++11, and no longer depends on Boost.
+[yaml-cpp 0.8.0](https://github.com/jbeder/yaml-cpp/releases/tag/0.8.0) released!

 [yaml-cpp 0.3.0](https://github.com/jbeder/yaml-cpp/releases/tag/release-0.3.0) is still available if you want the old API.

-**The old API will continue to be supported, and will still receive bugfixes!** The 0.3.x and 0.4.x versions will be old API releases, and 0.5.x and above will all be new API releases.
+**The old API will stop receiving bugfixes in 2026.** The 0.3.x versions provide the old API, and 0.5.x and above all provide the new API.

 # API Documentation 

@@ -1,10 +0,0 @@
-workspace(name = "com_github_jbeder_yaml_cpp")
-
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
-
-http_archive(
-    name = "com_google_googletest",
-    strip_prefix = "googletest-release-1.8.1",
-    url = "https://github.com/google/googletest/archive/release-1.8.1.tar.gz",
-    sha256 = "9bf1fe5182a604b4135edc1a425ae356c9ad15e9b23f9f12a02e80184c3a249c",
-)
@@ -9,18 +9,24 @@

 #include <cmath>
 #include <cstddef>
+#include <cstring>
 #include <limits>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <type_traits>

+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+#include <string_view>
+#endif
+
 #include "yaml-cpp/binary.h"
 #include "yaml-cpp/dll.h"
 #include "yaml-cpp/emitterdef.h"
 #include "yaml-cpp/emittermanip.h"
 #include "yaml-cpp/null.h"
 #include "yaml-cpp/ostream_wrapper.h"
+#include "yaml-cpp/fptostring.h"

 namespace YAML {
 class Binary;
@@ -67,6 +73,7 @@ class YAML_CPP_API Emitter {
  Emitter& SetLocalPrecision(const _Precision& precision);

  // overloads of write
+  Emitter& Write(const char* str, std::size_t size);
  Emitter& Write(const std::string& str);
  Emitter& Write(bool b);
  Emitter& Write(char ch);
@@ -180,7 +187,7 @@ inline Emitter& Emitter::WriteStreamable(T value) {
  }

  if (!special) {
-    stream << value;
+    stream << FpToString(value, stream.precision());
  }
  m_stream << stream.str();

@@ -200,8 +207,13 @@ inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) {
 }

 // overloads of insertion
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+inline Emitter& operator<<(Emitter& emitter, const std::string_view& v) {
+  return emitter.Write(v.data(), v.size());
+}
+#endif
 inline Emitter& operator<<(Emitter& emitter, const std::string& v) {
-  return emitter.Write(v);
+  return emitter.Write(v.data(), v.size());
 }
 inline Emitter& operator<<(Emitter& emitter, bool v) {
  return emitter.Write(v);
@@ -232,7 +244,7 @@ inline Emitter& operator<<(Emitter& emitter, const Binary& b) {
 }

 inline Emitter& operator<<(Emitter& emitter, const char* v) {
-  return emitter.Write(std::string(v));
+  return emitter.Write(v, std::strlen(v));
 }

 inline Emitter& operator<<(Emitter& emitter, int v) {
@@ -0,0 +1,15 @@
+#ifndef YAML_H_FPTOSTRING
+#define YAML_H_FPTOSTRING
+
+#include "yaml-cpp/dll.h"
+
+#include <string>
+
+namespace YAML {
+// "precision = 0" refers to shortest known unique representation of the value
+YAML_CPP_API std::string FpToString(float v, size_t precision = 0);
+YAML_CPP_API std::string FpToString(double v, size_t precision = 0);
+YAML_CPP_API std::string FpToString(long double v, size_t precision = 0);
+}
+
+#endif
@@ -28,6 +28,7 @@
 #include "yaml-cpp/node/node.h"
 #include "yaml-cpp/node/type.h"
 #include "yaml-cpp/null.h"
+#include "yaml-cpp/fptostring.h"


 namespace YAML {
@@ -129,7 +130,7 @@ inner_encode(const T& rhs, std::stringstream& stream){
      stream << ".inf";
    }
  } else {
-    stream << rhs;
+    stream << FpToString(rhs, stream.precision());
  }
 }

@@ -8,7 +8,7 @@
 #endif

 #include "yaml-cpp/dll.h"
-#include <string>
+#include <cstddef>

 namespace YAML {
 class Node;
@@ -18,7 +18,7 @@ inline bool operator==(const _Null&, const _Null&) { return true; }
 inline bool operator!=(const _Null&, const _Null&) { return false; }

 YAML_CPP_API bool IsNull(const Node& node);  // old API only
-YAML_CPP_API bool IsNullString(const std::string& str);
+YAML_CPP_API bool IsNullString(const char* str, std::size_t size);

 extern YAML_CPP_API _Null Null;
 }
@@ -116,8 +116,13 @@ void EmitFromEvents::BeginNode() {
 }

 void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) {
-  if (!tag.empty() && tag != "?" && tag != "!")
-    m_emitter << VerbatimTag(tag);
+  if (!tag.empty() && tag != "?" && tag != "!"){
+      if (tag[0] == '!') {
+        m_emitter << LocalTag(std::string(tag.begin()+1, tag.end()));
+      } else {
+        m_emitter << VerbatimTag(tag);
+      }
+  }
  if (anchor)
    m_emitter << Anchor(ToString(anchor));
 }
@@ -716,33 +716,33 @@ StringEscaping::value GetStringEscapingStyle(const EMITTER_MANIP emitterManip) {
  }
 }

-Emitter& Emitter::Write(const std::string& str) {
+Emitter& Emitter::Write(const char* str, std::size_t size) {
  if (!good())
    return *this;

  StringEscaping::value stringEscaping = GetStringEscapingStyle(m_pState->GetOutputCharset());

  const StringFormat::value strFormat =
-      Utils::ComputeStringFormat(str, m_pState->GetStringFormat(),
+      Utils::ComputeStringFormat(str, size, m_pState->GetStringFormat(),
                                 m_pState->CurGroupFlowType(), stringEscaping == StringEscaping::NonAscii);

-  if (strFormat == StringFormat::Literal || str.size() > 1024)
+  if (strFormat == StringFormat::Literal || size > 1024)
    m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local);

  PrepareNode(EmitterNodeType::Scalar);

  switch (strFormat) {
    case StringFormat::Plain:
-      m_stream << str;
+      m_stream.write(str, size);
      break;
    case StringFormat::SingleQuoted:
-      Utils::WriteSingleQuotedString(m_stream, str);
+      Utils::WriteSingleQuotedString(m_stream, str, size);
      break;
    case StringFormat::DoubleQuoted:
-      Utils::WriteDoubleQuotedString(m_stream, str, stringEscaping);
+      Utils::WriteDoubleQuotedString(m_stream, str, size, stringEscaping);
      break;
    case StringFormat::Literal:
-      Utils::WriteLiteralString(m_stream, str,
+      Utils::WriteLiteralString(m_stream, str, size,
                                m_pState->CurIndent() + m_pState->GetIndent());
      break;
  }
@@ -752,6 +752,10 @@ Emitter& Emitter::Write(const std::string& str) {
  return *this;
 }

+Emitter& Emitter::Write(const std::string& str) {
+  return Write(str.data(), str.size());
+}
+
 std::size_t Emitter::GetFloatPrecision() const {
  return m_pState->GetFloatPrecision();
 }
@@ -865,7 +869,7 @@ Emitter& Emitter::Write(const _Alias& alias) {

  PrepareNode(EmitterNodeType::Scalar);

-  if (!Utils::WriteAlias(m_stream, alias.content)) {
+  if (!Utils::WriteAlias(m_stream, alias.content.data(), alias.content.size())) {
    m_pState->SetError(ErrorMsg::INVALID_ALIAS);
    return *this;
  }
@@ -888,7 +892,7 @@ Emitter& Emitter::Write(const _Anchor& anchor) {

  PrepareNode(EmitterNodeType::Property);

-  if (!Utils::WriteAnchor(m_stream, anchor.content)) {
+  if (!Utils::WriteAnchor(m_stream, anchor.content.data(), anchor.content.size())) {
    m_pState->SetError(ErrorMsg::INVALID_ANCHOR);
    return *this;
  }
@@ -937,7 +941,7 @@ Emitter& Emitter::Write(const _Comment& comment) {

  if (m_stream.col() > 0)
    m_stream << Indentation(m_pState->GetPreCommentIndent());
-  Utils::WriteComment(m_stream, comment.content,
+  Utils::WriteComment(m_stream, comment.content.data(), comment.content.size(),
                      m_pState->GetPostCommentIndent());

  m_pState->SetNonContent();
@@ -89,8 +89,8 @@ int Utf8BytesIndicated(char ch) {
 bool IsTrailingByte(char ch) { return (ch & 0xC0) == 0x80; }

 bool GetNextCodePointAndAdvance(int& codePoint,
-                                std::string::const_iterator& first,
-                                std::string::const_iterator last) {
+                                const char*& first,
+                                const char* last) {
  if (first == last)
    return false;

@@ -153,23 +153,23 @@ void WriteCodePoint(ostream_wrapper& out, int codePoint) {
  }
 }

-bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
+bool IsValidPlainScalar(const char* str, std::size_t size, FlowType::value flowType,
                        bool allowOnlyAscii) {
  // check against null
-  if (IsNullString(str)) {
+  if (IsNullString(str, size)) {
    return false;
  }

  // check the start
  const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow()
                                                   : Exp::PlainScalar());
-  if (!start.Matches(str)) {
+  if (!start.Matches(StringCharSource(str, size))) {
    return false;
  }

  // and check the end for plain whitespace (which can't be faithfully kept in a
  // plain scalar)
-  if (!str.empty() && *str.rbegin() == ' ') {
+  if (size != 0 && str[size - 1] == ' ') {
    return false;
  }

@@ -185,7 +185,7 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
  const RegEx& disallowed =
      flowType == FlowType::Flow ? disallowed_flow : disallowed_block;

-  StringCharSource buffer(str.c_str(), str.size());
+  StringCharSource buffer(str, size);
  while (buffer) {
    if (disallowed.Matches(buffer)) {
      return false;
@@ -199,22 +199,22 @@ bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
  return true;
 }

-bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) {
+bool IsValidSingleQuotedScalar(const char* str, std::size_t size, bool escapeNonAscii) {
  // TODO: check for non-printable characters?
-  return std::none_of(str.begin(), str.end(), [=](char ch) {
+  return std::none_of(str, str + size, [=](char ch) {
    return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) ||
           (ch == '\n');
  });
 }

-bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
+bool IsValidLiteralScalar(const char* str, std::size_t size, FlowType::value flowType,
                          bool escapeNonAscii) {
  if (flowType == FlowType::Flow) {
    return false;
  }

  // TODO: check for non-printable characters?
-  return std::none_of(str.begin(), str.end(), [=](char ch) {
+  return std::none_of(str, str + size, [=](char ch) {
    return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch)));
  });
 }
@@ -254,10 +254,10 @@ void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint, StringE
    out << hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF];
 }

-bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
+bool WriteAliasName(ostream_wrapper& out, const char* str, std::size_t size) {
  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+  for (const char* i = str;
+       GetNextCodePointAndAdvance(codePoint, i, str + size);) {
    if (!IsAnchorChar(codePoint)) {
      return false;
    }
@@ -268,25 +268,25 @@ bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
 }
 }  // namespace

-StringFormat::value ComputeStringFormat(const std::string& str,
+StringFormat::value ComputeStringFormat(const char* str, std::size_t size,
                                        EMITTER_MANIP strFormat,
                                        FlowType::value flowType,
                                        bool escapeNonAscii) {
  switch (strFormat) {
    case Auto:
-      if (IsValidPlainScalar(str, flowType, escapeNonAscii)) {
+      if (IsValidPlainScalar(str, size, flowType, escapeNonAscii)) {
        return StringFormat::Plain;
      }
      return StringFormat::DoubleQuoted;
    case SingleQuoted:
-      if (IsValidSingleQuotedScalar(str, escapeNonAscii)) {
+      if (IsValidSingleQuotedScalar(str, size, escapeNonAscii)) {
        return StringFormat::SingleQuoted;
      }
      return StringFormat::DoubleQuoted;
    case DoubleQuoted:
      return StringFormat::DoubleQuoted;
    case Literal:
-      if (IsValidLiteralScalar(str, flowType, escapeNonAscii)) {
+      if (IsValidLiteralScalar(str, size, flowType, escapeNonAscii)) {
        return StringFormat::Literal;
      }
      return StringFormat::DoubleQuoted;
@@ -297,11 +297,11 @@ StringFormat::value ComputeStringFormat(const std::string& str,
  return StringFormat::DoubleQuoted;
 }

-bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) {
+bool WriteSingleQuotedString(ostream_wrapper& out, const char* str, std::size_t size) {
  out << "'";
  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+  for (const char* i = str;
+       GetNextCodePointAndAdvance(codePoint, i, str + size);) {
    if (codePoint == '\n') {
      return false;  // We can't handle a new line and the attendant indentation
                     // yet
@@ -317,12 +317,12 @@ bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) {
  return true;
 }

-bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
+bool WriteDoubleQuotedString(ostream_wrapper& out, const char* str, std::size_t size,
                             StringEscaping::value stringEscaping) {
  out << "\"";
  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+  for (const char* i = str;
+       GetNextCodePointAndAdvance(codePoint, i, str + size);) {
    switch (codePoint) {
      case '\"':
        out << "\\\"";
@@ -364,12 +364,12 @@ bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
  return true;
 }

-bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
+bool WriteLiteralString(ostream_wrapper& out, const char* str, std::size_t size,
                        std::size_t indent) {
  out << "|\n";
  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+  for (const char* i = str;
+       GetNextCodePointAndAdvance(codePoint, i, str + size);) {
    if (codePoint == '\n') {
      out << "\n";
    } else {
@@ -407,14 +407,14 @@ bool WriteChar(ostream_wrapper& out, char ch, StringEscaping::value stringEscapi
  return true;
 }

-bool WriteComment(ostream_wrapper& out, const std::string& str,
+bool WriteComment(ostream_wrapper& out, const char* str, std::size_t size,
                  std::size_t postCommentIndent) {
  const std::size_t curIndent = out.col();
  out << "#" << Indentation(postCommentIndent);
  out.set_comment();
  int codePoint;
-  for (std::string::const_iterator i = str.begin();
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+  for (const char* i = str;
+       GetNextCodePointAndAdvance(codePoint, i, str + size);) {
    if (codePoint == '\n') {
      out << "\n"
          << IndentTo(curIndent) << "#" << Indentation(postCommentIndent);
@@ -426,14 +426,14 @@ bool WriteComment(ostream_wrapper& out, const std::string& str,
  return true;
 }

-bool WriteAlias(ostream_wrapper& out, const std::string& str) {
+bool WriteAlias(ostream_wrapper& out, const char* str, std::size_t size) {
  out << "*";
-  return WriteAliasName(out, str);
+  return WriteAliasName(out, str, size);
 }

-bool WriteAnchor(ostream_wrapper& out, const std::string& str) {
+bool WriteAnchor(ostream_wrapper& out, const char* str, std::size_t size) {
  out << "&";
-  return WriteAliasName(out, str);
+  return WriteAliasName(out, str, size);
 }

 bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim) {
@@ -490,7 +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()),
+  std::string encoded = EncodeBase64(binary.data(), binary.size());
+  WriteDoubleQuotedString(out, encoded.data(), encoded.size(),
                          StringEscaping::None);
  return true;
 }
@@ -29,22 +29,22 @@ struct StringEscaping {
 };

 namespace Utils {
-StringFormat::value ComputeStringFormat(const std::string& str,
+StringFormat::value ComputeStringFormat(const char* str, std::size_t size,
                                        EMITTER_MANIP strFormat,
                                        FlowType::value flowType,
                                        bool escapeNonAscii);

-bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);
-bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
+bool WriteSingleQuotedString(ostream_wrapper& out, const char* str, std::size_t size);
+bool WriteDoubleQuotedString(ostream_wrapper& out, const char* str, std::size_t size,
                             StringEscaping::value stringEscaping);
-bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
+bool WriteLiteralString(ostream_wrapper& out, const char* str, std::size_t size,
                        std::size_t indent);
 bool WriteChar(ostream_wrapper& out, char ch,
               StringEscaping::value stringEscapingStyle);
-bool WriteComment(ostream_wrapper& out, const std::string& str,
+bool WriteComment(ostream_wrapper& out, const char* str, std::size_t size,
                  std::size_t postCommentIndent);
-bool WriteAlias(ostream_wrapper& out, const std::string& str);
-bool WriteAnchor(ostream_wrapper& out, const std::string& str);
+bool WriteAlias(ostream_wrapper& out, const char* str, std::size_t size);
+bool WriteAnchor(ostream_wrapper& out, const char* str, std::size_t size);
 bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim);
 bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,
                        const std::string& tag);
@@ -0,0 +1,238 @@
+#include "yaml-cpp/fptostring.h"
+#include "contrib/dragonbox.h"
+
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <limits>
+#include <sstream>
+#include <tuple>
+
+namespace YAML {
+namespace detail {
+namespace fp_formatting {
+
+/**
+ * Converts a integer into its ASCII digits.
+ *
+ * @param begin/end - a buffer, must be at least 20bytes long.
+ * @param value     - input value.
+ * @param width     - minimum number of digits, fill with '0' to the left. Must be equal or smaller than the buffer size.
+ * @return          - number of digits filled into the buffer (or -1 if preconditions are not meet)
+ *
+ * Example:
+ * std::array<char, 20> buffer;
+ * auto ct = ConvertToChars(buffer.begin(), buffer.end(), 23, 3);
+ * assert(ct = 3);
+ * assert(buffer[0] == '0');
+ * assert(buffer[1] == '2');
+ * assert(buffer[2] == '3');
+ */
+int ConvertToChars(char* begin, char* end, size_t value, int width=1) {
+  // precondition of this function (will trigger in debug build)
+  assert(width >= 1);
+  assert(end >= begin);       // end must be after begin
+  assert(end-begin >= width); // Buffer must be large enough
+  assert(end-begin >= 20);    // 2^64 has 20digits, so at least 20 digits must be available
+
+  // defensive programming, abort if precondition are not met (will trigger in release build)
+  if (width < 1) {
+    return -1;
+  }
+  if (end < begin) {
+    return -1;
+  }
+  if (end-begin < width) {
+    return -1;
+  }
+  if (end-begin < 20) {
+    return -1;
+  }
+
+
+  // count number of digits, and fill digits array accordingly
+  int digits_ct{};
+  while (value > 0) {
+    char c = value % 10 + '0';
+    value = value / 10;
+    digits_ct += 1;
+    *(end-digits_ct) = c;
+  }
+  while(digits_ct < width) {
+    assert(digits_ct < 64);
+    digits_ct += 1;
+    *(end-digits_ct) = '0';
+  }
+  // move data to the front of the array
+  std::memmove(begin, end-digits_ct, digits_ct);
+  return digits_ct;
+}
+
+/**
+ * Converts a float or double to a string.
+ *
+ * converts a value 'v' to a string. Uses dragonbox for formatting.
+ */
+template <typename T>
+std::string FpToString(T v, int precision = 0) {
+  // hard coded constant, at which exponent should switch to a scientific notation
+  int const lowerExponentThreshold = -5;
+  int const upperExponentThreshold =  (precision==0)?6:precision;
+  if (precision == 0) {
+    precision = 6;
+  }
+
+  // dragonbox/to_decimal does not handle value 0, inf, NaN
+  if (v == 0 || std::isinf(v) || std::isnan(v)) {
+    std::stringstream ss;
+    ss.imbue(std::locale("C"));
+    ss << v;
+    return ss.str();
+  }
+
+  auto r = jkj::dragonbox::to_decimal(v);
+
+  auto digits  = std::array<char, 20>{}; // max digits of size_t is 20.
+  auto digits_ct = ConvertToChars(digits.data(), digits.data() + digits.size(), r.significand);
+
+  // defensive programming, ConvertToChars arguments are invalid
+  if (digits_ct == -1) {
+    std::stringstream ss;
+    ss.imbue(std::locale("C"));
+    ss << v;
+    return ss.str();
+  }
+
+  // check if requested precision is lower than
+  // required digits for exact representation
+  if (digits_ct > precision) {
+    auto diff = digits_ct - precision;
+    r.exponent += diff;
+    digits_ct = precision;
+
+    // round numbers if required
+    if (digits[digits_ct] >= '5') {
+      int i{digits_ct-1};
+      digits[i] += 1;
+      while (digits[i] == '9'+1) {
+        digits_ct -= 1;
+        r.exponent += 1;
+        if (i > 0) {
+          digits[i-1] += 1;
+          i -= 1;
+        } else {
+          digits_ct = 1;
+          digits[0] = '1';
+          break;
+        }
+      }
+    }
+  }
+
+  std::array<char, 28> output_buffer; // max digits of size_t plus sign, a dot and 2 letters for 'e+' or 'e-' and 4 letters for the exponent
+  auto output_ptr = &output_buffer[0];
+
+  // print '-' symbol for negative numbers
+  if (r.is_negative) {
+    *(output_ptr++) = '-';
+  }
+
+  // exponent if only a single non-zero digit is before the decimal point
+  int const exponent = r.exponent + digits_ct - 1;
+
+  // case 1: scientific notation
+  if (exponent >= upperExponentThreshold || exponent <= lowerExponentThreshold) {
+    // print first digit
+    *(output_ptr++) = digits[0];
+
+    // print digits after decimal point
+    if (digits_ct > 1) {
+      *(output_ptr++) = '.';
+      // print significant numbers after decimal point
+      for (int i{1}; i < digits_ct; ++i) {
+         *(output_ptr++) = digits[i];
+      }
+    }
+    *(output_ptr++) = 'e';
+    *(output_ptr++) = (exponent>=0)?'+':'-';
+    auto exp_digits = std::array<char, 20>{};
+    auto exp_digits_ct = ConvertToChars(exp_digits.data(), exp_digits.data() + exp_digits.size(), std::abs(exponent), /*.precision=*/ 2);
+
+    // defensive programming, ConvertToChars arguments are invalid
+    if (exp_digits_ct == -1) {
+      std::stringstream ss;
+      ss.imbue(std::locale("C"));
+      ss << v;
+      return ss.str();
+    }
+
+    for (int i{0}; i < exp_digits_ct; ++i) {
+      *(output_ptr++) = exp_digits[i];
+    }
+
+  // case 2: default notation
+  } else {
+    auto const digits_end   = digits.begin() + digits_ct;
+    auto digits_iter    = digits.begin();
+
+    // print digits before point
+    int const before_decimal_digits = digits_ct + r.exponent;
+    if (before_decimal_digits > 0) {
+      // print digits before point
+      for (int i{0}; i < std::min(before_decimal_digits, digits_ct); ++i) {
+        *(output_ptr++) = *(digits_iter++);
+      }
+      // print trailing zeros before point
+      for (int i{0}; i < before_decimal_digits - digits_ct; ++i) {
+        *(output_ptr++) = '0';
+      }
+
+    // print 0 before point if none where printed before
+    } else {
+      *(output_ptr++) = '0';
+    }
+
+    if (digits_iter != digits_end) {
+      *(output_ptr++) = '.';
+      // print 0 after decimal point, to fill until first digits
+      int const after_decimal_zeros = -digits_ct - r.exponent;
+      for (int i{0}; i < after_decimal_zeros; ++i) {
+         *(output_ptr++) = '0';
+      }
+
+      // print significant numbers after decimal point
+      for (;digits_iter < digits_end; ++digits_iter) {
+         *(output_ptr++) = *digits_iter;
+      }
+    }
+  }
+  *output_ptr = '\0';
+  return std::string{&output_buffer[0], output_ptr};
+}
+
+}
+}
+
+std::string FpToString(float v, size_t precision) {
+  return detail::fp_formatting::FpToString(v, precision);
+}
+
+std::string FpToString(double v, size_t precision) {
+  return detail::fp_formatting::FpToString(v, precision);
+}
+
+/**
+ * dragonbox only works for floats/doubles not long double
+ */
+std::string FpToString(long double v, size_t precision) {
+  std::stringstream ss;
+  ss.imbue(std::locale("C"));
+  if (precision == 0) {
+     precision = std::numeric_limits<long double>::max_digits10;
+  }
+  ss.precision(precision);
+  ss << v;
+  return ss.str();
+}
+
+}
@@ -7,7 +7,6 @@
 #pragma once
 #endif

-#include <iostream>
 #include <cstddef>

 #include "yaml-cpp/ostream_wrapper.h"
@@ -1,10 +1,17 @@
 #include "yaml-cpp/null.h"
+#include <cstring>

 namespace YAML {
 _Null Null;

-bool IsNullString(const std::string& str) {
-  return str.empty() || str == "~" || str == "null" || str == "Null" ||
-         str == "NULL";
+template <std::size_t N>
+static bool same(const char* str, std::size_t size, const char (&literal)[N]) {
+  constexpr int literalSize = N - 1; // minus null terminator
+  return size == literalSize && std::strncmp(str, literal, literalSize) == 0;
+}
+
+bool IsNullString(const char* str, std::size_t size) {
+  return size == 0 || same(str, size, "~") || same(str, size, "null") ||
+         same(str, size, "Null") || same(str, size, "NULL");
 }
 }  // namespace YAML
@@ -2,7 +2,7 @@

 #include <algorithm>
 #include <cstring>
-#include <iostream>
+#include <ostream>

 namespace YAML {
 ostream_wrapper::ostream_wrapper()
@@ -27,6 +27,10 @@ inline bool RegEx::Matches(const Stream& in) const { return Match(in) >= 0; }

 template <typename Source>
 inline bool RegEx::Matches(const Source& source) const {
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201103L) || __cplusplus >= 201103L)
+  static_assert(!std::is_same<Source, const char*>::value,
+#endif
+    "Must use StringCharSource instead of plain C-string");
  return Match(source) >= 0;
 }

@@ -94,7 +94,7 @@ void SingleDocParser::HandleNode(EventHandler& eventHandler) {
    tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?");

  if (token.type == Token::PLAIN_SCALAR
-      && tag.compare("?") == 0 && IsNullString(token.value)) {
+      && tag.compare("?") == 0 && IsNullString(token.value.data(), token.value.size())) {
    eventHandler.OnNull(mark, anchor);
    m_scanner.pop();
    return;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Salim B	28f93bdec6	docs: Fix link in README	2025-03-13 14:45:33 -05:00
Patrick Diehl	39f737443b	Update README.md Bump the release note to the latest version	2025-01-24 16:01:30 -06:00
Jeremy Nimmer	73ef0060aa	Avoid including <iostream> in library code Including iostream means introducing the static (global) constructors and destructors for std::cin, std::cerr, and std::cout. That extra init and fini code is undesirable when those streams are not actually used. Instead, we'll use the narrower includes for exactly what's needed, i.e., <istream> or <ostream>.	2024-12-30 11:27:02 -06:00
Daniel Levin	7470c2d871	emitter: Support std::string_view Accept Emitter::operator<<(std::string_view). ABI remains C++11 compatible by exposing new method Emitter::Write(const char*, size_t). All affected calls optimized to pass std::string values as pointer + size tuple into appropriate routines.	2024-12-22 16:22:38 -06:00
Jesse Beder	8a9a7b74ef	Update CONTRIBUTING.md Add some details about testing.	2024-12-22 16:16:07 -06:00
Jesse Beder	d45c4fba3e	Update README.md	2024-12-18 11:43:01 -06:00
Jesse Beder	61db89741d	Exclude ubuntu/C++ 11/googletest system from the test matrix since it doesn't compile.	2024-12-17 15:59:47 -06:00
Jesse Beder	7def2046ff	Fix bazel build, and commit module lock file. Including: - Remove WORKSPACE and upgrade to MODULE.bazel. - The integration tests were not included since the directory was misspelled. - Their header files were not accessible.	2024-12-17 14:49:17 -06:00
IMaloney	1da813f56a	ensuring local tags are retained after loading a node + test	2024-12-17 09:20:46 -06:00
Phil Miller	f878043f12	Don't install embedded copy of GTest Goole Test itself documents the `INSTALL_GTEST` option as something that projects embedding it should set to `OFF`. Leaving it on means that projects downstream from libraries that embed it are likely to encounter conflicting copies. This is particularly annoying because GTest does not maintain anything like a stable API, and so causes builds to fail if include paths pick up an inappropriately installed copy ahead of the one that the code wanted. Fixes #488	2024-12-17 09:12:49 -06:00
Simon Gene Gottlieb	9ce5a25188	fix: spell fix	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	ebfbf27115	patch: added more defensive programming techniques	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	06ffaf3104	remove reduntant license information	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	0b945415fd	fix: add missing include	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	82f3c04081	fix: add YAML_CPP_API for windows-shared library builds	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	d8de96524c	patch: move dragonbox.h from 'include' folder to 'src' folder	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	5d9e4b6251	patch: split fp_to_string.h into fptostring.h and fptostring.cpp	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	28c0a1bc25	doc: add a little more information to dragonbox file	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	72865f7d32	fix: remove trailing return types	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	f4bca79dc4	fix: fp_to_string uses now 2 spaces	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	d4e00bd473	fix: rename fp_to_string to FpToString to match coding style	2024-11-07 15:14:36 -06:00
Simon Gene Gottlieb	bd070a7b76	fix: prettier floating point numbers Add dragonbox to compute the required precision to print floating point numbers. This avoids uglification of floating point numbers that happen by default via std::stringstream. Numbers like 34.34 used to be converted to '34.340000000000003' as strings. With this version they will be converted to the string '34.34'. This fixes issue https://github.com/jbeder/yaml-cpp/issues/1289	2024-11-07 15:14:36 -06:00