aboutsummaryrefslogtreecommitdiffstats
path: root/src/bindings/eina_js/eina_js_log.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/bindings/eina_js/eina_js_log.cc')
-rw-r--r--src/bindings/eina_js/eina_js_log.cc742
1 files changed, 742 insertions, 0 deletions
diff --git a/src/bindings/eina_js/eina_js_log.cc b/src/bindings/eina_js/eina_js_log.cc
new file mode 100644
index 0000000000..415a827d1f
--- /dev/null
+++ b/src/bindings/eina_js/eina_js_log.cc
@@ -0,0 +1,742 @@
+#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, std::string> 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.
+ std::string color = *String::Utf8Value(args[1]);
+ int d = eina_log_domain_register(*String::Utf8Value(args[0]),
+ color.c_str());
+ 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);
+ 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);
+}