dc1369f | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

dc1369f — Peter John 2026-11-01T21:39:34+05:30

perf: Json parser/escaper loops instead of per-char recursion; parseString returns Str

Files changed (1) hide show

plum-std/Json.plum +166 -146

plum-std/Json.plum CHANGED Viewed

@@ -128,7 +128,8 @@ record JsonParser(src: Str, pos: Int, text: Str) =
     self.skipSpace()
     c := self.peek()
     if c == 34
-      return self.parseString()
+      str := try self.parseString()
+      return str
     if c == 91
       return self.parseArray()
     if c == 123
@@ -197,87 +198,73 @@ record JsonParser(src: Str, pos: Int, text: Str) =
       return error.InvalidJson
     return mv * 10.pow(Float(ev))
-  fun parseString(self) -> error{InvalidJson}!Json =
+  fun parseString(self) -> error{InvalidJson}!Str =
     self.advance()
-    return self.parseStringBody(Buffer())
+    buf := Buffer()
-  fun parseStringBody(self, buf: Buffer) -> error{InvalidJson}!Json =
+    while true
-    c := self.peek()
+      c := self.peek()
-    if c == 0
+      if c == 0
-      self.note("unterminated string")
+        self.note("unterminated string")
-      return error.InvalidJson
+        return error.InvalidJson
-    if c == 34
+      if c == 34
-      self.advance()
+        self.advance()
-      return buf.toStr()
+        return buf.toStr()
-    if c == 92
+      if c == 92
-      return self.parseEscape(buf)
+        try self.parseEscape(buf)
+      else
-    n := self.src.codePointByteLength(self.pos)
+        n := self.src.codePointByteLength(self.pos)
-    buf.write(self.src.sub(self.pos, self.pos + n))
+        buf.write(self.src.sub(self.pos, self.pos + n))
-    self.pos = self.pos + n
+        self.pos = self.pos + n
-    return self.parseStringBody(buf)
+    return buf.toStr()
+  # Handles one escape sequence (the cursor is on the backslash), writing the
+  # decoded text into `buf`.
-  fun parseEscape(self, buf: Buffer) -> error{InvalidJson}!Json =
+  fun parseEscape(self, buf: Buffer) -> error{InvalidJson}!Unit =
     self.advance()
     esc := self.peek()
+    if esc == 117
+      self.advance()
+      return self.parseUnicodeEscape(buf)
     if esc == 34
       buf.write("\"")
-      self.advance()
-      return self.parseStringBody(buf)
-    if esc == 92
+    else if esc == 92
       buf.write("\\")
-      self.advance()
-      return self.parseStringBody(buf)
-    if esc == 47
+    else if esc == 47
       buf.write("/")
-      self.advance()
-      return self.parseStringBody(buf)
-    if esc == 98
+    else if esc == 98
       buf.write("\b")
-      self.advance()
-      return self.parseStringBody(buf)
-    if esc == 102
+    else if esc == 102
       buf.write("\f")
-      self.advance()
-      return self.parseStringBody(buf)
-    if esc == 110
+    else if esc == 110
       buf.write("\n")
-      self.advance()
-      return self.parseStringBody(buf)
-    if esc == 114
+    else if esc == 114
       buf.write("\r")
-      self.advance()
-      return self.parseStringBody(buf)
-    if esc == 116
+    else if esc == 116
       buf.write("\t")
-      self.advance()
+    else
-      return self.parseStringBody(buf)
-    if esc == 117
-      self.advance()
-      return self.parseUnicodeEscape(buf)
-    self.note("invalid escape character")
+      self.note("invalid escape character")
-    return error.InvalidJson
-  fun parseHex4(self) -> error{InvalidJson}!Int =
-    return self.parseHex4From(0, 0)
-  fun parseHex4From(self, value: Int, count: Int) -> error{InvalidJson}!Int =
-    if count == 4
-      return value
-    d := hexDigitValue(self.peek())
-    if d < 0
-      self.note("invalid unicode escape")
       return error.InvalidJson
     self.advance()
