JSON is a very common data interchange format. I don't love it, but sooner or later you have to deal with it.
So, this morning I wrote a JSON parser for MiniScript. This (or something very like it) will be in /sys/lib in Mini Micro 0.9, and will ship with command-line MiniScript once that gets support for import. But I thought I'd share here anyway, in case anyone has need of it before then.
Note that there are three useful entry points:
- parse(jsonString): returns a MiniScript data structure representing the data.
- unescape(s): undoes JSON-style escape sequences, converting \t into char(9) for example.
- hexToInt(hexString): converts a hex string like "002f" into a number like 47.
🤔 Given a big ol' input file, this will also serve as a great benchmark of general MiniScript processing.
So here's the code. It's a bit long, but a third or so of that is the unit tests. (And note that the syntax colorer on this forum gets a little confused by the backslashes... sorry about that.)
Enjoy,
Joe
// JSON (JavaScript Object Notation) is a common format for exchanging data
// between different computers or programs. See: https://json.org/
// The data types in JSON are number, string, object, and array, which
// correspond very neatly to MiniScript's number, string, map, and list.
//
// This module provides code to read and write data in JSON format, as well
// as a couple of utility functions for escaping/unescaping strings and
// converting numbers to/from hexadecimal.
// parse: convert a JSON string into a MiniScript value (which could
// include a list or map of other values). This is the main entry point
// for reading JSON data and converting it to native form.
// Example: parse("42") // returns 42
parse = function(jsonString)
p = new Parser
return p.parse(jsonString)
end function
// toJSON: convert a MiniScript value to its JSON representation.
// Example: toJSON(42) // returns "42"
//
// Parameters:
// value: MiniScript value to convert
// compact: if true, omit all unnecessary whitespace
// indent: amount to indent if multiple lines are needed
toJSON = function(value, compact=false, indent=0)
if @value isa funcRef then return """<function>"""
if value == null then return "null"
if value isa number then return str(value)
if value isa string then return """" + escape(value) + """"
if value isa list then return _listToJSON(value, compact, indent)
if value isa map then return _mapToJSON(value, compact, indent)
end function
// hexToInt: convert a string containing a hexadecimal number.
// Supports both uppercase and lowercase for digits A-F.
// Example: hexToInt("002A") // returns 42
hexToInt = function(s)
result = 0
for c in s
result = result * 16 + _hexDigitMap[c]
end for
return result
end function
// escape: find certain characters (tab, newline, etc.) in the given string,
// and represent them with backslash sequences.
// Example: escape(char(c)) // returns "\t"
escape = function(s)
for i in _escapeIndexes
s = s.replace(_escapeFrom[i], _escapeTo[i])
end for
return s
end function
// unescape: replace backslash sequences in the given string.
// Example: unescape("\t") // returns char(9)
unescape = function(s)
result = []
i = 0
maxi = s.len
while i < maxi
di = 1
if s[i] == "\" then
di = 2
c = s[i+1]
if c == "b" then
result.push char(8)
else if c == "t" then
result.push char(9)
else if c == "n" then
result.push char(10)
else if c == "f" then
result.push char(12)
else if c == "r" then
result.push char(13)
else if c == "u" then
// Unicode code point (must always be 4 digits)
hex = s[i+2:i+6]
result.push char(hexToInt(hex))
di = 6
else
result.push c
end if
else
result.push s[i]
end if
i = i + di
end while
return result.join("")
end function
//----------------------------------------------------------------------
// Stuff below is internal implementation;
// most users don't need to poke around here.
// Parsing JSON
Parser = {}
Parser.source = ""
Parser._sourceLen = 0
Parser._p = 0 // index of next character to consume in source
Parser.init = function(source)
self.source = source
self._sourceLen = source.len
end function
Parser.parse = function(source=null)
if source != null then self.init source
self._p = 0
return self._parseElement
end function
whitespace = " " + char(9) + char(10) + char(13)
Parser._skipWhitespace = function()
while self._p < self._sourceLen
c = self.source[self._p]
if whitespace.indexOf(c) == null then break
self._p = self._p + 1
end while
end function
Parser._parseElement = function()
return self._parseValue // for now!
end function
Parser._parseValue = function()
self._skipWhitespace
c = self.source[self._p]
if c == """" then return self._parseString
if "0123456789-.".indexOf(c) != null then return self._parseNumber
if c == "[" then return self._parseList
if c == "{" then return self._parseMap
if c == "t" and self.source[self._p:self._p+4] == "true" then
self._p = self._p + 4
return true
end if
if c == "f" and self.source[self._p:self._p+5] == "false" then
self._p = self._p + 5
return false
end if
if c == "n" and self.source[self._p:self._p+4] == "null" then
self._p = self._p + 4
return null
end if
end function
Parser._parseList = function()
self._p = self._p + 1 // skip "["
self._skipWhitespace
result = []
while self._p < self._sourceLen
c = self.source[self._p]
if c == "]" then break
result.push self._parseElement
self._skipWhitespace
// after an element, we should have either a comma or a ']'
c = self.source[self._p]
if c == "," then
self._p = self._p + 1
self._skipWhitespace
end if
end while
self._p = self._p + 1
return result
end function
Parser._parseMap = function()
self._p = self._p + 1 // skip "{"
self._skipWhitespace
result = {}
while self._p < self._sourceLen
// grab the key (must be a string)
c = self.source[self._p]
if c == "}" then break
if c != """" then
print "JSON error: object member key must be a string literal" // ToDo: better error handling!
print "Error at position " + self._p + ": " + self.source[self._p-60 : self._p+60]
return null
end if
key = self._parseString
self._skipWhitespace
// next token must be a colon
if self.source[self._p] != ":" then
print "JSON error: colon expected"
print "Error at position " + self._p + ": " + self.source[self._p-60 : self._p+60]
return null
end if
self._p = self._p + 1
self._skipWhitespace
// grab the value (could be anything)
value = self._parseElement
result[key] = value
self._skipWhitespace
// after a a key/value pair, we should have either a comma or a '}'
c = self.source[self._p]
if c == "," then
self._p = self._p + 1
self._skipWhitespace
end if
end while
self._p = self._p + 1
return result
end function
// Get a string literal from the source. Advance to the next
// character after the closing quote.
Parser._parseString = function()
self._p = self._p + 1
startPos = self._p
anyEscape = false
while self._p < self._sourceLen
c = self.source[self._p]
self._p = self._p + 1
if c == """" then break
if c == "\" then
anyEscape = true
self._p = self._p + 1
end if
end while
result = self.source[startPos : self._p-1]
if anyEscape then result = unescape(result)
return result
end function
// Get a numeric literal from the source. Advance to the next
// character after the number.
Parser._parseNumber = function()
startPos = self._p
while self._p < self._sourceLen
c = self.source[self._p]
// Note that we are rather permissive here, consuming things like
// 1-2e5+4E7, which is not valid JSON. But we're not trying to be
// a JSON validator; we're just trying to grok valid JSON as quickly
// as we can.
if "0123456789+-.eE".indexOf(c) == null then break
self._p = self._p + 1
end while
result = val(self.source[startPos : self._p])
return result
end function
// Generating JSON
_listToJSON = function(lst, compact, indent)
ws = (_eol + " "*(indent+1)) * (not compact)
parts = ["[", ws]
first = true
for item in lst
if not first then
parts.push ","
parts.push ws
end if
parts.push toJSON(item, compact, indent+1)
first = false
end for
if not compact then parts.push _eol + " " * indent
parts.push "]"
return join(parts, "")
end function
_mapToJSON = function(lst, compact, indent)
ws = (_eol + " "*(indent+1)) * (not compact)
parts = ["{", ws]
first = true
for kv in lst
if not first then
parts.push ","
parts.push ws
end if
parts.push toJSON(str(kv.key))
parts.push ":"
if not compact then parts.push " "
parts.push toJSON(@kv.value, compact, indent+1)
first = false
end for
if not compact then parts.push _eol + " " * indent
parts.push "}"
return join(parts, "")
end function
// General utility data structures
_eol = char(13)
_hexDigitMap = {}
for i in range(0,15)
if i < 10 then
_hexDigitMap[str(i)] = i
else
_hexDigitMap[char(55+i)] = i // (lowercase hex digit)
_hexDigitMap[char(87+i)] = i // (uppercase hex digit)
end if
end for
_escapeFrom = ["\", """", char(8), char(9), char(10), char(12), char(13)]
_escapeTo = ["\\", "\""", "\b","\t","\n","\f","\r"]
_escapeIndexes = _escapeFrom.indexes
//----------------------------------------------------------------------
// Unit tests (run when you load & run this script directly).
if locals == globals then
print "Unit testing: json"
errorCount = 0
assertEqual = function(actual, expected)
if actual != expected then
print "Unit test failure: expected " + expected + ", got " + actual
outer.errorCount = errorCount + 1
end if
end function
assertEqualEither = function(actual, expected, expected2)
if actual != expected and actual != expected2 then
print "Unit test failure: expected " + expected + ", got " + actual
outer.errorCount = errorCount + 1
end if
end function
p = new Parser
p.init(" true ")
assertEqual p.parse, "true"
assertEqual parse(char(13) + "42"), 42
assertEqual parse("-123.45"), -123.45
assertEqual parse(".5"), 0.5
assertEqual parse("""\tHello, \""Bob\""."""), char(9) + "Hello, ""Bob""."
assertEqual parse("""\u002F"""), "/"
assertEqual parse("[1, 2 , 3]"), [1, 2, 3]
assertEqual parse("[ ""hey"", true, [0]]"), ["hey", true, [0]]
assertEqual parse("{""hey"": ""ho"", ""9"" : 81}"), {"hey":"ho", "9":81}
// And here's a longer example... remember, quotes doubled only
// to make them valid MiniScript string literals...
data = parse("{""widget"": {" +
" ""debug"": ""on""," +
" ""window"": {" +
" ""title"": ""Sample Konfabulator Widget""," +
" ""name"": ""main_window""," +
" ""visible"": false," +
" ""width"": 500," +
" ""height"": 300," +
" ""left"": -123.456," +
" ""top"": 234.567," +
" }," +
" ""image"": { " +
" ""src"": ""Images\\Sun.png""," +
" ""name"": ""sun1""," +
" ""hOffset"": 250," +
" ""vOffset"": 250," +
" ""alignment"": ""center""" +
" }," +
" ""text"": {" +
" ""data"": ""Click Here""," +
" ""size"": 36," +
" ""style"": ""bold""," +
" ""name"": ""text1""," +
" ""hOffset"": 250," +
" ""vOffset"": 100," +
" ""alignment"": ""center""," +
" ""onMouseUp"": ""sun1.opacity = (sun1.opacity / 100) * 90;""" +
" }}}")
assertEqual data.widget.debug, "on"
assertEqual data.widget.window.width, 500
assertEqual data.widget.image.src, "Images\Sun.png"
assertEqual data.widget.text.size, 36
assertEqual toJSON(42), "42"
assertEqual toJSON(char(9)), """\t"""
assertEqual toJSON([1, 2, 3], true), "[1,2,3]"
// Maps are a bit tricky to unit-test, since the order in which the keys appear
// is undefined. But here we go:
assertEqualEither toJSON({"one":1, "two":2}, true),
"{""one"":1,""two"":2}", "{""two"":2,""one"":1}"
if errorCount == 0 then
print "All tests passed. Huzzah!"
else
print errorCount + " error" + "s" * (errorCount!=1) + " found."
end if
end if
