JSON: implement proper string escaping according to JSON spec (+ WIP)

axxel · axxel · commit cfdf0d5745f5 · 2025-05-23T00:30:45.000+02:00
Add a DecoderResult::addExtra convenience helper.
Also experiment with `BarcodeExtra::...` string constants for JSON keys.
diff --git a/core/src/Barcode.h b/core/src/Barcode.h
@@ -20,7 +20,17 @@
 #include <memory>
 namespace ZXing {
 class BitMatrix;
-}
+
+namespace BarcodeExtra {
+	#define ZX_EXTRA(NAME) static constexpr auto NAME = #NAME
+	ZX_EXTRA(DataMask); // QRCodes
+	ZX_EXTRA(Version);
+	ZX_EXTRA(EanAddOn); // EAN/UPC
+	ZX_EXTRA(UPCE);
+	#undef ZX_EXTRA
+} // namespace BarcodeExtra
+
+} // namespace ZXing
 
 extern "C" struct zint_symbol;
 struct zint_symbol_deleter
@@ -180,6 +190,8 @@ class Result
 	void zint(unique_zint_symbol&& z);
 	zint_symbol* zint() const { return _zint.get(); }
 	Result&& addExtra(std::string&& json) { _json += std::move(json); return std::move(*this); }
+	// template<typename T>
+	// Result&& addExtra(std::string_view key, T val, T ignore = {}) { _json += JsonProp(key, val, ignore); return std::move(*this); }
 	std::string extra(std::string_view key = "") const;
 #endif
 
diff --git a/core/src/DecoderResult.h b/core/src/DecoderResult.h
@@ -8,6 +8,7 @@
 
 #include "Content.h"
 #include "Error.h"
+#include "JSON.h"
 #include "StructuredAppend.h"
 
 #include <memory>
@@ -81,8 +82,11 @@ class DecoderResult
 	ZX_PROPERTY(bool, readerInit, setReaderInit)
 	ZX_PROPERTY(std::string, json, setJson)
 	ZX_PROPERTY(std::shared_ptr<CustomData>, customData, setCustomData)
-
 #undef ZX_PROPERTY
+
+	template<typename T>
+	DecoderResult&& addExtra(std::string_view key, T val, T ignore = {}) { _json += JsonProp(key, val, ignore); return std::move(*this); }
+
 };
 
 } // ZXing
diff --git a/core/src/JSON.cpp b/core/src/JSON.cpp
@@ -22,7 +22,8 @@
 #include "ctre.hpp"
 #pragma GCC diagnostic error "-Wundef"
 
