Renamed modpol/modpol directory to modpol_core for clarity and consistency

2021-12-18 14:50:41 -07:00
parent bd95fcf811
commit c2852b1bce
32 changed files with 6 additions and 8 deletions
--- a/modpol_core/util/ocutil/ocutil.lua
+++ b/modpol_core/util/ocutil/ocutil.lua
@ -0,0 +1,743 @@
+-- ===================================================================
+-- Overview.
+
+-- This file is "top/modpol.ocutil.lua".
+
+-- This file  provides a  collection of  largely portable  Lua utility
+-- functions.  The collection is descended  from one assembled by Old-
+-- Coder (Robert Kiraly).
+
+-- ===================================================================
+
+modpol.ocutil = {}
+
+modpol.ocutil.log_console = true       -- Flag: Copy log to console
+modpol.ocutil.logdir      = nil        -- Absolute path for  log-file  direc-
+                                -- tory (or nil)
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.fixnil
+-- Params:   string s
+-- Outputs:
+--
+-- If the string is nil   , returns "(nil)"
+-- if the string is empty , returns "(empty)"
+-- Otherwise, returns the string as it stands
+--
+-- This function can be used  to clarify -- and/or avoid crashes in --
+-- debug messages.
+
+-- ===================================================================
+
+modpol.ocutil.fixnil = function (s)
+    if     s == nil then s = "(nil)"
+    elseif s == ""  then s = "(empty)"
+    end
+    return s
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.setlogdir
+-- Params:   string path
+-- Outputs:
+--
+-- The input string should  be the absolute path for a writable direc-
+-- tory that already exists.  This function tells  "modpol.ocutil.log" to put
+-- log files in that directory.
+
+-- ===================================================================
+
+modpol.ocutil.setlogdir = function (path)
+    if path ~= nil and path ~= "" then
+        modpol.ocutil.logdir = path
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.setlogname
+-- Params:   string name
+-- Outputs:
+--
+-- The input string  should  be a filename  without a  path component.
+-- This function tells  "modpol.ocutil.log" to use the specified filename for
+-- the main log file.
+--
+-- "modpol.ocutil.setlogdir"  must be called  separately  to set the log-file
+-- directory.
+
+-- ===================================================================
+
+modpol.ocutil.setlogname = function (name)
+    if name ~= nil and name ~= "" then
+        modpol.ocutil.logname = name
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.log
+-- Params:   string s
+-- Outputs:
+--
+-- Logs the specified string.  Appends a  newline if not  already pre-
+-- sent.
+
+-- ===================================================================
+
+modpol.ocutil.log = function (s)
+    s = modpol.ocutil.fixnil (s)
+    s = s:gsub ("\n$", "", 1)   -- Remove trailing newline initially
+
+    if modpol.ocutil.log_console then
+        print (s)
+    end
+
+    if modpol.ocutil.logdir  ~= nil and
+       modpol.ocutil.logname ~= nil then
+        s = s .. "\n"           -- Add trailing newline
+
+        local logpath = modpol.ocutil.logdir .. "/" .. modpol.ocutil.logname
+        modpol.ocutil.file_append (logpath, s)
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.fatal_error
+-- Params:   string s
+-- Outputs:
+--
+-- Logs "Fatal error: " plus the specified string.  Appends a  newline
+-- if not already present. Terminates the program.
+
+-- ===================================================================
+
+modpol.ocutil.fatal_error = function (s)
+    modpol.ocutil.log ("Fatal Error: " .. s)
+    os.exit (1)
+    return nil                  -- Shouldn't be reached
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.panic
+-- Params:   string s
+-- Outputs:
+--
+-- Logs "Internal error: " plus the specified string.  Appends a  new-
+-- line if not already present. Terminates the program.
+
+-- ===================================================================
+
+modpol.ocutil.panic = function (s)
+    modpol.ocutil.log ("Internal Error: " .. s)
+    os.exit (1)
+    return nil                  -- Shouldn't be reached
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.str_empty
+-- Params:   string x
+-- Outputs:
+--
+-- Returns true if the string is nil or empty
+-- Returns false otherwise
+
+-- ===================================================================
+
+modpol.ocutil.str_empty = function (x)
+    if x == nil or x == "" then
+        return true
+    else
+        return false
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.str_nonempty
+-- Params:   string x
+-- Outputs:
+--
+-- Returns true if the string is nil or empty
+-- Returns false otherwise
+
+-- ===================================================================
+
+modpol.ocutil.str_nonempty = function (x)
+    if x == nil or x == "" then
+        return false
+    else
+        return true
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.table_empty
+-- Params:   table tab
+-- Outputs:
+--
+-- Returns true if the table is empty
+-- Returns false otherwise
+
+-- ===================================================================
+
+modpol.ocutil.table_empty = function (tab)
+    local next = next
+    if next (tab) == nil then return true end
+    return false
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.table_nonempty
+-- Params:   table tab
+-- Outputs:
+--
+-- Returns false if the table is empty
+-- Returns true otherwise
+
+-- ===================================================================
+
+modpol.ocutil.table_nonempty = function (tab)
+    if modpol.ocutil.table_empty (tab) then return false end
+    return true
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.string_contains
+-- Params:   strings a, b
+-- Outputs:
+--
+-- Returns true if the 1st string contains the 2nd one
+-- Returns false otherwise
+
+-- ===================================================================
+
+modpol.ocutil.str_contains = function (a, b)
+    if string.match (a, b) then
+        return true
+    else
+        return false
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.str_false
+-- Params:   string x
+-- Outputs:
+--
+-- This function checks the string for an  explicit false  (or equiva-
+-- lent)  setting (as  opposed to empty or nil). If such a  setting is
+-- found, true is returned. Otherwise, false is returned.
+
+-- ===================================================================
+
+modpol.ocutil.str_false = function (x)
+    if x == "false" or x == "no"  or
+       x == "off"   or x == "0"   or
+       x == false   or x == 0 then
+        return true
+    else
+        return false
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.str_true
+-- Params:   string x
+-- Outputs:
+--
+-- This function  checks the string for  an explicit true  (or equiva-
+-- lent) setting. If such a setting is found, true is returned. Other-
+-- wise, false is returned.
+
+-- ===================================================================
+
+modpol.ocutil.str_true  = function (x)
+    if x == "true" or x == "yes" or
+       x == "on"   or x == "1"   or
+       x == true   or x == 1 then
+        return true
+    else
+        return false
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.starts_with
+-- Params:   strings String, Start
+-- Outputs:
+--
+-- Returns true if the 1st string starts with the 2nd one
+-- Returns false otherwise
+
+-- ===================================================================
+
+modpol.ocutil.starts_with = function (String, Start)
+    if string.sub (String, 1, string.len (Start)) == Start then
+        return true
+    else
+        return false
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.not_starts_with
+-- Params:   strings String, Start
+-- Outputs:
+--
+-- Returns false if the 1st string starts with the 2nd one
+-- Returns true otherwise
+
+-- ===================================================================
+
+modpol.ocutil.not_starts_with = function (String, Start)
+    if string.sub (String, 1, string.len (Start)) == Start then
+        return false
+    else
+        return true
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.ends_with
+-- Params:   strings String, End
+-- Outputs:
+--
+-- Returns true if the 1st string ends with the 2nd one
+-- Returns false otherwise
+-- As a special case, returns true if the 2nd string is empty
+
+-- ===================================================================
+
+modpol.ocutil.ends_with = function (String, End)
+    return End == '' or string.sub (String,
+        -string.len (End)) == End
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.not_ends_with
+-- Params:   strings String, End
+-- Outputs:
+-- Returns false if the 1st string ends with the 2nd one
+-- Returns true otherwise
+-- As a special case, returns false if the 2nd string is empty
+
+-- ===================================================================
+
+modpol.ocutil.not_ends_with = function (String, End)
+    if modpol.ocutil.ends_with (String, End) then
+        return false
+    else
+        return true
+    end
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.firstch
+-- Params:   string str
+-- Outputs:
+-- Returns the 1st character of the string
+
+-- ===================================================================
+
+modpol.ocutil.firstch = function (str)
+    return string.sub (str, 1, 1)
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.first_to_upper
+-- Params:   string str
+-- Outputs:
+-- Returns the 1st character of the string in upper case
+
+-- ===================================================================
+
+modpol.ocutil.first_to_upper = function (str)
+    return (str:gsub ("^%l", string.upper))
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.all_first_to_upper
+-- Params:   string str, flag cvtspace
+-- Outputs:
+--
+-- Converts  the  1st character  of each word in  the string  to upper
+-- case and  returns the result.  Words are delimited by spaces or un-
+-- derscores.  If the flag is true,  also replaces  spaces with under-
+-- scores.
+
+-- ===================================================================
+
+modpol.ocutil.all_first_to_upper = function (str, cvtspace)
+
+    str = str:gsub ("^%l", string.upper)
+    str = str:gsub ("[_ ]%l",
+        function (a) return string.upper (a) end)
+
+    if modpol.ocutil.str_true (cvtspace) then
+        str = str:gsub ("_", " ")
+    end
+
+    return (str)
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.strtok
+-- Params:   strings source, delimitch
+-- Outputs:
+--
+-- Breaks  the source string up into  a list of words and  returns the
+-- list.
+--
+-- If "delimitch" is  omitted,  nil, or empty,  words are delimited by
+-- spaces. Otherwise, words are  delimited by any of the characters in
+-- "delimitch".
+
+-- ===================================================================
+
+modpol.ocutil.strtok = function (source, delimitch)
+    if delimitch == nil or
+       delimitch == ""  then delimitch = " " end
+
+    local parts   = {}
+    local pattern = '([^' .. delimitch .. ']+)'
+
+    string.gsub (source, pattern,
+        function (value)
+            value = value:gsub ("^ *", "")
+            value = value:gsub (" *$", "")
+            parts [#parts + 1] = value
+        end)
+
+    return parts
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.swap_key_value
+-- Params:   table itable
+-- Outputs:
+-- Turns  keys into values and  vice versa and  returns  the resulting
+-- table.
+
+-- ===================================================================
+
+modpol.ocutil.swap_key_value = function (itable)
+    if itable == nil then return nil end
+    local  otable = {}
+    for key, value in pairs (itable) do otable [value] = key end
+    return otable
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.ktable_to_vtable
+-- Params:   table ktable
+-- Outputs:
+--
+-- "ktable_to_vtable" is short for "convert key table to value table".
+--
+-- The input table is assumed to be an arbitrary key-based list of the
+-- general form:
+-- { dog="woof", apple="red", book="read" }
+--
+-- This function takes the keys and returns them as an integer-indexed
+-- array with the former keys stored now as values. The array is sort-
+-- ed based on the former keys. The original values in the input table
+-- are discarded. Sample output:
+--
+-- { "apple", "book", "dog", ... }
+
+-- Here's  a  complete  code fragment which  demonstrates operation of
+-- this function:
+
+-- local tabby = { dog="woof", apple="red", book="read" }
+--
+-- print ("\nInput table:")
+-- for ii, value in  pairs (tabby) do
+--     print (ii .. ") " .. tabby [ii])
+-- end
+--
+-- tabby = modpol.ocutil.ktable_to_vtable (tabby)
+--
+-- print ("\nOutput table:")
+-- for ii, value in ipairs (tabby) do
+--     print (ii .. ") " .. tabby [ii])
+-- end
+
+-- ===================================================================
+
+modpol.ocutil.ktable_to_vtable = function (ktable)
+    local vtable = {}
+    if ktable == nil then return vtable end
+
+    for key, _ in pairs (ktable) do
+        table.insert (vtable, key)
+    end
+
+    table.sort (vtable)
+    return vtable
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.vtable_to_ktable
+-- Params:   table vtable, scalar set_to
+-- Outputs:
+--
+-- "vtable_to_ktable" is short for "convert value table to key table".
+--
+-- The input table is assumed to be an integer-indexed array of scalar
+-- values.
+--
+-- This function creates a general table that holds the  scalar values
+-- stored  now as keys and returns  the new table.  The new table maps
+-- each of the keys to the value specified by "set_to".
+--
+-- If "set_to" is omitted or nil, it defaults to boolean true.
+
+-- Here's  a  complete  code fragment which  demonstrates operation of
+-- this function:
+--
+-- local tabby = { "apple", "book", "dog" }
+--
+-- print ("\nInput table:")
+-- for ii, value in ipairs (tabby) do
+--     print (ii .. ") " .. tabby [ii])
+-- end
+--
+-- tabby = modpol.ocutil.vtable_to_ktable (tabby, 42)
+--
+-- print ("\nOutput table:")
+-- for ii, value in  pairs (tabby) do
+--     print (ii .. ") " .. tabby [ii])
+-- end
+
+-- ===================================================================
+
+modpol.ocutil.vtable_to_ktable = function (vtable, set_to)
+
+    local ktable = {}
+    if vtable == nil then return ktable end
+    if set_to == nil then set_to = true end
+
+    for _, value in pairs (vtable) do
+        ktable [value] = set_to
+    end
+
+    return ktable
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.make_set
+-- Params:   array harry
+-- Outputs:
+--
+-- This function makes a set out of an array. Specifically, it returns
+-- a new table with the  array's values as keys.  The  new table  maps
+-- each key to boolean true.
+--
+-- Here's  a  complete  code fragment which  demonstrates operation of
+-- this function:
+--
+-- local color_set = modpol.ocutil.make_set { "red", "green", "blue" }
+-- if    color_set ["red"] ~= nil then print ("Supported color") end
+
+-- ===================================================================
+
+modpol.ocutil.make_set = function (list)
+    local set = {}
+    for _, l in ipairs (list) do set [l] = true end
+    return set
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.pos_to_str
+-- Params:   position-table pos
+-- Outputs:
+--
+-- This function takes a table of the following form as input:
+-- { x=25.0, y=-135.5, z=2750.0 }
+--
+-- It returns the x-y-z values, separated by commas, as a string.
+
+-- ===================================================================
+
+modpol.ocutil.pos_to_str = function (pos)
+    return pos.x .. "," .. pos.y .. "," .. pos.z
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.table_length
+-- Params:   table tabby
+-- Outputs:  Returns number of entries in table
+--
+-- Note: This function works for tables in general as well as for int-
+-- eger-indexed tables (i.e., arrays).
+
+-- ===================================================================
+
+modpol.ocutil.table_length = function (tabby)
+    local count = 0
+    for _ in pairs (tabby) do count = count+1 end
+    return count
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.clone_table
+-- Params:   table tabby
+-- Outputs:
+--
+-- This function returns  an independent clone of the input table.  It
+-- should work correctly for most cases,  but special cases  that  re-
+-- quire additional work may exist.
+--
+-- This function may also be called as "modpol.ocutil.table_clone".
+
+-- ===================================================================
+
+modpol.ocutil.clone_table = function (tabby)
+    if tabby == nil then return nil end
+    local copy = {}
+    for k, v in pairs (tabby) do
+        if type (v) == 'table' then v = modpol.ocutil.clone_table (v) end
+        copy [k] = v
+    end
+    return copy
+end
+
+modpol.ocutil.table_clone = modpol.ocutil.clone_table
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.file_exists
+-- Params:   string path
+-- Outputs:
+--
+-- The  input string should be the relative or absolute pathname for a
+-- data file.  If the  file is read-accessible,  this function returns
+-- true. Otherwise, it returns false.
+
+-- ===================================================================
+
+modpol.ocutil.file_exists = function (path)
+    local file, err
+    file, err = io.open (path, "rb")
+    if err then return false end
+    file:close()
+    return true
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.file_missing
+-- Params:   string path
+-- Outputs:
+--
+-- The  input string should be the relative or absolute pathname for a
+-- data file.  If the  file is read-accessible,  this function returns
+-- false. Otherwise, it returns true.
+
+-- ===================================================================
+
+modpol.ocutil.file_missing = function (path)
+    if modpol.ocutil.file_exists (path) then return false end
+    return true
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.file_read
+-- Params:   string path
+-- Outputs:
+--
+-- The  input string should be the  absolute pathname for a data file.
+-- If the file is read-accessible,  this function returns the contents
+-- of the file. Otherwise, it returns nil.
+--
+-- Warning: There is presently no check for a maximum file size.
+
+-- ===================================================================
+
+modpol.ocutil.file_read = function (path)
+    local file, err
+    file, err = io.open (path, "rb")
+    if err then return nil end
+    local data = file:read ("*a")
+    file:close()
+    return data
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.file_write
+-- Params:   strings path, data
+-- Outputs:
+--
+-- The 1st string should be the absolute pathname for a data file. The
+-- file  doesn't need to  exist initially but the  directory that will
+-- contain it does need to exist.
+--
+-- This function  writes the  2nd string to the file.  Existing stored
+-- data is discarded.
+--
+-- This function returns true if successful and false otherwise.
+
+-- ===================================================================
+
+modpol.ocutil.file_write = function (path, data)
+    local file, err
+    file, err = io.open (path, "wb")
+    if err then return false end
+    io.output (file)
+    io.write (data)
+    io.close (file)
+    return true
+end
+
+-- ===================================================================
+
+-- Function: modpol.ocutil.file_append
+-- Params:   strings path, data
+-- Outputs:
+--
+-- This function is  identical to  "modpol.ocutil.file_write"  except for one
+-- difference:  It  appends to existing files as opposed to overwrites
+-- them.
+
+-- ===================================================================
+
+modpol.ocutil.file_append = function (path, data)
+    local file, err
+    file, err = io.open (path, "ab")
+    if err then return false end
+    io.output (file)
+    io.write (data)
+    io.close (file)
+    return true
+end
+
+-- ===================================================================
+-- End of file.
--- a/modpol_core/util/serpent/LICENSE.txt
+++ b/modpol_core/util/serpent/LICENSE.txt
@ -0,0 +1,21 @@
+Serpent source is released under the MIT License
+
+Copyright (c) 2012-2018 Paul Kulchenko (paul@kulchenko.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- a/modpol_core/util/serpent/README.md
+++ b/modpol_core/util/serpent/README.md
@ -0,0 +1,293 @@
+# Serpent
+
+Lua serializer and pretty printer.
+
+## Features
+
+* Human readable:
+    * Provides single-line and multi-line output.
+    * Nested tables are properly indented in the multi-line output.
+    * Numerical keys are listed first.
+    * Keys are (optionally) sorted alphanumerically.
+    * Array part skips keys (`{'a', 'b'}` instead of `{[1] = 'a', [2] = 'b'}`).
+    * `nil` values are included when expected (`{1, nil, 3}` instead of `{1, [3]=3}`).
+    * Keys use short notation (`{foo = 'foo'}` instead of `{['foo'] = 'foo'}`).
+    * Shared references and self-references are marked in the output.
+* Machine readable: provides reliable deserialization using `loadstring()`.
+* Supports deeply nested tables.
+* Supports tables with self-references.
+* Keeps shared tables and functions shared after de/serialization.
+* Supports function serialization using `string.dump()`.
+* Supports serialization of global functions.
+* Supports `__tostring` and `__serialize` metamethods.
+* Escapes new-line `\010` and end-of-file control `\026` characters in strings.
+* Configurable with options and custom formatters.
+
+## Usage
+
+```lua
+local serpent = require("serpent")
+local a = {1, nil, 3, x=1, ['true'] = 2, [not true]=3}
+a[a] = a -- self-reference with a table as key and value
+
+print(serpent.dump(a)) -- full serialization
+print(serpent.line(a)) -- single line, no self-ref section
+print(serpent.block(a)) -- multi-line indented, no self-ref section
+
+local fun, err = loadstring(serpent.dump(a))
+if err then error(err) end
+local copy = fun()
+
+-- or using serpent.load:
+local ok, copy = serpent.load(serpent.dump(a))
+print(ok and copy[3] == a[3])
+```
+
+## Functions
+
+Serpent provides three functions that are shortcuts to the same
+internal function, but set different options by default:
+
+* `dump(a[, {...}])` -- full serialization; sets `name`, `compact` and `sparse` options;
+* `line(a[, {...}])` -- single line pretty printing, no self-ref section; sets `sortkeys` and `comment` options;
+* `block(a[, {...}])` -- multi-line indented pretty printing, no self-ref section; sets `indent`, `sortkeys`, and `comment` options.
+
+Note that `line` and `block` functions return pretty-printed data structures and if you want to deserialize them, you need to add `return` before running them through `loadstring`.
+For example: `loadstring('return '..require('mobdebug').line("foo"))() == "foo"`.
+
+While you can use `loadstring` or `load` functions to load serialized fragments, Serpent also provides `load` function that adds safety checks and reports an error if there is any executable code in the fragment.
+
+* `ok, res = serpent.load(str[, {safe = true}])` -- loads serialized fragment; you need to pass `{safe = false}` as the second value if you want to turn safety checks off.
+
+Similar to `pcall` and `loadstring` calls, `load` returns status as the first value and the result or the error message as the second value.
+
+## Options
+
+* indent (string) -- indentation; triggers long multi-line output.
+* comment (true/false/maxlevel) -- provide stringified value in a comment (up to `maxlevel` of depth).
+* sortkeys (true/false/function) -- sort keys.
+* sparse (true/false) -- force sparse encoding (no nil filling based on `#t`).
+* compact (true/false) -- remove spaces.
+* fatal (true/False) -- raise fatal error on non-serilizable values.
+* nocode (true/False) -- disable bytecode serialization for easy comparison.
+* nohuge (true/False) -- disable checking numbers against undefined and huge values.
+* maxlevel (number) -- specify max level up to which to expand nested tables.
+* maxnum (number) -- specify max number of elements in a table.
+* maxlength (number) -- specify max length for all table elements.
+* metatostring (True/false) -- use `__tostring` metamethod when serializing tables (**v0.29**);
+set to `false` to disable and serialize the table as is, even when `__tostring` is present.
+* numformat (string; "%.17g") -- specify format for numeric values as shortest possible round-trippable double (**v0.30**).
+Use "%.16g" for better readability and "%.17g" (the default value) to preserve floating point precision.
+* valignore (table) -- allows to specify a list of values to ignore (as keys).
+* keyallow (table) -- allows to specify the list of keys to be serialized.
+Any keys not in this list are not included in final output (as keys).
+* keyignore (table) -- allows to specity the list of keys to ignore in serialization.
+* valtypeignore (table) -- allows to specify a list of value *types* to ignore (as keys).
+* custom (function) -- provide custom output for tables.
+* name (string) -- name; triggers full serialization with self-ref section.
+
+These options can be provided as a second parameter to Serpent functions.
+
+```lua
+block(a, {fatal = true})
+line(a, {nocode = true, valignore = {[arrayToIgnore] = true}})
+function todiff(a) return dump(a, {nocode = true, indent = ' '}) end
+```
+
+Serpent functions set these options to different default values:
+
+* `dump` sets `compact` and `sparse` to `true`;
+* `line` sets `sortkeys` and `comment` to `true`;
+* `block` sets `sortkeys` and `comment` to `true` and `indent` to `'  '`.
+
+## Metatables with __tostring and __serialize methods
+
+If a table or a userdata value has `__tostring` or `__serialize` method, the method will be used to serialize the value.
+If `__serialize` method is present, it will be called with the value as a parameter.
+if `__serialize` method is not present, but `__tostring` is, then `tostring` will be called with the value as a parameter.
+In both cases, the result will be serialized, so `__serialize` method can return a table, that will be serialize and replace the original value.
+
+## Sorting
+
+A custom sort function can be provided to sort the contents of tables. The function takes 2 parameters, the first being the table (a list) with the keys, the second the original table. It should modify the first table in-place, and return nothing.
+For example, the following call will apply a sort function identical to the standard sort, except that it will not distinguish between lower- and uppercase.
+
+```lua
+local mysort  = function(k, o) -- k=keys, o=original table
+  local maxn, to = 12, {number = 'a', string = 'b'}
+  local function padnum(d) return ("%0"..maxn.."d"):format(d) end
+  local sort = function(a,b)
+    -- this -vvvvvvvvvv- is needed to sort array keys first
+    return ((k[a] and 0 or to[type(a)] or 'z')..(tostring(a):gsub("%d+",padnum))):upper()
+         < ((k[b] and 0 or to[type(b)] or 'z')..(tostring(b):gsub("%d+",padnum))):upper()
+  end
+  table.sort(k, sort)
+end
+
+local content = { some = 1, input = 2, To = 3, serialize = 4 }
+local result = require('serpent').block(content, {sortkeys = mysort})
+```
+
+## Formatters
+
+Serpent supports a way to provide a custom formatter that allows to fully
+customize the output. The formatter takes four values:
+
+* tag -- the name of the current element with '=' or an empty string in case of array index,
+* head -- an opening table bracket `{` and associated indentation and newline (if any),
+* body -- table elements concatenated into a string using commas and indentation/newlines (if any),
+* tail -- a closing table bracket `}` and associated indentation and newline (if any), and
+* level -- the current level.
+
+For example, the following call will apply
+`Foo{bar} notation to its output (used by Metalua to display ASTs):
+
+```lua
+print((require "serpent").block(ast, {comment = false, custom =
+  function(tag,head,body,tail)
+    local out = head..body..tail
+    if tag:find('^lineinfo') then
+      out = out:gsub("\n%s+", "") -- collapse lineinfo to one line
+    elseif tag == '' then
+      body = body:gsub('%s*lineinfo = [^\n]+', '')
+      local _,_,atag = body:find('tag = "(%w+)"%s*$')
+      if atag then
+        out = "`"..atag..head.. body:gsub('%s*tag = "%w+"%s*$', '')..tail
+        out = out:gsub("\n%s+", ""):gsub(",}","}")
+      else out = head..body..tail end
+    end
+    return tag..out
+  end}))
+```
+
+## Limitations
+
+* Doesn't handle userdata (except filehandles in `io.*` table).
+* Threads, function upvalues/environments, and metatables are not serialized.
+
+## Performance
+
+A simple performance test against `serialize.lua` from metalua, `pretty.write`
+from Penlight, and `tserialize.lua` from lua-nucleo is included in `t/bench.lua`.
+
+These are the results from one of the runs:
+
+* nucleo (1000): 0.256s
+* metalua (1000): 0.177s
+* serpent (1000): 0.22s
+* serpent (1000): 0.161s -- no comments, no string escapes, no math.huge check
+* penlight (1000): 0.132s
+
+Serpent does additional processing to escape `\010` and `\026` characters in
+strings (to address http://lua-users.org/lists/lua-l/2007-07/msg00362.html,
+which is already fixed in Lua 5.2) and to check all numbers for `math.huge`.
+The seconds number excludes this processing to put it on an equal footing
+with other modules that skip these checks (`nucleo` still checks for `math.huge`).
+
+## Author
+
+Paul Kulchenko (paul@kulchenko.com)
+
+## License
+
+See LICENSE file.
+
+## History
+
+### v0.30 (Sep 01 2017)
+  - Updated `pairs` to avoid using `__pairs` in Lua 5.2+.
+  - Added `metatostring` option to disable `__tostring` processing during serialization.
+  - Added `level` to the parameters of the custom function (closes #25).
+  - Added `maxlength` option to limit the space taken by table elements.
+  - Optimized serialization of functions when `nocode` option is specified.
+  - Added protection from `__serialize` check failing (pkulchenko/ZeroBraneStudio#732).
+  - Added `keyignore` option for the serializer.
+  - Added check for environments that may not have 'default' tables as tables.
+  - Added numeric format to preserve floating point precision (closes #17).
+  - Added using `debug.metatable` when available.
+  - Improved handling of failures in `__tostring` (pkulchenko/ZeroBraneStudio#446).
+
+### v0.28 (May 06 2015)
+  - Switched to a method proposed by @SoniEx2 to disallow function calls (#15).
+  - Added more `tostring` for Lua 5.3 support (pkulchenko/ZeroBraneStudio#401).
+  - Updated environment handling to localize the impact (#15).
+  - Added setting env to protect against assigning global functions (closes #15).
+  - Updated tests to work with Lua 5.3.
+  - Added explicit `tostring` for Lua 5.3 with `LUA_NOCVTN2S` set (pkulchenko/ZeroBraneStudio#401).
+  - Fixed crash when not all Lua standard libraries are loaded (thanks to Tommy Nguyen).
+  - Improved Lua 5.2 support for serialized functions.
+
+### v0.27 (Jan 11 2014)
+  - Fixed order of elements in the array part with `sortkeys=true` (fixes #13).
+  - Updated custom formatter documentation (closes #11).
+  - Added `load` function to deserialize; updated documentation (closes #9).
+
+### v0.26 (Nov 05 2013)
+  - Added `load` function that (safely) loads serialized/pretty-printed values.
+  - Updated documentation.
+
+### v0.25 (Sep 29 2013)
+  - Added `maxnum` option to limit the number of elements in tables.
+  - Optimized processing of tables with numeric indexes.
+
+### v0.24 (Jun 12 2013)
+  - Fixed an issue with missing numerical keys (fixes #8).
+  - Fixed an issue with luaffi that returns `getmetatable(ffi.C)` as `true`.
+
+### v0.23 (Mar 24 2013)
+  - Added support for `cdata` type in LuaJIT (thanks to [Evan](https://github.com/neomantra)).
+  - Added comment to indicate incomplete output.
+  - Added support for metatables with __serialize method.
+  - Added handling of metatables with __tostring method.
+  - Fixed an issue with having too many locals in self-reference section.
+  - Fixed emitting premature circular reference in self-reference section, which caused invalid serialization.
+  - Modified the sort function signature to also pass the original table, so not only keys are available when sorting, but also the values in the original table.
+
+### v0.22 (Jan 15 2013)
+  - Added ability to process __tostring results that may be non-string values.
+
+### v0.21 (Jan 08 2013)
+  - Added `keyallow` and `valtypeignore` options (thanks to Jess Telford).
+  - Renamed `ignore` to `valignore`.
+
+### v0.19 (Nov 16 2012)
+  - Fixed an issue with serializing shared functions as keys.
+  - Added serialization of metatables using __tostring (when present).
+
+### v0.18 (Sep 13 2012)
+  - Fixed an issue with serializing data structures with circular references that require emitting temporary variables.
+  - Fixed an issue with serializing keys pointing to shared references.
+  - Improved overall serialization logic to inline values when possible.
+
+### v0.17 (Sep 12 2012)
+  - Fixed an issue with serializing userdata that doesn't provide tostring().
+
+### v0.16 (Aug 28 2012)
+  - Removed confusing --[[err]] comment from serialized results.
+  - Added a short comment to serialized functions when the body is skipped.
+
+### v0.15 (Jun 17 2012)
+  - Added `ignore` option to allow ignoring table values.
+  - Added `comment=num` option to set the max level up to which add comments.
+  - Changed all comments (except math.huge) to be controlled by `comment` option.
+
+### v0.14 (Jun 13 2012)
+  - Fixed an issue with string keys with numeric values `['3']` getting mixed
+    with real numeric keys (only with `sortkeys` option set to `true`).
+  - Fixed an issue with negative and real value numeric keys being misplaced.
+
+### v0.13 (Jun 13 2012)
+  - Added `maxlevel` option.
+  - Fixed key sorting such that `true` and `'true'` are always sorted in
+    the same order (for a more stable output).
+  - Removed addresses from names of temporary variables (for stable output).
+
+### v0.12 (Jun 12 2012)
+  - Added options to configure serialization process.
+  - Added `goto` to the list of keywords for Lua 5.2.
+  - Changed interface to dump/line/block methods.
+  - Changed `math.huge` to 1/0 for better portability.
+  - Replaced \010 with \n for better readability.
+
+### v0.10 (Jun 03 2012)
+  - First public release.
--- a/modpol_core/util/serpent/serpent-git.tar.bz2
+++ b/modpol_core/util/serpent/serpent-git.tar.bz2
--- a/modpol_core/util/serpent/serpent.lua
+++ b/modpol_core/util/serpent/serpent.lua
@ -0,0 +1,148 @@
+local n, v = "serpent", "0.302" -- (C) 2012-18 Paul Kulchenko; MIT License
+local c, d = "Paul Kulchenko", "Lua serializer and pretty printer"
+local snum = {[tostring(1/0)]='1/0 --[[math.huge]]',[tostring(-1/0)]='-1/0 --[[-math.huge]]',[tostring(0/0)]='0/0'}
+local badtype = {thread = true, userdata = true, cdata = true}
+local getmetatable = debug and debug.getmetatable or getmetatable
+local pairs = function(t) return next, t end -- avoid using __pairs in Lua 5.2+
+local keyword, globals, G = {}, {}, (_G or _ENV)
+for _,k in ipairs({'and', 'break', 'do', 'else', 'elseif', 'end', 'false',
+  'for', 'function', 'goto', 'if', 'in', 'local', 'nil', 'not', 'or', 'repeat',
+  'return', 'then', 'true', 'until', 'while'}) do keyword[k] = true end
+for k,v in pairs(G) do globals[v] = k end -- build func to name mapping
+for _,g in ipairs({'coroutine', 'debug', 'io', 'math', 'string', 'table', 'os'}) do
+  for k,v in pairs(type(G[g]) == 'table' and G[g] or {}) do globals[v] = g..'.'..k end end
+
+local function s(t, opts)
+  local name, indent, fatal, maxnum = opts.name, opts.indent, opts.fatal, opts.maxnum
+  local sparse, custom, huge = opts.sparse, opts.custom, not opts.nohuge
+  local space, maxl = (opts.compact and '' or ' '), (opts.maxlevel or math.huge)
+  local maxlen, metatostring = tonumber(opts.maxlength), opts.metatostring
+  local iname, comm = '_'..(name or ''), opts.comment and (tonumber(opts.comment) or math.huge)
+  local numformat = opts.numformat or "%.17g"
+  local seen, sref, syms, symn = {}, {'local '..iname..'={}'}, {}, 0
+  local function gensym(val) return '_'..(tostring(tostring(val)):gsub("[^%w]",""):gsub("(%d%w+)",
+    -- tostring(val) is needed because __tostring may return a non-string value
+    function(s) if not syms[s] then symn = symn+1; syms[s] = symn end return tostring(syms[s]) end)) end
+  local function safestr(s) return type(s) == "number" and tostring(huge and snum[tostring(s)] or numformat:format(s))
+    or type(s) ~= "string" and tostring(s) -- escape NEWLINE/010 and EOF/026
+    or ("%q"):format(s):gsub("\010","n"):gsub("\026","\\026") end
+  local function comment(s,l) return comm and (l or 0) < comm and ' --[['..select(2, pcall(tostring, s))..']]' or '' end
+  local function globerr(s,l) return globals[s] and globals[s]..comment(s,l) or not fatal
+    and safestr(select(2, pcall(tostring, s))) or error("Can't serialize "..tostring(s)) end
+  local function safename(path, name) -- generates foo.bar, foo[3], or foo['b a r']
+    local n = name == nil and '' or name
+    local plain = type(n) == "string" and n:match("^[%l%u_][%w_]*$") and not keyword[n]
+    local safe = plain and n or '['..safestr(n)..']'
+    return (path or '')..(plain and path and '.' or '')..safe, safe end
+  local alphanumsort = type(opts.sortkeys) == 'function' and opts.sortkeys or function(k, o, n) -- k=keys, o=originaltable, n=padding
+    local maxn, to = tonumber(n) or 12, {number = 'a', string = 'b'}
+    local function padnum(d) return ("%0"..tostring(maxn).."d"):format(tonumber(d)) end
+    table.sort(k, function(a,b)
+      -- sort numeric keys first: k[key] is not nil for numerical keys
+      return (k[a] ~= nil and 0 or to[type(a)] or 'z')..(tostring(a):gsub("%d+",padnum))
+           < (k[b] ~= nil and 0 or to[type(b)] or 'z')..(tostring(b):gsub("%d+",padnum)) end) end
+  local function val2str(t, name, indent, insref, path, plainindex, level)
+    local ttype, level, mt = type(t), (level or 0), getmetatable(t)
+    local spath, sname = safename(path, name)
+    local tag = plainindex and
+      ((type(name) == "number") and '' or name..space..'='..space) or
+      (name ~= nil and sname..space..'='..space or '')
+    if seen[t] then -- already seen this element
+      sref[#sref+1] = spath..space..'='..space..seen[t]
+      return tag..'nil'..comment('ref', level) end
+    -- protect from those cases where __tostring may fail
+    if type(mt) == 'table' and metatostring ~= false then
+      local to, tr = pcall(function() return mt.__tostring(t) end)
+      local so, sr = pcall(function() return mt.__serialize(t) end)
+      if (to or so) then -- knows how to serialize itself
+        seen[t] = insref or spath
+        t = so and sr or tr
+        ttype = type(t)
+      end -- new value falls through to be serialized
+    end
+    if ttype == "table" then
+      if level >= maxl then return tag..'{}'..comment('maxlvl', level) end
+      seen[t] = insref or spath
+      if next(t) == nil then return tag..'{}'..comment(t, level) end -- table empty
+      if maxlen and maxlen < 0 then return tag..'{}'..comment('maxlen', level) end
+      local maxn, o, out = math.min(#t, maxnum or #t), {}, {}
+      for key = 1, maxn do o[key] = key end
+      if not maxnum or #o < maxnum then
+        local n = #o -- n = n + 1; o[n] is much faster than o[#o+1] on large tables
+        for key in pairs(t) do if o[key] ~= key then n = n + 1; o[n] = key end end end
+      if maxnum and #o > maxnum then o[maxnum+1] = nil end
+      if opts.sortkeys and #o > maxn then alphanumsort(o, t, opts.sortkeys) end
+      local sparse = sparse and #o > maxn -- disable sparsness if only numeric keys (shorter output)
+      for n, key in ipairs(o) do
+        local value, ktype, plainindex = t[key], type(key), n <= maxn and not sparse
+        if opts.valignore and opts.valignore[value] -- skip ignored values; do nothing
+        or opts.keyallow and not opts.keyallow[key]
+        or opts.keyignore and opts.keyignore[key]
+        or opts.valtypeignore and opts.valtypeignore[type(value)] -- skipping ignored value types
+        or sparse and value == nil then -- skipping nils; do nothing
+        elseif ktype == 'table' or ktype == 'function' or badtype[ktype] then
+          if not seen[key] and not globals[key] then
+            sref[#sref+1] = 'placeholder'
+            local sname = safename(iname, gensym(key)) -- iname is table for local variables
+            sref[#sref] = val2str(key,sname,indent,sname,iname,true) end
+          sref[#sref+1] = 'placeholder'
+          local path = seen[t]..'['..tostring(seen[key] or globals[key] or gensym(key))..']'
+          sref[#sref] = path..space..'='..space..tostring(seen[value] or val2str(value,nil,indent,path))
+        else
+          out[#out+1] = val2str(value,key,indent,nil,seen[t],plainindex,level+1)
+          if maxlen then
+            maxlen = maxlen - #out[#out]
+            if maxlen < 0 then break end
+          end
+        end
+      end
+      local prefix = string.rep(indent or '', level)
+      local head = indent and '{\n'..prefix..indent or '{'
+      local body = table.concat(out, ','..(indent and '\n'..prefix..indent or space))
+      local tail = indent and "\n"..prefix..'}' or '}'
+      return (custom and custom(tag,head,body,tail,level) or tag..head..body..tail)..comment(t, level)
+    elseif badtype[ttype] then
+      seen[t] = insref or spath
+      return tag..globerr(t, level)
+    elseif ttype == 'function' then
+      seen[t] = insref or spath
+      if opts.nocode then return tag.."function() --[[..skipped..]] end"..comment(t, level) end
+      local ok, res = pcall(string.dump, t)
+      local func = ok and "((loadstring or load)("..safestr(res)..",'@serialized'))"..comment(t, level)
+      return tag..(func or globerr(t, level))
+    else return tag..safestr(t) end -- handle all other types
+  end
+  local sepr = indent and "\n" or ";"..space
+  local body = val2str(t, name, indent) -- this call also populates sref
+  local tail = #sref>1 and table.concat(sref, sepr)..sepr or ''
+  local warn = opts.comment and #sref>1 and space.."--[[incomplete output with shared/self-references skipped]]" or ''
+  return not name and body..warn or "do local "..body..sepr..tail.."return "..name..sepr.."end"
+end
+
+local function deserialize(data, opts)
+  local env = (opts and opts.safe == false) and G
+    or setmetatable({}, {
+        __index = function(t,k) return t end,
+        __call = function(t,...) error("cannot call functions") end
+      })
+  local f, res = (loadstring or load)('return '..data, nil, nil, env)
+  if not f then f, res = (loadstring or load)(data, nil, nil, env) end
+  if not f then return f, res end
+  if setfenv then setfenv(f, env) end
+  return pcall(f)
+end
+
+local function merge(a, b) if b then for k,v in pairs(b) do a[k] = v end end; return a; end
+
+if false then
+return { _NAME = n, _COPYRIGHT = c, _DESCRIPTION = d, _VERSION = v, serialize = s,
+  load = deserialize,
+  dump = function(a, opts) return s(a, merge({name = '_', compact = true, sparse = true}, opts)) end,
+  line = function(a, opts) return s(a, merge({sortkeys = true, comment = true}, opts)) end,
+  block = function(a, opts) return s(a, merge({indent = '  ', sortkeys = true, comment = true}, opts)) end }
+end
+
+modpol.serpent.load  = deserialize
+modpol.serpent.dump  = function(a, opts) return s(a, merge({name = '_', compact = true, sparse = true}, opts)) end
+modpol.serpent.line  = function(a, opts) return s(a, merge({sortkeys = true, comment = true}, opts)) end
+modpol.serpent.block = function(a, opts) return s(a, merge({indent = '  ', sortkeys = true, comment = true}, opts)) end