-    return self.parseHex4From(value * 16 + d, count + 1)
-  fun parseUnicodeEscape(self, buf: Buffer) -> error{InvalidJson}!Json =
+  fun parseHex4(self) -> error{InvalidJson}!Int =
+    value := 0
+    count := 0
+    while count < 4
-    cp := try self.parseHex4()
+      d := hexDigitValue(self.peek())
+      if d < 0
-    return self.parseUnicodeEscapeCont(buf, cp)
+        self.note("invalid unicode escape")
+        return error.InvalidJson
+      self.advance()
+      value = value * 16 + d
+      count = count + 1
+    return value
-  # A high surrogate (`0xD800`..`0xDBFF`) must be followed immediately by a
+  # Decodes the four hex digits after `\u` (and, for a high surrogate
-  # low surrogate (`0xDC00`..`0xDFFF`) `\u` escape; the pair together encodes
+  # (`0xD800`..`0xDBFF`), the `\u` low surrogate (`0xDC00`..`0xDFFF`) that must
+  # follow immediately; the pair encodes one codepoint above `0xFFFF`). Any
-  # one codepoint above `0xFFFF`. Any other codepoint is used as-is.
+  # other codepoint is used as-is.
-  fun parseUnicodeEscapeCont(self, buf: Buffer, cp: Int) -> error{InvalidJson}!Json =
+  fun parseUnicodeEscape(self, buf: Buffer) -> error{InvalidJson}!Unit =
+    cp := try self.parseHex4()
     if cp >= 0xD800 && cp <= 0xDBFF && self.peek() == 92 && self.peekAt(1) == 117
       self.advance()
       self.advance()
@@ -287,9 +274,8 @@ record JsonParser(src: Str, pos: Int, text: Str) =
         return error.InvalidJson
       combined := 0x10000 + {{cp - 0xD800} << 10} + {low - 0xDC00}
       buf.writeRune(combined)
-      return self.parseStringBody(buf)
+      return
     buf.writeRune(cp)
-    return self.parseStringBody(buf)
   fun parseArray(self) -> error{InvalidJson}!Json =
     self.advance()
@@ -298,22 +284,20 @@ record JsonParser(src: Str, pos: Int, text: Str) =
     if self.peek() == 93
       self.advance()
       return items
-    return self.parseArrayItems(items)
+    while true
-  fun parseArrayItems(self, items: List[Json]) -> error{InvalidJson}!Json =
-    self.skipSpace()
+      self.skipSpace()
-    v := try self.parseValue()
+      v := try self.parseValue()
-    items.add(v)
+      items.add(v)
-    self.skipSpace()
+      self.skipSpace()
-    c := self.peek()
+      c := self.peek()
-    if c == 44
+      if c == 93
-      self.advance()
+        self.advance()
-      return self.parseArrayItems(items)
+        return items
-    if c == 93
+      if c != 44
+        self.note("expected ',' or ']'")
+        return error.InvalidJson
       self.advance()
-      return items
+    return items
-    self.note("expected ',' or ']'")
-    return error.InvalidJson
   fun parseObject(self) -> error{InvalidJson}!Json =
     self.advance()
@@ -322,40 +306,30 @@ record JsonParser(src: Str, pos: Int, text: Str) =
     if self.peek() == 125
       self.advance()
       return pairs
-    return self.parseObjectItems(pairs)
+    while true
-  fun parseObjectItems(self, pairs: Map[Str, Json]) -> error{InvalidJson}!Json =
-    self.skipSpace()
+      self.skipSpace()
-    if self.peek() != 34
+      if self.peek() != 34
-      self.note("expected string key")
+        self.note("expected string key")
-      return error.InvalidJson
+        return error.InvalidJson
-    keyJson := try self.parseString()
+      key := try self.parseString()
-    return self.parseObjectValue(pairs, jsonStrValue(keyJson))
-  fun parseObjectValue(self, pairs: Map[Str, Json], key: Str) -> error{InvalidJson}!Json =
-    self.skipSpace()
+      self.skipSpace()
-    if self.peek() != 58
+      if self.peek() != 58
-      self.note("expected ':'")
+        self.note("expected ':'")
-      return error.InvalidJson
+        return error.InvalidJson
-    self.advance()
-    self.skipSpace()
-    v := try self.parseValue()
-    pairs.set(key, v)
-    self.skipSpace()
-    c := self.peek()
-    if c == 44
       self.advance()
+      self.skipSpace()
-      return self.parseObjectItems(pairs)
+      v := try self.parseValue()
+      pairs.set(key, v)
+      self.skipSpace()
+      c := self.peek()
-    if c == 125
+      if c == 125
+        self.advance()
+        return pairs
+      if c != 44
+        self.note("expected ',' or '}}'")
+        return error.InvalidJson
       self.advance()
-      return pairs
+    return pairs
-    self.note("expected ',' or '}}'")
-    return error.InvalidJson
-fun jsonStrValue(j: Json) -> Str =
-  match j
-    Str => j
-    _ => ""
 # `Map` has no built-in `toStr`/`join` (unlike `List`, which uses `join` for
 # `Json.toStr`'s `JsonList` case above) — a plain free function taking the
@@ -390,35 +364,36 @@ fun exponentIndex(text: Str) -> Int =
   if e >= 0 then e else text.indexOf("E")
 fun escapeJsonStr(s: Str) -> Str =
