json.lua

   1 --
   2 -- https://github.com/rxi/json.lua
   3 --
   4 -- Copyright (c) 2020 rxi
   5 --
   6 -- Permission is hereby granted, free of charge, to any person obtaining a copy of
   7 -- this software and associated documentation files (the "Software"), to deal in
   8 -- the Software without restriction, including without limitation the rights to
   9 -- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  10 -- of the Software, and to permit persons to whom the Software is furnished to do
  11 -- so, subject to the following conditions:
  12 --
  13 -- The above copyright notice and this permission notice shall be included in all
  14 -- copies or substantial portions of the Software.
  15 --
  16 -- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 -- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 -- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19 -- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 -- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21 -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22 -- SOFTWARE.
  23 --
  24
  25 local json = { _version = "0.1.2" }
  26
  27 -------------------------------------------------------------------------------
  28 -- Encode
  29 -------------------------------------------------------------------------------
  30
  31 local encode
  32
  33 local escape_char_map = {
  34   [ "\\" ] = "\\",
  35   [ "\"" ] = "\"",
  36   [ "\b" ] = "b",
  37   [ "\f" ] = "f",
  38   [ "\n" ] = "n",
  39   [ "\r" ] = "r",
  40   [ "\t" ] = "t",
  41 }
  42
  43 local escape_char_map_inv = { [ "/" ] = "/" }
  44 for k, v in pairs(escape_char_map) do
  45   escape_char_map_inv[v] = k
  46 end
  47
  48
  49 local function escape_char(c)
  50   return "\\" .. (escape_char_map[c] or string.format("u%04x", c:byte()))
  51 end
  52
  53
  54 local function encode_nil(val)
  55   return "null"
  56 end
  57
  58
  59 local function encode_table(val, stack)
  60   local res = {}
  61   stack = stack or {}
  62
  63   -- Circular reference?
  64   if stack[val] then error("circular reference") end
  65
  66   stack[val] = true
  67
  68   if rawget(val, 1) ~= nil or next(val) == nil then
  69     -- Treat as array -- check keys are valid and it is not sparse
  70     local n = 0
  71     for k in pairs(val) do
  72       if type(k) ~= "number" then
  73         error("invalid table: mixed or invalid key types")
  74       end
  75       n = n + 1
  76     end
  77     if n ~= #val then
  78       error("invalid table: sparse array")
  79     end
  80     -- Encode
  81     for i, v in ipairs(val) do
  82       table.insert(res, encode(v, stack))
  83     end
  84     stack[val] = nil
  85     return "[" .. table.concat(res, ",") .. "]"
  86
  87   else
  88     -- Treat as an object
  89     for k, v in pairs(val) do
  90       if type(k) ~= "string" then
  91         error("invalid table: mixed or invalid key types")
  92       end
  93       table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
  94     end
  95     stack[val] = nil
  96     return "{" .. table.concat(res, ",") .. "}"
  97   end
  98 end
  99
 100
 101 local function encode_string(val)
 102   return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
 103 end
 104
 105
 106 local function encode_number(val)
 107   -- Check for NaN, -inf and inf
 108   if val ~= val or val <= -math.huge or val >= math.huge then
 109     error("unexpected number value '" .. tostring(val) .. "'")
 110   end
 111   return string.format("%.14g", val)
 112 end
 113
 114
 115 local type_func_map = {
 116   [ "nil"     ] = encode_nil,
 117   [ "table"   ] = encode_table,
 118   [ "string"  ] = encode_string,
 119   [ "number"  ] = encode_number,
 120   [ "boolean" ] = tostring,
 121 }
 122
 123
 124 encode = function(val, stack)
 125   local t = type(val)
 126   local f = type_func_map[t]
 127   if f then
 128     return f(val, stack)
 129   end
 130   error("unexpected type '" .. t .. "'")
 131 end
 132
 133
 134 function json.encode(val)
 135   return ( encode(val) )
 136 end
 137
 138
 139 -------------------------------------------------------------------------------
 140 -- Decode
 141 -------------------------------------------------------------------------------
 142
 143 local parse
 144
 145 local function create_set(...)
 146   local res = {}
 147   for i = 1, select("#", ...) do
 148     res[ select(i, ...) ] = true
 149   end
 150   return res
 151 end
 152
 153 local space_chars   = create_set(" ", "\t", "\r", "\n")
 154 local delim_chars   = create_set(" ", "\t", "\r", "\n", "]", "}", ",")
 155 local escape_chars  = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u")
 156 local literals      = create_set("true", "false", "null")
 157
 158 local literal_map = {
 159   [ "true"  ] = true,
 160   [ "false" ] = false,
 161   [ "null"  ] = nil,
 162 }
 163
 164
 165 local function next_char(str, idx, set, negate)
 166   for i = idx, #str do
 167     if set[str:sub(i, i)] ~= negate then
 168       return i
 169     end
 170   end
 171   return #str + 1
 172 end
 173
 174
 175 local function decode_error(str, idx, msg)
 176   local line_count = 1
 177   local col_count = 1
 178   for i = 1, idx - 1 do
 179     col_count = col_count + 1
 180     if str:sub(i, i) == "\n" then
 181       line_count = line_count + 1
 182       col_count = 1
 183     end
 184   end
 185   error( string.format("%s at line %d col %d", msg, line_count, col_count) )
 186 end
 187
 188
 189 local function codepoint_to_utf8(n)
 190   -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa
 191   local f = math.floor
 192   if n <= 0x7f then
 193     return string.char(n)
 194   elseif n <= 0x7ff then
 195     return string.char(f(n / 64) + 192, n % 64 + 128)
 196   elseif n <= 0xffff then
 197     return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128)
 198   elseif n <= 0x10ffff then
 199     return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128,
 200                        f(n % 4096 / 64) + 128, n % 64 + 128)
 201   end
 202   error( string.format("invalid unicode codepoint '%x'", n) )
 203 end
 204
 205
 206 local function parse_unicode_escape(s)
 207   local n1 = tonumber( s:sub(1, 4),  16 )
 208   local n2 = tonumber( s:sub(7, 10), 16 )
 209    -- Surrogate pair?
 210   if n2 then
 211     return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000)
 212   else
 213     return codepoint_to_utf8(n1)
 214   end
 215 end
 216
 217
 218 local function parse_string(str, i)
 219   local res = ""
 220   local j = i + 1
 221   local k = j
 222
 223   while j <= #str do
 224     local x = str:byte(j)
 225
 226     if x < 32 then
 227       decode_error(str, j, "control character in string")
 228
 229     elseif x == 92 then -- `\`: Escape
 230       res = res .. str:sub(k, j - 1)
 231       j = j + 1
 232       local c = str:sub(j, j)
 233       if c == "u" then
 234         local hex = str:match("^[dD][89aAbB]%x%x\\u%x%x%x%x", j + 1)
 235                  or str:match("^%x%x%x%x", j + 1)
 236                  or decode_error(str, j - 1, "invalid unicode escape in string")
 237         res = res .. parse_unicode_escape(hex)
 238         j = j + #hex
 239       else
 240         if not escape_chars[c] then
 241           decode_error(str, j - 1, "invalid escape char '" .. c .. "' in string")
 242         end
 243         res = res .. escape_char_map_inv[c]
 244       end
 245       k = j + 1
 246
 247     elseif x == 34 then -- `"`: End of string
 248       res = res .. str:sub(k, j - 1)
 249       return res, j + 1
 250     end
 251
 252     j = j + 1
 253   end
 254
 255   decode_error(str, i, "expected closing quote for string")
 256 end
 257
 258
 259 local function parse_number(str, i)
 260   local x = next_char(str, i, delim_chars)
 261   local s = str:sub(i, x - 1)
 262   local n = tonumber(s)
 263   if not n then
 264     decode_error(str, i, "invalid number '" .. s .. "'")
 265   end
 266   return n, x
 267 end
 268
 269
 270 local function parse_literal(str, i)
 271   local x = next_char(str, i, delim_chars)
 272   local word = str:sub(i, x - 1)
 273   if not literals[word] then
 274     decode_error(str, i, "invalid literal '" .. word .. "'")
 275   end
 276   return literal_map[word], x
 277 end
 278
 279
 280 local function parse_array(str, i)
 281   local res = {}
 282   local n = 1
 283   i = i + 1
 284   while 1 do
 285     local x
 286     i = next_char(str, i, space_chars, true)
 287     -- Empty / end of array?
 288     if str:sub(i, i) == "]" then
 289       i = i + 1
 290       break
 291     end
 292     -- Read token
 293     x, i = parse(str, i)
 294     res[n] = x
 295     n = n + 1
 296     -- Next token
 297     i = next_char(str, i, space_chars, true)
 298     local chr = str:sub(i, i)
 299     i = i + 1
 300     if chr == "]" then break end
 301     if chr ~= "," then decode_error(str, i, "expected ']' or ','") end
 302   end
 303   return res, i
 304 end
 305
 306
 307 local function parse_object(str, i)
 308   local res = {}
 309   i = i + 1
 310   while 1 do
 311     local key, val
 312     i = next_char(str, i, space_chars, true)
 313     -- Empty / end of object?
 314     if str:sub(i, i) == "}" then
 315       i = i + 1
 316       break
 317     end
 318     -- Read key
 319     if str:sub(i, i) ~= '"' then
 320       decode_error(str, i, "expected string for key")
 321     end
 322     key, i = parse(str, i)
 323     -- Read ':' delimiter
 324     i = next_char(str, i, space_chars, true)
 325     if str:sub(i, i) ~= ":" then
 326       decode_error(str, i, "expected ':' after key")
 327     end
 328     i = next_char(str, i + 1, space_chars, true)
 329     -- Read value
 330     val, i = parse(str, i)
 331     -- Set
 332     res[key] = val
 333     -- Next token
 334     i = next_char(str, i, space_chars, true)
 335     local chr = str:sub(i, i)
 336     i = i + 1
 337     if chr == "}" then break end
 338     if chr ~= "," then decode_error(str, i, "expected '}' or ','") end
 339   end
 340   return res, i
 341 end
 342
 343
 344 local char_func_map = {
 345   [ '"' ] = parse_string,
 346   [ "0" ] = parse_number,
 347   [ "1" ] = parse_number,
 348   [ "2" ] = parse_number,
 349   [ "3" ] = parse_number,
 350   [ "4" ] = parse_number,
 351   [ "5" ] = parse_number,
 352   [ "6" ] = parse_number,
 353   [ "7" ] = parse_number,
 354   [ "8" ] = parse_number,
 355   [ "9" ] = parse_number,
 356   [ "-" ] = parse_number,
 357   [ "t" ] = parse_literal,
 358   [ "f" ] = parse_literal,
 359   [ "n" ] = parse_literal,
 360   [ "[" ] = parse_array,
 361   [ "{" ] = parse_object,
 362 }
 363
 364
 365 parse = function(str, idx)
 366   local chr = str:sub(idx, idx)
 367   local f = char_func_map[chr]
 368   if f then
 369     return f(str, idx)
 370   end
 371   decode_error(str, idx, "unexpected character '" .. chr .. "'")
 372 end
 373
 374
 375 function json.decode(str)
 376   if type(str) ~= "string" then
 377     error("expected argument of type string, got " .. type(str))
 378   end
 379   local res, idx = parse(str, next_char(str, 1, space_chars, true))
 380   idx = next_char(str, idx, space_chars, true)
 381   if idx <= #str then
 382     decode_error(str, idx, "trailing garbage")
 383   end
 384   return res
 385 end
 386
 387
 388 return json