Merge pull request 'schemagen: reject absent additionalProperties' (#58) from weaselbot/weaseljson:weaselbot/issue-55 into main

Reviewed-on: weaselab/weaseljson#58

contrib/schemagen/README.md

@@ -60,8 +60,9 @@ into the result, so it is non-movable.
 ## Not supported (rejected at generation time, no fallback)
 
 `oneOf` / `anyOf` / `allOf` / `not` / `if`-`then`-`else`,
-`patternProperties`, `additionalProperties` with a schema (typed map),
-`additionalProperties: true`, `prefixItems` (tuples), `const`,
+`patternProperties`, `additionalProperties` absent or set to `true`,
+`additionalProperties` with a schema (typed map), `prefixItems` (tuples),
+`const`,
 `dependentSchemas`/`dependentRequired`, union `type` lists other than
 `["T", "null"]`, non-string enums, and remote (`$ref` to other documents).
 

contrib/schemagen/example.schema.json

@@ -56,6 +56,7 @@
       "type": "array",
       "items": {
         "type": "object",
+        "additionalProperties": false,
         "required": [
           "name"
         ],

contrib/schemagen/test_gen.cpp

@@ -68,6 +68,15 @@ int main() {
     expectReject(json, "unknown key in strict root");
   }
 
+  // ---- invalid stack size is rejected without crashing ----
+  {
+    RootBuilder b(-1);
+    char buf[] = "null";
+    WeaselJsonStatus s = b.feed(buf, sizeof(buf) - 1);
+    CHECK(s == WeaselJson_REJECT);
+    printf("ok   invalid stack size rejected, not crashed\n");
+  }
+
   {
     std::string json = R"({
       "name": "Ada É",

contrib/schemagen/test_schemagen.py

@@ -32,6 +32,7 @@ class SchemagenEnumTest(unittest.TestCase):
     def test_colliding_enum_values_deduplicate(self):
         schema = {
             "type": "object",
+            "additionalProperties": False,
             "properties": {"role": {"enum": ["foo-bar", "foo_bar"]}},
         }
         rc, stdout, stderr = self.run_schemagen(schema)
@@ -45,6 +46,7 @@ class SchemagenEnumTest(unittest.TestCase):
     def test_distinct_enum_values_generate(self):
         schema = {
             "type": "object",
+            "additionalProperties": False,
             "properties": {"role": {"enum": ["admin", "user", "guest"]}},
         }
         rc, stdout, stderr = self.run_schemagen(schema)
@@ -80,7 +82,7 @@ class SchemagenKeywordTest(unittest.TestCase):
             "module",
             "import",
         ]
-        schema = {"type": "object", "properties": {}}
+        schema = {"type": "object", "additionalProperties": False, "properties": {}}
         for kw in keywords:
             schema["properties"][kw] = {"type": "string"}
         rc, stdout, stderr = self.run_schemagen(schema)
@@ -164,11 +166,18 @@ class SchemagenCollisionTest(unittest.TestCase):
     def test_kind_enum_does_not_duplicate_arr0(self):
         schema = {
             "type": "object",
+            "additionalProperties": False,
             "properties": {
                 "arr": {"type": "array", "items": {"type": "string"}},
                 "obj": {"$ref": "#/$defs/Arr0"},
             },
-            "$defs": {"Arr0": {"type": "object", "properties": {}}},
+            "$defs": {
+                "Arr0": {
+                    "type": "object",
+                    "additionalProperties": False,
+                    "properties": {},
+                }
+            },
         }
         out = self.generate_and_compile(schema)
         self.assertIn("struct Arr0", out)
@@ -183,7 +192,13 @@ class SchemagenCollisionTest(unittest.TestCase):
         schema = {
             "type": "array",
             "items": {"$ref": "#/$defs/Skip"},
-            "$defs": {"Skip": {"type": "object", "properties": {}}},
+            "$defs": {
+                "Skip": {
+                    "type": "object",
+                    "additionalProperties": False,
+                    "properties": {},
+                }
+            },
         }
         out = self.generate_and_compile(schema)
         self.assertIn("struct Skip", out)
@@ -199,6 +214,7 @@ class SchemagenCollisionTest(unittest.TestCase):
         """Regression test for issue #17: enum and array $defs must be reused."""
         schema = {
             "type": "object",
+            "additionalProperties": False,
             "properties": {
                 "role1": {"$ref": "#/$defs/Role"},
                 "role2": {"$ref": "#/$defs/Role"},
@@ -252,17 +268,14 @@ class SchemagenAdditionalPropertiesTest(unittest.TestCase):
         self.assertNotEqual(rc, 0)
         self.assertIn("additionalProperties: true is not supported", stderr)
 
-    def test_additional_properties_absent_defaults_to_strict(self):
+    def test_additional_properties_absent_rejected(self):
         schema = {
             "type": "object",
             "properties": {"name": {"type": "string"}},
         }
         rc, stdout, stderr = self.run_schemagen(schema)
-        self.assertEqual(rc, 0, msg=stderr)
-        # The generated parser should reject unknown keys. Verify the key-matching
-        # helper returns -1 for an unknown key and cbKeyData rejects it.
-        self.assertIn("int matchKey(Kind k, std::string_view key) const {", stdout)
-        self.assertNotIn("bool isStrict(Kind k) const", stdout)
+        self.assertNotEqual(rc, 0)
+        self.assertIn("additionalProperties is required for object schemas", stderr)
 
     def test_additional_properties_false_accepted(self):
         schema = {
@@ -274,6 +287,216 @@ class SchemagenAdditionalPropertiesTest(unittest.TestCase):
         self.assertEqual(rc, 0, msg=stderr)
 
 
+class SchemagenCyclicArrayTest(unittest.TestCase):
+    """Regression tests for issue #33: cyclic array $ref targets."""
+
+    def run_schemagen(self, schema, args=None):
+        """Run schemagen on a schema dict. Returns (returncode, stdout, stderr)."""
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as fp:
+            json.dump(schema, fp)
+            schema_path = fp.name
+        try:
+            cmd = [sys.executable, SCRIPT, schema_path]
+            if args:
+                cmd.extend(args)
+            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+            return result.returncode, result.stdout, result.stderr
+        finally:
+            os.unlink(schema_path)
+
+    def test_direct_self_referential_array_rejected(self):
+        schema = {
+            "type": "array",
+            "items": {"$ref": "#/$defs/Node"},
+            "$defs": {
+                "Node": {
+                    "type": "array",
+                    "items": {"$ref": "#/$defs/Node"},
+                }
+            },
+        }
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertNotEqual(rc, 0)
+        self.assertIn("recursive array type is not supported", stderr)
+        self.assertIn("Node", stderr)
+
+    def test_object_field_to_self_referential_array_rejected(self):
+        schema = {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {"items": {"$ref": "#/$defs/Items"}},
+            "$defs": {
+                "Items": {
+                    "type": "array",
+                    "items": {"$ref": "#/$defs/Items"},
+                }
+            },
+        }
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertNotEqual(rc, 0)
+        self.assertIn("recursive array type is not supported", stderr)
+        self.assertIn("Items", stderr)
+
+    def test_chain_of_array_refs_rejected(self):
+        schema = {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {"x": {"$ref": "#/$defs/A"}},
+            "$defs": {
+                "A": {"type": "array", "items": {"$ref": "#/$defs/B"}},
+                "B": {"type": "array", "items": {"$ref": "#/$defs/A"}},
+            },
+        }
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertNotEqual(rc, 0)
+        self.assertIn("recursive array type is not supported", stderr)
+
+    def test_non_recursive_array_refs_still_allowed(self):
+        schema = {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {"roles": {"$ref": "#/$defs/Roles"}},
+            "$defs": {
+                "Role": {"enum": ["admin", "user"]},
+                "Roles": {
+                    "type": "array",
+                    "items": {"$ref": "#/$defs/Role"},
+                },
+            },
+        }
+        rc, stdout, stderr = self.run_schemagen(schema)
+        self.assertEqual(rc, 0, msg=stderr)
+        self.assertIn("std::optional<std::vector<Role>> roles;", stdout)
+
+
+class SchemagenCyclicNullableObjectTest(unittest.TestCase):
+    """Regression tests for issue #14: nullable cyclic $ref targets."""
+
+    def setUp(self):
+        self.repo_root = os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+        self.include_dir = os.path.join(self.repo_root, "include")
+        self.lib_src = os.path.join(self.repo_root, "src", "lib.cpp")
+        self.compiler = shutil.which("c++")
+
+    def _compile_harness(self, tmpdir, schema, harness):
+        schema_path = os.path.join(tmpdir, "schema.json")
+        with open(schema_path, "w") as fp:
+            json.dump(schema, fp)
+        header_path = os.path.join(tmpdir, "gen.h")
+        result = subprocess.run(
+            [
+                sys.executable,
+                SCRIPT,
+                schema_path,
+                "-o",
+                header_path,
+                "--namespace",
+                "test_schema",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        self.assertEqual(result.returncode, 0, msg=result.stderr)
+
+        lib_obj = os.path.join(tmpdir, "lib.o")
+        comp_lib = subprocess.run(
+            [
+                self.compiler,
+                "-std=c++20",
+                "-I",
+                self.include_dir,
+                "-I",
+                os.path.join(self.repo_root, "third_party", "include"),
+                "-I",
+                os.path.join(self.repo_root, "third_party", "valgrind"),
+                "-c",
+                self.lib_src,
+                "-o",
+                lib_obj,
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        self.assertEqual(comp_lib.returncode, 0, msg=comp_lib.stderr)
+
+        cpp_path = os.path.join(tmpdir, "test.cpp")
+        with open(cpp_path, "w") as fp:
+            fp.write(harness)
+
+        exe_path = os.path.join(tmpdir, "test")
+        comp = subprocess.run(
+            [
+                self.compiler,
+                "-std=c++20",
+                "-I",
+                self.include_dir,
+                "-I",
+                tmpdir,
+                lib_obj,
+                cpp_path,
+                "-o",
+                exe_path,
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        self.assertEqual(comp.returncode, 0, msg=comp.stderr)
+        run = subprocess.run([exe_path], capture_output=True, text=True, check=False)
+        self.assertEqual(run.returncode, 0, msg=run.stdout + run.stderr)
+
+    def test_self_referential_nullable_object_accepts_nested_null(self):
+        """A nullable object $def must stay nullable on recursive $refs."""
+        if not self.compiler:
+            self.skipTest("C++ compiler not available")
+        schema = {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {"self": {"$ref": "#/$defs/Self"}},
+            "$defs": {
+                "Self": {
+                    "type": ["object", "null"],
+                    "additionalProperties": False,
+                    "properties": {"self": {"$ref": "#/$defs/Self"}},
+                }
+            },
+        }
+        harness = textwrap.dedent(
+            """
+            #include "gen.h"
+            #include <cstdio>
+            #include <cstring>
+            struct Case { const char *s; WeaselJsonStatus expected; };
+            int main() {
+              Case cases[] = {
+                { R"({"self": null})", WeaselJson_OK },
+                { R"({"self": {"self": null}})", WeaselJson_OK },
+                { R"({"self": {"self": {}}})", WeaselJson_OK },
+              };
+              for (const auto &c : cases) {
+                test_schema::RootBuilder b;
+                char buf[256];
+                std::strncpy(buf, c.s, sizeof(buf) - 1);
+                buf[sizeof(buf) - 1] = '\\0';
+                WeaselJsonStatus st = b.feed(buf, std::strlen(buf));
+                st = b.finish();
+                if (st != c.expected) {
+                  std::printf("case %s expected %d got %d\\n", c.s, c.expected, st);
+                  return 1;
+                }
+              }
+              return 0;
+            }
+            """
+        )
+        with tempfile.TemporaryDirectory() as tmpdir:
+            self._compile_harness(tmpdir, schema, harness)
+
+
 class SchemagenIntegerBoundaryTest(unittest.TestCase):
     """Regression tests for issue #19: integer slot parsing near int64 boundaries."""
 
@@ -382,9 +605,18 @@ class SchemagenIntegerBoundaryTest(unittest.TestCase):
             ("1e-3", "WeaselJson_REJECT", 0),
             ("1000e-3", "WeaselJson_OK", 1),
             ("100.0e-2", "WeaselJson_OK", 1),
+            ("0.0001e4", "WeaselJson_OK", 1),
+            ("0.001e3", "WeaselJson_OK", 1),
             ("123.0", "WeaselJson_OK", 123),
             ("9e18", "WeaselJson_OK", 9000000000000000000),
             ("10e18", "WeaselJson_REJECT", 0),
+            # Issue #56: zero written with a negative exponent must be accepted.
+            ("0e-1", "WeaselJson_OK", 0),
+            ("0e-2", "WeaselJson_OK", 0),
+            ("0.0e-2", "WeaselJson_OK", 0),
+            ("-0e-2", "WeaselJson_OK", 0),
+            ("0e-20", "WeaselJson_OK", 0),
+            ("0.000e-5", "WeaselJson_OK", 0),
         ]
         cases_src = self._build_cases_array("root", cases)
         harness = textwrap.dedent(
@@ -425,7 +657,11 @@ class SchemagenIntegerBoundaryTest(unittest.TestCase):
             ('{"age":-9223372036854775809}', "WeaselJson_REJECT", 0),
             ('{"age":1e3}', "WeaselJson_OK", 1000),
             ('{"age":2.0}', "WeaselJson_OK", 2),
+            ('{"age":0.0001e4}', "WeaselJson_OK", 1),
             ('{"age":0.001}', "WeaselJson_REJECT", 0),
+            # Issue #56: zero written with a negative exponent must be accepted.
+            ('{"age":0e-2}', "WeaselJson_OK", 0),
+            ('{"age":-0e-20}', "WeaselJson_OK", 0),
             (
                 '{"age":-9223372036854775808.0}',
                 "WeaselJson_OK",
@@ -462,12 +698,167 @@ class SchemagenIntegerBoundaryTest(unittest.TestCase):
         )
         schema = {
             "type": "object",
+            "additionalProperties": False,
             "properties": {"age": {"type": "integer"}},
             "required": ["age"],
         }
         with tempfile.TemporaryDirectory() as tmpdir:
             self._compile_harness(tmpdir, schema, harness)
 
+    def test_integer_no_quadratic_leading_zero_loop(self):
+        """Regression test for issue #34: leading-zero stripping must not be quadratic."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            schema_path = os.path.join(tmpdir, "schema.json")
+            with open(schema_path, "w") as fp:
+                json.dump({"type": "integer"}, fp)
+            result = subprocess.run(
+                [sys.executable, SCRIPT, schema_path],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            self.assertEqual(result.returncode, 0, msg=result.stderr)
+            self.assertIn("parseJsonInt64", result.stdout)
+            self.assertNotIn("digits.erase(digits.begin())", result.stdout)
+
+    def test_integer_large_fractional_leading_zeros(self):
+        """Numbers with many leading fractional zeros must parse correctly."""
+        if not self.compiler:
+            self.skipTest("C++ compiler not available")
+        harness = textwrap.dedent(
+            """
+            #include "gen.h"
+            #include <cstdio>
+            #include <string>
+            int main() {
+              const int n = 100000;
+              std::string s = std::string("0.") + std::string(n - 1, '0') + "1e" + std::to_string(n);
+              test_schema::RootBuilder b;
+              WeaselJsonStatus st = b.feed(s.data(), static_cast<int>(s.size()));
+              st = b.finish();
+              if (st != WeaselJson_OK) {
+                std::printf("expected OK, got %d\\n", st);
+                return 1;
+              }
+              if (b.take() != 1) {
+                std::printf("expected value 1\\n");
+                return 2;
+              }
+              return 0;
+            }
+            """
+        )
+        with tempfile.TemporaryDirectory() as tmpdir:
+            self._compile_harness(tmpdir, {"type": "integer"}, harness)
+
+
+class SchemagenStringEscapeTest(unittest.TestCase):
+    """Regression tests for issue #35: control characters in string literals."""
+
+    def setUp(self):
+        self.repo_root = os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+        self.include_dir = os.path.join(self.repo_root, "include")
+        self.compiler = shutil.which("c++")
+
+    def generate_and_compile(self, schema):
+        """Run schemagen on schema and syntax-check the resulting header."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            schema_path = os.path.join(tmpdir, "schema.json")
+            with open(schema_path, "w") as fp:
+                json.dump(schema, fp)
+            header_path = os.path.join(tmpdir, "gen.h")
+            cmd = [
+                sys.executable,
+                SCRIPT,
+                schema_path,
+                "-o",
+                header_path,
+                "--namespace",
+                "test_schema",
+            ]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+            self.assertEqual(result.returncode, 0, msg=result.stderr)
+
+            if self.compiler:
+                cpp_path = os.path.join(tmpdir, "test.cpp")
+                with open(cpp_path, "w") as fp:
+                    fp.write(
+                        '#include "gen.h"\n'
+                        "int main() {\n"
+                        "  test_schema::RootBuilder b;\n"
+                        "  test_schema::Root r = b.take();\n"
+                        "  (void)r;\n"
+                        "}\n"
+                    )
+                comp = subprocess.run(
+                    [
+                        self.compiler,
+                        "-std=c++20",
+                        "-fsyntax-only",
+                        "-I",
+                        self.include_dir,
+                        "-I",
+                        tmpdir,
+                        cpp_path,
+                    ],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                self.assertEqual(comp.returncode, 0, msg=comp.stderr)
+
+            with open(header_path) as fp:
+                return fp.read()
+
+    def test_newline_in_property_key(self):
+        """A JSON key containing a newline must become a valid C++ literal."""
+        schema = {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {"a\nb": {"type": "string"}},
+        }
+        out = self.generate_and_compile(schema)
+        self.assertIn('// "a\\nb"', out)
+        self.assertIn('if (key == "a\\nb") return 0;', out)
+
+    def test_newline_in_enum_value(self):
+        """An enum value containing a newline must become a valid C++ literal."""
+        schema = {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {"x": {"enum": ["a\nb"]}},
+        }
+        out = self.generate_and_compile(schema)
+        self.assertIn('static constexpr const char *X_names[] = { "a\\nb" };', out)
+
+    def test_mixed_control_chars_in_enum_value(self):
+        """Mixed control characters in an enum value must be escaped."""
+        schema = {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {
+                "x": {"enum": ["x\ny\rz\tw\vq\x00\x01"]},
+            },
+        }
+        out = self.generate_and_compile(schema)
+        self.assertIn(
+            'static constexpr const char *X_names[] = { "x\\ny\\rz\\tw\\vq\\u0000\\u0001" };',
+            out,
+        )
+
+    def test_backslash_and_quote_still_escaped(self):
+        """Existing escaping for backslash and double quote must remain correct."""
+        schema = {
+            "type": "object",
+            "additionalProperties": False,
+            "properties": {'a"b\\c': {"type": "string"}},
+        }
+        out = self.generate_and_compile(schema)
+        self.assertIn('// "a\\"b\\\\c"', out)
+        self.assertIn('if (key == "a\\"b\\\\c") return 0;', out)
+
 
 if __name__ == "__main__":
     unittest.main()

contrib/schemagen/weaseljson_schemagen.py

@@ -18,6 +18,43 @@ import keyword
 import sys
 
 
+def _escape_cpp_string(s):
+    """Return *s* escaped for use inside a C++ double-quoted string literal.
+
+    JSON strings may contain control characters; emitting them verbatim into
+    generated C++ source breaks tokenization.  This helper escapes backslashes
+    and double quotes, maps common control characters to their short escape
+    sequences, and uses universal character names (\\u00XX) for any other
+    character below 0x20.
+    """
+    out = []
+    for ch in s:
+        cp = ord(ch)
+        if cp == 0x09:
+            out.append("\\t")
+        elif cp == 0x0A:
+            out.append("\\n")
+        elif cp == 0x0B:
+            out.append("\\v")
+        elif cp == 0x0C:
+            out.append("\\f")
+        elif cp == 0x0D:
+            out.append("\\r")
+        elif cp == 0x08:
+            out.append("\\b")
+        elif cp == 0x07:
+            out.append("\\a")
+        elif cp < 0x20:
+            out.append(f"\\u{cp:04X}")
+        elif ch == "\\":
+            out.append("\\\\")
+        elif ch == '"':
+            out.append('\\"')
+        else:
+            out.append(ch)
+    return "".join(out)
+
+
 class GenError(Exception):
     pass
 
@@ -235,6 +272,24 @@ class Builder:
         """Names generated internally that must not collide with user types."""
         return name in ("Root", "RootScalar")
 
+    @staticmethod
+    def _array_reaches(target, ty):
+        """Return True if `target` can be reached from `ty` by following
+        TArr element types. This detects self-referential array cycles that
+        cannot be expressed as C++ structs."""
+        seen = set()
+        stack = [ty]
+        while stack:
+            cur = stack.pop()
+            if cur is target:
+                return True
+            if id(cur) in seen:
+                continue
+            seen.add(id(cur))
+            if isinstance(cur, TArr):
+                stack.append(cur.elem)
+        return False
+
     def ref_name(self, ref):
         if not ref.startswith("#/"):
             raise GenError(f"only local $ref supported, got: {ref}")
@@ -322,6 +377,12 @@ class Builder:
             )
             t.elem = elem
             t.elem_nullable = elem_nullable
+            # Self-referential array cycles (directly or through a chain of
+            # array definitions) cannot be represented as a C++ value type.
+            if self._array_reaches(t, elem):
+                raise GenError(
+                    "recursive array type is not supported: " f"{defname or hint!r}"
+                )
             return result
 
         scalar = {
@@ -356,7 +417,13 @@ class Builder:
         tobj = TObj(name)
         if defname is not None:
             self._building[defname] = (tobj, nullable)
-        ap = node.get("additionalProperties", False)
+        ap = node.get("additionalProperties", None)
+        if ap is None:
+            raise GenError(
+                "additionalProperties is required for object schemas; set it "
+                "explicitly to false to reject unknown keys (absent "
+                "additionalProperties is not supported)"
+            )
         if ap is True:
             raise GenError("additionalProperties: true is not supported")
         if isinstance(ap, dict):
@@ -618,7 +685,8 @@ namespace {ns} {{"""
                     and f.ty.kind in ("int", "dbl", "bool")
                 ):
                     init = " = 0" if f.ty.kind != "bool" else " = false"
-                out.append(f'  {store} {f.cpp}{init};  // "{f.key}"')
+                esc_key = _escape_cpp_string(f.key)
+                out.append(f'  {store} {f.cpp}{init};  // "{esc_key}"')
             out.append("};")
             out.append("")
         return "\n".join(out)
@@ -746,7 +814,7 @@ namespace {ns} {{"""
         for name, obj in self.b.objects.items():
             lines.append(f"    case Kind::{name}:")
             for i, fld in enumerate(obj.fields):
-                esc = fld.key.replace("\\", "\\\\").replace('"', '\\"')
+                esc = _escape_cpp_string(fld.key)
                 lines.append(f'      if (key == "{esc}") return {i};')
             lines.append("      return -1;")
         lines.append("    default: return -1;")
@@ -829,10 +897,7 @@ namespace {ns} {{"""
     def _enum_name_arrays(self):
         out = []
         for e in self.b.enums.values():
-            lits = ", ".join(
-                '"' + v.replace("\\", "\\\\").replace('"', '\\"') + '"'
-                for v in e.values
-            )
+            lits = ", ".join('"' + _escape_cpp_string(v) + '"' for v in e.values)
             out.append(
                 f"  static constexpr const char *{e.name}_names[] = {{ {lits} }};"
             )
@@ -892,6 +957,10 @@ public:
   explicit RootBuilder(int stackSize = 1024) {{
     cb_ = makeCallbacks();
     parser_ = WeaselJsonParser_create(stackSize, &cb_, this, 0);
+    if (!parser_) {{
+      error_ = true;
+      return;
+    }}
 {self._ctor_body()}
   }}
   ~RootBuilder() {{ if (parser_) WeaselJsonParser_destroy(parser_); }}
@@ -995,9 +1064,11 @@ private:
       ++trim;
     }}
     int64_t finalExp = exp - fracDigits + trim;
+    size_t leadingZeros = 0;
+    while (leadingZeros < digits.size() && digits[leadingZeros] == '0') ++leadingZeros;
+    if (leadingZeros == digits.size()) {{ out = 0; return true; }}
     if (finalExp < 0) return false;
-    while (!digits.empty() && digits.front() == '0') digits.erase(digits.begin());
-    if (digits.empty()) {{ out = 0; return true; }}
+    if (leadingZeros > 0) digits.erase(0, leadingZeros);
 
     constexpr uint64_t kMaxNeg = 9223372036854775808ULL;
     constexpr uint64_t kMaxPos = 9223372036854775807ULL;

include/weaseljson.h

@@ -38,6 +38,8 @@ enum WeaselJsonStatus {
   WeaselJson_REJECT,
   /** json is too deeply nested */
   WeaselJson_OVERFLOW,
+  /** Tried to call parse on a null parser */
+  WeaselJson_NULL,
 };
 
 typedef struct WeaselJsonParser WeaselJsonParser;
@@ -65,7 +67,7 @@ void WeaselJsonParser_destroy(WeaselJsonParser *parser);
 /** Incrementally parse `len` more bytes starting at `buf`. `buf` may be
  * modified. Call with `len` 0 to indicate end of data. `buf` may be null if
  * `len` is 0. `len` must not be negative; a negative length is treated as a
- * rejected input. */
+ * rejected input. Returns WeaselJson_NULL if parser is null */
 WeaselJsonStatus WeaselJsonParser_parse(WeaselJsonParser *parser, char *buf,
                                         int len);
 

src/lib.cpp

@@ -46,6 +46,9 @@ WeaselJsonParser_destroy(WeaselJsonParser *parser) {
 
 __attribute__((visibility("default"))) WeaselJsonStatus
 WeaselJsonParser_parse(WeaselJsonParser *parser, char *buf, int len) {
+  if (parser == nullptr) [[unlikely]] {
+    return WeaselJson_NULL;
+  }
   return ((Parser3 *)parser)->parse(buf, len);
 }
 }

src/parser3.h

@@ -139,7 +139,7 @@ struct Parser3 {
     stackPtr = stack();
     std::ignore = push({N_VALUE, N_WHITESPACE, T_EOF});
     inKey = false;
-    rejected = false;
+    terminalStatus = WeaselJson_OK;
     utf8Codepoint = 0;
     utf16Surrogate = 0;
     minCodepoint = 0;
@@ -162,7 +162,7 @@ struct Parser3 {
   NumDfa numDfa;
   Utf8Dfa strDfa;
   bool inKey = false;
-  bool rejected = false;
+  WeaselJsonStatus terminalStatus = WeaselJson_OK;
 
 #ifndef HAS_MUSTTAIL
   char *stashBufForTrampoline;
@@ -650,7 +650,7 @@ inline PRESERVE_NONE ContinuationStatus n_string2(Parser3 *self, char *buf,
             self->writeBuf[0] = (0b00000111 & codepoint) | 0b11110000;
             self->writeBuf += 4;
           }
-        } else if (0xdc00 <= codepoint && codepoint <= 0xdfff) {
+        } else if (0xdc00 <= codepoint && codepoint <= 0xdfff) [[unlikely]] {
           return WeaselJson_REJECT;
         } else {
           if (!(self->flags & WeaselJsonRaw)) {
@@ -1070,12 +1070,12 @@ constexpr inline struct ContinuationTable {
 inline WeaselJsonStatus Parser3::parse(char *buf, int len) {
   this->dataBegin = this->writeBuf = buf;
 
-  if (this->rejected) [[unlikely]] {
-    return WeaselJson_REJECT;
+  if (this->terminalStatus != WeaselJson_OK) [[unlikely]] {
+    return this->terminalStatus;
   }
 
   if (len < 0) [[unlikely]] {
-    this->rejected = true;
+    this->terminalStatus = WeaselJson_REJECT;
     return WeaselJson_REJECT;
   }
 
@@ -1085,8 +1085,8 @@ inline WeaselJsonStatus Parser3::parse(char *buf, int len) {
   // range.
   ContinuationStatus status =
       symbolTables.continuations[top()](this, buf, buf + len);
-  if (status == WeaselJson_REJECT) {
-    this->rejected = true;
+  if (status > WeaselJson_AGAIN) {
+    this->terminalStatus = WeaselJsonStatus(status);
   }
   return WeaselJsonStatus(status);
 #else
@@ -1095,8 +1095,8 @@ inline WeaselJsonStatus Parser3::parse(char *buf, int len) {
   while ((result = symbolTables.continuations[top()](
               this, stashBufForTrampoline, buf + len)) == kBounce)
     ;
-  if (result == WeaselJson_REJECT) {
-    this->rejected = true;
+  if (result > WeaselJson_AGAIN) {
+    this->terminalStatus = WeaselJsonStatus(result);
   }
   return WeaselJsonStatus(result);
 #endif

src/test.cpp

@@ -202,6 +202,62 @@ TEST_CASE("parser3") {
   }
 }
 
+TEST_CASE("overflow state is sticky") {
+  auto c = noopCallbacks();
+  // stackSize 3 is exactly big enough to hold reset()'s bootstrap, but too
+  // small for nested arrays. Overflows must be terminal like rejects: a later
+  // end-of-data call must never report OK for an incomplete document.
+  auto *parser = WeaselJsonParser_create(3, &c, nullptr, 0);
+  REQUIRE(parser != nullptr);
+
+  std::string doc = "[[";
+  REQUIRE(WeaselJsonParser_parse(parser, doc.data(), doc.size()) ==
+          WeaselJson_OVERFLOW);
+
+  // After overflow, the end-of-data call must not return OK.
+  REQUIRE(WeaselJsonParser_parse(parser, nullptr, 0) != WeaselJson_OK);
+  // It should keep reporting a terminal failure.
+  REQUIRE(WeaselJsonParser_parse(parser, nullptr, 0) != WeaselJson_OK);
+
+  // Further data chunks must also stay terminal.
+  std::string more = "]]";
+  REQUIRE(WeaselJsonParser_parse(parser, more.data(), more.size()) !=
+          WeaselJson_OK);
+
+  WeaselJsonParser_destroy(parser);
+}
+
+TEST_CASE("overflow is sticky for nested objects") {
+  auto c = noopCallbacks();
+  auto *parser = WeaselJsonParser_create(4, &c, nullptr, 0);
+  REQUIRE(parser != nullptr);
+
+  std::string doc = "{\"a\":{ \"a\":";
+  REQUIRE(WeaselJsonParser_parse(parser, doc.data(), doc.size()) ==
+          WeaselJson_OVERFLOW);
+  REQUIRE(WeaselJsonParser_parse(parser, nullptr, 0) != WeaselJson_OK);
+
+  WeaselJsonParser_destroy(parser);
+}
+
+TEST_CASE("reset clears overflow state") {
+  auto c = noopCallbacks();
+  auto *parser = WeaselJsonParser_create(3, &c, nullptr, 0);
+  REQUIRE(parser != nullptr);
+
+  std::string doc = "[[";
+  REQUIRE(WeaselJsonParser_parse(parser, doc.data(), doc.size()) ==
+          WeaselJson_OVERFLOW);
+  // After reset the parser should accept a minimal document again.
+  WeaselJsonParser_reset(parser);
+  std::string copy = "1";
+  REQUIRE(WeaselJsonParser_parse(parser, copy.data(), copy.size()) ==
+          WeaselJson_AGAIN);
+  REQUIRE(WeaselJsonParser_parse(parser, nullptr, 0) == WeaselJson_OK);
+
+  WeaselJsonParser_destroy(parser);
+}
+
 TEST_CASE("rejected state is sticky") {
   auto c = noopCallbacks();
   auto *parser = WeaselJsonParser_create(1024, &c, nullptr, 0);
@@ -274,6 +330,10 @@ TEST_CASE("parse rejects negative length") {
   WeaselJsonParser_destroy(parser);
 }
 
+TEST_CASE("Calling parse with nullptr doesn't crash") {
+  REQUIRE(WeaselJsonParser_parse(nullptr, nullptr, 0) == WeaselJson_NULL);
+}
+
 TEST_CASE("streaming") { testStreaming(json); }
 
 TEST_CASE("reset clears inKey and transient state") {

src/validate.cpp

@@ -33,6 +33,9 @@ int main(int argc, char **argv) {
     case WeaselJson_REJECT:
     case WeaselJson_OVERFLOW:
       return 1;
+    case WeaselJson_NULL:
+      fprintf(stderr, "parse called with a null parser\n");
+      return 1;
     }
     if (l == 0) {
       return 1;

weaseljson.py

@@ -30,6 +30,7 @@ class WeaselJsonStatus(enum.Enum):
     AGAIN = 1
     REJECT = 2
     OVERFLOW = 3
+    NULL = 4
 
 
 class WeaselJsonCallbacksBase: