--- /dev/null
+-----------------------------------------------------------------------------
+-- JSON4Lua: JSON encoding / decoding support for the Lua language.
+-- json Module.
+-- Author: Craig Mason-Jones
+-- Homepage: http://json.luaforge.net/
+-- Version: 0.9.50
+-- This module is released under the MIT License (MIT).
+-- Please see LICENCE.txt for details.
+--
+-- USAGE:
+-- This module exposes two functions:
+-- encode(o)
+-- Returns the table / string / boolean / number / nil / json.null value as a JSON-encoded string.
+-- decode(json_string)
+-- Returns a Lua object populated with the data encoded in the JSON string json_string.
+--
+-- REQUIREMENTS:
+-- compat-5.1 if using Lua 5.0
+--
+-- CHANGELOG
+-- 0.9.50 Radical performance improvement on decode from Eike Decker. Many thanks!
+-- 0.9.40 Changed licence to MIT License (MIT)
+-- 0.9.20 Introduction of local Lua functions for private functions (removed _ function prefix).
+-- Fixed Lua 5.1 compatibility issues.
+-- Introduced json.null to have null values in associative arrays.
+-- encode() performance improvement (more than 50%) through table.concat rather than ..
+-- Introduced decode ability to ignore /**/ comments in the JSON string.
+-- 0.9.10 Fix to array encoding / decoding to correctly manage nil/null values in arrays.
+-----------------------------------------------------------------------------
+
+-----------------------------------------------------------------------------
+-- Imports and dependencies
+-----------------------------------------------------------------------------
+local math = require('math')
+local string = require("string")
+local table = require("table")
+local tostring = tostring
+
+local base = _G
+
+-----------------------------------------------------------------------------
+-- Module declaration
+-----------------------------------------------------------------------------
+module("json")
+
+-- Public functions
+
+-- Private functions
+local decode_scanArray
+local decode_scanComment
+local decode_scanConstant
+local decode_scanNumber
+local decode_scanObject
+local decode_scanString
+local decode_scanWhitespace
+local encodeString
+local isArray
+local isEncodable
+
+-----------------------------------------------------------------------------
+-- PUBLIC FUNCTIONS
+-----------------------------------------------------------------------------
+--- Encodes an arbitrary Lua object / variable.
+-- @param v The Lua object / variable to be JSON encoded.
+-- @return String containing the JSON encoding in internal Lua string format (i.e. not unicode)
+function encode (v)
+ -- Handle nil values
+ if v==nil then
+ return "null"
+ end
+
+ local vtype = base.type(v)
+
+ -- Handle strings
+ if vtype=='string' then
+ return '"' .. encodeString(v) .. '"' -- Need to handle encoding in string
+ end
+
+ -- Handle booleans
+ if vtype=='number' or vtype=='boolean' then
+ return base.tostring(v)
+ end
+
+ -- Handle tables
+ if vtype=='table' then
+ local rval = {}
+ -- Consider arrays separately
+ local bArray, maxCount = isArray(v)
+ if bArray then
+ for i = 1,maxCount do
+ table.insert(rval, encode(v[i]))
+ end
+ else -- An object, not an array
+ for i,j in base.pairs(v) do
+ if isEncodable(i) and isEncodable(j) then
+ table.insert(rval, '"' .. encodeString(i) .. '":' .. encode(j))
+ end
+ end
+ end
+ if bArray then
+ return '[' .. table.concat(rval,',') ..']'
+ else
+ return '{' .. table.concat(rval,',') .. '}'
+ end
+ end
+
+ -- Handle null values
+ if vtype=='function' and v==null then
+ return 'null'
+ end
+
+ base.assert(false,'encode attempt to encode unsupported type ' .. vtype .. ':' .. base.tostring(v))
+end
+
+
+--- Decodes a JSON string and returns the decoded value as a Lua data structure / value.
+-- @param s The string to scan.
+-- @return Lua objectthat was scanned, as a Lua table / string / number / boolean or nil.
+function decode(s)
+ -- Function is re-defined below after token and other items are created.
+ -- Just defined here for code neatness.
+ return null
+end
+
+--- The null function allows one to specify a null value in an associative array (which is otherwise
+-- discarded if you set the value with 'nil' in Lua. Simply set t = { first=json.null }
+function null()
+ return null -- so json.null() will also return null ;-)
+end
+
+-----------------------------------------------------------------------------
+-- Internal, PRIVATE functions.
+-----------------------------------------------------------------------------
+
+--- Encodes a string to be JSON-compatible.
+-- This just involves back-quoting inverted commas, back-quotes and newlines, I think ;-)
+-- @param s The string to return as a JSON encoded (i.e. backquoted string)
+-- @return The string appropriately escaped.
+local qrep = {["\\"]="\\\\", ['"']='\\"',['\n']='\\n',['\t']='\\t'}
+function encodeString(s)
+ return tostring(s):gsub('["\\\n\t]',qrep)
+end
+
+-- Determines whether the given Lua type is an array or a table / dictionary.
+-- We consider any table an array if it has indexes 1..n for its n items, and no
+-- other data in the table.
+-- I think this method is currently a little 'flaky', but can't think of a good way around it yet...
+-- @param t The table to evaluate as an array
+-- @return boolean, number True if the table can be represented as an array, false otherwise. If true,
+-- the second returned value is the maximum
+-- number of indexed elements in the array.
+function isArray(t)
+ -- Next we count all the elements, ensuring that any non-indexed elements are not-encodable
+ -- (with the possible exception of 'n')
+ local maxIndex = 0
+ for k,v in base.pairs(t) do
+ if (base.type(k)=='number' and math.floor(k)==k and 1<=k) then -- k,v is an indexed pair
+ if (not isEncodable(v)) then return false end -- All array elements must be encodable
+ maxIndex = math.max(maxIndex,k)
+ else
+ if (k=='n') then
+ if v ~= table.getn(t) then return false end -- False if n does not hold the number of elements
+ else -- Else of (k=='n')
+ if isEncodable(v) then return false end
+ end -- End of (k~='n')
+ end -- End of k,v not an indexed pair
+ end -- End of loop across all pairs
+ return true, maxIndex
+end
+
+--- Determines whether the given Lua object / table / variable can be JSON encoded. The only
+-- types that are JSON encodable are: string, boolean, number, nil, table and json.null.
+-- In this implementation, all other types are ignored.
+-- @param o The object to examine.
+-- @return boolean True if the object should be JSON encoded, false if it should be ignored.
+function isEncodable(o)
+ local t = base.type(o)
+ return (t=='string' or t=='boolean' or t=='number' or t=='nil' or t=='table') or (t=='function' and o==null)
+end
+
+-- Radical performance improvement for decode from Eike Decker!
+do
+ local type = base.type
+ local error = base.error
+ local assert = base.assert
+ local print = base.print
+ local tonumber = base.tonumber
+ -- initialize some values to be used in decoding function
+
+ -- initializes a table to contain a byte=>table mapping
+ -- the table contains tokens (byte values) as keys and maps them on other
+ -- token tables (mostly, the boolean value 'true' is used to indicate termination
+ -- of a token sequence)
+ -- the token table's purpose is, that it allows scanning a sequence of bytes
+ -- until something interesting has been found (e.g. a token that is not expected)
+ -- name is a descriptor for the table to be printed in error messages
+ local function init_token_table (tt)
+ local struct = {}
+ local value
+ function struct:link(other_tt)
+ value = other_tt
+ return struct
+ end
+ function struct:to(chars)
+ for i=1,#chars do
+ tt[chars:byte(i)] = value
+ end
+ return struct
+ end
+ return function (name)
+ tt.name = name
+ return struct
+ end
+ end
+
+ -- keep "named" byte values at hands
+ local
+ c_esc,
+ c_e,
+ c_l,
+ c_r,
+ c_u,
+ c_f,
+ c_a,
+ c_s,
+ c_slash = ("\\elrufas/"):byte(1,9)
+
+ -- token tables - tt_doublequote_string = strDoubleQuot, tt_singlequote_string = strSingleQuot
+ local
+ tt_object_key,
+ tt_object_colon,
+ tt_object_value,
+ tt_doublequote_string,
+ tt_singlequote_string,
+ tt_array_value,
+ tt_array_seperator,
+ tt_numeric,
+ tt_boolean,
+ tt_null,
+ tt_comment_start,
+ tt_comment_middle,
+ tt_ignore --< tt_ignore is special - marked tokens will be tt_ignored
+ = {},{},{},{},{},{},{},{},{},{},{},{},{}
+
+ -- strings to be used in certain token tables
+ local strchars = "" -- all valid string characters (all except newlines)
+ local allchars = "" -- all characters that are valid in comments
+ --local escapechar = {}
+ for i=0,0xff do
+ local c = string.char(i)
+ if c~="\n" and c~="\r" then strchars = strchars .. c end
+ allchars = allchars .. c
+ --escapechar[i] = "\\" .. string.char(i)
+ end
+
+--[[
+ charstounescape = "\"\'\\bfnrt/";
+ unescapechars = "\"'\\\b\f\n\r\t\/";
+ for i=1,#charstounescape do
+ escapechar[ charstounescape:byte(i) ] = unescapechars:sub(i,i)
+ end
+]]--
+
+ -- obj key reader, expects the end of the object or a quoted string as key
+ init_token_table (tt_object_key) "object (' or \" or } or , expected)"
+ :link(tt_singlequote_string) :to "'"
+ :link(tt_doublequote_string) :to '"'
+ :link(true) :to "}"
+ :link(tt_object_key) :to ","
+ :link(tt_comment_start) :to "/"
+ :link(tt_ignore) :to " \t\r\n"
+
+
+ -- after the key, a colon is expected (or comment)
+ init_token_table (tt_object_colon) "object (: expected)"
+ :link(tt_object_value) :to ":"
+ :link(tt_comment_start) :to "/"
+ :link(tt_ignore) :to" \t\r\n"
+
+ -- as values, anything is possible, numbers, arrays, objects, boolean, null, strings
+ init_token_table (tt_object_value) "object ({ or [ or ' or \" or number or boolean or null expected)"
+ :link(tt_object_key) :to "{"
+ :link(tt_array_seperator) :to "["
+ :link(tt_singlequote_string) :to "'"
+ :link(tt_doublequote_string) :to '"'
+ :link(tt_numeric) :to "0123456789.-"
+ :link(tt_boolean) :to "tf"
+ :link(tt_null) :to "n"
+ :link(tt_comment_start) :to "/"
+ :link(tt_ignore) :to " \t\r\n"
+
+ -- token tables for reading strings
+ init_token_table (tt_doublequote_string) "double quoted string"
+ :link(tt_ignore) :to (strchars)
+ :link(c_esc) :to "\\"
+ :link(true) :to '"'
+
+ init_token_table (tt_singlequote_string) "single quoted string"
+ :link(tt_ignore) :to (strchars)
+ :link(c_esc) :to "\\"
+ :link(true) :to "'"
+
+ -- array reader that expects termination of the array or a comma that indicates the next value
+ init_token_table (tt_array_value) "array (, or ] expected)"
+ :link(tt_array_seperator) :to ","
+ :link(true) :to "]"
+ :link(tt_comment_start) :to "/"
+ :link(tt_ignore) :to " \t\r\n"
+
+ -- a value, pretty similar to tt_object_value
+ init_token_table (tt_array_seperator) "array ({ or [ or ' or \" or number or boolean or null expected)"
+ :link(tt_object_key) :to "{"
+ :link(tt_array_seperator) :to "["
+ :link(tt_singlequote_string) :to "'"
+ :link(tt_doublequote_string) :to '"'
+ :link(tt_comment_start) :to "/"
+ :link(tt_numeric) :to "0123456789.-"
+ :link(tt_boolean) :to "tf"
+ :link(tt_null) :to "n"
+ :link(tt_ignore) :to " \t\r\n"
+
+ -- valid number tokens
+ init_token_table (tt_numeric) "number"
+ :link(tt_ignore) :to "0123456789.-Ee"
+
+ -- once a comment has been started with /, a * is expected
+ init_token_table (tt_comment_start) "comment start (* expected)"
+ :link(tt_comment_middle) :to "*"
+
+ -- now everything is allowed, watch out for * though. The next char is then checked manually
+ init_token_table (tt_comment_middle) "comment end"
+ :link(tt_ignore) :to (allchars)
+ :link(true) :to "*"
+
+ function decode (js_string)
+ local pos = 1 -- position in the string
+
+ -- read the next byte value
+ local function next_byte () pos = pos + 1 return js_string:byte(pos-1) end
+
+ -- in case of error, report the location using line numbers
+ local function location ()
+ local n = ("\n"):byte()
+ local line,lpos = 1,0
+ for i=1,pos do
+ if js_string:byte(i) == n then
+ line,lpos = line + 1,1
+ else
+ lpos = lpos + 1
+ end
+ end
+ return "Line "..line.." character "..lpos
+ end
+
+ -- debug func
+ --local function status (str)
+ -- print(str.." ("..s:sub(math.max(1,p-10),p+10)..")")
+ --end
+
+ -- read the next token, according to the passed token table
+ local function next_token (tok)
+ while pos <= #js_string do
+ local b = js_string:byte(pos)
+ local t = tok[b]
+ if not t then
+ error("Unexpected character at "..location()..": "..
+ string.char(b).." ("..b..") when reading "..tok.name.."\nContext: \n"..
+ js_string:sub(math.max(1,pos-30),pos+30).."\n"..(" "):rep(pos+math.min(-1,30-pos)).."^")
+ end
+ pos = pos + 1
+ if t~=tt_ignore then return t end
+ end
+ error("unexpected termination of JSON while looking for "..tok.name)
+ end
+
+ -- read a string, double and single quoted ones
+ local function read_string (tok)
+ local start = pos
+ --local returnString = {}
+ repeat
+ local t = next_token(tok)
+ if t == c_esc then
+ --table.insert(returnString, js_string:sub(start, pos-2))
+ --table.insert(returnString, escapechar[ js_string:byte(pos) ])
+ pos = pos + 1
+ --start = pos
+ end -- jump over escaped chars, no matter what
+ until t == true
+ return (base.loadstring("return " .. js_string:sub(start-1, pos-1) ) ())
+
+ -- We consider the situation where no escaped chars were encountered separately,
+ -- and use the fastest possible return in this case.
+
+ --if 0 == #returnString then
+ -- return js_string:sub(start,pos-2)
+ --else
+ -- table.insert(returnString, js_string:sub(start,pos-2))
+ -- return table.concat(returnString,"");
+ --end
+ --return js_string:sub(start,pos-2)
+ end
+
+ local function read_num ()
+ local start = pos
+ while pos <= #js_string do
+ local b = js_string:byte(pos)
+ if not tt_numeric[b] then break end
+ pos = pos + 1
+ end
+ return tonumber(js_string:sub(start-1,pos-1))
+ end
+
+ -- read_bool and read_null are both making an assumption that I have not tested:
+ -- I would expect that the string extraction is more expensive than actually
+ -- making manual comparision of the byte values
+ local function read_bool ()
+ pos = pos + 3
+ local a,b,c,d = js_string:byte(pos-3,pos)
+ if a == c_r and b == c_u and c == c_e then return true end
+ pos = pos + 1
+ if a ~= c_a or b ~= c_l or c ~= c_s or d ~= c_e then
+ error("Invalid boolean: "..js_string:sub(math.max(1,pos-5),pos+5))
+ end
+ return false
+ end
+
+ -- same as read_bool: only last
+ local function read_null ()
+ pos = pos + 3
+ local u,l1,l2 = js_string:byte(pos-3,pos-1)
+ if u == c_u and l1 == c_l and l2 == c_l then return nil end
+ error("Invalid value (expected null):"..js_string:sub(pos-4,pos-1)..
+ " ("..js_string:byte(pos-1).."="..js_string:sub(pos-1,pos-1).." / "..c_l..")")
+ end
+
+ local read_object_value,read_object_key,read_array,read_value,read_comment
+
+ -- read a value depending on what token was returned, might require info what was used (in case of comments)
+ function read_value (t,fromt)
+ if t == tt_object_key then return read_object_key({}) end
+ if t == tt_array_seperator then return read_array({}) end
+ if t == tt_singlequote_string or
+ t == tt_doublequote_string then return read_string(t) end
+ if t == tt_numeric then return read_num() end
+ if t == tt_boolean then return read_bool() end
+ if t == tt_null then return read_null() end
+ if t == tt_comment_start then return read_value(read_comment(fromt)) end
+ error("unexpected termination - "..js_string:sub(math.max(1,pos-10),pos+10))
+ end
+
+ -- read comments until something noncomment like surfaces, using the token reader which was
+ -- used when stumbling over this comment
+ function read_comment (fromt)
+ while true do
+ next_token(tt_comment_start)
+ while true do
+ local t = next_token(tt_comment_middle)
+ if next_byte() == c_slash then
+ local t = next_token(fromt)
+ if t~= tt_comment_start then return t end
+ break
+ end
+ end
+ end
+ end
+
+ -- read arrays, empty array expected as o arg
+ function read_array (o,i)
+ --if not i then status "arr open" end
+ i = i or 1
+ -- loop until ...
+ while true do
+ o[i] = read_value(next_token(tt_array_seperator),tt_array_seperator)
+ local t = next_token(tt_array_value)
+ if t == tt_comment_start then
+ t = read_comment(tt_array_value)
+ end
+ if t == true then -- ... we found a terminator token
+ --status "arr close"
+ return o
+ end
+ i = i + 1
+ end
+ end
+
+ -- object value reading
+ function read_object_value (o)
+ local t = next_token(tt_object_value)
+ return read_value(t,tt_object_value)
+ end
+
+ -- object key reading, might also terminate the object
+ function read_object_key (o)
+ while true do
+ local t = next_token(tt_object_key)
+ if t == tt_comment_start then
+ t = read_comment(tt_object_key)
+ end
+ if t == true then return o end
+ if t == tt_object_key then return read_object_key(o) end
+ local k = read_string(t)
+
+ if next_token(tt_object_colon) == tt_comment_start then
+ t = read_comment(tt_object_colon)
+ end
+
+ local v = read_object_value(o)
+ o[k] = v
+ end
+ end
+
+ -- now let's read data from our string and pretend it's an object value
+ local r = read_object_value()
+ if pos<=#js_string then
+ -- not sure about what to do with dangling characters
+ --error("Dangling characters in JSON code ("..location()..")")
+ end
+
+ return r
+ end
+end
projects / scpubgit/stemmatology.git / commitdiff