forked from enlightenment/efl
212 lines
5.3 KiB
Lua
212 lines
5.3 KiB
Lua
-- EFL LuaJIT bindings: Eina (log module)
|
|
-- For use with Elua
|
|
|
|
local ffi = require("ffi")
|
|
local C = ffi.C
|
|
|
|
ffi.cdef [[
|
|
typedef enum _Eina_Log_Level {
|
|
EINA_LOG_LEVEL_CRITICAL,
|
|
EINA_LOG_LEVEL_ERR,
|
|
EINA_LOG_LEVEL_WARN,
|
|
EINA_LOG_LEVEL_INFO,
|
|
EINA_LOG_LEVEL_DBG,
|
|
EINA_LOG_LEVELS,
|
|
EINA_LOG_LEVEL_UNKNOWN = (-2147483647 - 1)
|
|
} Eina_Log_Level;
|
|
|
|
extern int EINA_LOG_DOMAIN_GLOBAL;
|
|
|
|
int eina_log_domain_register (const char *name, const char *color);
|
|
void eina_log_domain_unregister(int domain);
|
|
|
|
int eina_log_domain_registered_level_get(int domain);
|
|
void eina_log_domain_registered_level_set(int domain, int level);
|
|
|
|
void eina_log_print(int domain,
|
|
Eina_Log_Level level,
|
|
const char *file,
|
|
const char *function,
|
|
int line,
|
|
const char *fmt,
|
|
...);
|
|
|
|
typedef struct _Domain_Private {
|
|
int domain;
|
|
} Domain_Private;
|
|
|
|
typedef struct _Domain Domain;
|
|
|
|
void *malloc(size_t);
|
|
void free(void*);
|
|
]]
|
|
|
|
local cutil = require("cutil")
|
|
local util = require("util")
|
|
|
|
local M = {}
|
|
|
|
local eina
|
|
local default_domain, global_domain
|
|
|
|
local init = function()
|
|
eina = util.lib_load("eina")
|
|
global_domain = ffi.new("Domain_Private", eina.EINA_LOG_DOMAIN_GLOBAL)
|
|
default_domain = global_domain
|
|
end
|
|
|
|
local shutdown = function()
|
|
util.lib_unload("eina")
|
|
default_domain, global_domain = nil, nil
|
|
end
|
|
|
|
cutil.init_module(init, shutdown)
|
|
|
|
M.level = {
|
|
CRITICAL = C.EINA_LOG_LEVEL_CRITICAL,
|
|
ERR = C.EINA_LOG_LEVEL_ERR,
|
|
WARN = C.EINA_LOG_LEVEL_WARN,
|
|
INFO = C.EINA_LOG_LEVEL_INFO,
|
|
DBG = C.EINA_LOG_LEVEL_DBG,
|
|
UNKNOWN = C.EINA_LOG_LEVEL_UNKNOWN,
|
|
levels = C.EINA_LOG_LEVELS
|
|
}
|
|
|
|
M.color = {
|
|
DEFAULT = "\x1B[36m",
|
|
LIGHTRED = "\x1B[31;1m",
|
|
RED = "\x1B[31m",
|
|
LIGHTBLUE = "\x1B[34;1m",
|
|
BLUE = "\x1B[34m",
|
|
GREEN = "\x1B[32;1m",
|
|
YELLOW = "\x1B[33;1m",
|
|
ORANGE = "\x1B[0;33m",
|
|
WHITE = "\x1B[37;1m",
|
|
LIGHTCYAN = "\x1B[36;1m",
|
|
CYAN = "\x1B[36m",
|
|
RESET = "\x1B[0m",
|
|
HIGH = "\x1B[1m"
|
|
}
|
|
|
|
local get_dom = function(dom)
|
|
dom = dom:__get_domain()
|
|
if not dom then return nil end
|
|
return ffi.cast("Domain_Private*", dom).domain
|
|
end
|
|
|
|
local unregister_dom = function(dom)
|
|
local dompri = ffi.cast("Domain_Private*", dom)
|
|
eina.eina_log_domain_unregister(dompri.domain)
|
|
C.free(dompri)
|
|
end
|
|
|
|
local log_full = function(dom, level, file, func, line, msg)
|
|
dom = get_dom(dom)
|
|
if not dom then return end
|
|
eina.eina_log_print(dom, level, file, func, line, msg)
|
|
end
|
|
M.log_full = log_full
|
|
|
|
local getinfo = debug.getinfo
|
|
|
|
local getfuncname = function(info)
|
|
return info.name or "<" .. tostring(info.func) .. ">"
|
|
end
|
|
|
|
local log = function(dom, level, msg, loff)
|
|
local info = getinfo(2 + (loff or 0), "nlSf")
|
|
log_full(dom, level, info.source, getfuncname(info), info.currentline, msg)
|
|
end
|
|
M.log = log
|
|
|
|
local logfuncs = {
|
|
{ "crit", C.EINA_LOG_LEVEL_CRITICAL },
|
|
{ "err", C.EINA_LOG_LEVEL_ERR },
|
|
{ "warn", C.EINA_LOG_LEVEL_WARN },
|
|
{ "info", C.EINA_LOG_LEVEL_INFO },
|
|
{ "dbg", C.EINA_LOG_LEVEL_DBG }
|
|
}
|
|
|
|
for i, v in ipairs(logfuncs) do
|
|
M[v[1]] = function(msg)
|
|
if not default_domain then return end
|
|
local info = getinfo(2, "nlSf")
|
|
local dom = ffi.cast("Domain_Private*", default_domain).domain
|
|
eina.eina_log_print(dom, v[2], info.source, getfuncname(info),
|
|
info.currentline, msg)
|
|
end
|
|
end
|
|
|
|
logfuncs = nil
|
|
|
|
M.Domain_Base = util.Object:clone {
|
|
set_level = function(self, level)
|
|
local dom = get_dom(self)
|
|
if not dom then return end
|
|
eina.eina_log_domain_registered_level_set(dom, level)
|
|
end,
|
|
|
|
get_level = function(self)
|
|
local dom = get_dom(self)
|
|
if not dom then return -1 end
|
|
return eina.eina_log_domain_registered_level_get(dom)
|
|
end,
|
|
|
|
__get_domain = function(self)
|
|
return nil
|
|
end,
|
|
|
|
log = function(self, level, msg, loff)
|
|
log(self, level, msg, (loff or 0) + 1)
|
|
end,
|
|
|
|
is_valid = function(self)
|
|
return self:__get_domain() ~= nil
|
|
end
|
|
}
|
|
|
|
M.Domain_Global = M.Domain_Base:clone {
|
|
__get_domain = function(self)
|
|
return global_domain
|
|
end
|
|
}
|
|
|
|
M.global_domain = M.Domain_Global
|
|
|
|
M.Domain_Default = M.Domain_Base:clone {
|
|
__get_domain = function(self)
|
|
return default_domain
|
|
end
|
|
}
|
|
|
|
M.default_domain = M.Domain_Default
|
|
|
|
M.Domain = M.Domain_Base:clone {
|
|
__ctor = function(self, name, color)
|
|
local dom = eina.eina_log_domain_register(name, color or "\x1B[36m")
|
|
if dom < 0 then return end
|
|
local dompri = ffi.cast("Domain_Private*",
|
|
C.malloc(ffi.sizeof("Domain_Private")))
|
|
dompri.domain = dom
|
|
self.__domain = ffi.gc(ffi.cast("Domain*", dompri), unregister_dom)
|
|
end,
|
|
|
|
unregister = function(self)
|
|
if not self.__domain then return end
|
|
unregister_dom(ffi.gc(self.__domain, nil))
|
|
self.__domain = nil
|
|
end,
|
|
|
|
__get_domain = function(self)
|
|
return self.__domain
|
|
end
|
|
}
|
|
|
|
M.set_default_domain = function(dom)
|
|
dom = dom:__get_domain()
|
|
if not dom then return end
|
|
default_domain = dom
|
|
end
|
|
|
|
return M
|