mirror of
https://github.com/clusterio/clusterio.git
synced 2026-11-12 07:04:52 +09:00
851 lines
27 KiB
Lua
851 lines
27 KiB
Lua
-- Simple JSON encoding and decoding in pure Lua.
|
|
--
|
|
-- Copyright 2010-2016 Jeffrey Friedl
|
|
-- http://regex.info/blog/
|
|
-- Latest version: http://regex.info/blog/lua/json
|
|
--
|
|
-- This code is released under a Creative Commons CC-BY "Attribution" License:
|
|
-- http://creativecommons.org/licenses/by/3.0/deed.en_US
|
|
--
|
|
-- It can be used for any purpose so long as the copyright notice above,
|
|
-- the web-page links above, and the 'AUTHOR_NOTE' string below are
|
|
-- maintained. Enjoy.
|
|
--
|
|
local VERSION = 20160728.17 -- version history at end of file
|
|
local AUTHOR_NOTE = "-[ JSON.lua package by Jeffrey Friedl (http://regex.info/blog/lua/json) version 20160728.17 ]-"
|
|
|
|
--
|
|
-- The 'AUTHOR_NOTE' variable exists so that information about the source
|
|
-- of the package is maintained even in compiled versions. It's also
|
|
-- included in OBJDEF below mostly to quiet warnings about unused variables.
|
|
--
|
|
local OBJDEF = {
|
|
VERSION = VERSION,
|
|
AUTHOR_NOTE = AUTHOR_NOTE,
|
|
}
|
|
|
|
local default_pretty_indent = " "
|
|
local default_pretty_options = { pretty = true, align_keys = false, indent = default_pretty_indent }
|
|
|
|
local isArray = { __tostring = function() return "JSON array" end } isArray.__index = isArray
|
|
local isObject = { __tostring = function() return "JSON object" end } isObject.__index = isObject
|
|
|
|
function OBJDEF:newArray(tbl)
|
|
return setmetatable(tbl or {}, isArray)
|
|
end
|
|
|
|
function OBJDEF:newObject(tbl)
|
|
return setmetatable(tbl or {}, isObject)
|
|
end
|
|
|
|
|
|
|
|
|
|
local function getnum(op)
|
|
return type(op) == 'number' and op or op.N
|
|
end
|
|
|
|
local isNumber = {
|
|
__index = isNumber,
|
|
|
|
__tostring = function(T) return T.S end,
|
|
__unm = function(op) return getnum(op) end,
|
|
|
|
__concat = function(op1, op2) return tostring(op1) .. tostring(op2) end,
|
|
__add = function(op1, op2) return getnum(op1) + getnum(op2) end,
|
|
__sub = function(op1, op2) return getnum(op1) - getnum(op2) end,
|
|
__mul = function(op1, op2) return getnum(op1) * getnum(op2) end,
|
|
__div = function(op1, op2) return getnum(op1) / getnum(op2) end,
|
|
__mod = function(op1, op2) return getnum(op1) % getnum(op2) end,
|
|
__pow = function(op1, op2) return getnum(op1) ^ getnum(op2) end,
|
|
__lt = function(op1, op2) return getnum(op1) < getnum(op2) end,
|
|
__eq = function(op1, op2) return getnum(op1) == getnum(op2) end,
|
|
__le = function(op1, op2) return getnum(op1) <= getnum(op2) end,
|
|
}
|
|
|
|
function OBJDEF:asNumber(item)
|
|
|
|
if getmetatable(item) == isNumber then
|
|
-- it's already a JSON number object.
|
|
return item
|
|
elseif type(item) == 'table' and type(item.S) == 'string' and type(item.N) == 'number' then
|
|
-- it's a number-object table that lost its metatable, so give it one
|
|
return setmetatable(item, isNumber)
|
|
else
|
|
-- the normal situation... given a number or a string representation of a number....
|
|
local holder = {
|
|
S = tostring(item), -- S is the representation of the number as a string, which remains precise
|
|
N = tonumber(item), -- N is the number as a Lua number.
|
|
}
|
|
return setmetatable(holder, isNumber)
|
|
end
|
|
end
|
|
|
|
local function unicode_codepoint_as_utf8(codepoint)
|
|
--
|
|
-- codepoint is a number
|
|
--
|
|
if codepoint <= 127 then
|
|
return string.char(codepoint)
|
|
|
|
elseif codepoint <= 2047 then
|
|
--
|
|
-- 110yyyxx 10xxxxxx <-- useful notation from http://en.wikipedia.org/wiki/Utf8
|
|
--
|
|
local highpart = math.floor(codepoint / 0x40)
|
|
local lowpart = codepoint - (0x40 * highpart)
|
|
return string.char(0xC0 + highpart,
|
|
0x80 + lowpart)
|
|
|
|
elseif codepoint <= 65535 then
|
|
--
|
|
-- 1110yyyy 10yyyyxx 10xxxxxx
|
|
--
|
|
local highpart = math.floor(codepoint / 0x1000)
|
|
local remainder = codepoint - 0x1000 * highpart
|
|
local midpart = math.floor(remainder / 0x40)
|
|
local lowpart = remainder - 0x40 * midpart
|
|
|
|
highpart = 0xE0 + highpart
|
|
midpart = 0x80 + midpart
|
|
lowpart = 0x80 + lowpart
|
|
|
|
--
|
|
-- Check for an invalid character (thanks Andy R. at Adobe).
|
|
-- See table 3.7, page 93, in http://www.unicode.org/versions/Unicode5.2.0/ch03.pdf#G28070
|
|
--
|
|
if ( highpart == 0xE0 and midpart < 0xA0 ) or
|
|
( highpart == 0xED and midpart > 0x9F ) or
|
|
( highpart == 0xF0 and midpart < 0x90 ) or
|
|
( highpart == 0xF4 and midpart > 0x8F )
|
|
then
|
|
return "?"
|
|
else
|
|
return string.char(highpart,
|
|
midpart,
|
|
lowpart)
|
|
end
|
|
|
|
else
|
|
--
|
|
-- 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
|
|
--
|
|
local highpart = math.floor(codepoint / 0x40000)
|
|
local remainder = codepoint - 0x40000 * highpart
|
|
local midA = math.floor(remainder / 0x1000)
|
|
remainder = remainder - 0x1000 * midA
|
|
local midB = math.floor(remainder / 0x40)
|
|
local lowpart = remainder - 0x40 * midB
|
|
|
|
return string.char(0xF0 + highpart,
|
|
0x80 + midA,
|
|
0x80 + midB,
|
|
0x80 + lowpart)
|
|
end
|
|
end
|
|
|
|
function OBJDEF:onDecodeError(message, text, location, etc)
|
|
if text then
|
|
if location then
|
|
message = string.format("%s at char %d of: %s", message, location, text)
|
|
else
|
|
message = string.format("%s: %s", message, text)
|
|
end
|
|
end
|
|
|
|
if etc ~= nil then
|
|
message = message .. " (" .. OBJDEF:encode(etc) .. ")"
|
|
end
|
|
|
|
if self.assert then
|
|
self.assert(false, message)
|
|
else
|
|
assert(false, message)
|
|
end
|
|
end
|
|
|
|
OBJDEF.onDecodeOfNilError = OBJDEF.onDecodeError
|
|
OBJDEF.onDecodeOfHTMLError = OBJDEF.onDecodeError
|
|
|
|
function OBJDEF:onEncodeError(message, etc)
|
|
if etc ~= nil then
|
|
message = message .. " (" .. OBJDEF:encode(etc) .. ")"
|
|
end
|
|
|
|
if self.assert then
|
|
self.assert(false, message)
|
|
else
|
|
assert(false, message)
|
|
end
|
|
end
|
|
|
|
local function grok_number(self, text, start, options)
|
|
--
|
|
-- Grab the integer part
|
|
--
|
|
local integer_part = text:match('^-?[1-9]%d*', start)
|
|
or text:match("^-?0", start)
|
|
|
|
if not integer_part then
|
|
self:onDecodeError("expected number", text, start, options.etc)
|
|
end
|
|
|
|
local i = start + integer_part:len()
|
|
|
|
--
|
|
-- Grab an optional decimal part
|
|
--
|
|
local decimal_part = text:match('^%.%d+', i) or ""
|
|
|
|
i = i + decimal_part:len()
|
|
|
|
--
|
|
-- Grab an optional exponential part
|
|
--
|
|
local exponent_part = text:match('^[eE][-+]?%d+', i) or ""
|
|
|
|
i = i + exponent_part:len()
|
|
|
|
local full_number_text = integer_part .. decimal_part .. exponent_part
|
|
|
|
if options.decodeNumbersAsObjects then
|
|
return OBJDEF:asNumber(full_number_text), i
|
|
end
|
|
|
|
--
|
|
-- If we're told to stringify under certain conditions, so do.
|
|
-- We punt a bit when there's an exponent by just stringifying no matter what.
|
|
-- I suppose we should really look to see whether the exponent is actually big enough one
|
|
-- way or the other to trip stringification, but I'll be lazy about it until someone asks.
|
|
--
|
|
if (options.decodeIntegerStringificationLength
|
|
and
|
|
(integer_part:len() >= options.decodeIntegerStringificationLength or exponent_part:len() > 0))
|
|
|
|
or
|
|
|
|
(options.decodeDecimalStringificationLength
|
|
and
|
|
(decimal_part:len() >= options.decodeDecimalStringificationLength or exponent_part:len() > 0))
|
|
then
|
|
return full_number_text, i -- this returns the exact string representation seen in the original JSON
|
|
end
|
|
|
|
|
|
|
|
local as_number = tonumber(full_number_text)
|
|
|
|
if not as_number then
|
|
self:onDecodeError("bad number", text, start, options.etc)
|
|
end
|
|
|
|
return as_number, i
|
|
end
|
|
|
|
|
|
local function grok_string(self, text, start, options)
|
|
|
|
if text:sub(start,start) ~= '"' then
|
|
self:onDecodeError("expected string's opening quote", text, start, options.etc)
|
|
end
|
|
|
|
local i = start + 1 -- +1 to bypass the initial quote
|
|
local text_len = text:len()
|
|
local VALUE = ""
|
|
while i <= text_len do
|
|
local c = text:sub(i,i)
|
|
if c == '"' then
|
|
return VALUE, i + 1
|
|
end
|
|
if c ~= '\\' then
|
|
VALUE = VALUE .. c
|
|
i = i + 1
|
|
elseif text:match('^\\b', i) then
|
|
VALUE = VALUE .. "\b"
|
|
i = i + 2
|
|
elseif text:match('^\\f', i) then
|
|
VALUE = VALUE .. "\f"
|
|
i = i + 2
|
|
elseif text:match('^\\n', i) then
|
|
VALUE = VALUE .. "\n"
|
|
i = i + 2
|
|
elseif text:match('^\\r', i) then
|
|
VALUE = VALUE .. "\r"
|
|
i = i + 2
|
|
elseif text:match('^\\t', i) then
|
|
VALUE = VALUE .. "\t"
|
|
i = i + 2
|
|
else
|
|
local hex = text:match('^\\u([0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF])', i)
|
|
if hex then
|
|
i = i + 6 -- bypass what we just read
|
|
|
|
-- We have a Unicode codepoint. It could be standalone, or if in the proper range and
|
|
-- followed by another in a specific range, it'll be a two-code surrogate pair.
|
|
local codepoint = tonumber(hex, 16)
|
|
if codepoint >= 0xD800 and codepoint <= 0xDBFF then
|
|
-- it's a hi surrogate... see whether we have a following low
|
|
local lo_surrogate = text:match('^\\u([dD][cdefCDEF][0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF])', i)
|
|
if lo_surrogate then
|
|
i = i + 6 -- bypass the low surrogate we just read
|
|
codepoint = 0x2400 + (codepoint - 0xD800) * 0x400 + tonumber(lo_surrogate, 16)
|
|
else
|
|
-- not a proper low, so we'll just leave the first codepoint as is and spit it out.
|
|
end
|
|
end
|
|
VALUE = VALUE .. unicode_codepoint_as_utf8(codepoint)
|
|
|
|
else
|
|
|
|
-- just pass through what's escaped
|
|
VALUE = VALUE .. text:match('^\\(.)', i)
|
|
i = i + 2
|
|
end
|
|
end
|
|
end
|
|
|
|
self:onDecodeError("unclosed string", text, start, options.etc)
|
|
end
|
|
|
|
local function skip_whitespace(text, start)
|
|
|
|
local _, match_end = text:find("^[ \n\r\t]+", start) -- [http://www.ietf.org/rfc/rfc4627.txt] Section 2
|
|
if match_end then
|
|
return match_end + 1
|
|
else
|
|
return start
|
|
end
|
|
end
|
|
|
|
local grok_one -- assigned later
|
|
|
|
local function grok_object(self, text, start, options)
|
|
|
|
if text:sub(start,start) ~= '{' then
|
|
self:onDecodeError("expected '{'", text, start, options.etc)
|
|
end
|
|
|
|
local i = skip_whitespace(text, start + 1) -- +1 to skip the '{'
|
|
|
|
local VALUE = self.strictTypes and self:newObject { } or { }
|
|
|
|
if text:sub(i,i) == '}' then
|
|
return VALUE, i + 1
|
|
end
|
|
local text_len = text:len()
|
|
while i <= text_len do
|
|
local key, new_i = grok_string(self, text, i, options)
|
|
|
|
i = skip_whitespace(text, new_i)
|
|
|
|
if text:sub(i, i) ~= ':' then
|
|
self:onDecodeError("expected colon", text, i, options.etc)
|
|
end
|
|
|
|
i = skip_whitespace(text, i + 1)
|
|
|
|
local new_val, new_i = grok_one(self, text, i, options)
|
|
|
|
VALUE[key] = new_val
|
|
|
|
--
|
|
-- Expect now either '}' to end things, or a ',' to allow us to continue.
|
|
--
|
|
i = skip_whitespace(text, new_i)
|
|
|
|
local c = text:sub(i,i)
|
|
|
|
if c == '}' then
|
|
return VALUE, i + 1
|
|
end
|
|
|
|
if text:sub(i, i) ~= ',' then
|
|
self:onDecodeError("expected comma or '}'", text, i, options.etc)
|
|
end
|
|
|
|
i = skip_whitespace(text, i + 1)
|
|
end
|
|
|
|
self:onDecodeError("unclosed '{'", text, start, options.etc)
|
|
end
|
|
|
|
local function grok_array(self, text, start, options)
|
|
if text:sub(start,start) ~= '[' then
|
|
self:onDecodeError("expected '['", text, start, options.etc)
|
|
end
|
|
|
|
local i = skip_whitespace(text, start + 1) -- +1 to skip the '['
|
|
local VALUE = self.strictTypes and self:newArray { } or { }
|
|
if text:sub(i,i) == ']' then
|
|
return VALUE, i + 1
|
|
end
|
|
|
|
local VALUE_INDEX = 1
|
|
|
|
local text_len = text:len()
|
|
while i <= text_len do
|
|
local val, new_i = grok_one(self, text, i, options)
|
|
|
|
-- can't table.insert(VALUE, val) here because it's a no-op if val is nil
|
|
VALUE[VALUE_INDEX] = val
|
|
VALUE_INDEX = VALUE_INDEX + 1
|
|
|
|
i = skip_whitespace(text, new_i)
|
|
|
|
--
|
|
-- Expect now either ']' to end things, or a ',' to allow us to continue.
|
|
--
|
|
local c = text:sub(i,i)
|
|
if c == ']' then
|
|
return VALUE, i + 1
|
|
end
|
|
if text:sub(i, i) ~= ',' then
|
|
self:onDecodeError("expected comma or '['", text, i, options.etc)
|
|
end
|
|
i = skip_whitespace(text, i + 1)
|
|
end
|
|
self:onDecodeError("unclosed '['", text, start, options.etc)
|
|
end
|
|
|
|
|
|
grok_one = function(self, text, start, options)
|
|
-- Skip any whitespace
|
|
start = skip_whitespace(text, start)
|
|
|
|
if start > text:len() then
|
|
self:onDecodeError("unexpected end of string", text, nil, options.etc)
|
|
end
|
|
|
|
if text:find('^"', start) then
|
|
return grok_string(self, text, start, options.etc)
|
|
|
|
elseif text:find('^[-0123456789 ]', start) then
|
|
return grok_number(self, text, start, options)
|
|
|
|
elseif text:find('^%{', start) then
|
|
return grok_object(self, text, start, options)
|
|
|
|
elseif text:find('^%[', start) then
|
|
return grok_array(self, text, start, options)
|
|
|
|
elseif text:find('^true', start) then
|
|
return true, start + 4
|
|
|
|
elseif text:find('^false', start) then
|
|
return false, start + 5
|
|
|
|
elseif text:find('^null', start) then
|
|
return nil, start + 4
|
|
|
|
else
|
|
self:onDecodeError("can't parse JSON", text, start, options.etc)
|
|
end
|
|
end
|
|
|
|
function OBJDEF:decode(text, etc, options)
|
|
--
|
|
-- If the user didn't pass in a table of decode options, make an empty one.
|
|
--
|
|
if type(options) ~= 'table' then
|
|
options = {}
|
|
end
|
|
|
|
--
|
|
-- If they passed in an 'etc' argument, stuff it into the options.
|
|
-- (If not, any 'etc' field in the options they passed in remains to be used)
|
|
--
|
|
if etc ~= nil then
|
|
options.etc = etc
|
|
end
|
|
|
|
|
|
if type(self) ~= 'table' or self.__index ~= OBJDEF then
|
|
OBJDEF:onDecodeError("JSON:decode must be called in method format", nil, nil, options.etc)
|
|
end
|
|
|
|
if text == nil then
|
|
self:onDecodeOfNilError(string.format("nil passed to JSON:decode()"), nil, nil, options.etc)
|
|
elseif type(text) ~= 'string' then
|
|
self:onDecodeError(string.format("expected string argument to JSON:decode(), got %s", type(text)), nil, nil, options.etc)
|
|
end
|
|
|
|
if text:match('^%s*$') then
|
|
return nil
|
|
end
|
|
|
|
if text:match('^%s*<') then
|
|
-- Can't be JSON... we'll assume it's HTML
|
|
self:onDecodeOfHTMLError(string.format("html passed to JSON:decode()"), text, nil, options.etc)
|
|
end
|
|
|
|
--
|
|
-- Ensure that it's not UTF-32 or UTF-16.
|
|
-- Those are perfectly valid encodings for JSON (as per RFC 4627 section 3),
|
|
-- but this package can't handle them.
|
|
--
|
|
if text:sub(1,1):byte() == 0 or (text:len() >= 2 and text:sub(2,2):byte() == 0) then
|
|
self:onDecodeError("JSON package groks only UTF-8, sorry", text, nil, options.etc)
|
|
end
|
|
|
|
--
|
|
-- apply global options
|
|
--
|
|
if options.decodeNumbersAsObjects == nil then
|
|
options.decodeNumbersAsObjects = self.decodeNumbersAsObjects
|
|
end
|
|
if options.decodeIntegerStringificationLength == nil then
|
|
options.decodeIntegerStringificationLength = self.decodeIntegerStringificationLength
|
|
end
|
|
if options.decodeDecimalStringificationLength == nil then
|
|
options.decodeDecimalStringificationLength = self.decodeDecimalStringificationLength
|
|
end
|
|
|
|
local success, value = pcall(grok_one, self, text, 1, options)
|
|
|
|
if success then
|
|
return value
|
|
else
|
|
-- if JSON:onDecodeError() didn't abort out of the pcall, we'll have received the error message here as "value", so pass it along as an assert.
|
|
if self.assert then
|
|
self.assert(false, value)
|
|
else
|
|
assert(false, value)
|
|
end
|
|
-- and if we're still here, return a nil and throw the error message on as a second arg
|
|
return nil, value
|
|
end
|
|
end
|
|
|
|
local function backslash_replacement_function(c)
|
|
if c == "\n" then
|
|
return "\\n"
|
|
elseif c == "\r" then
|
|
return "\\r"
|
|
elseif c == "\t" then
|
|
return "\\t"
|
|
elseif c == "\b" then
|
|
return "\\b"
|
|
elseif c == "\f" then
|
|
return "\\f"
|
|
elseif c == '"' then
|
|
return '\\"'
|
|
elseif c == '\\' then
|
|
return '\\\\'
|
|
else
|
|
return string.format("\\u%04x", c:byte())
|
|
end
|
|
end
|
|
|
|
local chars_to_be_escaped_in_JSON_string
|
|
= '['
|
|
.. '"' -- class sub-pattern to match a double quote
|
|
.. '%\\' -- class sub-pattern to match a backslash
|
|
.. '%z' -- class sub-pattern to match a null
|
|
.. '\001' .. '-' .. '\031' -- class sub-pattern to match control characters
|
|
.. ']'
|
|
|
|
|
|
local LINE_SEPARATOR_as_utf8 = unicode_codepoint_as_utf8(0x2028)
|
|
local PARAGRAPH_SEPARATOR_as_utf8 = unicode_codepoint_as_utf8(0x2029)
|
|
local function json_string_literal(value, options)
|
|
local newval = value:gsub(chars_to_be_escaped_in_JSON_string, backslash_replacement_function)
|
|
if options.stringsAreUtf8 then
|
|
--
|
|
-- This feels really ugly to just look into a string for the sequence of bytes that we know to be a particular utf8 character,
|
|
-- but utf8 was designed purposefully to make this kind of thing possible. Still, feels dirty.
|
|
-- I'd rather decode the byte stream into a character stream, but it's not technically needed so
|
|
-- not technically worth it.
|
|
--
|
|
newval = newval:gsub(LINE_SEPARATOR_as_utf8, '\\u2028'):gsub(PARAGRAPH_SEPARATOR_as_utf8,'\\u2029')
|
|
end
|
|
return '"' .. newval .. '"'
|
|
end
|
|
|
|
local function object_or_array(self, T, etc)
|
|
--
|
|
-- We need to inspect all the keys... if there are any strings, we'll convert to a JSON
|
|
-- object. If there are only numbers, it's a JSON array.
|
|
--
|
|
-- If we'll be converting to a JSON object, we'll want to sort the keys so that the
|
|
-- end result is deterministic.
|
|
--
|
|
local string_keys = { }
|
|
local number_keys = { }
|
|
local number_keys_must_be_strings = false
|
|
local maximum_number_key
|
|
|
|
for key in pairs(T) do
|
|
if type(key) == 'string' then
|
|
table.insert(string_keys, key)
|
|
elseif type(key) == 'number' then
|
|
table.insert(number_keys, key)
|
|
if key <= 0 or key >= math.huge then
|
|
number_keys_must_be_strings = true
|
|
elseif not maximum_number_key or key > maximum_number_key then
|
|
maximum_number_key = key
|
|
end
|
|
else
|
|
self:onEncodeError("can't encode table with a key of type " .. type(key), etc)
|
|
end
|
|
end
|
|
|
|
if #string_keys == 0 and not number_keys_must_be_strings then
|
|
--
|
|
-- An empty table, or a numeric-only array
|
|
--
|
|
if #number_keys > 0 then
|
|
return nil, maximum_number_key -- an array
|
|
elseif tostring(T) == "JSON array" then
|
|
return nil
|
|
elseif tostring(T) == "JSON object" then
|
|
return { }
|
|
else
|
|
-- have to guess, so we'll pick array, since empty arrays are likely more common than empty objects
|
|
return nil
|
|
end
|
|
end
|
|
|
|
table.sort(string_keys)
|
|
|
|
local map
|
|
if #number_keys > 0 then
|
|
--
|
|
-- If we're here then we have either mixed string/number keys, or numbers inappropriate for a JSON array
|
|
-- It's not ideal, but we'll turn the numbers into strings so that we can at least create a JSON object.
|
|
--
|
|
|
|
if self.noKeyConversion then
|
|
self:onEncodeError("a table with both numeric and string keys could be an object or array; aborting", etc)
|
|
end
|
|
|
|
--
|
|
-- Have to make a shallow copy of the source table so we can remap the numeric keys to be strings
|
|
--
|
|
map = { }
|
|
for key, val in pairs(T) do
|
|
map[key] = val
|
|
end
|
|
|
|
table.sort(number_keys)
|
|
|
|
--
|
|
-- Throw numeric keys in there as strings
|
|
--
|
|
for _, number_key in ipairs(number_keys) do
|
|
local string_key = tostring(number_key)
|
|
if map[string_key] == nil then
|
|
table.insert(string_keys , string_key)
|
|
map[string_key] = T[number_key]
|
|
else
|
|
self:onEncodeError("conflict converting table with mixed-type keys into a JSON object: key " .. number_key .. " exists both as a string and a number.", etc)
|
|
end
|
|
end
|
|
end
|
|
|
|
return string_keys, nil, map
|
|
end
|
|
|
|
--
|
|
-- Encode
|
|
--
|
|
-- 'options' is nil, or a table with possible keys:
|
|
--
|
|
-- pretty -- If true, return a pretty-printed version.
|
|
--
|
|
-- indent -- A string (usually of spaces) used to indent each nested level.
|
|
--
|
|
-- align_keys -- If true, align all the keys when formatting a table.
|
|
--
|
|
-- null -- If this exists with a string value, table elements with this value are output as JSON null.
|
|
--
|
|
-- stringsAreUtf8 -- If true, consider Lua strings not as a sequence of bytes, but as a sequence of UTF-8 characters.
|
|
-- (Currently, the only practical effect of setting this option is that Unicode LINE and PARAGRAPH
|
|
-- separators, if found in a string, are encoded with a JSON escape instead of as raw UTF-8.
|
|
-- The JSON is valid either way, but encoding this way, apparently, allows the resulting JSON
|
|
-- to also be valid Java.)
|
|
--
|
|
--
|
|
local encode_value -- must predeclare because it calls itself
|
|
function encode_value(self, value, parents, etc, options, indent, for_key)
|
|
|
|
--
|
|
-- keys in a JSON object can never be null, so we don't even consider options.null when converting a key value
|
|
--
|
|
if value == nil or (not for_key and options and options.null and value == options.null) then
|
|
return 'null'
|
|
|
|
elseif type(value) == 'string' then
|
|
return json_string_literal(value, options)
|
|
|
|
elseif type(value) == 'number' then
|
|
if value ~= value then
|
|
--
|
|
-- NaN (Not a Number).
|
|
-- JSON has no NaN, so we have to fudge the best we can. This should really be a package option.
|
|
--
|
|
return "null"
|
|
elseif value >= math.huge then
|
|
--
|
|
-- Positive infinity. JSON has no INF, so we have to fudge the best we can. This should
|
|
-- really be a package option. Note: at least with some implementations, positive infinity
|
|
-- is both ">= math.huge" and "<= -math.huge", which makes no sense but that's how it is.
|
|
-- Negative infinity is properly "<= -math.huge". So, we must be sure to check the ">="
|
|
-- case first.
|
|
--
|
|
return "1e+9999"
|
|
elseif value <= -math.huge then
|
|
--
|
|
-- Negative infinity.
|
|
-- JSON has no INF, so we have to fudge the best we can. This should really be a package option.
|
|
--
|
|
return "-1e+9999"
|
|
else
|
|
return tostring(value)
|
|
end
|
|
|
|
elseif type(value) == 'boolean' then
|
|
return tostring(value)
|
|
|
|
elseif type(value) ~= 'table' then
|
|
self:onEncodeError("can't convert " .. type(value) .. " to JSON", etc)
|
|
|
|
elseif getmetatable(value) == isNumber then
|
|
return tostring(value)
|
|
else
|
|
--
|
|
-- A table to be converted to either a JSON object or array.
|
|
--
|
|
local T = value
|
|
|
|
if type(options) ~= 'table' then
|
|
options = {}
|
|
end
|
|
if type(indent) ~= 'string' then
|
|
indent = ""
|
|
end
|
|
|
|
if parents[T] then
|
|
self:onEncodeError("table " .. tostring(T) .. " is a child of itself", etc)
|
|
else
|
|
parents[T] = true
|
|
end
|
|
|
|
local result_value
|
|
|
|
local object_keys, maximum_number_key, map = object_or_array(self, T, etc)
|
|
if maximum_number_key then
|
|
--
|
|
-- An array...
|
|
--
|
|
local ITEMS = { }
|
|
for i = 1, maximum_number_key do
|
|
table.insert(ITEMS, encode_value(self, T[i], parents, etc, options, indent))
|
|
end
|
|
|
|
if options.pretty then
|
|
result_value = "[ " .. table.concat(ITEMS, ", ") .. " ]"
|
|
else
|
|
result_value = "[" .. table.concat(ITEMS, ",") .. "]"
|
|
end
|
|
|
|
elseif object_keys then
|
|
--
|
|
-- An object
|
|
--
|
|
local TT = map or T
|
|
|
|
if options.pretty then
|
|
|
|
local KEYS = { }
|
|
local max_key_length = 0
|
|
for _, key in ipairs(object_keys) do
|
|
local encoded = encode_value(self, tostring(key), parents, etc, options, indent, true)
|
|
if options.align_keys then
|
|
max_key_length = math.max(max_key_length, #encoded)
|
|
end
|
|
table.insert(KEYS, encoded)
|
|
end
|
|
local key_indent = indent .. tostring(options.indent or "")
|
|
local subtable_indent = key_indent .. string.rep(" ", max_key_length) .. (options.align_keys and " " or "")
|
|
local FORMAT = "%s%" .. string.format("%d", max_key_length) .. "s: %s"
|
|
|
|
local COMBINED_PARTS = { }
|
|
for i, key in ipairs(object_keys) do
|
|
local encoded_val = encode_value(self, TT[key], parents, etc, options, subtable_indent)
|
|
table.insert(COMBINED_PARTS, string.format(FORMAT, key_indent, KEYS[i], encoded_val))
|
|
end
|
|
result_value = "{\n" .. table.concat(COMBINED_PARTS, ",\n") .. "\n" .. indent .. "}"
|
|
|
|
else
|
|
|
|
local PARTS = { }
|
|
for _, key in ipairs(object_keys) do
|
|
local encoded_val = encode_value(self, TT[key], parents, etc, options, indent)
|
|
local encoded_key = encode_value(self, tostring(key), parents, etc, options, indent, true)
|
|
table.insert(PARTS, string.format("%s:%s", encoded_key, encoded_val))
|
|
end
|
|
result_value = "{" .. table.concat(PARTS, ",") .. "}"
|
|
|
|
end
|
|
else
|
|
--
|
|
-- An empty array/object... we'll treat it as an array, though it should really be an option
|
|
--
|
|
result_value = "[]"
|
|
end
|
|
|
|
parents[T] = false
|
|
return result_value
|
|
end
|
|
end
|
|
|
|
|
|
function OBJDEF:encode(value, etc, options)
|
|
if type(self) ~= 'table' or self.__index ~= OBJDEF then
|
|
OBJDEF:onEncodeError("JSON:encode must be called in method format", etc)
|
|
end
|
|
|
|
--
|
|
-- If the user didn't pass in a table of decode options, make an empty one.
|
|
--
|
|
if type(options) ~= 'table' then
|
|
options = {}
|
|
end
|
|
|
|
return encode_value(self, value, {}, etc, options)
|
|
end
|
|
|
|
function OBJDEF:encode_pretty(value, etc, options)
|
|
if type(self) ~= 'table' or self.__index ~= OBJDEF then
|
|
OBJDEF:onEncodeError("JSON:encode_pretty must be called in method format", etc)
|
|
end
|
|
|
|
--
|
|
-- If the user didn't pass in a table of decode options, use the default pretty ones
|
|
--
|
|
if type(options) ~= 'table' then
|
|
options = default_pretty_options
|
|
end
|
|
|
|
return encode_value(self, value, {}, etc, options)
|
|
end
|
|
|
|
function OBJDEF.__tostring()
|
|
return "JSON encode/decode package"
|
|
end
|
|
|
|
OBJDEF.__index = OBJDEF
|
|
|
|
function OBJDEF:new(args)
|
|
local new = { }
|
|
|
|
if args then
|
|
for key, val in pairs(args) do
|
|
new[key] = val
|
|
end
|
|
end
|
|
|
|
return setmetatable(new, OBJDEF)
|
|
end
|
|
|
|
return OBJDEF:new() |