EAPI int
efl_model_init(void)
{
EFL_MODEL_ERROR_INCORRECT_VALUE = eina_error_msg_static_register(
EFL_MODEL_ERROR_INCORRECT_VALUE_STR);
EFL_MODEL_ERROR_UNKNOWN = eina_error_msg_static_register(
EFL_MODEL_ERROR_UNKNOWN_STR);
EFL_MODEL_ERROR_NOT_SUPPORTED = eina_error_msg_static_register(
EFL_MODEL_ERROR_NOT_SUPPORTED_STR);
EFL_MODEL_ERROR_NOT_FOUND = eina_error_msg_static_register(
EFL_MODEL_ERROR_NOT_FOUND_STR);
EFL_MODEL_ERROR_READ_ONLY = eina_error_msg_static_register(
EFL_MODEL_ERROR_READ_ONLY_STR);
EFL_MODEL_ERROR_INIT_FAILED = eina_error_msg_static_register(
EFL_MODEL_ERROR_INIT_FAILED_STR);
EFL_MODEL_ERROR_PERMISSION_DENIED = eina_error_msg_static_register(
EFL_MODEL_ERROR_PERMISSION_DENIED_STR);
EFL_MODEL_ERROR_INVALID_OBJECT = eina_error_msg_static_register(
EFL_MODEL_ERROR_INVALID_OBJECT_STR);
return EINA_TRUE;
}
int main(void)
{
void *data;
if (!eina_init())
{
printf ("Error during the initialization of eina_error module\n");
return EXIT_FAILURE;
}
MY_ERROR_NEGATIVE = eina_error_msg_static_register("Negative number");
MY_ERROR_NULL = eina_error_msg_static_register("NULL pointer");
data = data_new();
if (!data)
{
Eina_Error err;
err = eina_error_get();
if (err)
printf("Error during memory allocation: %s\n",
eina_error_msg_get(err));
}
if (!test(0))
{
Eina_Error err;
err = eina_error_get();
if (err)
printf("Error during test function: %s\n",
eina_error_msg_get(err));
}
if (!test(-1))
{
Eina_Error err;
err = eina_error_get();
if (err)
printf("Error during test function: %s\n",
eina_error_msg_get(err));
}
eina_shutdown();
return EXIT_SUCCESS;
}
/**
* @internal
* @brief Initialize the error module.
*
* @return #EINA_TRUE on success, #EINA_FALSE on failure.
*
* This function sets up the error module of Eina. It is called by
* eina_init().
*
* This function registers the error #EINA_ERROR_OUT_OF_MEMORY.
*
* @see eina_init()
*/
Eina_Bool eina_error_init(void)
{
/* TODO register the eina's basic errors */
EINA_ERROR_OUT_OF_MEMORY =
eina_error_msg_static_register(EINA_ERROR_OUT_OF_MEMORY_STR);
return EINA_TRUE;
}
/**
* @internal
* @brief Initialize the magic string module.
*
* @return #EINA_TRUE on success, #EINA_FALSE on failure.
*
* This function sets up the magic string module of Eina. It is called by
* eina_init().
*
* @see eina_init()
*/
Eina_Bool
eina_magic_string_init(void)
{
_eina_magic_string_log_dom = eina_log_domain_register
("eina_magic_string", EINA_LOG_COLOR_DEFAULT);
if (_eina_magic_string_log_dom < 0)
{
EINA_LOG_ERR("Could not register log domain: eina_magic_string");
return EINA_FALSE;
}
EINA_ERROR_MAGIC_FAILED = eina_error_msg_static_register(
EINA_ERROR_MAGIC_FAILED_STR);
return EINA_TRUE;
}
static void
azy_lib_register_errors_(void)
{
AZY_ERROR_REQUEST_JSON_OBJECT = eina_error_msg_static_register(AZY_ERROR_REQUEST_JSON_OBJECT_err);
AZY_ERROR_REQUEST_JSON_METHOD = eina_error_msg_static_register(AZY_ERROR_REQUEST_JSON_METHOD_err);
AZY_ERROR_REQUEST_JSON_PARAM = eina_error_msg_static_register(AZY_ERROR_REQUEST_JSON_PARAM_err);
AZY_ERROR_RESPONSE_JSON_OBJECT = eina_error_msg_static_register(AZY_ERROR_RESPONSE_JSON_OBJECT_err);
AZY_ERROR_RESPONSE_JSON_ERROR = eina_error_msg_static_register(AZY_ERROR_RESPONSE_JSON_ERROR_err);
AZY_ERROR_RESPONSE_JSON_NULL = eina_error_msg_static_register(AZY_ERROR_RESPONSE_JSON_NULL_err);
AZY_ERROR_RESPONSE_JSON_INVALID = eina_error_msg_static_register(AZY_ERROR_RESPONSE_JSON_INVALID_err);
#ifdef HAVE_XML
AZY_ERROR_REQUEST_XML_DOC = eina_error_msg_static_register(AZY_ERROR_REQUEST_XML_DOC_err);
AZY_ERROR_REQUEST_XML_ROOT = eina_error_msg_static_register(AZY_ERROR_REQUEST_XML_ROOT_err);
AZY_ERROR_REQUEST_XML_METHODNAME = eina_error_msg_static_register(AZY_ERROR_REQUEST_XML_METHODNAME_err);
AZY_ERROR_REQUEST_XML_PARAM = eina_error_msg_static_register(AZY_ERROR_REQUEST_XML_PARAM_err);
AZY_ERROR_RESPONSE_XML_DOC = eina_error_msg_static_register(AZY_ERROR_RESPONSE_XML_DOC_err);
AZY_ERROR_RESPONSE_XML_ROOT = eina_error_msg_static_register(AZY_ERROR_RESPONSE_XML_ROOT_err);
AZY_ERROR_RESPONSE_XML_RETVAL = eina_error_msg_static_register(AZY_ERROR_RESPONSE_XML_RETVAL_err);
AZY_ERROR_RESPONSE_XML_MULTI = eina_error_msg_static_register(AZY_ERROR_RESPONSE_XML_MULTI_err);
AZY_ERROR_RESPONSE_XML_FAULT = eina_error_msg_static_register(AZY_ERROR_RESPONSE_XML_FAULT_err);
AZY_ERROR_RESPONSE_XML_INVAL = eina_error_msg_static_register(AZY_ERROR_RESPONSE_XML_INVAL_err);
AZY_ERROR_XML_UNSERIAL = eina_error_msg_static_register(AZY_ERROR_XML_UNSERIAL_err);
#else
AZY_ERROR_XML_UNSUPPORTED = eina_error_msg_static_register(AZY_ERROR_XML_UNSUPPORTED_err);
#endif
}
/**
* @internal
* @brief Initialize the safety checks module.
*
* @return #EINA_TRUE on success, #EINA_FALSE on failure.
*
* This function sets up the safety checks module of Eina. It is
* called by eina_init().
*
* @see eina_init()
*/
Eina_Bool
eina_safety_checks_init(void)
{
EINA_ERROR_SAFETY_FAILED = eina_error_msg_static_register(EINA_ERROR_SAFETY_FAILED_STR);
return EINA_TRUE;
}
EAPI int
eina_init(void)
{
const struct eina_desc_setup *itr, *itr_end;
if (EINA_LIKELY(_eina_main_count > 0))
return ++_eina_main_count;
srand(time(NULL));
while (eina_seed == 0)
eina_seed = rand();
#ifdef MT
if ((getenv("EINA_MTRACE")) && (getenv("MALLOC_TRACE")))
{
_mt_enabled = 1;
mtrace();
}
#endif
if (!eina_log_init())
{
fprintf(stderr, "Could not initialize eina logging system.\n");
return 0;
}
_eina_log_dom = eina_log_domain_register("eina", EINA_LOG_COLOR_DEFAULT);
if (_eina_log_dom < 0)
{
EINA_LOG_ERR("Could not register log domain: eina");
eina_log_shutdown();
return 0;
}
EINA_ERROR_NOT_MAIN_LOOP = eina_error_msg_static_register(
EINA_ERROR_NOT_MAIN_LOOP_STR);
#ifdef EFL_HAVE_THREADS
# ifdef _WIN32
_eina_main_loop = GetCurrentThreadId();
# else
_eina_main_loop = pthread_self();
# endif
_eina_pid = getpid();
#endif
#ifdef EINA_HAVE_DEBUG_THREADS
pthread_mutex_init(&_eina_tracking_lock, NULL);
if (getenv("EINA_DEBUG_THREADS"))
_eina_threads_debug = atoi(getenv("EINA_DEBUG_THREADS"));
#endif
itr = _eina_desc_setup;
itr_end = itr + _eina_desc_setup_len;
for (; itr < itr_end; itr++)
{
if (!itr->init())
{
ERR("Could not initialize eina module '%s'.", itr->name);
_eina_shutdown_from_desc(itr);
return 0;
}
}
eina_cpu_count_internal();
_eina_main_count = 1;
return 1;
}
Eina_Bool
eina_mempool_init(void)
{
char *path;
_eina_mempool_log_dom = eina_log_domain_register("eina_mempool",
EINA_LOG_COLOR_DEFAULT);
if (_eina_mempool_log_dom < 0)
{
EINA_LOG_ERR("Could not register log domain: eina_mempool");
return 0;
}
EINA_ERROR_NOT_MEMPOOL_MODULE = eina_error_msg_static_register(
EINA_ERROR_NOT_MEMPOOL_MODULE_STR);
_backends = eina_hash_string_superfast_new(NULL);
/* dynamic backends */
_modules = eina_module_arch_list_get(NULL,
PACKAGE_LIB_DIR "/eina/modules/mp",
MODULE_ARCH);
path = eina_module_environment_path_get("HOME", "/.eina/mp/modules/mp");
_modules = eina_module_arch_list_get(_modules, path, MODULE_ARCH);
if (path)
free(path);
path = eina_module_environment_path_get("EINA_MODULES_MEMPOOL_DIR",
"/eina/modules/mp");
_modules = eina_module_arch_list_get(_modules, path, MODULE_ARCH);
if (path)
free(path);
path = eina_module_symbol_path_get((const void *)eina_init,
"/eina/modules/mp");
_modules = eina_module_arch_list_get(_modules, path, MODULE_ARCH);
if (path)
free(path);
if (!_modules)
{
ERR("no mempool modules able to be loaded.");
eina_hash_free(_backends);
goto mempool_init_error;
}
eina_module_list_load(_modules);
/* builtin backends */
#ifdef EINA_STATIC_BUILD_BUDDY
buddy_init();
#endif
#ifdef EINA_STATIC_BUILD_CHAINED_POOL
chained_init();
#endif
#ifdef EINA_STATIC_BUILD_EMEMOA_FIXED
ememoa_fixed_init();
#endif
#ifdef EINA_STATIC_BUILD_EMEMOA_UNKNOWN
ememoa_unknown_init();
#endif
#ifdef EINA_STATIC_BUILD_FIXED_BITMAP
fixed_bitmap_init();
#endif
#ifdef EINA_STATIC_BUILD_ONE_BIG
one_big_init();
#endif
#ifdef EINA_STATIC_BUILD_PASS_THROUGH
pass_through_init();
#endif
return EINA_TRUE;
mempool_init_error:
eina_log_domain_unregister(_eina_mempool_log_dom);
_eina_mempool_log_dom = -1;
return EINA_FALSE;
}