+  buf := Buffer()
-  escapeJsonFrom(s, 0, s.length())
+  len := s.length()
-# Byte-at-a-time except for the pass-through case, which copies a whole
-# UTF-8 codepoint at once — copying a lone continuation byte as its own
-# "character" (as a naive byte-by-byte pass-through would) would corrupt any
-# non-ASCII text, the same hazard documented on `Str`'s own `escapeChar` in
-# `libs/std/str.plum`.
+  i := 0
-fun escapeJsonFrom(s: Str, i: Int, len: Int) -> Str =
-  if i >= len
+  while i < len
-    return ""
-  b := s.byteAt(i)
+    b := s.byteAt(i)
-  if b == 34
+    if b == 34
-    return "\\\"" + escapeJsonFrom(s, i + 1, len)
+      buf.write("\\\"")
-  if b == 92
+    else if b == 92
-    return "\\\\" + escapeJsonFrom(s, i + 1, len)
+      buf.write("\\\\")
-  if b == 10
+    else if b == 10
-    return "\\n" + escapeJsonFrom(s, i + 1, len)
+      buf.write("\\n")
-  if b == 13
+    else if b == 13
-    return "\\r" + escapeJsonFrom(s, i + 1, len)
+      buf.write("\\r")
-  if b == 9
+    else if b == 9
-    return "\\t" + escapeJsonFrom(s, i + 1, len)
+      buf.write("\\t")
-  if b == 8
+    else if b == 8
-    return "\\b" + escapeJsonFrom(s, i + 1, len)
+      buf.write("\\b")
-  if b == 12
+    else if b == 12
-    return "\\f" + escapeJsonFrom(s, i + 1, len)
+      buf.write("\\f")
-  if b < 0x20
+    else if b < 0x20
+      buf.write("\\u00")
+      buf.write(hexByteStr(b))
+    else
+      # Copies a whole UTF-8 codepoint at once: copying a lone continuation
-    return "\\u00" + hexByteStr(b) + escapeJsonFrom(s, i + 1, len)
+      # byte as its own "character" would corrupt any non-ASCII text.
-  n := s.codePointByteLength(i)
+      n := s.codePointByteLength(i)
-  return s.sub(i, i + n) + escapeJsonFrom(s, i + n, len)
+      buf.write(s.sub(i, i + n))
+      i = i + n - 1
+    i = i + 1
+  return buf.toStr()
 fun hexByteStr(b: Int) -> Str =
   hexDigitChar(b / 16) + hexDigitChar(b % 16)
@@ -460,7 +435,7 @@ fun isDigit(c: Int) -> Bool =
 # ---- regression tests ----
-fun jsonOf(s: Str) -> Json = s
 fun parseFloatValue(s: Str) -> Float =
   v := Json.fromStr(s) catch e
@@ -527,5 +502,50 @@ test "round-trips a value through toStr and back"
   assert again.toStr() == v.toStr()
 test "toStr escapes special characters in strings"
-  v := jsonOf("a\"b\\c\nd")
+  v: Json := "a\"b\\c\nd"
   assert v.toStr() == "\"a\\\"b\\\\c\\nd\""
+test "round-trips a 100000 character string"
+  buf := Buffer()
+  i := 0
+  while i < 100000
+    buf.write("a")
+    i = i + 1
+  doc := "\"" + buf.toStr() + "\""
+  v := Json.fromStr(doc)!
+  assert v.asStr()!.length() == 100000
+  assert v.toStr().length() == 100002
+test "parses a 10000 element array"
+  buf := Buffer()
+  buf.write("[0")
+  i := 1
+  while i < 10000
+    buf.write(",{i}")
+    i = i + 1
+  buf.write("]")
+  items := Json.fromStr(buf.toStr())!.asList()!
+  assert items.length() == 10000
+  assert items.get(9999)!.asFloat()! == 9999.0f
+test "parses an object with 2000 keys"
+  buf := Buffer()
+  buf.write("{{\"k0\":0")
+  i := 1
+  while i < 2000
+    buf.write(",\"k{i}\":{i}")
+    i = i + 1
+  buf.write("}}")
+  pairs := Json.fromStr(buf.toStr())!.asMap()!
+  assert pairs.get("k1999")!.asFloat()! == 1999.0f
+  assert pairs.get("k0")!.asFloat()! == 0.0f
+test "escapes a 50000 character string of quotes and newlines"
+  buf := Buffer()
+  i := 0
+  while i < 25000
+    buf.write("\"\n")
+    i = i + 1
+  j: Json := buf.toStr()
+  out := j.toStr()
+  assert out.length() == 100002