← json token ideal • runtime • formats • json parser json printer →
JSON parser implementation.
class json parser
import ideal • runtime • patterns • list pattern
import ideal • machine • channels • string writer
auto constructor class parse result
readonly value the value
character handler the character handler
var list[readonly data] tokens
var string or null error
json parser(character handler the character handler)
this • the character handler = the character handler
tokens = base list[readonly data] • new()
boolean has error => error is_not null
private void tokenize(string input)
tokens • clear()
var nonnegative start : 0
while start < input • size && error is null
start = scan(input, start)
list[readonly data] test tokenize(string input)
tokenize(input)
assert !has error()
return tokens
readonly value parse(string input)
tokenize(input)
assert !has error()
assert !has error()
return result • the value
private nonnegative scan(string input, nonnegative start)
next : input[start]
var nonnegative index : start + 1
if the character handler • is whitespace(next)
while index < input • size && the character handler • is whitespace(input[index])
index += 1
return index
if next == '"'
result : string writer • new()
while index < input • size
next in input : input[index]
if next in input == '"'
tokens • append(result • elements())
return index + 1
else if next in input == '\\'
if index >= input • size
report error("Escape at the end of input")
return index
index += 1
escaped character : input[index]
if escaped character == '"' || escaped character == '\\' || escaped character == '/'
result • write(escaped character)
else if escaped character == 'b'
result • write('\b')
else if escaped character == 'f'
result • write('\f')
else if escaped character == 'n'
result • write('\n')
else if escaped character == 'r'
result • write('\r')
else if escaped character == 't'
result • write('\t')
else if escaped character == 'u'
if index + 4 >= input • size
report error("Unicode escape at the end of input")
return index
var code : hex digit(input[index + 1])
code = code * 16 + hex digit(input[index + 2])
code = code * 16 + hex digit(input[index + 3])
code = code * 16 + hex digit(input[index + 4])
result • write(the character handler • from code(code))
index += 4
else
report error("Unrecognized escape character: " ++ escaped character)
return index
else
result • write(next in input)
index += 1
report error("No closing quote in a string")
return index
if the character handler • is digit(next)
return scan number(input, start, false)
if next == '-'
if index < input • size
return scan number(input, index, true)
else
report error("Minus at the end of input")
return index
if next == json token • OPEN BRACE • the character
return index
if next == json token • CLOSE BRACE • the character
return index
if next == json token • OPEN BRACKET • the character
return index
if next == json token • CLOSE BRACKET • the character
return index
if next == json token • COMMA • the character
return index
if next == json token • COLON • the character
return index
if next == 't'
return scan symbol(input, start, "true", true)
if next == 'f'
return scan symbol(input, start, "false", false)
if next == 'n'
return scan symbol(input, start, "null", missing • instance)
report error("Unrecognized character in a string: " ++ next)
return index
private nonnegative hex digit(character the character)
result : the character handler • from digit(the character, 16)
if result is nonnegative
return result
else
report error("Unrecognized character in hex escape: " ++ the character)
return 0
private nonnegative scan number(string input, nonnegative start, boolean negate)
next : input[start]
if !the character handler • is digit(next)
report error("Unrecognized digit: " ++ next)
return start
assert digit is nonnegative
var nonnegative result : digit
var index : start + 1
while index < input • size && the character handler • is digit(input[index])
assert next digit is nonnegative
result = result * radix • DEFAULT RADIX + next digit
index += 1
tokens • append(negate ? -result : result)
return index
private nonnegative scan symbol(string input, nonnegative start, string symbol, deeply immutable data value)
prefix : list pattern[character] • new(symbol) • match prefix(input • skip(start))
if prefix is_not null
if prefix == symbol • size
tokens • append(value)
return start + prefix
report error("Can't scan symbol: " ++ symbol)
return start + 1
private parse result parse value(nonnegative start)
if start >= tokens • size
return parse error("End of tokens when parsing value")
next : tokens[start]
if next == json token • OPEN BRACE
return parse object(start)
else if next == json token • OPEN BRACKET
return parse array(start)
if next is json token
return parse error("Unexpected token: " ++ next)
return parse result • new(next, start + 1)
private parse result parse object(nonnegative start)
if tokens[start] != json token • OPEN BRACE
return parse error("Open brace expected")
result : hash dictionary[string, readonly value] • new()
var index : start + 1
while index < tokens • size
next : tokens[index]
if next == json token • CLOSE BRACE
return parse result • new(result, index + 1)
if next is_not string
return parse error("Expected string identifier in object")
index += 1
while index >= tokens • size || tokens[index] != json token • COLON
return parse error("Expected colon in object")
index += 1
element : parse value(index)
if has error()
return element
result • put(next, element • the value)
index = element • end index
if index >= tokens • size
return parse error("No closing brace in object")
if tokens[index] == json token • CLOSE BRACE
return parse result • new(result, index + 1)
if tokens[index] != json token • COMMA
return parse error("Expected comma in object")
index += 1
return parse error("No closing brace in object")
private parse result parse array(nonnegative start)
if tokens[start] != json token • OPEN BRACKET
return parse error("Open bracket expected")
result : base list[readonly value] • new()
var index : start + 1
while index < tokens • size
if tokens[index] == json token • CLOSE BRACKET
return parse result • new(result, index + 1)
element : parse value(index)
if has error()
return element
result • append(element • the value)
index = element • end index
if index >= tokens • size
return parse error("No closing bracket in array")
if tokens[index] == json token • CLOSE BRACKET
return parse result • new(result, index + 1)
if tokens[index] != json token • COMMA
return parse error("Expected comma in array")
index += 1
return parse error("No closing bracket in array")
private void report error(string message)
error = message
private parse result parse error(string message)
report error(message)
return parse result • new(message, 0)
← json token ideal • runtime • formats • json parser json printer →