744 lines
27 KiB
C++
744 lines
27 KiB
C++
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <string>
|
|
#include <map>
|
|
#include <Eina_Js.hh>
|
|
|
|
namespace efl { namespace eina { namespace js {
|
|
|
|
v8::Local<v8::String> to_v8_string(v8::Isolate *isolate, const char *fmt,
|
|
va_list args)
|
|
{
|
|
using v8::String;
|
|
#if 0
|
|
/* TODO: unfortunately, the elegant and exception-safe version isn't
|
|
compiling (yet!) */
|
|
efl::eina::stringshare s(eina_stringshare_vprintf(fmt, args),
|
|
efl::eina::steal_stringshare_ref);
|
|
return compatibility_new<String>(isolate, s.data(), String::kNormalString,
|
|
s.size());
|
|
#else
|
|
auto s = eina_stringshare_vprintf(fmt, args);
|
|
auto ret = compatibility_new<String>(isolate, s);
|
|
eina_stringshare_del(s);
|
|
return ret;
|
|
#endif
|
|
}
|
|
|
|
static global_ref<v8::Value> js_eina_log_print_cb_data;
|
|
static std::map<int, const char *> js_eina_log_color_map;
|
|
|
|
static void js_eina_log_print_cb(const Eina_Log_Domain *d, Eina_Log_Level level,
|
|
const char *file, const char *fnc, int line,
|
|
const char *fmt, void */*data*/, va_list args)
|
|
{
|
|
using v8::String;
|
|
using v8::Integer;
|
|
using v8::Isolate;
|
|
|
|
Isolate *const isolate = Isolate::GetCurrent();
|
|
constexpr unsigned argc = 7;
|
|
|
|
v8::Handle<v8::Value> argv[argc] = {
|
|
compatibility_new<String>(isolate, d->name ? d->name : ""),
|
|
compatibility_new<String>(isolate, d->color ? d->color : ""),
|
|
compatibility_new<Integer>(isolate, static_cast<int>(level)),
|
|
compatibility_new<String>(isolate, file),
|
|
compatibility_new<String>(isolate, fnc),
|
|
compatibility_new<Integer>(isolate, line),
|
|
to_v8_string(isolate, fmt, args)
|
|
};
|
|
|
|
auto o = js_eina_log_print_cb_data.handle();
|
|
v8::Function::Cast(*o)->Call(o->ToObject(), argc, argv);
|
|
}
|
|
|
|
static bool valid_level_conversion(int src, Eina_Log_Level &dst)
|
|
{
|
|
if (src != EINA_LOG_LEVEL_CRITICAL && src != EINA_LOG_LEVEL_ERR
|
|
&& src != EINA_LOG_LEVEL_WARN && src != EINA_LOG_LEVEL_INFO
|
|
&& src != EINA_LOG_LEVEL_DBG)
|
|
return false;
|
|
|
|
dst = static_cast<Eina_Log_Level>(src);
|
|
return true;
|
|
}
|
|
|
|
EAPI
|
|
void register_log_print(v8::Isolate *isolate, v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::String;
|
|
using v8::StackTrace;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto print = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 3 || !args[0]->IsNumber() || !args[1]->IsNumber()
|
|
|| !args[2]->IsString())
|
|
return compatibility_return();
|
|
|
|
Eina_Log_Level level;
|
|
if (!valid_level_conversion(args[1]->NumberValue(), level))
|
|
return compatibility_return();
|
|
|
|
auto frame = compatibility_current_stack_trace<>(args.GetIsolate(), 1,
|
|
StackTrace::kDetailed)->GetFrame(0);
|
|
|
|
eina_log_print(args[0]->NumberValue(), level,
|
|
*String::Utf8Value(frame->GetScriptNameOrSourceURL()),
|
|
*String::Utf8Value(frame->GetFunctionName()),
|
|
frame->GetLineNumber(), "%s",
|
|
*String::Utf8Value(args[2]));
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, print)
|
|
->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_domain_register(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::Local;
|
|
using v8::String;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 2 || !args[0]->IsString() || !args[1]->IsString())
|
|
return compatibility_return();
|
|
|
|
// We duplicate the color string as eina takes a const char* but does take care of
|
|
// its lifetime, assuming a ever lasting string.
|
|
const char *color = strdup(*String::Utf8Value(args[1]));
|
|
int d = eina_log_domain_register(*String::Utf8Value(args[0]),
|
|
color);
|
|
js_eina_log_color_map[d] = color;
|
|
|
|
auto isolate = args.GetIsolate();
|
|
return compatibility_return(value_cast<Local<Value>>(d, isolate), args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_domain_unregister(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsNumber())
|
|
return compatibility_return();
|
|
|
|
int domain = args[0]->NumberValue();
|
|
eina_log_domain_unregister(domain);
|
|
free((void*)js_eina_log_color_map[domain]);
|
|
js_eina_log_color_map.erase(domain);
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_domain_registered_level_get(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::Local;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsNumber())
|
|
return compatibility_return();
|
|
|
|
int l = eina_log_domain_registered_level_get(args[0]->NumberValue());
|
|
auto isolate = args.GetIsolate();
|
|
return compatibility_return(value_cast<Local<Value>>(l, isolate), args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_domain_registered_level_set(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 2 || !args[0]->IsNumber() || !args[1]->IsNumber())
|
|
return compatibility_return();
|
|
|
|
eina_log_domain_registered_level_set(args[0]->NumberValue(),
|
|
args[1]->NumberValue());
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_print_cb_set(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsFunction())
|
|
return compatibility_return();
|
|
|
|
js_eina_log_print_cb_data
|
|
= global_ref<v8::Value>(args.GetIsolate(), args[0]);
|
|
eina_log_print_cb_set(js_eina_log_print_cb, NULL);
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_level_set(v8::Isolate *isolate, v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsNumber())
|
|
return compatibility_return();
|
|
|
|
eina_log_level_set(args[0]->NumberValue());
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_level_get(v8::Isolate *isolate, v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
using v8::Integer;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 0)
|
|
return compatibility_return();
|
|
|
|
int l = eina_log_level_get();
|
|
auto ret = compatibility_new<Integer>(args.GetIsolate(), l);
|
|
return compatibility_return(ret, args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_level_check(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
using v8::Boolean;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsNumber())
|
|
return compatibility_return();
|
|
|
|
bool b = eina_log_level_check(args[0]->NumberValue());
|
|
auto ret = compatibility_new<Boolean>(args.GetIsolate(), b);
|
|
return compatibility_return(ret, args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_color_disable_set(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsBoolean())
|
|
return compatibility_return();
|
|
|
|
eina_log_color_disable_set(args[0]->BooleanValue());
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_color_disable_get(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::Boolean;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 0)
|
|
return compatibility_return();
|
|
|
|
bool b = eina_log_color_disable_get();
|
|
auto ret = compatibility_new<Boolean>(args.GetIsolate(), b);
|
|
return compatibility_return(ret, args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_file_disable_set(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsBoolean())
|
|
return compatibility_return();
|
|
|
|
eina_log_file_disable_set(args[0]->BooleanValue());
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_file_disable_get(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::Boolean;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 0)
|
|
return compatibility_return();
|
|
|
|
bool b = eina_log_file_disable_get();
|
|
auto ret = compatibility_new<Boolean>(args.GetIsolate(), b);
|
|
return compatibility_return(ret, args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_function_disable_set(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsBoolean())
|
|
return compatibility_return();
|
|
|
|
eina_log_function_disable_set(args[0]->BooleanValue());
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_function_disable_get(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::Boolean;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 0)
|
|
return compatibility_return();
|
|
|
|
bool b = eina_log_function_disable_get();
|
|
auto ret = compatibility_new<Boolean>(args.GetIsolate(), b);
|
|
return compatibility_return(ret, args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_abort_on_critical_set(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsBoolean())
|
|
return compatibility_return();
|
|
|
|
eina_log_abort_on_critical_set(args[0]->BooleanValue());
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_abort_on_critical_get(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::Boolean;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 0)
|
|
return compatibility_return();
|
|
|
|
bool b = eina_log_abort_on_critical_get();
|
|
auto ret = compatibility_new<Boolean>(args.GetIsolate(), b);
|
|
return compatibility_return(ret, args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_abort_on_critical_level_set(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsNumber())
|
|
return compatibility_return();
|
|
|
|
eina_log_abort_on_critical_level_set(args[0]->NumberValue());
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_abort_on_critical_level_get(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
using v8::Integer;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 0)
|
|
return compatibility_return();
|
|
|
|
int l = eina_log_abort_on_critical_level_get();
|
|
auto ret = compatibility_new<Integer>(args.GetIsolate(), l);
|
|
return compatibility_return(ret, args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_domain_level_set(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
using v8::String;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 2 || !args[0]->IsString() || !args[1]->IsNumber())
|
|
return compatibility_return();
|
|
|
|
eina_log_domain_level_set(*String::Utf8Value(args[0]),
|
|
args[1]->NumberValue());
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_domain_level_get(v8::Isolate *isolate,
|
|
v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
using v8::String;
|
|
using v8::Integer;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 1 || !args[0]->IsString())
|
|
return compatibility_return();
|
|
|
|
int l = eina_log_domain_level_get(*String::Utf8Value(args[0]));
|
|
auto ret = compatibility_new<Integer>(args.GetIsolate(), l);
|
|
return compatibility_return(ret, args);
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
EAPI
|
|
void register_log_timing(v8::Isolate *isolate, v8::Handle<v8::Object> global,
|
|
v8::Handle<v8::String> name)
|
|
{
|
|
using v8::Value;
|
|
using v8::FunctionTemplate;
|
|
using v8::String;
|
|
|
|
auto f = [](compatibility_callback_info_type args)
|
|
-> compatibility_return_type {
|
|
if (args.Length() != 3 || !args[0]->IsNumber() || !args[1]->IsNumber()
|
|
|| !args[2]->IsString()) {
|
|
return compatibility_return();
|
|
}
|
|
|
|
eina_log_timing(args[0]->NumberValue(),
|
|
static_cast<Eina_Log_State>(args[1]->NumberValue()),
|
|
*String::Utf8Value(args[2]));
|
|
return compatibility_return();
|
|
};
|
|
|
|
global->Set(name,
|
|
compatibility_new<FunctionTemplate>(isolate, f)->GetFunction());
|
|
}
|
|
|
|
static void register_constant(v8::Isolate *isolate, v8::Handle<v8::Object> global, int value, const char* name)
|
|
{
|
|
global->Set(compatibility_new<v8::String>(isolate, name), compatibility_new<v8::Integer>(isolate, value));
|
|
}
|
|
|
|
static void register_constant(v8::Isolate *isolate, v8::Handle<v8::Object> global, const char* value, const char* name)
|
|
{
|
|
global->Set(compatibility_new<v8::String>(isolate, name), compatibility_new<v8::String>(isolate, value));
|
|
}
|
|
|
|
EAPI void register_log_constants(v8::Isolate *isolate, v8::Handle<v8::Object> global)
|
|
{
|
|
register_constant(isolate, global, EINA_LOG_STATE_START, "LOG_STATE_START");
|
|
register_constant(isolate, global, EINA_LOG_STATE_START, "LOG_STATE_STOP");
|
|
|
|
register_constant(isolate, global, EINA_LOG_LEVEL_CRITICAL, "LOG_LEVEL_CRITICAL");
|
|
register_constant(isolate, global, EINA_LOG_LEVEL_ERR, "LOG_LEVEL_ERR");
|
|
register_constant(isolate, global, EINA_LOG_LEVEL_WARN, "LOG_LEVEL_WARN");
|
|
register_constant(isolate, global, EINA_LOG_LEVEL_INFO, "LOG_LEVEL_INFO");
|
|
register_constant(isolate, global, EINA_LOG_LEVEL_DBG, "LOG_LEVEL_DBG");
|
|
register_constant(isolate, global, EINA_LOG_LEVELS, "LOG_LEVELS");
|
|
register_constant(isolate, global, EINA_LOG_LEVEL_UNKNOWN, "LOG_LEVEL_UNKNOWN");
|
|
|
|
register_constant(isolate, global, EINA_LOG_DOMAIN_GLOBAL, "LOG_DOMAIN_GLOBAL");
|
|
|
|
register_constant(isolate, global, EINA_COLOR_LIGHTRED, "COLOR_LIGHTRED");
|
|
register_constant(isolate, global, EINA_COLOR_RED, "COLOR_RED");
|
|
register_constant(isolate, global, EINA_COLOR_LIGHTBLUE, "COLOR_LIGHTBLUE");
|
|
register_constant(isolate, global, EINA_COLOR_BLUE, "COLOR_BLUE");
|
|
register_constant(isolate, global, EINA_COLOR_GREEN, "COLOR_GREEN");
|
|
register_constant(isolate, global, EINA_COLOR_YELLOW, "COLOR_YELLOW");
|
|
register_constant(isolate, global, EINA_COLOR_ORANGE, "COLOR_ORANGE");
|
|
register_constant(isolate, global, EINA_COLOR_WHITE, "COLOR_WHITE");
|
|
register_constant(isolate, global, EINA_COLOR_LIGHTCYAN, "COLOR_LIGHTCYAN");
|
|
register_constant(isolate, global, EINA_COLOR_CYAN, "COLOR_CYAN");
|
|
register_constant(isolate, global, EINA_COLOR_RESET, "COLOR_RESET");
|
|
register_constant(isolate, global, EINA_COLOR_HIGH, "COLOR_HIGH");
|
|
}
|
|
|
|
|
|
#define REGISTER_LOG_HELPER(isolate, global, level, name) \
|
|
{ \
|
|
using v8::String; \
|
|
using v8::FunctionTemplate;\
|
|
using v8::StackTrace;\
|
|
\
|
|
auto wrapper = [](compatibility_callback_info_type args)\
|
|
-> compatibility_return_type {\
|
|
if (args.Length() != 1 || !args[0]->IsString()) {\
|
|
eina::js::compatibility_throw \
|
|
(args.GetIsolate(), v8::Exception::TypeError(\
|
|
eina::js::compatibility_new<v8::String>(args.GetIsolate(), "Message must be a string."))); \
|
|
return compatibility_return();\
|
|
} \
|
|
\
|
|
auto frame = compatibility_current_stack_trace<>(args.GetIsolate(), 1,\
|
|
StackTrace::kDetailed)->GetFrame(0);\
|
|
\
|
|
eina_log_print(EINA_LOG_DOMAIN_GLOBAL, level,\
|
|
*String::Utf8Value(frame->GetScriptNameOrSourceURL()),\
|
|
*String::Utf8Value(frame->GetFunctionName()),\
|
|
frame->GetLineNumber(), "%s",\
|
|
*String::Utf8Value(args[0]));\
|
|
\
|
|
return compatibility_return();\
|
|
};\
|
|
\
|
|
global->Set(compatibility_new<String>(isolate, name),\
|
|
compatibility_new<FunctionTemplate>(isolate, wrapper)->GetFunction());\
|
|
}
|
|
|
|
EAPI void register_log_helpers(v8::Isolate *isolate, v8::Handle<v8::Object> global)
|
|
{
|
|
REGISTER_LOG_HELPER(isolate, global, EINA_LOG_LEVEL_CRITICAL, "logCritical");
|
|
REGISTER_LOG_HELPER(isolate, global, EINA_LOG_LEVEL_ERR, "logError");
|
|
REGISTER_LOG_HELPER(isolate, global, EINA_LOG_LEVEL_WARN, "logWarning");
|
|
REGISTER_LOG_HELPER(isolate, global, EINA_LOG_LEVEL_INFO, "logInfo");
|
|
REGISTER_LOG_HELPER(isolate, global, EINA_LOG_LEVEL_DBG, "logDebug");
|
|
}
|
|
|
|
} } } // namespace efl { namespace js {
|
|
|
|
EAPI
|
|
void eina_log_register(v8::Handle<v8::Object> exports, v8::Isolate* isolate)
|
|
{
|
|
using efl::eina::js::compatibility_new;
|
|
|
|
efl::eina::js::register_log_domain_register(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "registerLogDomain"));
|
|
efl::eina::js::register_log_domain_unregister(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "unregisterLogDomain"));
|
|
efl::eina::js::register_log_domain_registered_level_set(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "setLogDomainRegisteredLevel"));
|
|
efl::eina::js::register_log_domain_registered_level_get(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "getLogDomainRegisteredLevel"));
|
|
|
|
efl::eina::js::register_log_print(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "logPrint"
|
|
));
|
|
efl::eina::js::register_log_print_cb_set(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "setLogPrintCb"
|
|
));
|
|
|
|
efl::eina::js::register_log_level_set(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "setLogLevel"
|
|
));
|
|
efl::eina::js::register_log_level_get(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "getLogLevel"
|
|
));
|
|
efl::eina::js::register_log_level_check(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "checkLogLevel"
|
|
));
|
|
|
|
efl::eina::js::register_log_color_disable_set(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "setLogColorDisable"
|
|
));
|
|
efl::eina::js::register_log_color_disable_get(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "getLogColorDisable"
|
|
));
|
|
|
|
efl::eina::js::register_log_file_disable_set(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "setLogFileDisable"
|
|
));
|
|
efl::eina::js::register_log_file_disable_get(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "getLogFileDisable"
|
|
));
|
|
|
|
efl::eina::js::register_log_function_disable_set(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "setLogFunctionDisable"
|
|
));
|
|
efl::eina::js::register_log_function_disable_get(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "getLogFunctionDisable"
|
|
));
|
|
|
|
efl::eina::js::register_log_abort_on_critical_set(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "setLogAbortOnCritical"
|
|
));
|
|
efl::eina::js::register_log_abort_on_critical_get(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "getLogAbortOnCritical"
|
|
));
|
|
efl::eina::js::register_log_abort_on_critical_level_set(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "setLogAbortOnCriticalLevel"
|
|
));
|
|
efl::eina::js::register_log_abort_on_critical_level_get(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "getLogAbortOnCriticalLevel"
|
|
));
|
|
|
|
efl::eina::js::register_log_domain_level_set(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "setLogDomainLevel"
|
|
));
|
|
efl::eina::js::register_log_domain_level_get(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "getLogDomainLevel"
|
|
));
|
|
|
|
efl::eina::js::register_log_timing(isolate, exports
|
|
, compatibility_new<v8::String>(isolate, "logTiming"));
|
|
|
|
efl::eina::js::register_log_constants(isolate, exports);
|
|
|
|
efl::eina::js::register_log_helpers(isolate, exports);
|
|
}
|