Update talents + beasts

tools/luajson/json/decode/composite.lua

@@ -0,0 +1,190 @@
+--[[
+	Licensed according to the included 'LICENSE' document
+	Author: Thomas Harning Jr <harningt@gmail.com>
+]]
+local pairs = pairs
+local type = type
+
+local lpeg = require("lpeg")
+
+local util = require("json.decode.util")
+local jsonutil = require("json.util")
+
+local rawset = rawset
+
+local assert = assert
+local tostring = tostring
+
+local error = error
+local getmetatable = getmetatable
+
+local _ENV = nil
+
+local defaultOptions = {
+	array = {
+		trailingComma = true
+	},
+	object = {
+		trailingComma = true,
+		number = true,
+		identifier = true,
+		setObjectKey = rawset
+	},
+	calls = {
+		defs = nil,
+		-- By default, do not allow undefined calls to be de-serialized as call objects
+		allowUndefined = false
+	}
+}
+
+local modeOptions = {
+	default = nil,
+	strict = {
+		array = {
+			trailingComma = false
+		},
+		object = {
+			trailingComma = false,
+			number = false,
+			identifier = false
+		}
+	}
+}
+
+local function BEGIN_ARRAY(state)
+	state:push()
+	state:new_array()
+end
+local function END_ARRAY(state)
+	state:end_array()
+	state:pop()
+end
+
+local function BEGIN_OBJECT(state)
+	state:push()
+	state:new_object()
+end
+local function END_OBJECT(state)
+	state:end_object()
+	state:pop()
+end
+
+local function END_CALL(state)
+	state:end_call()
+	state:pop()
+end
+
+local function SET_KEY(state)
+	state:set_key()
+end
+
+local function NEXT_VALUE(state)
+	state:put_value()
+end
+
+local function mergeOptions(options, mode)
+	jsonutil.doOptionMerge(options, true, 'array', defaultOptions, mode and modeOptions[mode])
+	jsonutil.doOptionMerge(options, true, 'object', defaultOptions, mode and modeOptions[mode])
+	jsonutil.doOptionMerge(options, true, 'calls', defaultOptions, mode and modeOptions[mode])
+end
+
+
+local isPattern
+if lpeg.type then
+	function isPattern(value)
+		return lpeg.type(value) == 'pattern'
+	end
+else
+	local metaAdd = getmetatable(lpeg.P("")).__add
+	function isPattern(value)
+		return getmetatable(value).__add == metaAdd
+	end
+end
+
+
+local function generateSingleCallLexer(name, func)
+	if type(name) ~= 'string' and not isPattern(name) then
+		error("Invalid functionCalls name: " .. tostring(name) .. " not a string or LPEG pattern")
+	end
+	-- Allow boolean or function to match up w/ encoding permissions
+	if type(func) ~= 'boolean' and type(func) ~= 'function' then
+		error("Invalid functionCalls item: " .. name .. " not a function")
+	end
+	local function buildCallCapture(name)
+		return function(state)
+			if func == false then
+				error("Function call on '" .. name .. "' not permitted")
+			end
+			state:push()
+			state:new_call(name, func)
+		end
+	end
+	local nameCallCapture
+	if type(name) == 'string' then
+		nameCallCapture = lpeg.P(name .. "(") * lpeg.Cc(name) / buildCallCapture
+	else
+		-- Name matcher expected to produce a capture
+		nameCallCapture = name * "(" / buildCallCapture
+	end
+	-- Call func over nameCallCapture and value to permit function receiving name
+	return nameCallCapture
+end
+
+local function generateNamedCallLexers(options)
+	if not options.calls or not options.calls.defs then
+		return
+	end
+	local callCapture
+	for name, func in pairs(options.calls.defs) do
+		local newCapture = generateSingleCallLexer(name, func)
+		if not callCapture then
+			callCapture = newCapture
+		else
+			callCapture = callCapture + newCapture
+		end
+	end
+	return callCapture
+end
+
+local function generateCallLexer(options)
+	local lexer
+	local namedCapture = generateNamedCallLexers(options)
+	if options.calls and options.calls.allowUndefined then
+		lexer = generateSingleCallLexer(lpeg.C(util.identifier), true)
+	end
+	if namedCapture then
+		lexer = lexer and lexer + namedCapture or namedCapture
+	end
+	if lexer then
+		lexer = lexer + lpeg.P(")") * lpeg.Cc(END_CALL)
+	end
+	return lexer
+end
+
+local function generateLexer(options)
+	local ignored = options.ignored
+	local array_options, object_options = options.array, options.object
+	local lexer =
+		lpeg.P("[") * lpeg.Cc(BEGIN_ARRAY)
+		+ lpeg.P("]") * lpeg.Cc(END_ARRAY)
+		+ lpeg.P("{") * lpeg.Cc(BEGIN_OBJECT)
+		+ lpeg.P("}") * lpeg.Cc(END_OBJECT)
+		+ lpeg.P(":") * lpeg.Cc(SET_KEY)
+		+ lpeg.P(",") * lpeg.Cc(NEXT_VALUE)
+	if object_options.identifier then
+		-- Add identifier match w/ validation check that it is in key
+		lexer = lexer + lpeg.C(util.identifier) * ignored * lpeg.P(":") * lpeg.Cc(SET_KEY)
+	end
+	local callLexers = generateCallLexer(options)
+	if callLexers then
+		lexer = lexer + callLexers
+	end
+	return lexer
+end
+
+local composite = {
+	mergeOptions = mergeOptions,
+	generateLexer = generateLexer
+}
+
+return composite

