Add JSONBuilder.string_with_len() method (#1244)

Author: Akuli

doc/json-building.md

@@ -82,6 +82,9 @@ To actually build the JSON, use the following methods, where `jb` is a `JSONBuil
 - `jb.string(s: byte*)` adds a string to the JSON.
     If `s` is `NULL`, it instead adds `null` just like `jb.null()` would.
     See also [the notes about strings below](#notes-about-strings).
+- `jb.string_with_len(s: byte*, len: intnative)` is like `jb.string(s)` except that the string may contain zero bytes.
+    Instead of looking for a zero byte to figure out where the string ends,
+    the length in bytes is given as an argument.
 - `jb.begin_array()` and `jb.end_array()` are used to build a JSON array.
     Between calling these methods, you build each item of the array.
     See also [the notes about arrays and objects below](#notes-about-arrays-and-objects).
@@ -133,10 +136,6 @@ There is a similar problem with [parsing JSON](json-parsing.md#notes-about-numbe
 
 ## Notes about strings
 
-It is currently not possible to add a string containing the zero byte `\0` to JSON.
-This would be easy to implement if needed, so
-please [create an issue on GitHub](https://github.com/Akuli/jou/issues/new) if you need this.
-
 The string given to `JSONBuilder.string()` should be valid UTF-8.
 If it isn't, the resulting JSON will simply contain the given invalid UTF-8.
 

stdlib/json.jou

@@ -1,5 +1,6 @@
 import "stdlib/ascii.jou"
 import "stdlib/assert.jou"
+import "stdlib/intnative.jou"
 import "stdlib/list.jou"
 import "stdlib/mem.jou"
 import "stdlib/str.jou"
@@ -85,7 +86,7 @@ class JSONBuilder:
 
         self.add_comma_if_needed()
         self.new_line()
-        self.add_string_to_output(key)
+        self.add_string_to_output(key, strlen(key))
         self.output.append(':')
         if self.pretty_print != 0:
             self.output.append(' ')
@@ -127,49 +128,55 @@ class JSONBuilder:
             self.output.extend_from_ptr("false", 5)
 
     @public
-    def string(self, s: byte*) -> None:
+    def string_with_len(self, s: byte*, len: intnative) -> None:
         if s == NULL:
             self.null()
         else:
+            assert len >= 0
             self.before_a_value()
-            self.add_string_to_output(s)
+            self.add_string_to_output(s, len)
+
+    @public
+    def string(self, s: byte*) -> None:
+        self.string_with_len(s, 0 if s == NULL else strlen(s))
 
     # This method is used for .string() and .key() methods.
-    def add_string_to_output(self, s: byte*) -> None:
+    def add_string_to_output(self, s: byte*, len: intnative) -> None:
         self.output.append('"')
-        while *s != '\0':
-            match *s:
+        i: intnative = 0
+        while i < len:
+            match s[i]:
                 case '\n':
                     self.output.extend_from_ptr("\\n", 2)
-                    s++
+                    i++
                 case '\t':
                     self.output.extend_from_ptr("\\t", 2)
-                    s++
+                    i++
                 case '\r':
                     self.output.extend_from_ptr("\\r", 2)
-                    s++
+                    i++
                 case '"' | '\\':
                     self.output.append('\\')
-                    self.output.append(*s++)
+                    self.output.append(s[i++])
                 case _:
-                    if is_ascii_printable(*s):
-                        self.output.append(*s++)
-                    elif *s < 128:
+                    if is_ascii_printable(s[i]):
+                        self.output.append(s[i++])
+                    elif s[i] < 128:
                         # unprintable ASCII character, do these carefully
                         buf: byte[16]
-                        sprintf(buf, "\\u00%02x", *s++)
+                        sprintf(buf, "\\u00%02x", s[i++])
                         self.output.extend_from_ptr(buf, strlen(buf))
-                    elif starts_with(s, "\xe2\x80\xa8"):
+                    elif len-i >= 3 and starts_with(&s[i], "\xe2\x80\xa8"):
                         # Unicode character U+2028, placing it directly into JSON may cause problems
                         self.output.extend_from_ptr("\\u2028", 6)
-                        s = &s[3]
-                    elif starts_with(s, "\xe2\x80\xa9"):
+                        i += 3
+                    elif len-i >= 3 and starts_with(&s[i], "\xe2\x80\xa9"):
                         # Unicode character U+2029, placing it directly into JSON may cause problems
                         self.output.extend_from_ptr("\\u2029", 6)
-                        s = &s[3]
+                        i += 3
                     else:
                         # part of a non-ASCII character in UTF-8, output it as is
-                        self.output.append(*s++)
+                        self.output.append(s[i++])
         self.output.append('"')
 
     @public

tests/should_succeed/json_test_builder.jou

@@ -147,6 +147,33 @@ def test_strings() -> None:
     printf("%d\n", strcmp(json, "\"non-ASCII like €£💸 is valid as is\""))  # Output: 0
     free(json)
 
+    # String that contains zero bytes
+    hello0world = ['h', 'e', 'l', 'l', 'o', '\0', 'w', 'o', 'r', 'l', 'd']
+    corner_case: byte[7] = ['w', 'a', 't', '\0', '\xe2', '\x80', '\xa9']
+    jb = JSONBuilder{}
+    jb.begin_array()
+    jb.string_with_len(hello0world, 11)
+    jb.string_with_len("test", 5)
+    jb.string_with_len(corner_case, 7)
+    jb.end_array()
+    json = jb.finish()
+    puts(json)  # Output: ["hello\u0000world","test\u0000","wat\u0000\u2029"]
+    free(json)
+
+    # Invalid UTF-8 is passed through as is. The check for U+2028/U+2029
+    # shouldn't read beyond the end of the string even in this case.
+    #
+    # Using malloc() so any problems can hopefully be found with valgrind.
+    s: byte* = malloc(2)
+    s[0] = '\xe2'
+    s[1] = '\x80'
+    jb = JSONBuilder{}
+    jb.string_with_len(s, 2)
+    free(s)
+    json = jb.finish()
+    printf("%d\n", strcmp(json, "\"\xe2\x80\""))  # Output: 0
+    free(json)
+
 
 def test_numbers() -> None:
     jb = JSONBuilder{pretty_print = 2}