2014-08-30 06:35:42 -07:00
|
|
|
local ffi = require('ffi')
|
|
|
|
local formatc = require('test.unit.formatc')
|
|
|
|
local Set = require('test.unit.set')
|
|
|
|
local Preprocess = require('test.unit.preprocess')
|
|
|
|
local Paths = require('test.config.paths')
|
2016-04-23 16:53:11 -07:00
|
|
|
local global_helpers = require('test.helpers')
|
2016-09-25 13:48:22 -07:00
|
|
|
local assert = require('luassert')
|
|
|
|
local say = require('say')
|
2016-04-23 16:53:11 -07:00
|
|
|
|
2016-11-04 13:57:28 -07:00
|
|
|
local posix = nil
|
|
|
|
local syscall = nil
|
|
|
|
|
2017-03-11 03:28:18 -07:00
|
|
|
local check_cores = global_helpers.check_cores
|
2017-04-01 02:52:28 -07:00
|
|
|
local dedent = global_helpers.dedent
|
2016-04-23 16:53:11 -07:00
|
|
|
local neq = global_helpers.neq
|
2017-03-11 06:02:47 -07:00
|
|
|
local map = global_helpers.map
|
2016-04-23 16:53:11 -07:00
|
|
|
local eq = global_helpers.eq
|
2016-06-21 15:01:21 -07:00
|
|
|
local ok = global_helpers.ok
|
2014-08-30 06:35:42 -07:00
|
|
|
|
2017-01-07 03:52:51 -07:00
|
|
|
-- C constants.
|
|
|
|
local NULL = ffi.cast('void*', 0)
|
|
|
|
|
|
|
|
local OK = 1
|
|
|
|
local FAIL = 0
|
|
|
|
|
2017-03-11 06:02:47 -07:00
|
|
|
local cimport
|
|
|
|
|
2014-08-30 06:35:42 -07:00
|
|
|
-- add some standard header locations
|
2014-09-06 15:36:00 -07:00
|
|
|
for _, p in ipairs(Paths.include_paths) do
|
2014-08-30 06:35:42 -07:00
|
|
|
Preprocess.add_to_include_path(p)
|
|
|
|
end
|
|
|
|
|
2017-03-11 13:48:16 -07:00
|
|
|
local child_pid = nil
|
2017-03-11 06:02:47 -07:00
|
|
|
local function only_separate(func)
|
|
|
|
return function(...)
|
2017-03-11 13:48:16 -07:00
|
|
|
if child_pid ~= 0 then
|
|
|
|
error('This function must be run in a separate process only')
|
2017-03-11 06:02:47 -07:00
|
|
|
end
|
|
|
|
return func(...)
|
|
|
|
end
|
|
|
|
end
|
2017-03-11 16:54:23 -07:00
|
|
|
local child_calls_init = {}
|
|
|
|
local child_calls_mod = nil
|
|
|
|
local child_calls_mod_once = nil
|
|
|
|
local function child_call(func, ret)
|
2017-03-11 06:02:47 -07:00
|
|
|
return function(...)
|
2017-03-11 16:54:23 -07:00
|
|
|
local child_calls = child_calls_mod or child_calls_init
|
2017-03-11 13:48:16 -07:00
|
|
|
if child_pid ~= 0 then
|
2017-03-11 16:54:23 -07:00
|
|
|
child_calls[#child_calls + 1] = {func=func, args={...}}
|
2017-03-11 06:02:47 -07:00
|
|
|
return ret
|
|
|
|
else
|
|
|
|
return func(...)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-03-11 16:54:23 -07:00
|
|
|
-- Run some code at the start of the child process, before running the test
|
|
|
|
-- itself. Is supposed to be run in `before_each`.
|
|
|
|
local function child_call_once(func, ...)
|
|
|
|
if child_pid ~= 0 then
|
|
|
|
child_calls_mod_once[#child_calls_mod_once + 1] = {
|
|
|
|
func=func, args={...}}
|
|
|
|
else
|
|
|
|
func(...)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
local child_cleanups_mod_once = nil
|
|
|
|
|
|
|
|
-- Run some code at the end of the child process, before exiting. Is supposed to
|
|
|
|
-- be run in `before_each` because `after_each` is run after child has exited.
|
|
|
|
local function child_cleanup_once(func, ...)
|
|
|
|
local child_cleanups = child_cleanups_mod_once
|
|
|
|
if child_pid ~= 0 then
|
|
|
|
child_cleanups[#child_cleanups + 1] = {func=func, args={...}}
|
|
|
|
else
|
|
|
|
func(...)
|
2017-03-11 06:02:47 -07:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
local libnvim = nil
|
|
|
|
|
|
|
|
local lib = setmetatable({}, {
|
2017-03-11 13:48:16 -07:00
|
|
|
__index = only_separate(function(_, idx)
|
2017-03-11 06:02:47 -07:00
|
|
|
return libnvim[idx]
|
|
|
|
end),
|
2017-03-11 16:54:23 -07:00
|
|
|
__newindex = child_call(function(_, idx, val)
|
2017-03-11 06:02:47 -07:00
|
|
|
libnvim[idx] = val
|
|
|
|
end),
|
|
|
|
})
|
|
|
|
|
|
|
|
local init = only_separate(function()
|
|
|
|
-- load neovim shared library
|
|
|
|
libnvim = ffi.load(Paths.test_libnvim_path)
|
2017-03-11 16:54:23 -07:00
|
|
|
for _, c in ipairs(child_calls_init) do
|
2017-03-11 06:02:47 -07:00
|
|
|
c.func(unpack(c.args))
|
|
|
|
end
|
|
|
|
libnvim.time_init()
|
|
|
|
libnvim.early_init()
|
|
|
|
libnvim.event_init()
|
2017-03-11 16:54:23 -07:00
|
|
|
if child_calls_mod then
|
|
|
|
for _, c in ipairs(child_calls_mod) do
|
|
|
|
c.func(unpack(c.args))
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if child_calls_mod_once then
|
|
|
|
for _, c in ipairs(child_calls_mod_once) do
|
2017-03-11 06:02:47 -07:00
|
|
|
c.func(unpack(c.args))
|
|
|
|
end
|
2017-03-11 16:54:23 -07:00
|
|
|
child_calls_mod_once = nil
|
2017-03-11 06:02:47 -07:00
|
|
|
end
|
|
|
|
end)
|
|
|
|
|
|
|
|
local deinit = only_separate(function()
|
2017-03-11 16:54:23 -07:00
|
|
|
if child_cleanups_mod_once then
|
|
|
|
for _, c in ipairs(child_cleanups_mod_once) do
|
2017-03-11 06:02:47 -07:00
|
|
|
c.func(unpack(c.args))
|
|
|
|
end
|
2017-03-11 16:54:23 -07:00
|
|
|
child_cleanups_mod_once = nil
|
2017-03-11 06:02:47 -07:00
|
|
|
end
|
|
|
|
end)
|
2014-08-30 06:35:42 -07:00
|
|
|
|
2014-09-06 15:36:00 -07:00
|
|
|
local function trim(s)
|
2014-08-30 06:35:42 -07:00
|
|
|
return s:match('^%s*(.*%S)') or ''
|
|
|
|
end
|
|
|
|
|
|
|
|
-- a Set that keeps around the lines we've already seen
|
2017-03-11 17:02:14 -07:00
|
|
|
local cdefs_init = Set:new()
|
|
|
|
local cdefs_mod = nil
|
2015-11-17 07:49:12 -07:00
|
|
|
local imported = Set:new()
|
|
|
|
local pragma_pack_id = 1
|
2014-10-26 03:20:19 -07:00
|
|
|
|
2014-08-30 06:35:42 -07:00
|
|
|
-- some things are just too complex for the LuaJIT C parser to digest. We
|
|
|
|
-- usually don't need them anyway.
|
2014-09-06 15:36:00 -07:00
|
|
|
local function filter_complex_blocks(body)
|
2014-08-30 06:35:42 -07:00
|
|
|
local result = {}
|
|
|
|
|
|
|
|
for line in body:gmatch("[^\r\n]+") do
|
2016-02-08 17:20:16 -07:00
|
|
|
if not (string.find(line, "(^)", 1, true) ~= nil
|
|
|
|
or string.find(line, "_ISwupper", 1, true)
|
2018-02-25 02:23:12 -07:00
|
|
|
or string.find(line, "_Float")
|
2016-02-08 17:20:16 -07:00
|
|
|
or string.find(line, "msgpack_zone_push_finalizer")
|
2016-06-21 15:01:21 -07:00
|
|
|
or string.find(line, "msgpack_unpacker_reserve_buffer")
|
2016-12-28 10:46:58 -07:00
|
|
|
or string.find(line, "UUID_NULL") -- static const uuid_t UUID_NULL = {...}
|
2016-06-21 15:01:21 -07:00
|
|
|
or string.find(line, "inline _Bool")) then
|
2014-08-30 06:35:42 -07:00
|
|
|
result[#result + 1] = line
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
return table.concat(result, "\n")
|
|
|
|
end
|
|
|
|
|
2017-01-02 22:57:43 -07:00
|
|
|
|
2016-10-31 23:50:49 -07:00
|
|
|
local cdef = ffi.cdef
|
|
|
|
|
|
|
|
local cimportstr
|
|
|
|
|
2017-03-11 06:02:47 -07:00
|
|
|
local previous_defines_init = ''
|
|
|
|
local preprocess_cache_init = {}
|
|
|
|
local previous_defines_mod = ''
|
|
|
|
local preprocess_cache_mod = nil
|
|
|
|
|
2017-03-11 17:14:34 -07:00
|
|
|
local function is_child_cdefs()
|
|
|
|
return (os.getenv('NVIM_TEST_MAIN_CDEFS') ~= '1')
|
|
|
|
end
|
|
|
|
|
2014-08-30 06:35:42 -07:00
|
|
|
-- use this helper to import C files, you can pass multiple paths at once,
|
|
|
|
-- this helper will return the C namespace of the nvim library.
|
2017-03-11 06:02:47 -07:00
|
|
|
cimport = function(...)
|
2017-03-11 18:20:31 -07:00
|
|
|
local previous_defines, preprocess_cache, cdefs
|
2017-03-11 17:14:34 -07:00
|
|
|
if is_child_cdefs() and preprocess_cache_mod then
|
2017-03-11 06:02:47 -07:00
|
|
|
preprocess_cache = preprocess_cache_mod
|
|
|
|
previous_defines = previous_defines_mod
|
2017-03-11 17:02:14 -07:00
|
|
|
cdefs = cdefs_mod
|
2017-03-11 06:02:47 -07:00
|
|
|
else
|
|
|
|
preprocess_cache = preprocess_cache_init
|
|
|
|
previous_defines = previous_defines_init
|
2017-03-11 17:02:14 -07:00
|
|
|
cdefs = cdefs_init
|
2014-08-30 06:35:42 -07:00
|
|
|
end
|
2017-03-11 06:02:47 -07:00
|
|
|
for _, path in ipairs({...}) do
|
|
|
|
if not (path:sub(1, 1) == '/' or path:sub(1, 1) == '.'
|
|
|
|
or path:sub(2, 2) == ':') then
|
|
|
|
path = './' .. path
|
|
|
|
end
|
2017-03-11 13:48:16 -07:00
|
|
|
if not preprocess_cache[path] then
|
|
|
|
local body
|
2017-03-11 06:02:47 -07:00
|
|
|
body, previous_defines = Preprocess.preprocess(previous_defines, path)
|
|
|
|
-- format it (so that the lines are "unique" statements), also filter out
|
|
|
|
-- Objective-C blocks
|
|
|
|
if os.getenv('NVIM_TEST_PRINT_I') == '1' then
|
|
|
|
local lnum = 0
|
|
|
|
for line in body:gmatch('[^\n]+') do
|
|
|
|
lnum = lnum + 1
|
|
|
|
print(lnum, line)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
body = formatc(body)
|
|
|
|
body = filter_complex_blocks(body)
|
2017-03-11 17:02:14 -07:00
|
|
|
-- add the formatted lines to a set
|
|
|
|
local new_cdefs = Set:new()
|
|
|
|
for line in body:gmatch("[^\r\n]+") do
|
|
|
|
line = trim(line)
|
|
|
|
-- give each #pragma pack an unique id, so that they don't get removed
|
|
|
|
-- if they are inserted into the set
|
|
|
|
-- (they are needed in the right order with the struct definitions,
|
|
|
|
-- otherwise luajit has wrong memory layouts for the sturcts)
|
|
|
|
if line:match("#pragma%s+pack") then
|
|
|
|
line = line .. " // " .. pragma_pack_id
|
|
|
|
pragma_pack_id = pragma_pack_id + 1
|
|
|
|
end
|
|
|
|
new_cdefs:add(line)
|
|
|
|
end
|
|
|
|
|
|
|
|
-- subtract the lines we've already imported from the new lines, then add
|
|
|
|
-- the new unique lines to the old lines (so they won't be imported again)
|
|
|
|
new_cdefs:diff(cdefs)
|
|
|
|
cdefs:union(new_cdefs)
|
|
|
|
-- request a sorted version of the new lines (same relative order as the
|
|
|
|
-- original preprocessed file) and feed that to the LuaJIT ffi
|
|
|
|
local new_lines = new_cdefs:to_table()
|
|
|
|
if os.getenv('NVIM_TEST_PRINT_CDEF') == '1' then
|
|
|
|
for lnum, line in ipairs(new_lines) do
|
|
|
|
print(lnum, line)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
body = table.concat(new_lines, '\n')
|
|
|
|
|
2017-03-11 06:02:47 -07:00
|
|
|
preprocess_cache[path] = body
|
|
|
|
end
|
|
|
|
cimportstr(preprocess_cache, path)
|
2014-08-30 06:35:42 -07:00
|
|
|
end
|
2017-03-11 06:02:47 -07:00
|
|
|
return lib
|
|
|
|
end
|
2014-08-30 06:35:42 -07:00
|
|
|
|
2017-03-11 06:02:47 -07:00
|
|
|
local cimport_immediate = function(...)
|
2017-03-11 13:48:16 -07:00
|
|
|
local saved_pid = child_pid
|
|
|
|
child_pid = 0
|
2017-03-11 06:02:47 -07:00
|
|
|
local err, emsg = pcall(cimport, ...)
|
2017-03-11 13:48:16 -07:00
|
|
|
child_pid = saved_pid
|
2017-03-11 06:02:47 -07:00
|
|
|
if not err then
|
|
|
|
emsg = tostring(emsg)
|
|
|
|
io.stderr:write(emsg .. '\n')
|
|
|
|
assert(false)
|
|
|
|
else
|
|
|
|
return lib
|
2014-08-30 06:35:42 -07:00
|
|
|
end
|
2016-10-31 23:50:49 -07:00
|
|
|
end
|
|
|
|
|
2017-03-11 17:14:34 -07:00
|
|
|
local function _cimportstr(preprocess_cache, path)
|
2017-03-11 06:02:47 -07:00
|
|
|
if imported:contains(path) then
|
|
|
|
return lib
|
2017-02-24 14:22:46 -07:00
|
|
|
end
|
2017-03-11 06:02:47 -07:00
|
|
|
local body = preprocess_cache[path]
|
2017-03-11 17:02:14 -07:00
|
|
|
if body == '' then
|
2017-03-11 06:02:47 -07:00
|
|
|
return lib
|
2014-08-30 06:35:42 -07:00
|
|
|
end
|
2017-03-11 17:02:14 -07:00
|
|
|
cdef(body)
|
2017-03-11 06:02:47 -07:00
|
|
|
imported:add(path)
|
2014-08-30 06:35:42 -07:00
|
|
|
|
2017-03-11 06:02:47 -07:00
|
|
|
return lib
|
2017-03-11 17:14:34 -07:00
|
|
|
end
|
|
|
|
|
|
|
|
if is_child_cdefs() then
|
|
|
|
cimportstr = child_call(_cimportstr, lib)
|
|
|
|
else
|
|
|
|
cimportstr = _cimportstr
|
|
|
|
end
|
2014-08-30 06:35:42 -07:00
|
|
|
|
2017-01-07 09:12:18 -07:00
|
|
|
local function alloc_log_new()
|
2017-01-07 03:52:51 -07:00
|
|
|
local log = {
|
|
|
|
log={},
|
|
|
|
lib=cimport('./src/nvim/memory.h'),
|
|
|
|
original_functions={},
|
|
|
|
null={['\0:is_null']=true},
|
|
|
|
}
|
|
|
|
local allocator_functions = {'malloc', 'free', 'calloc', 'realloc'}
|
|
|
|
function log:save_original_functions()
|
|
|
|
for _, funcname in ipairs(allocator_functions) do
|
2017-03-11 06:02:47 -07:00
|
|
|
if not self.original_functions[funcname] then
|
|
|
|
self.original_functions[funcname] = self.lib['mem_' .. funcname]
|
|
|
|
end
|
2017-01-07 03:52:51 -07:00
|
|
|
end
|
|
|
|
end
|
2017-03-11 16:54:23 -07:00
|
|
|
log.save_original_functions = child_call(log.save_original_functions)
|
2017-01-07 03:52:51 -07:00
|
|
|
function log:set_mocks()
|
|
|
|
for _, k in ipairs(allocator_functions) do
|
|
|
|
do
|
|
|
|
local kk = k
|
|
|
|
self.lib['mem_' .. k] = function(...)
|
|
|
|
local log_entry = {func=kk, args={...}}
|
|
|
|
self.log[#self.log + 1] = log_entry
|
|
|
|
if kk == 'free' then
|
|
|
|
self.original_functions[kk](...)
|
|
|
|
else
|
|
|
|
log_entry.ret = self.original_functions[kk](...)
|
|
|
|
end
|
|
|
|
for i, v in ipairs(log_entry.args) do
|
|
|
|
if v == nil then
|
|
|
|
-- XXX This thing thinks that {NULL} ~= {NULL}.
|
|
|
|
log_entry.args[i] = self.null
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if self.hook then self:hook(log_entry) end
|
|
|
|
if log_entry.ret then
|
|
|
|
return log_entry.ret
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2017-03-11 16:54:23 -07:00
|
|
|
log.set_mocks = child_call(log.set_mocks)
|
2017-01-07 03:52:51 -07:00
|
|
|
function log:clear()
|
|
|
|
self.log = {}
|
|
|
|
end
|
|
|
|
function log:check(exp)
|
|
|
|
eq(exp, self.log)
|
|
|
|
self:clear()
|
|
|
|
end
|
2017-10-15 17:06:34 -07:00
|
|
|
function log:clear_tmp_allocs(clear_null_frees)
|
2017-03-12 11:58:57 -07:00
|
|
|
local toremove = {}
|
|
|
|
local allocs = {}
|
|
|
|
for i, v in ipairs(self.log) do
|
|
|
|
if v.func == 'malloc' or v.func == 'calloc' then
|
|
|
|
allocs[tostring(v.ret)] = i
|
|
|
|
elseif v.func == 'realloc' or v.func == 'free' then
|
|
|
|
if allocs[tostring(v.args[1])] then
|
|
|
|
toremove[#toremove + 1] = allocs[tostring(v.args[1])]
|
|
|
|
if v.func == 'free' then
|
|
|
|
toremove[#toremove + 1] = i
|
|
|
|
end
|
2017-10-15 17:06:34 -07:00
|
|
|
elseif clear_null_frees and v.args[1] == self.null then
|
|
|
|
toremove[#toremove + 1] = i
|
2017-03-12 11:58:57 -07:00
|
|
|
end
|
|
|
|
if v.func == 'realloc' then
|
|
|
|
allocs[tostring(v.ret)] = i
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
table.sort(toremove)
|
|
|
|
for i = #toremove,1,-1 do
|
|
|
|
table.remove(self.log, toremove[i])
|
|
|
|
end
|
|
|
|
end
|
2017-01-07 03:52:51 -07:00
|
|
|
function log:restore_original_functions()
|
2017-03-11 06:02:47 -07:00
|
|
|
-- Do nothing: set mocks live in a separate process
|
|
|
|
return
|
|
|
|
--[[
|
|
|
|
[ for k, v in pairs(self.original_functions) do
|
|
|
|
[ self.lib['mem_' .. k] = v
|
|
|
|
[ end
|
|
|
|
]]
|
2017-01-07 03:52:51 -07:00
|
|
|
end
|
2017-03-11 06:02:47 -07:00
|
|
|
function log:setup()
|
2017-01-07 03:52:51 -07:00
|
|
|
log:save_original_functions()
|
|
|
|
log:set_mocks()
|
|
|
|
end
|
2017-03-11 06:02:47 -07:00
|
|
|
function log:before_each()
|
|
|
|
return
|
|
|
|
end
|
2017-01-07 03:52:51 -07:00
|
|
|
function log:after_each()
|
|
|
|
log:restore_original_functions()
|
|
|
|
end
|
2017-03-11 06:02:47 -07:00
|
|
|
log:setup()
|
2017-01-07 03:52:51 -07:00
|
|
|
return log
|
|
|
|
end
|
|
|
|
|
2014-08-30 06:35:42 -07:00
|
|
|
-- take a pointer to a C-allocated string and return an interned
|
|
|
|
-- version while also freeing the memory
|
2014-09-06 15:36:00 -07:00
|
|
|
local function internalize(cdata, len)
|
2014-08-30 06:35:42 -07:00
|
|
|
ffi.gc(cdata, ffi.C.free)
|
|
|
|
return ffi.string(cdata, len)
|
|
|
|
end
|
|
|
|
|
|
|
|
local cstr = ffi.typeof('char[?]')
|
2014-09-06 15:36:00 -07:00
|
|
|
local function to_cstr(string)
|
2017-01-03 12:51:29 -07:00
|
|
|
return cstr(#string + 1, string)
|
2014-08-30 06:35:42 -07:00
|
|
|
end
|
|
|
|
|
2016-10-31 23:50:49 -07:00
|
|
|
local sc
|
|
|
|
|
|
|
|
if posix ~= nil then
|
|
|
|
sc = {
|
|
|
|
fork = posix.fork,
|
|
|
|
pipe = posix.pipe,
|
|
|
|
read = posix.read,
|
|
|
|
write = posix.write,
|
|
|
|
close = posix.close,
|
|
|
|
wait = posix.wait,
|
|
|
|
exit = posix._exit,
|
|
|
|
}
|
2016-11-01 00:38:03 -07:00
|
|
|
elseif syscall ~= nil then
|
2016-10-31 23:50:49 -07:00
|
|
|
sc = {
|
|
|
|
fork = syscall.fork,
|
|
|
|
pipe = function()
|
|
|
|
local ret = {syscall.pipe()}
|
|
|
|
return ret[3], ret[4]
|
|
|
|
end,
|
|
|
|
read = function(rd, len)
|
|
|
|
return rd:read(nil, len)
|
|
|
|
end,
|
|
|
|
write = function(wr, s)
|
|
|
|
return wr:write(s)
|
|
|
|
end,
|
|
|
|
close = function(p)
|
|
|
|
return p:close()
|
|
|
|
end,
|
|
|
|
wait = syscall.wait,
|
|
|
|
exit = syscall.exit,
|
|
|
|
}
|
2016-11-01 00:38:03 -07:00
|
|
|
else
|
2017-03-11 06:02:47 -07:00
|
|
|
cimport_immediate('./test/unit/fixtures/posix.h')
|
2016-11-01 00:38:03 -07:00
|
|
|
sc = {
|
|
|
|
fork = function()
|
|
|
|
return tonumber(ffi.C.fork())
|
|
|
|
end,
|
|
|
|
pipe = function()
|
|
|
|
local ret = ffi.new('int[2]', {-1, -1})
|
|
|
|
ffi.errno(0)
|
|
|
|
local res = ffi.C.pipe(ret)
|
|
|
|
if (res ~= 0) then
|
|
|
|
local err = ffi.errno(0)
|
|
|
|
assert(res == 0, ("pipe() error: %u: %s"):format(
|
|
|
|
err, ffi.string(ffi.C.strerror(err))))
|
|
|
|
end
|
|
|
|
assert(ret[0] ~= -1 and ret[1] ~= -1)
|
|
|
|
return ret[0], ret[1]
|
|
|
|
end,
|
|
|
|
read = function(rd, len)
|
|
|
|
local ret = ffi.new('char[?]', len, {0})
|
|
|
|
local total_bytes_read = 0
|
|
|
|
ffi.errno(0)
|
|
|
|
while total_bytes_read < len do
|
|
|
|
local bytes_read = tonumber(ffi.C.read(
|
|
|
|
rd,
|
|
|
|
ffi.cast('void*', ret + total_bytes_read),
|
|
|
|
len - total_bytes_read))
|
|
|
|
if bytes_read == -1 then
|
|
|
|
local err = ffi.errno(0)
|
2017-03-11 06:02:47 -07:00
|
|
|
if err ~= ffi.C.kPOSIXErrnoEINTR then
|
2016-11-01 00:38:03 -07:00
|
|
|
assert(false, ("read() error: %u: %s"):format(
|
|
|
|
err, ffi.string(ffi.C.strerror(err))))
|
|
|
|
end
|
|
|
|
elseif bytes_read == 0 then
|
|
|
|
break
|
|
|
|
else
|
|
|
|
total_bytes_read = total_bytes_read + bytes_read
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return ffi.string(ret, total_bytes_read)
|
|
|
|
end,
|
|
|
|
write = function(wr, s)
|
|
|
|
local wbuf = to_cstr(s)
|
|
|
|
local total_bytes_written = 0
|
|
|
|
ffi.errno(0)
|
|
|
|
while total_bytes_written < #s do
|
|
|
|
local bytes_written = tonumber(ffi.C.write(
|
|
|
|
wr,
|
|
|
|
ffi.cast('void*', wbuf + total_bytes_written),
|
|
|
|
#s - total_bytes_written))
|
|
|
|
if bytes_written == -1 then
|
|
|
|
local err = ffi.errno(0)
|
2017-03-11 06:02:47 -07:00
|
|
|
if err ~= ffi.C.kPOSIXErrnoEINTR then
|
2016-11-01 00:38:03 -07:00
|
|
|
assert(false, ("write() error: %u: %s"):format(
|
|
|
|
err, ffi.string(ffi.C.strerror(err))))
|
|
|
|
end
|
|
|
|
elseif bytes_written == 0 then
|
|
|
|
break
|
|
|
|
else
|
|
|
|
total_bytes_written = total_bytes_written + bytes_written
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return total_bytes_written
|
|
|
|
end,
|
|
|
|
close = ffi.C.close,
|
|
|
|
wait = function(pid)
|
|
|
|
ffi.errno(0)
|
|
|
|
while true do
|
2017-03-11 06:02:47 -07:00
|
|
|
local r = ffi.C.waitpid(pid, nil, ffi.C.kPOSIXWaitWUNTRACED)
|
2016-11-01 00:38:03 -07:00
|
|
|
if r == -1 then
|
|
|
|
local err = ffi.errno(0)
|
2017-03-11 06:02:47 -07:00
|
|
|
if err == ffi.C.kPOSIXErrnoECHILD then
|
2016-11-01 00:38:03 -07:00
|
|
|
break
|
2017-03-11 06:02:47 -07:00
|
|
|
elseif err ~= ffi.C.kPOSIXErrnoEINTR then
|
2016-11-01 00:38:03 -07:00
|
|
|
assert(false, ("waitpid() error: %u: %s"):format(
|
|
|
|
err, ffi.string(ffi.C.strerror(err))))
|
|
|
|
end
|
|
|
|
else
|
|
|
|
assert(r == pid)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end,
|
|
|
|
exit = ffi.C._exit,
|
|
|
|
}
|
2016-10-31 23:50:49 -07:00
|
|
|
end
|
|
|
|
|
2016-11-01 02:20:42 -07:00
|
|
|
local function format_list(lst)
|
|
|
|
local ret = ''
|
|
|
|
for _, v in ipairs(lst) do
|
|
|
|
if ret ~= '' then ret = ret .. ', ' end
|
|
|
|
ret = ret .. assert:format({v, n=1})[1]
|
|
|
|
end
|
|
|
|
return ret
|
|
|
|
end
|
|
|
|
|
|
|
|
if os.getenv('NVIM_TEST_PRINT_SYSCALLS') == '1' then
|
|
|
|
for k_, v_ in pairs(sc) do
|
|
|
|
(function(k, v)
|
|
|
|
sc[k] = function(...)
|
2016-11-04 13:57:28 -07:00
|
|
|
local rets = {v(...)}
|
2016-11-01 02:20:42 -07:00
|
|
|
io.stderr:write(('%s(%s) = %s\n'):format(k, format_list({...}),
|
|
|
|
format_list(rets)))
|
|
|
|
return unpack(rets)
|
|
|
|
end
|
|
|
|
end)(k_, v_)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-04-01 01:19:41 -07:00
|
|
|
local function just_fail(_)
|
|
|
|
return false
|
|
|
|
end
|
|
|
|
say:set('assertion.just_fail.positive', '%s')
|
|
|
|
say:set('assertion.just_fail.negative', '%s')
|
|
|
|
assert:register('assertion', 'just_fail', just_fail,
|
|
|
|
'assertion.just_fail.positive',
|
|
|
|
'assertion.just_fail.negative')
|
|
|
|
|
2017-04-01 02:25:10 -07:00
|
|
|
local hook_fnamelen = 30
|
|
|
|
local hook_sfnamelen = 30
|
|
|
|
local hook_numlen = 5
|
|
|
|
local hook_msglen = 1 + 1 + 1 + (1 + hook_fnamelen) + (1 + hook_sfnamelen) + (1 + hook_numlen) + 1
|
|
|
|
|
2017-04-01 02:52:28 -07:00
|
|
|
local tracehelp = dedent([[
|
2017-11-11 13:50:37 -07:00
|
|
|
Trace: either in the format described below or custom debug output starting
|
|
|
|
with `>`. Latter lines still have the same width in byte.
|
|
|
|
|
2017-04-01 02:52:28 -07:00
|
|
|
┌ Trace type: _r_eturn from function , function _c_all, _l_ine executed,
|
2017-04-02 04:25:47 -07:00
|
|
|
│ _t_ail return, _C_ount (should not actually appear),
|
2017-11-11 13:50:37 -07:00
|
|
|
│ _s_aved from previous run for reference, _>_ for custom debug
|
|
|
|
│ output.
|
2017-04-01 02:52:28 -07:00
|
|
|
│┏ Function type: _L_ua function, _C_ function, _m_ain part of chunk,
|
|
|
|
│┃ function that did _t_ail call.
|
|
|
|
│┃┌ Function name type: _g_lobal, _l_ocal, _m_ethod, _f_ield, _u_pvalue,
|
|
|
|
│┃│ space for unknown.
|
|
|
|
│┃│ ┏ Source file name ┌ Function name ┏ Line
|
|
|
|
│┃│ ┃ (trunc to 30 bytes, no .lua) │ (truncated to last 30 bytes) ┃ number
|
|
|
|
CWN SSSSSSSSSSSSSSSSSSSSSSSSSSSSSS:FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:LLLLL\n
|
|
|
|
]])
|
|
|
|
|
2017-04-01 02:25:10 -07:00
|
|
|
local function child_sethook(wr)
|
2017-04-01 10:57:23 -07:00
|
|
|
local trace_level = os.getenv('NVIM_TEST_TRACE_LEVEL')
|
|
|
|
if not trace_level or trace_level == '' then
|
|
|
|
trace_level = 1
|
|
|
|
else
|
|
|
|
trace_level = tonumber(trace_level)
|
|
|
|
end
|
|
|
|
if trace_level <= 0 then
|
2017-04-01 02:25:10 -07:00
|
|
|
return
|
|
|
|
end
|
2017-04-01 10:57:23 -07:00
|
|
|
local trace_only_c = trace_level <= 1
|
2017-04-02 04:25:47 -07:00
|
|
|
local prev_info, prev_reason, prev_lnum
|
|
|
|
local function hook(reason, lnum, use_prev)
|
2017-04-01 02:25:10 -07:00
|
|
|
local info = nil
|
2017-04-02 04:25:47 -07:00
|
|
|
if use_prev then
|
|
|
|
info = prev_info
|
|
|
|
elseif reason ~= 'tail return' then -- tail return
|
2017-04-01 02:25:10 -07:00
|
|
|
info = debug.getinfo(2, 'nSl')
|
|
|
|
end
|
2017-04-01 03:16:25 -07:00
|
|
|
|
2017-04-02 04:25:47 -07:00
|
|
|
if trace_only_c and (not info or info.what ~= 'C') and not use_prev then
|
|
|
|
if info.source:sub(-9) == '_spec.lua' then
|
|
|
|
prev_info = info
|
|
|
|
prev_reason = 'saved'
|
|
|
|
prev_lnum = lnum
|
|
|
|
end
|
2017-04-01 03:16:25 -07:00
|
|
|
return
|
|
|
|
end
|
2017-04-02 04:25:47 -07:00
|
|
|
if trace_only_c and not use_prev and prev_reason then
|
|
|
|
hook(prev_reason, prev_lnum, true)
|
|
|
|
prev_reason = nil
|
|
|
|
end
|
2017-04-01 03:16:25 -07:00
|
|
|
|
2017-04-01 02:25:10 -07:00
|
|
|
local whatchar = ' '
|
|
|
|
local namewhatchar = ' '
|
|
|
|
local funcname = ''
|
|
|
|
local source = ''
|
2017-04-01 03:16:25 -07:00
|
|
|
local msgchar = reason:sub(1, 1)
|
|
|
|
|
|
|
|
if reason == 'count' then
|
|
|
|
msgchar = 'C'
|
|
|
|
end
|
|
|
|
|
2017-04-01 02:25:10 -07:00
|
|
|
if info then
|
|
|
|
funcname = (info.name or ''):sub(1, hook_fnamelen)
|
|
|
|
whatchar = info.what:sub(1, 1)
|
|
|
|
namewhatchar = info.namewhat:sub(1, 1)
|
|
|
|
if namewhatchar == '' then
|
|
|
|
namewhatchar = ' '
|
|
|
|
end
|
|
|
|
source = info.source
|
|
|
|
if source:sub(1, 1) == '@' then
|
|
|
|
if source:sub(-4, -1) == '.lua' then
|
|
|
|
source = source:sub(1, -5)
|
|
|
|
end
|
|
|
|
source = source:sub(-hook_sfnamelen, -1)
|
|
|
|
end
|
|
|
|
lnum = lnum or info.currentline
|
|
|
|
end
|
|
|
|
|
|
|
|
-- assert(-1 <= lnum and lnum <= 99999)
|
|
|
|
local lnum_s
|
|
|
|
if lnum == -1 then
|
|
|
|
lnum_s = 'nknwn'
|
|
|
|
else
|
|
|
|
lnum_s = ('%u'):format(lnum)
|
|
|
|
end
|
|
|
|
local msg = ( -- lua does not support %*
|
|
|
|
''
|
|
|
|
.. msgchar
|
|
|
|
.. whatchar
|
|
|
|
.. namewhatchar
|
|
|
|
.. ' '
|
|
|
|
.. source .. (' '):rep(hook_sfnamelen - #source)
|
|
|
|
.. ':'
|
|
|
|
.. funcname .. (' '):rep(hook_fnamelen - #funcname)
|
|
|
|
.. ':'
|
|
|
|
.. ('0'):rep(hook_numlen - #lnum_s) .. lnum_s
|
|
|
|
.. '\n'
|
|
|
|
)
|
|
|
|
-- eq(hook_msglen, #msg)
|
|
|
|
sc.write(wr, msg)
|
|
|
|
end
|
2017-04-02 04:25:47 -07:00
|
|
|
debug.sethook(hook, 'crl')
|
2017-04-01 02:25:10 -07:00
|
|
|
end
|
|
|
|
|
2017-04-01 03:16:25 -07:00
|
|
|
local trace_end_msg = ('E%s\n'):format((' '):rep(hook_msglen - 2))
|
|
|
|
|
2017-11-11 13:50:37 -07:00
|
|
|
local _debug_log
|
|
|
|
|
|
|
|
local debug_log = only_separate(function(...)
|
|
|
|
return _debug_log(...)
|
|
|
|
end)
|
|
|
|
|
2017-04-01 01:19:41 -07:00
|
|
|
local function itp_child(wr, func)
|
2017-11-11 13:50:37 -07:00
|
|
|
_debug_log = function(s)
|
|
|
|
s = s:sub(1, hook_msglen - 2)
|
|
|
|
sc.write(wr, '>' .. s .. (' '):rep(hook_msglen - 2 - #s) .. '\n')
|
|
|
|
end
|
2017-11-19 11:46:54 -07:00
|
|
|
local err, emsg = pcall(init)
|
|
|
|
if err then
|
|
|
|
collectgarbage('stop')
|
|
|
|
child_sethook(wr)
|
|
|
|
err, emsg = pcall(func)
|
|
|
|
debug.sethook()
|
|
|
|
end
|
2017-04-01 01:19:41 -07:00
|
|
|
emsg = tostring(emsg)
|
2017-04-01 03:16:25 -07:00
|
|
|
sc.write(wr, trace_end_msg)
|
2017-04-01 01:19:41 -07:00
|
|
|
if not err then
|
2017-04-01 02:25:10 -07:00
|
|
|
if #emsg > 99999 then
|
|
|
|
emsg = emsg:sub(1, 99999)
|
|
|
|
end
|
2017-04-01 01:19:41 -07:00
|
|
|
sc.write(wr, ('-\n%05u\n%s'):format(#emsg, emsg))
|
|
|
|
deinit()
|
|
|
|
else
|
|
|
|
sc.write(wr, '+\n')
|
|
|
|
deinit()
|
|
|
|
end
|
2017-12-24 07:42:23 -07:00
|
|
|
collectgarbage('restart')
|
|
|
|
collectgarbage()
|
|
|
|
sc.write(wr, '$\n')
|
|
|
|
sc.close(wr)
|
|
|
|
sc.exit(err and 0 or 1)
|
2017-04-01 01:19:41 -07:00
|
|
|
end
|
|
|
|
|
|
|
|
local function check_child_err(rd)
|
2017-04-01 02:25:10 -07:00
|
|
|
local trace = {}
|
2017-04-05 22:23:33 -07:00
|
|
|
local did_traceline = false
|
2017-11-30 01:44:48 -07:00
|
|
|
local maxtrace = tonumber(os.getenv('NVIM_TEST_MAXTRACE')) or 1024
|
2017-04-01 02:25:10 -07:00
|
|
|
while true do
|
|
|
|
local traceline = sc.read(rd, hook_msglen)
|
|
|
|
if #traceline ~= hook_msglen then
|
|
|
|
if #traceline == 0 then
|
|
|
|
break
|
|
|
|
else
|
|
|
|
trace[#trace + 1] = 'Partial read: <' .. trace .. '>\n'
|
|
|
|
end
|
|
|
|
end
|
2017-04-01 03:16:25 -07:00
|
|
|
if traceline == trace_end_msg then
|
2017-04-05 22:23:33 -07:00
|
|
|
did_traceline = true
|
2017-04-01 02:25:10 -07:00
|
|
|
break
|
|
|
|
end
|
|
|
|
trace[#trace + 1] = traceline
|
2017-12-24 07:13:42 -07:00
|
|
|
if #trace > maxtrace then
|
|
|
|
table.remove(trace, 1)
|
|
|
|
end
|
2017-04-01 02:25:10 -07:00
|
|
|
end
|
2017-04-01 01:19:41 -07:00
|
|
|
local res = sc.read(rd, 2)
|
2017-12-24 07:42:23 -07:00
|
|
|
if #res == 2 then
|
|
|
|
local err = ''
|
|
|
|
if res ~= '+\n' then
|
|
|
|
eq('-\n', res)
|
|
|
|
local len_s = sc.read(rd, 5)
|
|
|
|
local len = tonumber(len_s)
|
|
|
|
neq(0, len)
|
|
|
|
if os.getenv('NVIM_TEST_TRACE_ON_ERROR') == '1' and #trace ~= 0 then
|
|
|
|
err = '\nTest failed, trace:\n' .. tracehelp
|
|
|
|
for _, traceline in ipairs(trace) do
|
|
|
|
err = err .. traceline
|
|
|
|
end
|
2017-04-01 10:57:23 -07:00
|
|
|
end
|
2017-12-24 07:42:23 -07:00
|
|
|
err = err .. sc.read(rd, len + 1)
|
2017-04-01 02:25:10 -07:00
|
|
|
end
|
2017-12-24 07:42:23 -07:00
|
|
|
local eres = sc.read(rd, 2)
|
|
|
|
if eres ~= '$\n' then
|
|
|
|
if #trace == 0 then
|
|
|
|
err = '\nTest crashed, no trace available\n'
|
|
|
|
else
|
|
|
|
err = '\nTest crashed, trace:\n' .. tracehelp
|
|
|
|
for i = 1, #trace do
|
|
|
|
err = err .. trace[i]
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if not did_traceline then
|
|
|
|
err = err .. '\nNo end of trace occurred'
|
|
|
|
end
|
|
|
|
local cc_err, cc_emsg = pcall(check_cores, Paths.test_luajit_prg, true)
|
|
|
|
if not cc_err then
|
|
|
|
err = err .. '\ncheck_cores failed: ' .. cc_emsg
|
|
|
|
end
|
2017-04-05 22:23:33 -07:00
|
|
|
end
|
2017-12-24 07:42:23 -07:00
|
|
|
if err ~= '' then
|
|
|
|
assert.just_fail(err)
|
2017-09-26 13:13:55 -07:00
|
|
|
end
|
|
|
|
end
|
2017-04-01 01:19:41 -07:00
|
|
|
end
|
|
|
|
|
|
|
|
local function itp_parent(rd, pid, allow_failure)
|
|
|
|
local err, emsg = pcall(check_child_err, rd)
|
|
|
|
sc.wait(pid)
|
|
|
|
sc.close(rd)
|
|
|
|
if not err then
|
|
|
|
if allow_failure then
|
|
|
|
io.stderr:write('Errorred out:\n' .. tostring(emsg) .. '\n')
|
|
|
|
os.execute([[
|
|
|
|
sh -c "source ci/common/test.sh
|
|
|
|
check_core_dumps --delete \"]] .. Paths.test_luajit_prg .. [[\""]])
|
|
|
|
else
|
|
|
|
error(emsg)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-25 13:48:22 -07:00
|
|
|
local function gen_itp(it)
|
2017-03-11 16:54:23 -07:00
|
|
|
child_calls_mod = {}
|
|
|
|
child_calls_mod_once = {}
|
|
|
|
child_cleanups_mod_once = {}
|
2017-03-11 06:02:47 -07:00
|
|
|
preprocess_cache_mod = map(function(v) return v end, preprocess_cache_init)
|
|
|
|
previous_defines_mod = previous_defines_init
|
2017-03-11 17:02:14 -07:00
|
|
|
cdefs_mod = cdefs_init:copy()
|
2016-11-04 08:20:58 -07:00
|
|
|
local function itp(name, func, allow_failure)
|
2016-11-04 14:01:25 -07:00
|
|
|
if allow_failure and os.getenv('NVIM_TEST_RUN_FAILING_TESTS') ~= '1' then
|
|
|
|
-- FIXME Fix tests with this true
|
|
|
|
return
|
|
|
|
end
|
2016-09-25 13:48:22 -07:00
|
|
|
it(name, function()
|
2016-10-31 23:50:49 -07:00
|
|
|
local rd, wr = sc.pipe()
|
2017-03-11 13:48:16 -07:00
|
|
|
child_pid = sc.fork()
|
|
|
|
if child_pid == 0 then
|
2016-10-31 23:50:49 -07:00
|
|
|
sc.close(rd)
|
2017-04-01 01:19:41 -07:00
|
|
|
itp_child(wr, func)
|
2016-09-25 13:48:22 -07:00
|
|
|
else
|
2016-10-31 23:50:49 -07:00
|
|
|
sc.close(wr)
|
2017-04-01 03:17:25 -07:00
|
|
|
local saved_child_pid = child_pid
|
2017-04-01 01:07:08 -07:00
|
|
|
child_pid = nil
|
2017-04-01 01:19:41 -07:00
|
|
|
itp_parent(rd, saved_child_pid, allow_failure)
|
2016-09-25 13:48:22 -07:00
|
|
|
end
|
|
|
|
end)
|
|
|
|
end
|
|
|
|
return itp
|
|
|
|
end
|
|
|
|
|
2017-03-11 06:02:47 -07:00
|
|
|
local function cppimport(path)
|
|
|
|
return cimport(Paths.test_include_path .. '/' .. path)
|
|
|
|
end
|
|
|
|
|
|
|
|
cimport('./src/nvim/types.h', './src/nvim/main.h', './src/nvim/os/time.h')
|
|
|
|
|
2017-09-03 09:57:24 -07:00
|
|
|
local function conv_enum(etab, eval)
|
|
|
|
local n = tonumber(eval)
|
|
|
|
return etab[n] or n
|
|
|
|
end
|
|
|
|
|
|
|
|
local function array_size(arr)
|
|
|
|
return ffi.sizeof(arr) / ffi.sizeof(arr[0])
|
|
|
|
end
|
|
|
|
|
|
|
|
local function kvi_size(kvi)
|
|
|
|
return array_size(kvi.init_array)
|
|
|
|
end
|
|
|
|
|
|
|
|
local function kvi_init(kvi)
|
|
|
|
kvi.capacity = kvi_size(kvi)
|
|
|
|
kvi.items = kvi.init_array
|
|
|
|
return kvi
|
|
|
|
end
|
|
|
|
|
2017-10-15 17:06:34 -07:00
|
|
|
local function kvi_destroy(kvi)
|
|
|
|
if kvi.items ~= kvi.init_array then
|
|
|
|
lib.xfree(kvi.items)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-09-03 09:57:24 -07:00
|
|
|
local function kvi_new(ct)
|
|
|
|
return kvi_init(ffi.new(ct))
|
|
|
|
end
|
|
|
|
|
2017-10-29 15:48:32 -07:00
|
|
|
local function make_enum_conv_tab(m, values, skip_pref, set_cb)
|
2017-09-03 11:58:16 -07:00
|
|
|
child_call_once(function()
|
|
|
|
local ret = {}
|
|
|
|
for _, v in ipairs(values) do
|
|
|
|
local str_v = v
|
|
|
|
if v:sub(1, #skip_pref) == skip_pref then
|
|
|
|
str_v = v:sub(#skip_pref + 1)
|
|
|
|
end
|
2017-10-29 15:48:32 -07:00
|
|
|
ret[tonumber(m[v])] = str_v
|
2017-09-03 11:58:16 -07:00
|
|
|
end
|
|
|
|
set_cb(ret)
|
|
|
|
end)
|
|
|
|
end
|
|
|
|
|
|
|
|
local function ptr2addr(ptr)
|
|
|
|
return tonumber(ffi.cast('intptr_t', ffi.cast('void *', ptr)))
|
|
|
|
end
|
|
|
|
|
|
|
|
local s = ffi.new('char[64]', {0})
|
|
|
|
|
|
|
|
local function ptr2key(ptr)
|
|
|
|
ffi.C.snprintf(s, ffi.sizeof(s), '%p', ffi.cast('void *', ptr))
|
|
|
|
return ffi.string(s)
|
|
|
|
end
|
|
|
|
|
2017-03-11 03:28:18 -07:00
|
|
|
local module = {
|
2014-08-30 06:35:42 -07:00
|
|
|
cimport = cimport,
|
|
|
|
cppimport = cppimport,
|
|
|
|
internalize = internalize,
|
2016-06-21 15:01:21 -07:00
|
|
|
ok = ok,
|
2016-04-23 16:53:11 -07:00
|
|
|
eq = eq,
|
|
|
|
neq = neq,
|
2014-08-30 06:35:42 -07:00
|
|
|
ffi = ffi,
|
2017-03-11 06:02:47 -07:00
|
|
|
lib = lib,
|
2014-08-30 06:35:42 -07:00
|
|
|
cstr = cstr,
|
|
|
|
to_cstr = to_cstr,
|
|
|
|
NULL = NULL,
|
|
|
|
OK = OK,
|
2017-01-07 03:52:51 -07:00
|
|
|
FAIL = FAIL,
|
|
|
|
alloc_log_new = alloc_log_new,
|
2016-09-25 13:48:22 -07:00
|
|
|
gen_itp = gen_itp,
|
2017-03-11 06:02:47 -07:00
|
|
|
only_separate = only_separate,
|
2017-03-11 16:54:23 -07:00
|
|
|
child_call_once = child_call_once,
|
|
|
|
child_cleanup_once = child_cleanup_once,
|
2017-04-01 01:19:41 -07:00
|
|
|
sc = sc,
|
2017-09-03 09:57:24 -07:00
|
|
|
conv_enum = conv_enum,
|
2017-10-29 15:48:32 -07:00
|
|
|
array_size = array_size,
|
2017-10-15 17:06:34 -07:00
|
|
|
kvi_destroy = kvi_destroy,
|
2017-09-03 09:57:24 -07:00
|
|
|
kvi_size = kvi_size,
|
|
|
|
kvi_init = kvi_init,
|
|
|
|
kvi_new = kvi_new,
|
2017-09-03 11:58:16 -07:00
|
|
|
make_enum_conv_tab = make_enum_conv_tab,
|
|
|
|
ptr2addr = ptr2addr,
|
|
|
|
ptr2key = ptr2key,
|
2017-11-11 13:50:37 -07:00
|
|
|
debug_log = debug_log,
|
2014-08-30 06:35:42 -07:00
|
|
|
}
|
2017-04-05 22:23:33 -07:00
|
|
|
return function()
|
2017-03-11 03:28:18 -07:00
|
|
|
return module
|
|
|
|
end
|