tools/luajson/json/decode/number.lua

@@ -0,0 +1,100 @@
+--[[
+	Licensed according to the included 'LICENSE' document
+	Author: Thomas Harning Jr <harningt@gmail.com>
+]]
+local lpeg = require("lpeg")
+local tonumber = tonumber
+local jsonutil = require("json.util")
+local merge = jsonutil.merge
+local util = require("json.decode.util")
+
+local _ENV = nil
+
+local digit  = lpeg.R("09")
+local digits = digit^1
+
+-- Illegal octal declaration
+local illegal_octal_detect = #(lpeg.P('0') * digits) * util.denied("Octal numbers")
+
+local int = (lpeg.P('-') + 0) * (lpeg.R("19") * digits + illegal_octal_detect + digit)
+
+local frac = lpeg.P('.') * digits
+
+local exp = lpeg.S("Ee") * (lpeg.S("-+") + 0) * digits
+
+local nan = lpeg.S("Nn") * lpeg.S("Aa") * lpeg.S("Nn")
+local inf = lpeg.S("Ii") * lpeg.P("nfinity")
+local ninf = lpeg.P('-') * lpeg.S("Ii") * lpeg.P("nfinity")
+local hex = (lpeg.P("0x") + lpeg.P("0X")) * lpeg.R("09","AF","af")^1
+
+local defaultOptions = {
+	nan = true,
+	inf = true,
+	frac = true,
+	exp = true,
+	hex = false
+}
+
+local modeOptions = {}
+
+modeOptions.strict = {
+	nan = false,
+	inf = false
+}
+
+local nan_value = 0/0
+local inf_value = 1/0
+local ninf_value = -1/0
+
+--[[
+	Options: configuration options for number rules
+		nan: match NaN
+		inf: match Infinity
+	   frac: match fraction portion (.0)
+	    exp: match exponent portion  (e1)
+	DEFAULT: nan, inf, frac, exp
+]]
+local function mergeOptions(options, mode)
+	jsonutil.doOptionMerge(options, false, 'number', defaultOptions, mode and modeOptions[mode])
+end
+
+local function generateLexer(options)
+	options = options.number
+	local ret = int
+	if options.frac then
+		ret = ret * (frac + 0)
+	else
+		ret = ret * (#frac * util.denied("Fractions", "number.frac") + 0)
+	end
+	if options.exp then
+		ret = ret * (exp + 0)
+	else
+		ret = ret * (#exp * util.denied("Exponents", "number.exp") + 0)
+	end
+	if options.hex then
+		ret = hex + ret
+	else
+		ret = #hex * util.denied("Hexadecimal", "number.hex") + ret
+	end
+	-- Capture number now
+	ret = ret / tonumber
+	if options.nan then
+		ret = ret + nan / function() return nan_value end
+	else
+		ret = ret + #nan * util.denied("NaN", "number.nan")
+	end
+	if options.inf then
+		ret = ret + ninf / function() return ninf_value end + inf / function() return inf_value end
+	else
+		ret = ret + (#ninf + #inf) * util.denied("+/-Inf", "number.inf")
+	end
+	return ret
+end
+
+local number = {
+	int = int,
+	mergeOptions = mergeOptions,
+	generateLexer = generateLexer
+}
+
+return number

tools/luajson/json/decode/others.lua

@@ -0,0 +1,62 @@
+--[[
+	Licensed according to the included 'LICENSE' document
+	Author: Thomas Harning Jr <harningt@gmail.com>
+]]
+local lpeg = require("lpeg")
+local jsonutil = require("json.util")
+local merge = jsonutil.merge
+local util = require("json.decode.util")
+
+-- Container module for other JavaScript types (bool, null, undefined)
+
+local _ENV = nil
+
+-- For null and undefined, use the util.null value to preserve null-ness
+local booleanCapture =
+	lpeg.P("true") * lpeg.Cc(true)
+	+ lpeg.P("false") * lpeg.Cc(false)
+
+local nullCapture = lpeg.P("null")
+local undefinedCapture = lpeg.P("undefined")
+
+local defaultOptions = {
+	allowUndefined = true,
+	null = jsonutil.null,
+	undefined = jsonutil.undefined
+}
+
+local modeOptions = {}
+
+modeOptions.simple = {
+	null = false,     -- Mapped to nil
+	undefined = false -- Mapped to nil
+}
+modeOptions.strict = {
+	allowUndefined = false
+}
+
+local function mergeOptions(options, mode)
+	jsonutil.doOptionMerge(options, false, 'others', defaultOptions, mode and modeOptions[mode])
+end
+
+local function generateLexer(options)
+	-- The 'or nil' clause allows false to map to a nil value since 'nil' cannot be merged
+	options = options.others
+	local valueCapture = (
+		booleanCapture
+		+ nullCapture * lpeg.Cc(options.null or nil)
+	)
+	if options.allowUndefined then
+		valueCapture = valueCapture + undefinedCapture * lpeg.Cc(options.undefined or nil)
+	else
+		valueCapture = valueCapture + #undefinedCapture * util.denied("undefined", "others.allowUndefined")
+	end
+	return valueCapture
+end
+
+local others = {
+	mergeOptions = mergeOptions,	
+	generateLexer = generateLexer
+}
+
+return others

tools/luajson/json/decode/state.lua

@@ -0,0 +1,189 @@
+--[[
+	Licensed according to the included 'LICENSE' document
+	Author: Thomas Harning Jr <harningt@gmail.com>
+]]
+
+local setmetatable = setmetatable
+local jsonutil = require("json.util")
+local assert = assert
+local type = type
+local next = next
+local unpack = require("table").unpack or unpack
+
+local _ENV = nil
+
+local state_ops = {}
+local state_mt = {
+	__index = state_ops
+}
+
+function state_ops.pop(self)
+	self.previous_set = true
+	self.previous = self.active
+	local i = self.i
+	-- Load in this array into the active item
+	self.active = self.stack[i]
+	self.active_state = self.state_stack[i]
+	self.active_key = self.key_stack[i]
+	self.stack[i] = nil
+	self.state_stack[i] = nil
+	self.key_stack[i] = nil
+
+	self.i = i - 1
+end
+
+function state_ops.push(self)
+	local i = self.i + 1
+	self.i = i
+	
+	self.stack[i] = self.active
+	self.state_stack[i] = self.active_state
+	self.key_stack[i] = self.active_key
+end
+
+function state_ops.put_object_value(self, trailing)
+	local object_options = self.options.object
+	if trailing and object_options.trailingComma then
+		if not self.active_key then
+			return
+		end
+	end
+	assert(self.active_key, "Missing key value")
+	object_options.setObjectKey(self.active, self.active_key, self:grab_value())
+	self.active_key = nil
+end
+
+function state_ops.put_array_value(self, trailing)
+	-- Safety check
+	if trailing and not self.previous_set and self.options.array.trailingComma then
+		return
+	end
+	local new_index = self.active_state + 1
+	self.active_state = new_index
+	self.active[new_index] = self:grab_value()
+end
+
+function state_ops.put_value(self, trailing)
+	if self.active_state == 'object' then
+		self:put_object_value(trailing)
+	else
+		self:put_array_value(trailing)
+	end
+end
+
+function state_ops.new_array(self)
+	local new_array = {}
+	if jsonutil.InitArray then
+		new_array = jsonutil.InitArray(new_array) or new_array
+	end
+	self.active = new_array
+	self.active_state = 0
+	self.active_key = nil
+	self:unset_value()
+end
+
+function state_ops.end_array(self)
+	if self.previous_set or self.active_state ~= 0 then
+		-- Not an empty array
+		self:put_value(true)
+	end
+	if self.active_state ~= #self.active then
+		-- Store the length in
+		self.active.n = self.active_state
+	end
+end
+
+function state_ops.new_object(self)
+	local new_object = {}
+	self.active = new_object
+	self.active_state = 'object'
+	self.active_key = nil
+	self:unset_value()
+end
+
+function state_ops.end_object(self)
+	if self.previous_set or next(self.active) then
+		-- Not an empty object
+		self:put_value(true)
+	end
+end
+
+function state_ops.new_call(self, name, func)
+	-- TODO setup properly
+	local new_call = {}
+	new_call.name = name
+	new_call.func = func
+	self.active = new_call
+	self.active_state = 0
+	self.active_key = nil
+	self:unset_value()
+end
+
+function state_ops.end_call(self)
+	if self.previous_set or self.active_state ~= 0 then
+		-- Not an empty array
+		self:put_value(true)
+	end
+	if self.active_state ~= #self.active then
+		-- Store the length in
+		self.active.n = self.active_state
+	end
+	local func = self.active.func
+	if func == true then
+		func = jsonutil.buildCall
+	end
+	self.active = func(self.active.name, unpack(self.active, 1, self.active.n or #self.active))
+end
+
+
+function state_ops.unset_value(self)
+	self.previous_set = false
+	self.previous = nil
+end
+
+function state_ops.grab_value(self)
+	assert(self.previous_set, "Previous value not set")
+	self.previous_set = false
+	return self.previous
+end
+
+function state_ops.set_value(self, value)
+	assert(not self.previous_set, "Value set when one already in slot")
+	self.previous_set = true
+	self.previous = value
+end
+
+function state_ops.set_key(self)
+	assert(self.active_state == 'object', "Cannot set key on array")
+	local value = self:grab_value()
+	local value_type = type(value)
+	if self.options.object.number then
+		assert(value_type == 'string' or value_type == 'number', "As configured, a key must be a number or string") 
+	else
+		assert(value_type == 'string', "As configured, a key must be a string")
+	end
+	self.active_key = value
+end
+
+
+local function create(options)
+	local ret = {
+		options = options,
+		stack = {},
+		state_stack = {},
+		key_stack = {},
+		i = 0,
+		active = nil,
+		active_key = nil,
+		previous = nil,
+		active_state = nil
+
+	}
+	return setmetatable(ret, state_mt)
+end
+
+local state = {
+	create = create
+}
+
+return state

tools/luajson/json/decode/strings.lua

@@ -0,0 +1,133 @@
+--[[
+	Licensed according to the included 'LICENSE' document
+	Author: Thomas Harning Jr <harningt@gmail.com>
+]]
+local lpeg = require("lpeg")
+local jsonutil = require("json.util")
+local util = require("json.decode.util")
+local merge = jsonutil.merge
+
+local tonumber = tonumber
+local string_char = require("string").char
+local floor = require("math").floor
+local table_concat = require("table").concat
+
+local error = error
+
+local _ENV = nil
+
+local function get_error(item)
+	local fmt_string = item .. " in string [%q] @ %i:%i"
+	return lpeg.P(function(data, index)
+		local line, line_index, bad_char, last_line = util.get_invalid_character_info(data, index)
+		local err = fmt_string:format(bad_char, line, line_index)
+		error(err)
+	end) * 1
+end
+
+local bad_unicode   = get_error("Illegal unicode escape")
+local bad_hex       = get_error("Illegal hex escape")
+local bad_character = get_error("Illegal character")
+local bad_escape    = get_error("Illegal escape")
+
+local knownReplacements = {
+	["'"] = "'",
+	['"'] = '"',
+	['\\'] = '\\',
+	['/'] = '/',
+	b = '\b',
+	f = '\f',
+	n = '\n',
+	r = '\r',
+	t = '\t',
+	v = '\v',
+	z = '\z'
+}
+
+-- according to the table at http://da.wikipedia.org/wiki/UTF-8
+local function utf8DecodeUnicode(code1, code2)
+	code1, code2 = tonumber(code1, 16), tonumber(code2, 16)
+	if code1 == 0 and code2 < 0x80 then
+		return string_char(code2)
+	end
+	if code1 < 0x08 then
+		return string_char(
+			0xC0 + code1 * 4 + floor(code2 / 64),
+			0x80 + code2 % 64)
+	end
+	return string_char(
+		0xE0 + floor(code1 / 16),
+		0x80 + (code1 % 16) * 4 + floor(code2 / 64),
+		0x80 + code2 % 64)
+end
+
+local function decodeX(code)
+	code = tonumber(code, 16)
+	return string_char(code)
+end
+
+local doSimpleSub = lpeg.C(lpeg.S("'\"\\/bfnrtvz")) / knownReplacements
+local doUniSub = lpeg.P('u') * (lpeg.C(util.hexpair) * lpeg.C(util.hexpair) + bad_unicode)
+local doXSub = lpeg.P('x') * (lpeg.C(util.hexpair) + bad_hex)
+
+local defaultOptions = {
+	badChars = '',
+	additionalEscapes = false, -- disallow untranslated escapes
+	escapeCheck = #lpeg.S('bfnrtv/\\"xu\'z'), -- no check on valid characters
+	decodeUnicode = utf8DecodeUnicode,
+	strict_quotes = false
+}
+
+local modeOptions = {}
+
+modeOptions.strict = {
+	badChars = '\b\f\n\r\t\v',
+	additionalEscapes = false, -- no additional escapes
+	escapeCheck = #lpeg.S('bfnrtv/\\"u'), --only these chars are allowed to be escaped
+	strict_quotes = true
+}
+
+local function mergeOptions(options, mode)
+	jsonutil.doOptionMerge(options, false, 'strings', defaultOptions, mode and modeOptions[mode])
+end
+
+local function buildCaptureString(quote, badChars, escapeMatch)
+	local captureChar = (1 - lpeg.S("\\" .. badChars .. quote)) + (lpeg.P("\\") / "" * escapeMatch)
+	-- During error, force end
+	local captureString = captureChar^0 + (-#lpeg.P(quote) * bad_character + -1)
+	return lpeg.P(quote) * lpeg.Cs(captureString) * lpeg.P(quote)
+end
+
+local function generateLexer(options)
+	options = options.strings
+	local quotes = { '"' }
+	if not options.strict_quotes then
+		quotes[#quotes + 1] = "'"
+	end
+	local escapeMatch = doSimpleSub
+	escapeMatch = escapeMatch + doXSub / decodeX
+	escapeMatch = escapeMatch + doUniSub / options.decodeUnicode
+	if options.escapeCheck then
+		escapeMatch = options.escapeCheck * escapeMatch + bad_escape
+	end
+	if options.additionalEscapes then
+		escapeMatch = options.additionalEscapes + escapeMatch
+	end
+	local captureString
+	for i = 1, #quotes do
+		local cap = buildCaptureString(quotes[i], options.badChars, escapeMatch)
+		if captureString == nil then
+			captureString = cap
+		else
+			captureString = captureString + cap
+		end
+	end
+	return captureString
+end
+
+local strings = {
+	mergeOptions = mergeOptions,
+	generateLexer = generateLexer
+}
+
+return strings

tools/luajson/json/decode/util.lua

@@ -0,0 +1,121 @@
+--[[
+	Licensed according to the included 'LICENSE' document
+	Author: Thomas Harning Jr <harningt@gmail.com>
+]]
+local lpeg = require("lpeg")
+local select = select
+local pairs, ipairs = pairs, ipairs
+local tonumber = tonumber
+local string_char = require("string").char
+local rawset = rawset
+local jsonutil = require("json.util")
+
+local error = error
+local setmetatable = setmetatable
+
+local table_concat = require("table").concat
+
+local merge = require("json.util").merge
+
+local _ENV = nil
+
+local function get_invalid_character_info(input, index)
+	local parsed = input:sub(1, index)
+	local bad_character = input:sub(index, index)
+	local _, line_number = parsed:gsub('\n',{})
+	local last_line = parsed:match("\n([^\n]+.)$") or parsed
+	return line_number, #last_line, bad_character, last_line
+end
+
+local function build_report(msg)
+	local fmt = msg:gsub("%%", "%%%%") .. " @ character: %i %i:%i [%s] line:\n%s"
+	return lpeg.P(function(data, pos)
+		local line, line_index, bad_char, last_line = get_invalid_character_info(data, pos)
+		local text = fmt:format(pos, line, line_index, bad_char, last_line)
+		error(text)
+	end) * 1
+end
+local function unexpected()
+	local msg = "unexpected character"
+	return build_report(msg)
+end
+local function denied(item, option)
+	local msg
+	if option then
+		msg = ("'%s' denied by option set '%s'"):format(item, option)
+	else
+		msg = ("'%s' denied"):format(item)
+	end
+	return build_report(msg)
+end
+
+-- 09, 0A, 0B, 0C, 0D, 20
+local ascii_space = lpeg.S("\t\n\v\f\r ")
+local unicode_space
+do
+	local chr = string_char
+	local u_space = ascii_space
+	-- \u0085 \u00A0
+	u_space = u_space + lpeg.P(chr(0xC2)) * lpeg.S(chr(0x85) .. chr(0xA0))
+	-- \u1680 \u180E
+	u_space = u_space + lpeg.P(chr(0xE1)) * (lpeg.P(chr(0x9A, 0x80)) + chr(0xA0, 0x8E))
+	-- \u2000 - \u200A, also 200B
+	local spacing_end = ""
+	for i = 0x80,0x8b do
+		spacing_end = spacing_end .. chr(i)
+	end
+	-- \u2028 \u2029 \u202F
+	spacing_end = spacing_end .. chr(0xA8) .. chr(0xA9) .. chr(0xAF)
+	u_space = u_space + lpeg.P(chr(0xE2, 0x80)) * lpeg.S(spacing_end)
+	-- \u205F
+	u_space = u_space + lpeg.P(chr(0xE2, 0x81, 0x9F))
+	-- \u3000
+	u_space = u_space + lpeg.P(chr(0xE3, 0x80, 0x80))
+	-- BOM \uFEFF
+	u_space = u_space + lpeg.P(chr(0xEF, 0xBB, 0xBF))
+	unicode_space = u_space
+end
+
+local identifier = lpeg.R("AZ","az","__") * lpeg.R("AZ","az", "__", "09") ^0
+
+local hex = lpeg.R("09","AF","af")
+local hexpair = hex * hex
+
+local comments = {
+	cpp = lpeg.P("//") * (1 - lpeg.P("\n"))^0 * lpeg.P("\n"),
+	c = lpeg.P("/*") * (1 - lpeg.P("*/"))^0 * lpeg.P("*/")
+}
+
+local comment = comments.cpp + comments.c
+
+local ascii_ignored = (ascii_space + comment)^0
+
+local unicode_ignored = (unicode_space + comment)^0
+
+-- Parse the lpeg version skipping patch-values
+-- LPEG <= 0.7 have no version value... so 0.7 is value
+local DecimalLpegVersion = lpeg.version and tonumber(lpeg.version():match("^(%d+%.%d+)")) or 0.7
+
+local function setObjectKeyForceNumber(t, key, value)
+	key = tonumber(key) or key
+	return rawset(t, key, value)
+end
+
+local util = {
+	unexpected = unexpected,
+	denied = denied,
+	ascii_space = ascii_space,
+	unicode_space = unicode_space,
+	identifier = identifier,
+	hex = hex,
+	hexpair = hexpair,
+	comments = comments,
+	comment = comment,
+	ascii_ignored = ascii_ignored,
+	unicode_ignored = unicode_ignored,
+	DecimalLpegVersion = DecimalLpegVersion,
+	get_invalid_character_info = get_invalid_character_info,
+	setObjectKeyForceNumber = setObjectKeyForceNumber
+}
+
+return util