-static constexpr auto PATTERN = ctll::fixed_string{R"(["']?([[:alpha:]][[:alnum:]]*)["']?\s*(?:[:]\s*["']?([[:alnum:]]+)["']?)?(?:,|\}|$))"};
+static constexpr auto PATTERN =
+	ctll::fixed_string{R"(["']?([[:alpha:]][[:alnum:]]*)["']?\s*(?:[:]\s*["']?([[:alnum:]]+)["']?)?(?:,|\}|$))"};
 #else
 #include "ZXAlgorithms.h"
 #endif
@@ -76,4 +77,83 @@ std::string_view JsonGetStr(std::string_view json, std::string_view key)
 #endif
 }
 
+std::string JsonEscapeStr(std::string_view str)
+{
+	std::string res;
+	res.reserve(str.size() + 10);
+
+	for (unsigned char c : str) {
+		switch (c) {
+		case '\"': res += "\\\""; break;
+		case '\\': res += "\\\\"; break;
+		case '\b': res += "\\b"; break;
+		case '\f': res += "\\f"; break;
+		case '\n': res += "\\n"; break;
+		case '\r': res += "\\r"; break;
+		case '\t': res += "\\t"; break;
+		default:
+			if (c <= 0x1F) {
+				char buf[7];
+				std::snprintf(buf, sizeof(buf), "\\u%04X", c);
+				res += buf;
+			} else {
+				res += c;
+			}
+			break;
+		}
+	}
+
+	return res;
+}
+
+std::string JsonUnEscapeStr(std::string_view str)
+{
+	std::string res;
+	res.reserve(str.size());
+
+	for (size_t i = 0; i < str.size(); ++i) {
+		char c = str[i];
+		if (c == '\\') {
+			if (++i >= str.size())
+				throw std::runtime_error("Invalid escape sequence");
+
+			char esc = str[i];
+			switch (esc) {
+			case '"': res += '\"'; break;
+			case '\\': res += '\\'; break;
+			case '/': res += '/'; break;
+			case 'b': res += '\b'; break;
+			case 'f': res += '\f'; break;
+			case 'n': res += '\n'; break;
+			case 'r': res += '\r'; break;
+			case 't': res += '\t'; break;
+			case 'u': {
+				if (i + 4 >= str.size())
+					throw std::runtime_error("Incomplete \\u escape");
+
+				uint32_t code = 0;
+				auto first = str.data() + i + 1;
+				auto last = first + 4;
+
+				auto [ptr, ec] = std::from_chars(first, last, code, 16);
+				if (ec != std::errc() || ptr != last)
+					throw std::runtime_error("Failed to parse hex code");
+
+				if (code > 0x1F)
+					throw std::runtime_error("Unexpected code point in \\u escape");
+
+				res += static_cast<char>(code);
+				i += 4;
+				break;
+			}
+			default: throw std::runtime_error("Unknown escape sequence");
+			}
+		} else {
+			res += c;
+		}
+	}
+
+	return res;
+}
+
 } // ZXing
diff --git a/core/src/JSON.h b/core/src/JSON.h
@@ -14,22 +14,25 @@
 
 namespace ZXing {
 
-inline std::string JsonKeyValue(std::string_view key, std::string_view val)
-{
-	return val.empty() ? std::string() : StrCat("\"", key, "\":", val, ',');
-}
+std::string JsonEscapeStr(std::string_view str);
+std::string JsonUnEscapeStr(std::string_view str);
 
 template<typename T>
-inline std::string JsonValue(std::string_view key, T val)
+inline std::string JsonProp(std::string_view key, T val, T ignore = {})
 {
+	if (val == ignore)
+		return {};
+
+	#define ZX_JSON_KEY_VAL(...) StrCat("\"", key, "\":", __VA_ARGS__, ',')
 	if constexpr (std::is_same_v<T, bool>)
-		return val ? JsonKeyValue(key, "true") : "";
+		return val ? ZX_JSON_KEY_VAL("true") : "";
 	else if constexpr (std::is_arithmetic_v<T>)
-		return JsonKeyValue(key, std::to_string(val));
+		return ZX_JSON_KEY_VAL(std::to_string(val));
 	else if constexpr (std::is_convertible_v<T, std::string_view>)
-		return JsonKeyValue(key, StrCat("\"" , val, "\""));
+		return ZX_JSON_KEY_VAL("\"" , JsonEscapeStr(val), "\"");
 	else
 		static_assert("unsupported JSON value type");
+	#undef ZX_JSON_KEY_VAL
 }
 
 std::string_view JsonGetStr(std::string_view json, std::string_view key);
@@ -45,8 +48,8 @@ inline std::optional<T> JsonGet(std::string_view json, std::string_view key)
 		return str.empty() || Contains("1tT", str.front()) ? std::optional(true) : std::nullopt;
 	else if constexpr (std::is_arithmetic_v<T>)
 		return str.empty() ? std::nullopt : std::optional(FromString<T>(str));
-	else if constexpr (std::is_same_v<std::string_view, T>)
-		return str;
+	else if constexpr (std::is_same_v<std::string, T>)
+		return JsonUnEscapeStr(str);
 	else
 		static_assert("unsupported JSON value type");
 }
diff --git a/core/src/datamatrix/DMDecoder.cpp b/core/src/datamatrix/DMDecoder.cpp
@@ -437,7 +437,11 @@ static DecoderResult DoDecode(const BitMatrix& bits)
 
 	// Decode the contents of that stream of bytes
 	return DecodedBitStreamParser::Decode(std::move(resultBytes), version->isDMRE())
-		.setVersionNumber(version->versionNumber);
+		.setVersionNumber(version->versionNumber)
+#ifdef ZXING_EXPERIMENTAL_API
+		.addExtra(BarcodeExtra::Version, std::to_string(version->symbolWidth) + 'x' + std::to_string(version->symbolWidth))
+#endif
+		;
 }
 
 static BitMatrix FlippedL(const BitMatrix& bits)
diff --git a/core/src/oned/ODMultiUPCEANReader.cpp b/core/src/oned/ODMultiUPCEANReader.cpp
@@ -115,7 +115,6 @@ static bool DecodeDigits(int digitCount, PatternView& next, std::string& txt, in
 struct PartialResult
 {
 	std::string txt;
-	std::string json;
 	PatternView end;
 	BarcodeFormat format = BarcodeFormat::None;
 
@@ -282,8 +281,9 @@ Barcode MultiUPCEANReader::decodePattern(int rowNumber, PatternView& next, std::
 
 	// ISO/IEC 15420:2009 (& GS1 General Specifications 5.1.3) states that the content for "]E0" should be 13 digits,
 	// i.e. converted to EAN-13 if UPC-A/E
+	std::string upceTxt;
 	if (res.format == BarcodeFormat::UPCE) {
-		res.json = JsonValue("UPC-E", res.txt);
+		upceTxt = res.txt;
 		res.txt = "0" + UPCEANCommon::ConvertUPCEtoUPCA(res.txt);
 	}
 
@@ -319,7 +319,8 @@ Barcode MultiUPCEANReader::decodePattern(int rowNumber, PatternView& next, std::
 
 	return Barcode(res.txt, rowNumber, begin.pixelsInFront(), next.pixelsTillEnd(), res.format, symbologyIdentifier, error)
 #ifdef ZXING_EXPERIMENTAL_API
-		.addExtra(std::move(res.json))
+		.addExtra(JsonProp(BarcodeExtra::UPCE, upceTxt))
+		.addExtra(JsonProp(BarcodeExtra::EanAddOn, addOnRes.txt))
 #endif
 		;
 }
diff --git a/core/src/pdf417/PDFReader.cpp b/core/src/pdf417/PDFReader.cpp
@@ -13,7 +13,6 @@
 #include "BitMatrixCursor.h"
 #include "DecoderResult.h"
 #include "DetectorResult.h"
-#include "JSON.h"
 #include "PDFCodewordDecoder.h"
 #include "PDFCustomData.h"
 #include "PDFDetector.h"
@@ -98,19 +97,19 @@ static Barcodes DoDecode(const BinaryBitmap& image, bool multiple, bool tryRotat
 					return p;
 				}
 			};
-			auto barcode =
-				Barcode(std::move(decoderResult), DetectorResult{{}, {point(0), point(2), point(3), point(1)}}, BarcodeFormat::PDF417)
 #ifdef ZXING_EXPERIMENTAL_API
-					.addExtra(JsonValue("Sender", customData->sender))
-					.addExtra(JsonValue("Addresse", customData->addressee))
-					.addExtra(JsonValue("FileId", customData->fileId))
-					.addExtra(JsonValue("FileName", customData->fileName))
-					.addExtra(customData->fileSize != -1 ? JsonValue("FileSize", customData->fileSize) : "")
-					.addExtra(customData->timestamp != -1 ? JsonValue("Timestamp", customData->timestamp) : "")
-					.addExtra(customData->checksum != -1 ? JsonValue("Checksum", customData->checksum) : "")
+			decoderResult
+				.addExtra("Sender", customData->sender)
+				.addExtra("Addressee", customData->addressee)
+				.addExtra("FileId", customData->fileId)
+				.addExtra("FileName", customData->fileName)
+				.addExtra("FileSize", customData->fileSize, -1L)
+				.addExtra("Timestamp", customData->timestamp, -1L)
+				.addExtra("Checksum", customData->checksum, -1)
+			;
 #endif
-					;
-			res.push_back(std::move(barcode));
+			res.emplace_back(std::move(decoderResult), DetectorResult{{}, {point(0), point(2), point(3), point(1)}},
+							 BarcodeFormat::PDF417);
 			if (!multiple)
 				return res;
 		}
diff --git a/core/src/qrcode/QRDecoder.cpp b/core/src/qrcode/QRDecoder.cpp
@@ -6,12 +6,14 @@
 
 #include "QRDecoder.h"
 
+#ifdef ZXING_EXPERIMENTAL_API
+#include "Barcode.h"
+#endif
 #include "BitMatrix.h"
 #include "BitSource.h"
 #include "CharacterSet.h"
 #include "DecoderResult.h"
 #include "GenericGF.h"
-#include "JSON.h"
 #include "QRBitMatrixParser.h"
 #include "QRCodecMode.h"
 #include "QRDataBlock.h"
@@ -367,7 +369,11 @@ DecoderResult Decode(const BitMatrix& bits)
 	// Decode the contents of that stream of bytes
 	auto ret = DecodeBitStream(std::move(resultBytes), version, formatInfo.ecLevel)
 		.setIsMirrored(formatInfo.isMirrored)
-		.setJson(JsonValue("DataMask", formatInfo.dataMask) + JsonValue("Version", versionStr));
+#ifdef ZXING_EXPERIMENTAL_API
+		.addExtra(BarcodeExtra::DataMask, formatInfo.dataMask, uint8_t(255))
+		.addExtra(BarcodeExtra::Version, versionStr)
+#endif
+		;
 	if (error)
 		ret.setError(error);
 	return ret;
diff --git a/core/src/qrcode/QRFormatInformation.h b/core/src/qrcode/QRFormatInformation.h
@@ -28,7 +28,7 @@ class FormatInformation
 	uint8_t bitsIndex = 255;
 
 	bool isMirrored = false;
-	uint8_t dataMask = 0;
+	uint8_t dataMask = 255;
 	uint8_t microVersion = 0;
 	ErrorCorrectionLevel ecLevel = ErrorCorrectionLevel::Invalid;
 
diff --git a/test/unit/JSONTest.cpp b/test/unit/JSONTest.cpp
@@ -9,11 +9,14 @@
 
 using namespace ZXing;
 
-TEST(JSONTest, Value)
+TEST(JSONTest, Prop)
 {
-	EXPECT_EQ(JsonValue("key", "val"), R"("key":"val",)");
-	EXPECT_EQ(JsonValue("key", true), R"("key":true,)");
-	EXPECT_EQ(JsonValue("key", 1), R"("key":1,)");
+	EXPECT_EQ(JsonProp("key", "val"), R"("key":"val",)");
+	EXPECT_EQ(JsonProp("key", true), R"("key":true,)");
+	EXPECT_EQ(JsonProp("key", 1), R"("key":1,)");
+
+	EXPECT_EQ(JsonProp("key", R"(C:\)"), R"("key":"C:\\",)");
+	EXPECT_EQ(JsonProp("key", R"("quotes")"), R"("key":"\"quotes\"",)");
 }
 
 TEST(JSONTest, GetStr)
@@ -49,8 +52,8 @@ TEST(JSONTest, GetBool)
 	EXPECT_FALSE(JsonGet<bool>("keys", "key"));
 	EXPECT_FALSE(JsonGet<bool>("thekey", "key"));
 
-	EXPECT_TRUE(JsonGet<bool>("key , other", "key"));
-	EXPECT_TRUE(JsonGet<bool>("\"key\": \"true\"", "key"));
+	EXPECT_TRUE(JsonGet<bool>("key , other", "key").value());
+	EXPECT_TRUE(JsonGet<bool>("\"key\": \"true\"", "key").value());
 	EXPECT_TRUE(JsonGet<bool>("{\"key\": true}", "key")); // JSON
 	EXPECT_TRUE(JsonGet<bool>("{'key': True'}", "key"));  // Python
 }
@@ -62,5 +65,25 @@ TEST(JSONTest, GetInt)
 
 	EXPECT_EQ(JsonGet<int>("key:1", "key").value(), 1);
 	EXPECT_EQ(JsonGet<int>("{\"key\": 2}", "key").value(), 2); // JSON
-	EXPECT_EQ(JsonGet<int>("{'key': 1}", "key").value(), 1);  // Python
+	EXPECT_EQ(JsonGet<int>("{'key': 1}", "key").value(), 1);   // Python
+}
+
+TEST(JSONTest, GetString)
+{
+	EXPECT_FALSE(JsonGet<std::string>("key:", "key"));
+
+	EXPECT_EQ(JsonGet<std::string>("key:abc", "key").value(), "abc");
+	EXPECT_EQ(JsonGet<std::string>("{\"key\":\"abc\\n\"}", "key").value(), "abc\n"); // JSON
+	EXPECT_EQ(JsonGet<std::string>("{'key': 'abc'}", "key").value(), "abc");         // Python
+}
+
+TEST(JSONTest, Escaping)
+{
+	EXPECT_EQ("\\u0001", JsonEscapeStr("\x01"));
+	EXPECT_EQ("\x80", JsonEscapeStr("\x80"));
+
+	for (int c = 0; c <= 0xFF; ++c) {
+		auto str = std::string(1, static_cast<char>(c));
+		EXPECT_EQ(str, JsonUnEscapeStr(JsonEscapeStr(str)));
+	}
 }

Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,6 @@ static bool DecodeDigits(int digitCount, PatternView& next, std::string& txt, in`
`115`	`115`	`struct PartialResult`
`116`	`116`	`{`
`117`	`117`	`std::string txt;`
`118`		`- std::string json;`
`119`	`118`	`PatternView end;`
`120`	`119`	`BarcodeFormat format = BarcodeFormat::None;`
`121`	`120`
`@@ -282,8 +281,9 @@ Barcode MultiUPCEANReader::decodePattern(int rowNumber, PatternView& next, std::`
`282`	`281`
`283`	`282`	`// ISO/IEC 15420:2009 (& GS1 General Specifications 5.1.3) states that the content for "]E0" should be 13 digits,`
`284`	`283`	`// i.e. converted to EAN-13 if UPC-A/E`
	`284`	`+ std::string upceTxt;`
`285`	`285`	`if (res.format == BarcodeFormat::UPCE) {`
`286`		`- res.json = JsonValue("UPC-E", res.txt);`
	`286`	`+ upceTxt = res.txt;`
`287`	`287`	`res.txt = "0" + UPCEANCommon::ConvertUPCEtoUPCA(res.txt);`
`288`	`288`	`}`
`289`	`289`
`@@ -319,7 +319,8 @@ Barcode MultiUPCEANReader::decodePattern(int rowNumber, PatternView& next, std::`
`319`	`319`
`320`	`320`	`return Barcode(res.txt, rowNumber, begin.pixelsInFront(), next.pixelsTillEnd(), res.format, symbologyIdentifier, error)`
`321`	`321`	`#ifdef ZXING_EXPERIMENTAL_API`
`322`		`- .addExtra(std::move(res.json))`
	`322`	`+ .addExtra(JsonProp(BarcodeExtra::UPCE, upceTxt))`
	`323`	`+ .addExtra(JsonProp(BarcodeExtra::EanAddOn, addOnRes.txt))`
`323`	`324`	`#endif`
`324`	`325`	`;`
`325`	`326`	`}`