main/lua-turbo: upgrade to 2.1.1 and various fixes

* use lua-cjson instead of bundeled json lib
* correct license
* disable tests as they dont work
* cleanup apkbuild
* split lua5.1 version from main package
* use correct luajit version

3 files changed, 942 insertions, 44 deletions

diff --git a/main/lua-turbo/0001-use-cjson-instead-of-JSON.lua.patch b/main/lua-turbo/0001-use-cjson-instead-of-JSON.lua.patch
new file mode 100644
index 0000000000..4a46f4aa7c
--- /dev/null
+++ b/main/lua-turbo/0001-use-cjson-instead-of-JSON.lua.patch
@@ -0,0 +1,906 @@
+From 31475d83acb92f3ec4d0cc05e42a5d0c89d3db1f Mon Sep 17 00:00:00 2001
+From: Carlo Landmeter <clandmeter@gmail.com>
+Date: Wed, 16 Aug 2017 13:11:58 +0200
+Subject: [PATCH] use cjson instead of JSON.lua
+
+---
+ turbo/3rdparty/JSON.lua | 855 ------------------------------------------------
+ turbo/escape.lua        |   6 +-
+ 2 files changed, 3 insertions(+), 858 deletions(-)
+ delete mode 100644 turbo/3rdparty/JSON.lua
+
+diff --git a/turbo/3rdparty/JSON.lua b/turbo/3rdparty/JSON.lua
+deleted file mode 100644
+index c3cd7c7..0000000
+--- a/turbo/3rdparty/JSON.lua
++++ /dev/null
+@@ -1,855 +0,0 @@
+--- -*- coding: utf-8 -*-
+---
+--- Copyright 2010-2011 Jeffrey Friedl
+--- http://regex.info/blog/
+---
+-local VERSION = 20111207.5  -- version history at end of file
+-local OBJDEF = { VERSION = VERSION }
+-
+---
+--- Simple JSON encoding and decoding in pure Lua.
+--- http://www.json.org/
+---
+---
+---   JSON = loadfile "JSON.lua" -- one-time load of the routines
+---
+---   local lua_value = JSON:decode(raw_json_text)
+---
+---   local raw_json_text    = JSON:encode(lua_table_or_value)
+---   local pretty_json_text = JSON:encode_pretty(lua_table_or_value) -- "pretty printed" version for human readability
+---
+---
+--- DECODING
+---
+---   JSON = (loadfile "JSON.lua")() -- one-time load of the routines
+---
+---   local lua_value = JSON:decode(raw_json_text)
+---
+---   If the JSON text is for an object or an array, e.g.
+---     { "what": "books", "count": 3 }
+---   or
+---     [ "Larry", "Curly", "Moe" ]
+---
+---   the result is a Lua table, e.g.
+---     { what = "books", count = 3 }
+---   or
+---     { "Larry", "Curly", "Moe" }
+---
+---
+---   The encode and decode routines accept an optional second argument, "etc", which is not used
+---   during encoding or decoding, but upon error is passed along to error handlers. It can be of any
+---   type (including nil).
+---
+---   With most errors during decoding, this code calls
+---
+---      JSON:onDecodeError(message, text, location, etc)
+---
+---   with a message about the error, and if known, the JSON text being parsed and the byte count
+---   where the problem was discovered. You can replace the default JSON:onDecodeError() with your
+---   own function.
+---
+---   The default onDecodeError() merely augments the message with data about the text and the
+---   location if known (and if a second 'etc' argument had been provided to decode(), its value is
+---   tacked onto the message as well), and then calls JSON.assert(), which itself defaults to Lua's
+---   built-in assert(), and can also be overridden.
+---
+---   For example, in an Adobe Lightroom plugin, you might use something like
+---
+---          function JSON:onDecodeError(message, text, location, etc)
+---             LrErrors.throwUserError("Internal Error: invalid JSON data")
+---          end
+---
+---   or even just
+---
+---          function JSON.assert(message)
+---             LrErrors.throwUserError("Internal Error: " .. message)
+---          end
+---
+---   If JSON:decode() is passed a nil, this is called instead:
+---
+---      JSON:onDecodeOfNilError(message, nil, nil, etc)
+---
+---   and if JSON:decode() is passed HTML instead of JSON, this is called:
+---
+---      JSON:onDecodeOfHTMLError(message, text, nil, etc)
+---
+---   The use of the fourth 'etc' argument allows stronger coordination between decoding and error
+---   reporting, especially when you provide your own error-handling routines. Continuing with the
+---   the Adobe Lightroom plugin example:
+---
+---          function JSON:onDecodeError(message, text, location, etc)
+---             local note = "Internal Error: invalid JSON data"
+---             if type(etc) = 'table' and etc.photo then
+---                note = note .. " while processing for " .. etc.photo:getFormattedMetadata('fileName')
+---             end
+---             LrErrors.throwUserError(note)
+---          end
+---
+---            :
+---            :
+---
+---          for i, photo in ipairs(photosToProcess) do
+---               :
+---               :
+---               local data = JSON:decode(someJsonText, { photo = photo })
+---               :
+---               :
+---          end
+---
+---
+---
+---
+-
+--- DECODING AND STRICT TYPES
+---
+---   Because both JSON objects and JSON arrays are converted to Lua tables, it's not normally
+---   possible to tell which a Lua table came from, or guarantee decode-encode round-trip
+---   equivalency.
+---
+---   However, if you enable strictTypes, e.g.
+---
+---      JSON = (loadfile "JSON.lua")() --load the routines
+---      JSON.strictTypes = true
+---
+---   then the Lua table resulting from the decoding of a JSON object or JSON array is marked via Lua
+---   metatable, so that when re-encoded with JSON:encode() it ends up as the appropriate JSON type.
+---
+---   (This is not the default because other routines may not work well with tables that have a
+---   metatable set, for example, Lightroom API calls.)
+---
+---
+--- ENCODING
+---
+---   JSON = (loadfile "JSON.lua")() -- one-time load of the routines
+---
+---   local raw_json_text    = JSON:encode(lua_table_or_value)
+---   local pretty_json_text = JSON:encode_pretty(lua_table_or_value) -- "pretty printed" version for human readability
+-
+---   On error during encoding, this code calls:
+---
+---    JSON:onEncodeError(message, etc)
+---
+---   which you can override in your local JSON object.
+---
+---
+--- SUMMARY OF METHODS YOU CAN OVERRIDE IN YOUR LOCAL LUA JSON OBJECT
+---
+---    assert
+---    onDecodeError
+---    onDecodeOfNilError
+---    onDecodeOfHTMLError
+---    onEncodeError
+---
+---  If you want to create a separate Lua JSON object with its own error handlers,
+---  you can reload JSON.lua or use the :new() method.
+---
+----------------------------------------------------------------------------
+-
+-
+-local author = "-[ JSON.lua package by Jeffrey Friedl (http://regex.info/blog/lua/json), version " .. tostring(VERSION) .. " ]-"
+-local isArray  = { __tostring = function() return "JSON array"  end }    isArray.__index  = isArray
+-local isObject = { __tostring = function() return "JSON object" end }    isObject.__index = isObject
+-
+-
+-function OBJDEF:newArray(tbl)
+-   return setmetatable(tbl or {}, isArray)
+-end
+-
+-function OBJDEF:newObject(tbl)
+-   return setmetatable(tbl or {}, isObject)
+-end
+-
+-local function unicode_codepoint_as_utf8(codepoint)
+-   --
+-   -- codepoint is a number
+-   --
+-   if codepoint <= 127 then
+-      return string.char(codepoint)
+-
+-   elseif codepoint <= 2047 then
+-      --
+-      -- 110yyyxx 10xxxxxx         <-- useful notation from http://en.wikipedia.org/wiki/Utf8
+-      --
+-      local highpart = math.floor(codepoint / 0x40)
+-      local lowpart  = codepoint - (0x40 * highpart)
+-      return string.char(0xC0 + highpart,
+-                         0x80 + lowpart)
+-
+-   elseif codepoint <= 65535 then
+-      --
+-      -- 1110yyyy 10yyyyxx 10xxxxxx
+-      --
+-      local highpart  = math.floor(codepoint / 0x1000)
+-      local remainder = codepoint - 0x1000 * highpart
+-      local midpart   = math.floor(remainder / 0x40)
+-      local lowpart   = remainder - 0x40 * midpart
+-
+-      highpart = 0xE0 + highpart
+-      midpart  = 0x80 + midpart
+-      lowpart  = 0x80 + lowpart
+-
+-      --
+-      -- Check for an invalid character (thanks Andy R. at Adobe).
+-      -- See table 3.7, page 93, in http://www.unicode.org/versions/Unicode5.2.0/ch03.pdf#G28070
+-      --
+-      if ( highpart == 0xE0 and midpart < 0xA0 ) or
+-         ( highpart == 0xED and midpart > 0x9F ) or
+-         ( highpart == 0xF0 and midpart < 0x90 ) or
+-         ( highpart == 0xF4 and midpart > 0x8F )
+-      then
+-         return "?"
+-      else
+-         return string.char(highpart,
+-                            midpart,
+-                            lowpart)
+-      end
+-
+-   else
+-      --
+-      -- 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
+-      --
+-      local highpart  = math.floor(codepoint / 0x40000)
+-      local remainder = codepoint - 0x40000 * highpart
+-      local midA      = math.floor(remainder / 0x1000)
+-      remainder       = remainder - 0x1000 * midA
+-      local midB      = math.floor(remainder / 0x40)
+-      local lowpart   = remainder - 0x40 * midB
+-
+-      return string.char(0xF0 + highpart,
+-                         0x80 + midA,
+-                         0x80 + midB,
+-                         0x80 + lowpart)
+-   end
+-end
+-
+-function OBJDEF:onDecodeError(message, text, location, etc)
+-   if text then
+-      if location then
+-         message = string.format("%s at char %d of: %s", message, location, text)
+-      else
+-         message = string.format("%s: %s", message, text)
+-      end
+-   end
+-   if etc ~= nil then
+-      message = message .. " (" .. OBJDEF:encode(etc) .. ")"
+-   end
+-
+-   if self.assert then
+-      self.assert(false, message)
+-   else
+-      assert(false, message)
+-   end
+-end
+-
+-OBJDEF.onDecodeOfNilError  = OBJDEF.onDecodeError
+-OBJDEF.onDecodeOfHTMLError = OBJDEF.onDecodeError
+-
+-function OBJDEF:onEncodeError(message, etc)
+-   if etc ~= nil then
+-      message = message .. " (" .. OBJDEF:encode(etc) .. ")"
+-   end
+-
+-   if self.assert then
+-      self.assert(false, message)
+-   else
+-      assert(false, message)
+-   end
+-end
+-
+-local function grok_number(self, text, start, etc)
+-   --
+-   -- Grab the integer part
+-   --
+-   local integer_part = text:match('^-?[1-9]%d*', start)
+-                     or text:match("^-?0",        start)
+-
+-   if not integer_part then
+-      self:onDecodeError("expected number", text, start, etc)
+-   end
+-
+-   local i = start + integer_part:len()
+-
+-   --
+-   -- Grab an optional decimal part
+-   --
+-   local decimal_part = text:match('^%.%d+', i) or ""
+-
+-   i = i + decimal_part:len()
+-
+-   --
+-   -- Grab an optional exponential part
+-   --
+-   local exponent_part = text:match('^[eE][-+]?%d+', i) or ""
+-
+-   i = i + exponent_part:len()
+-
+-   local full_number_text = integer_part .. decimal_part .. exponent_part
+-   local as_number = tonumber(full_number_text)
+-
+-   if not as_number then
+-      self:onDecodeError("bad number", text, start, etc)
+-   end
+-
+-   return as_number, i
+-end
+-
+-
+-local function grok_string(self, text, start, etc)
+-
+-   if text:sub(start,start) ~= '"' then
+-      self:onDecodeError("expected string's opening quote", text, start, etc)
+-   end
+-
+-   local i = start + 1 -- +1 to bypass the initial quote
+-   local text_len = text:len()
+-   local VALUE = ""
+-   while i <= text_len do
+-      local c = text:sub(i,i)
+-      if c == '"' then
+-         return VALUE, i + 1
+-      end
+-      if c ~= '\\' then
+-         VALUE = VALUE .. c
+-         i = i + 1
+-      elseif text:match('^\\b', i) then
+-         VALUE = VALUE .. "\b"
+-         i = i + 2
+-      elseif text:match('^\\f', i) then
+-         VALUE = VALUE .. "\f"
+-         i = i + 2
+-      elseif text:match('^\\n', i) then
+-         VALUE = VALUE .. "\n"
+-         i = i + 2
+-      elseif text:match('^\\r', i) then
+-         VALUE = VALUE .. "\r"
+-         i = i + 2
+-      elseif text:match('^\\t', i) then
+-         VALUE = VALUE .. "\t"
+-         i = i + 2
+-      else
+-         local hex = text:match('^\\u([0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF])', i)
+-         if hex then
+-            i = i + 6 -- bypass what we just read
+-
+-            -- We have a Unicode codepoint. It could be standalone, or if in the proper range and
+-            -- followed by another in a specific range, it'll be a two-code surrogate pair.
+-            local codepoint = tonumber(hex, 16)
+-            if codepoint >= 0xD800 and codepoint <= 0xDBFF then
+-               -- it's a hi surrogate... see whether we have a following low
+-               local lo_surrogate = text:match('^\\u([dD][cdefCDEF][0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF])', i)
+-               if lo_surrogate then
+-                  i = i + 6 -- bypass the low surrogate we just read
+-                  codepoint = 0x2400 + (codepoint - 0xD800) * 0x400 + tonumber(lo_surrogate, 16)
+-               else
+-                  -- not a proper low, so we'll just leave the first codepoint as is and spit it out.
+-               end
+-            end
+-            VALUE = VALUE .. unicode_codepoint_as_utf8(codepoint)
+-
+-         else
+-
+-            -- just pass through what's escaped
+-            VALUE = VALUE .. text:match('^\\(.)', i)
+-            i = i + 2
+-         end
+-      end
+-   end
+-
+-   self:onDecodeError("unclosed string", text, start, etc)
+-end
+-
+-local function skip_whitespace(text, start)
+-
+-   local match_start, match_end = text:find("^[ \n\r\t]+", start) -- [http://www.ietf.org/rfc/rfc4627.txt] Section 2
+-   if match_end then
+-      return match_end + 1
+-   else
+-      return start
+-   end
+-end
+-
+-local grok_one -- assigned later
+-
+-local function grok_object(self, text, start, etc)
+-   if not text:sub(start,start) == '{' then
+-      self:onDecodeError("expected '{'", text, start, etc)
+-   end
+-
+-   local i = skip_whitespace(text, start + 1) -- +1 to skip the '{'
+-
+-   local VALUE = self.strictTypes and self:newObject { } or { }
+-
+-   if text:sub(i,i) == '}' then
+-      return VALUE, i + 1
+-   end
+-   local text_len = text:len()
+-   while i <= text_len do
+-      local key, new_i = grok_string(self, text, i, etc)
+-
+-      i = skip_whitespace(text, new_i)
+-
+-      if text:sub(i, i) ~= ':' then
+-         self:onDecodeError("expected colon", text, i, etc)
+-      end
+-
+-      i = skip_whitespace(text, i + 1)
+-
+-      local val, new_i = grok_one(self, text, i)
+-
+-      VALUE[key] = val
+-
+-      --
+-      -- Expect now either '}' to end things, or a ',' to allow us to continue.
+-      --
+-      i = skip_whitespace(text, new_i)
+-
+-      local c = text:sub(i,i)
+-
+-      if c == '}' then
+-         return VALUE, i + 1
+-      end
+-
+-      if text:sub(i, i) ~= ',' then
+-         self:onDecodeError("expected comma or '}'", text, i, etc)
+-      end
+-
+-      i = skip_whitespace(text, i + 1)
+-   end
+-
+-   self:onDecodeError("unclosed '{'", text, start, etc)
+-end
+-
+-local function grok_array(self, text, start, etc)
+-   if not text:sub(start,start) == '[' then
+-      self:onDecodeError("expected '['", text, start, etc)
+-   end
+-
+-   local i = skip_whitespace(text, start + 1) -- +1 to skip the '['
+-   local VALUE = self.strictTypes and self:newArray { } or { }
+-   if text:sub(i,i) == ']' then
+-      return VALUE, i + 1
+-   end
+-
+-   local text_len = text:len()
+-   while i <= text_len do
+-      local val, new_i = grok_one(self, text, i)
+-
+-      table.insert(VALUE, val)
+-
+-      i = skip_whitespace(text, new_i)
+-
+-      --
+-      -- Expect now either ']' to end things, or a ',' to allow us to continue.
+-      --
+-      local c = text:sub(i,i)
+-      if c == ']' then
+-         return VALUE, i + 1
+-      end
+-      if text:sub(i, i) ~= ',' then
+-         self:onDecodeError("expected comma or '['", text, i, etc)
+-      end
+-      i = skip_whitespace(text, i + 1)
+-   end
+-   self:onDecodeError("unclosed '['", text, start, etc)
+-end
+-
+-
+-grok_one = function(self, text, start, etc)
+-   -- Skip any whitespace
+-   start = skip_whitespace(text, start)
+-
+-   if start > text:len() then
+-      self:onDecodeError("unexpected end of string", text, nil, etc)
+-   end
+-
+-   if text:find('^"', start) then
+-      return grok_string(self, text, start, etc)
+-
+-   elseif text:find('^[-0123456789 ]', start) then
+-      return grok_number(self, text, start, etc)
+-
+-   elseif text:find('^%{', start) then
+-      return grok_object(self, text, start, etc)
+-
+-   elseif text:find('^%[', start) then
+-      return grok_array(self, text, start, etc)
+-
+-   elseif text:find('^true', start) then
+-      return true, start + 4
+-
+-   elseif text:find('^false', start) then
+-      return false, start + 5
+-
+-   elseif text:find('^null', start) then
+-      return nil, start + 4
+-
+-   else
+-      self:onDecodeError("can't parse JSON", text, start, etc)
+-   end
+-end
+-
+-function OBJDEF:decode(text, etc)
+-   if type(self) ~= 'table' or self.__index ~= OBJDEF then
+-      OBJDEF:onDecodeError("JSON:decode must be called in method format", nil, nil, etc)
+-   end
+-
+-   if text == nil then
+-      self:onDecodeOfNilError(string.format("nil passed to JSON:decode()"), nil, nil, etc)
+-   elseif type(text) ~= 'string' then
+-      self:onDecodeError(string.format("expected string argument to JSON:decode(), got %s", type(text)), nil, nil, etc)
+-   end
+-
+-   if text:match('^%s*$') then
+-      return nil
+-   end
+-
+-   if text:match('^%s*<') then
+-      -- Can't be JSON... we'll assume it's HTML
+-      self:onDecodeOfHTMLError(string.format("html passed to JSON:decode()"), text, nil, etc)
+-   end
+-
+-   --
+-   -- Ensure that it's not UTF-32 or UTF-16.
+-   -- Those are perfectly valid encodings for JSON (as per RFC 4627 section 3),
+-   -- but this package can't handle them.
+-   --
+-   if text:sub(1,1):byte() == 0 or (text:len() >= 2 and text:sub(2,2):byte() == 0) then
+-      self:onDecodeError("JSON package groks only UTF-8, sorry", text, nil, etc)
+-   end
+-
+-   local success, value = pcall(grok_one, self, text, 1, etc)
+-   if success then
+-      return value
+-   else
+-      -- should never get here... JSON parse errors should have been caught earlier
+-      assert(false, value)
+-      return nil
+-   end
+-end
+-
+-local function backslash_replacement_function(c)
+-   if c == "\n" then
+-      return "\\n"
+-   elseif c == "\r" then
+-      return "\\r"
+-   elseif c == "\t" then
+-      return "\\t"
+-   elseif c == "\b" then
+-      return "\\b"
+-   elseif c == "\f" then
+-      return "\\f"
+-   elseif c == '"' then
+-      return '\\"'
+-   elseif c == '\\' then
+-      return '\\\\'
+-   else
+-      return string.format("\\u%04x", c:byte())
+-   end
+-end
+-
+-local chars_to_be_escaped_in_JSON_string
+-   = '['
+-   ..    '"'    -- class sub-pattern to match a double quote
+-   ..    '%\\'  -- class sub-pattern to match a backslash
+-   ..    '%z'   -- class sub-pattern to match a null
+-   ..    '\001' .. '-' .. '\031' -- class sub-pattern to match control characters
+-   .. ']'
+-
+-local function json_string_literal(value)
+-   local newval = value:gsub(chars_to_be_escaped_in_JSON_string, backslash_replacement_function)
+-   return '"' .. newval .. '"'
+-end
+-
+-local function object_or_array(self, T, etc)
+-   --
+-   -- We need to inspect all the keys... if there are any strings, we'll convert to a JSON
+-   -- object. If there are only numbers, it's a JSON array.
+-   --
+-   -- If we'll be converting to a JSON object, we'll want to sort the keys so that the
+-   -- end result is deterministic.
+-   --
+-   local string_keys = { }
+-   local seen_number_key = false
+-   local maximum_number_key
+-
+-   for key in pairs(T) do
+-      if type(key) == 'number' then
+-         seen_number_key = true
+-         if not maximum_number_key or maximum_number_key < key then
+-            maximum_number_key = key
+-         end
+-      elseif type(key) == 'string' then
+-         table.insert(string_keys, key)
+-      else
+-         self:onEncodeError("can't encode table with a key of type " .. type(key), etc)
+-      end
+-   end
+-
+-   if seen_number_key and #string_keys > 0 then
+-      --
+-      -- Mixed key types... don't know what to do, so bail
+-      --
+-      self:onEncodeError("a table with both numeric and string keys could be an object or array; aborting", etc)
+-
+-   elseif #string_keys == 0  then
+-      --
+-      -- An array
+-      --
+-      if seen_number_key then
+-         return nil, maximum_number_key -- an array
+-      else
+-         --
+-         -- An empty table...
+-         --
+-         if tostring(T) == "JSON array" then
+-            return nil
+-         elseif tostring(T) == "JSON object" then
+-            return { }
+-         else
+-            -- have to guess, so we'll pick array, since empty arrays are likely more common than empty objects
+-            return nil
+-         end
+-      end
+-   else
+-      --
+-      -- An object, so return a list of keys
+-      --
+-      table.sort(string_keys)
+-      return string_keys
+-   end
+-end
+-
+---
+--- Encode
+---
+-local encode_value -- must predeclare because it calls itself
+-function encode_value(self, value, parents, etc)
+-
+-
+-   if value == nil then
+-      return 'null'
+-   end
+-
+-   if type(value) == 'string' then
+-      return json_string_literal(value)
+-   elseif type(value) == 'number' then
+-      if value ~= value then
+-         --
+-         -- NaN (Not a Number).
+-         -- JSON has no NaN, so we have to fudge the best we can. This should really be a package option.
+-         --
+-         return "null"
+-      elseif value >= math.huge then
+-         --
+-         -- Positive infinity. JSON has no INF, so we have to fudge the best we can. This should
+-         -- really be a package option. Note: at least with some implementations, positive infinity
+-         -- is both ">= math.huge" and "<= -math.huge", which makes no sense but that's how it is.
+-         -- Negative infinity is properly "<= -math.huge". So, we must be sure to check the ">="
+-         -- case first.
+-         --
+-         return "1e+9999"
+-      elseif value <= -math.huge then
+-         --
+-         -- Negative infinity.
+-         -- JSON has no INF, so we have to fudge the best we can. This should really be a package option.
+-         --
+-         return "-1e+9999"
+-      else
+-         return tostring(value)
+-      end
+-   elseif type(value) == 'boolean' then
+-      return tostring(value)
+-
+-   elseif type(value) ~= 'table' then
+-      self:onEncodeError("can't convert " .. type(value) .. " to JSON", etc)
+-
+-   else
+-      --
+-      -- A table to be converted to either a JSON object or array.
+-      --
+-      local T = value
+-
+-      if parents[T] then
+-         self:onEncodeError("table " .. tostring(T) .. " is a child of itself", etc)
+-      else
+-         parents[T] = true
+-      end
+-
+-      local result_value
+-
+-      local object_keys, maximum_number_key = object_or_array(self, T, etc)
+-      if maximum_number_key then
+-         --
+-         -- An array...
+-         --
+-         local ITEMS = { }
+-         for i = 1, maximum_number_key do
+-            table.insert(ITEMS, encode_value(self, T[i], parents, etc))
+-         end
+-
+-         result_value = "[" .. table.concat(ITEMS, ",") .. "]"
+-      elseif object_keys then
+-         --
+-         -- An object
+-         --
+-
+-         --
+-         -- We'll always sort the keys, so that comparisons can be made on
+-         -- the results, etc. The actual order is not particularly
+-         -- important (e.g. it doesn't matter what character set we sort
+-         -- as); it's only important that it be deterministic... the same
+-         -- every time.
+-         --
+-         local PARTS = { }
+-         for _, key in ipairs(object_keys) do
+-            local encoded_key = encode_value(self, tostring(key), parents, etc)
+-            local encoded_val = encode_value(self, T[key],        parents, etc)
+-            table.insert(PARTS, string.format("%s:%s", encoded_key, encoded_val))
+-         end
+-         result_value = "{" .. table.concat(PARTS, ",") .. "}"
+-      else
+-         --
+-         -- An empty array/object... we'll treat it as an array, though it should really be an option
+-         --
+-         result_value = "[]"
+-      end
+-
+-      parents[T] = false
+-      return result_value
+-   end
+-end
+-
+-local encode_pretty_value -- must predeclare because it calls itself
+-function encode_pretty_value(self, value, parents, indent, etc)
+-
+-   if type(value) == 'string' then
+-      return json_string_literal(value)
+-
+-   elseif type(value) == 'number' then
+-      return tostring(value)
+-
+-   elseif type(value) == 'boolean' then
+-      return tostring(value)
+-
+-   elseif type(value) == 'nil' then
+-      return 'null'
+-
+-   elseif type(value) ~= 'table' then
+-      self:onEncodeError("can't convert " .. type(value) .. " to JSON", etc)
+-
+-   else
+-      --
+-      -- A table to be converted to either a JSON object or array.
+-      --
+-      local T = value
+-
+-      if parents[T] then
+-         self:onEncodeError("table " .. tostring(T) .. " is a child of itself", etc)
+-      end
+-      parents[T] = true
+-
+-      local result_value
+-
+-      local object_keys = object_or_array(self, T, etc)
+-      if not object_keys then
+-         --
+-         -- An array...
+-         --
+-         local ITEMS = { }
+-         for i = 1, #T do
+-            table.insert(ITEMS, encode_pretty_value(self, T[i], parents, indent, etc))
+-         end
+-
+-         result_value = "[ " .. table.concat(ITEMS, ", ") .. " ]"
+-
+-      else
+-
+-         --
+-         -- An object -- can keys be numbers?
+-         --
+-
+-         local KEYS = { }
+-         local max_key_length = 0
+-         for _, key in ipairs(object_keys) do
+-            local encoded = encode_pretty_value(self, tostring(key), parents, "", etc)
+-            max_key_length = math.max(max_key_length, #encoded)
+-            table.insert(KEYS, encoded)
+-         end
+-         local key_indent = indent .. "    "
+-         local subtable_indent = indent .. string.rep(" ", max_key_length + 2 + 4)
+-         local FORMAT = "%s%" .. tostring(max_key_length) .. "s: %s"
+-
+-         local COMBINED_PARTS = { }
+-         for i, key in ipairs(object_keys) do
+-            local encoded_val = encode_pretty_value(self, T[key], parents, subtable_indent, etc)
+-            table.insert(COMBINED_PARTS, string.format(FORMAT, key_indent, KEYS[i], encoded_val))
+-         end
+-         result_value = "{\n" .. table.concat(COMBINED_PARTS, ",\n") .. "\n" .. indent .. "}"
+-      end
+-
+-      parents[T] = false
+-      return result_value
+-   end
+-end
+-
+-function OBJDEF:encode(value, etc)
+-   if type(self) ~= 'table' or self.__index ~= OBJDEF then
+-      OBJDEF:onEncodeError("JSON:encode must be called in method format", etc)
+-   end
+-
+-   local parents = {}
+-   return encode_value(self, value, parents, etc)
+-end
+-
+-function OBJDEF:encode_pretty(value, etc)
+-   local parents = {}
+-   local subtable_indent = ""
+-   return encode_pretty_value(self, value, parents, subtable_indent, etc)
+-end
+-
+-function OBJDEF.__tostring()
+-   return "JSON encode/decode package"
+-end
+-
+-OBJDEF.__index = OBJDEF
+-
+-function OBJDEF:new(args)
+-   local new = { }
+-
+-   if args then
+-      for key, val in pairs(args) do
+-         new[key] = val
+-      end
+-   end
+-
+-   return setmetatable(new, OBJDEF)
+-end
+-
+-return OBJDEF:new()
+-
+---
+--- Version history:
+---
+---   20111207.5    Added support for the 'etc' arguments, for better error reporting.
+---
+---   20110731.4    More feedback from David Kolf on how to make the tests for Nan/Infinity system independent.
+---
+---   20110730.3    Incorporated feedback from David Kolf at http://lua-users.org/wiki/JsonModules:
+---
+---                   * When encoding lua for JSON, Sparse numeric arrays are now handled by
+---                     spitting out full arrays, such that
+---                        JSON:encode({"one", "two", [10] = "ten"})
+---                     returns
+---                        ["one","two",null,null,null,null,null,null,null,"ten"]
+---
+---                     In 20100810.2 and earlier, only up to the first non-null value would have been retained.
+---
+---                   * When encoding lua for JSON, numeric value NaN gets spit out as null, and infinity as "1+e9999".
+---                     Version 20100810.2 and earlier created invalid JSON in both cases.
+---
+---                   * Unicode surrogate pairs are now detected when decoding JSON.
+---
+---   20100810.2    added some checking to ensure that an invalid Unicode character couldn't leak in to the UTF-8 encoding
+---
+---   20100731.1    initial public release
+---
+diff --git a/turbo/escape.lua b/turbo/escape.lua
+index 81678f7..e489337 100644
+--- a/turbo/escape.lua
++++ b/turbo/escape.lua
+@@ -20,7 +20,7 @@
+ -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ -- SOFTWARE."
+ 
+-local json = require('turbo.3rdparty.JSON')
++local json = require('cjson')
+ 
+ local escape = {} -- escape namespace
+ 
+@@ -28,7 +28,7 @@ local escape = {} -- escape namespace
+ -- @param t Value to JSON encode.
+ -- @note May raise a error if table could not be decoded.
+ function escape.json_encode(t)
+-    return json:encode(t)
++    return json.encode(t)
+ end
+ 
+ --- Decode a JSON string to table.
+@@ -36,7 +36,7 @@ end
+ -- Lua primitives.
+ -- @return (Table)
+ function escape.json_decode(s)
+-    return json:decode(s)
++    return json.decode(s)
+ end
+ 
+ local function _unhex(hex) return string.char(tonumber(hex, 16)) end
+-- 
+2.14.0
+
diff --git a/main/lua-turbo/APKBUILD b/main/lua-turbo/APKBUILD
index 59413aa25b..77613e699f 100644
--- a/main/lua-turbo/APKBUILD
+++ b/main/lua-turbo/APKBUILD
@@ -2,39 +2,34 @@
 # Maintainer: Carlo Landmeter <clandmeter@gmail.com>
 
 pkgname=lua-turbo
-_jitver=2.1.0_beta2
-pkgver=2.0.4
-pkgrel=4
+_jitver=2.1.0_beta3
+pkgver=2.1.1
+pkgrel=0
 pkgdesc="a framework built for LuaJIT 2 and Linux"
 url="http://www.turbolua.org/"
 # luajit is not available for disabled arches
 arch="all !s390x"
-license="GPL"
-depends="luajit"
-depends_dev=""
-makedepends="$depends_dev libressl-dev"
+license="Apache-2.0"
+depends="luajit ca-certificates lua5.1-cjson"
+makedepends="libressl-dev util-linux"
+# bundled tests dont work
+options="!check"
 install=""
-subpackages=""
+subpackages="lua5.1-turbo:lua51_turbo:noarch"
 source="$pkgname-$pkgver.tar.gz::https://github.com/kernelsauce/turbo/archive/v$pkgver.tar.gz
+	0001-use-cjson-instead-of-JSON.lua.patch
 	${pkgname}.initd
 	${pkgname}.confd"
 
-_builddir="$srcdir/turbo-$pkgver"
+builddir="$srcdir/turbo-$pkgver"
 
 prepare() {
-	local i
-	cd "$_builddir"
-	for i in $source; do
-		case $i in
-		*.patch) msg $i; patch -p1 -i "$srcdir"/$i || return 1;;
-		esac
-	done
+	cd "$builddir"
+	default_prepare
 	# check if we are using the current luajit version
 	if [ -r ../../../../main/luajit/APKBUILD ]; then
 		local _currentjit=$(grep "^pkgver=" ../../../../main/luajit/APKBUILD)
-		export LUAJIT_VERSION="$_jitver"
-		msg "Building for luajit version $_jitver"
-		if [ "${_currentjit#*=}" != "$LUAJIT_VERSION" ]; then
+		if [ "${_currentjit#*=}" != "$_jitver" ]; then
 			die "luajit version does not match!"
 		fi
 	else
@@ -44,32 +39,39 @@ prepare() {
 	# so we replace symlink with real filename
 	sed -i -e \
 		"s|os.getenv(\"TURBO_LIBSSL\") or \"ssl\"|\"$(readlink /usr/lib/libssl.so)\"|" \
-		turbo/hash.lua || return 1
+		turbo/hash.lua
 	sed -i -e \
 		"s|os.getenv(\"TURBO_LIBSSL\") or \"ssl\"|\"$(readlink /usr/lib/libssl.so)\"|" \
-		turbo/crypto_linux.lua || return 1
+		turbo/crypto_linux.lua
 }
 
 build() {
-	cd "$_builddir"
-	make PREFIX=/usr || return 1
+	cd "$builddir"
+	export LUAJIT_VERSION="${_jitver/_/-}"
+	make
+}
+
+lua51_turbo() {
+	pkgdesc="$pkgdesc (lua 5.1 files)"
+	mkdir -p "$subpkgdir/usr/share"
+	mv "$pkgdir/usr/share/lua" \
+		"$subpkgdir"/usr/share/
 }
 
 package() {
-	cd "$_builddir"
-	make PREFIX="$pkgdir"/usr install || return 1
+	cd "$builddir"
+	make PREFIX="$pkgdir"/usr install
 	install -Dm 755 "$srcdir"/${pkgname}.initd \
-		$pkgdir/etc/init.d/$pkgname || return 1
+		$pkgdir/etc/init.d/$pkgname
 	install -Dm 644 "$srcdir"/${pkgname}.confd \
-		$pkgdir/etc/conf.d/$pkgname || return 1
+		$pkgdir/etc/conf.d/$pkgname
+	# remove ca-certificates
+	rm -f "$pkgdir"/usr/share/*/turbo/ca-certificates.crt \
+		"$pkgdir"/usr/share/*/*/turbo/ca-certificates.crt
 }
 
-md5sums="450d9025014f314ad555cb2b61acce2f  lua-turbo-2.0.4.tar.gz
-61c475d79bef1c65d9913e7c8fbfc9e3  lua-turbo.initd
-321fe55bbd0b124b65339ad22823eda0  lua-turbo.confd"
-sha256sums="5bee3132d28e56b432bd76221b4bd221666130000814a7eb5867f12b11d23b0f  lua-turbo-2.0.4.tar.gz
-379fe987aaab428051cf6ab4f3b9246b0ce29e09b0dee0b74a7b6c85b3e14629  lua-turbo.initd
-9796bf17f8971440453b636f4fe2f132cbceea0ca091fe1165be274310746f4b  lua-turbo.confd"
-sha512sums="68617d912e5bbc967de912fdcc3053e6fcf48495b92e423c687ec3ee4c48aba9ac0e385678e101e384ac836b481fc34e3285b5999fd41cb4a75c077071db9dc3  lua-turbo-2.0.4.tar.gz
+sha512sums="207b630ce2b3cfa06266fdabaa82420bc04ecfff3998f04db080c8af14bea3d8b01433416f3a827fe2d2fdb8e72085e36956de5f812305b3fa77207dd4152d5b  lua-turbo-2.1.1.tar.gz
+39d5b667e1e0410cce2cfbff21012eeef5059f4ce4e2ca7446420270084ad957d0df7f39cf8fd64e853fb8d43eed52abeb1866cbad6247dc554b7475671817d8  0001-use-cjson-instead-of-JSON.lua.patch
+6be9ca5d8a02c88d82bc43c4f2de779872a8400c8bd59663f71bfe4ac151c17bb213b4e31f2668fc57ca8b98fa44846f666c9865eb786203b34666e64e885861  makefile.patch
 2e91d5dda33b4bf09667fd23c80a471e93605125a820c440c2b1b022b8bce6ab065493473b153f1fa1863e9655f6413dbe42dc983260da4ed8bee3b2e3743ec2  lua-turbo.initd
 3d2816738a2ee615bb6523b6b0aff12a51062e56ade5dbaa4b1b63afda8dce0a532c099b8a03fe67d589058ac8a7d49434a68fb28d93b167a56c56acc7596fdb  lua-turbo.confd"
diff --git a/main/lua-turbo/fix-bindir.patch b/main/lua-turbo/fix-bindir.patch
deleted file mode 100644
index 92bb5ef9d8..0000000000
--- a/main/lua-turbo/fix-bindir.patch
+++ /dev/null
@@ -1,10 +0,0 @@
---- a/Makefile.orig
-+++ b/Makefile
-@@ -89,6 +89,7 @@
- 	@echo "==== $(LUAJIT_LIBRARYDIR) and ===="
- 	@echo "==== $(LUAJIT_MODULEDIR) ===="
- 	$(MKDIR) $(INSTALL_LIB)
-+	$(MKDIR) $(INSTALL_BIN)
- 	$(MKDIR) $(LUA_MODULEDIR)/turbo
- 	$(MKDIR) $(LUAJIT_MODULEDIR)/turbo
- 	$(CP_R) turbo/* $(LUA_MODULEDIR)/turbo