2009-08-24 14:43:48 -07:00
|
|
|
/* EINA - EFL data type library
|
|
|
|
* Copyright (C) 2007-2009 Jorge Luis Zapata Muga, Cedric Bail, Andre Dieb
|
|
|
|
* Martins
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library;
|
|
|
|
* if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
2013-01-10 12:25:26 -08:00
|
|
|
#include <unistd.h>
|
2009-10-28 05:48:04 -07:00
|
|
|
#include <fnmatch.h>
|
2010-01-28 02:03:31 -08:00
|
|
|
#include <assert.h>
|
2010-10-07 15:14:03 -07:00
|
|
|
#include <errno.h>
|
2010-01-28 02:03:31 -08:00
|
|
|
|
2012-04-18 17:23:06 -07:00
|
|
|
#if defined HAVE_EXECINFO_H && defined HAVE_BACKTRACE && defined HAVE_BACKTRACE_SYMBOLS
|
|
|
|
# include <execinfo.h>
|
|
|
|
# define EINA_LOG_BACKTRACE
|
2012-04-18 02:21:39 -07:00
|
|
|
#endif
|
|
|
|
|
2013-03-16 02:46:45 -07:00
|
|
|
#ifdef HAVE_SYSTEMD
|
|
|
|
# include <systemd/sd-journal.h>
|
|
|
|
#endif
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
#ifdef HAVE_EVIL
|
|
|
|
# include <Evil.h>
|
|
|
|
#endif
|
|
|
|
|
2009-08-28 05:03:34 -07:00
|
|
|
#include "eina_config.h"
|
2009-08-24 14:43:48 -07:00
|
|
|
#include "eina_private.h"
|
2009-09-06 15:21:56 -07:00
|
|
|
#include "eina_inlist.h"
|
2012-12-31 08:14:40 -08:00
|
|
|
#include "eina_lock.h"
|
|
|
|
#include "eina_thread.h"
|
2013-03-16 02:46:45 -07:00
|
|
|
#include "eina_convert.h"
|
|
|
|
#include "eina_strbuf.h"
|
2009-09-06 15:21:56 -07:00
|
|
|
|
|
|
|
/* undefs EINA_ARG_NONULL() so NULL checks are not compiled out! */
|
2009-08-24 14:43:48 -07:00
|
|
|
#include "eina_safety_checks.h"
|
2009-08-28 05:03:34 -07:00
|
|
|
#include "eina_log.h"
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
#include "eina_inline_private.h"
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
/* TODO
|
|
|
|
* + printing logs to stdout or stderr can be implemented
|
|
|
|
* using a queue, useful for multiple threads printing
|
|
|
|
* + add a wrapper for assert?
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*============================================================================*
|
2010-07-27 19:37:05 -07:00
|
|
|
* Local *
|
|
|
|
*============================================================================*/
|
2009-08-24 14:43:48 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @cond LOCAL
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define EINA_LOG_ENV_ABORT "EINA_LOG_ABORT"
|
2009-11-13 09:52:43 -08:00
|
|
|
#define EINA_LOG_ENV_ABORT_LEVEL "EINA_LOG_ABORT_LEVEL"
|
2009-08-24 14:43:48 -07:00
|
|
|
#define EINA_LOG_ENV_LEVEL "EINA_LOG_LEVEL"
|
|
|
|
#define EINA_LOG_ENV_LEVELS "EINA_LOG_LEVELS"
|
2009-10-28 05:48:04 -07:00
|
|
|
#define EINA_LOG_ENV_LEVELS_GLOB "EINA_LOG_LEVELS_GLOB"
|
2009-08-24 14:43:48 -07:00
|
|
|
#define EINA_LOG_ENV_COLOR_DISABLE "EINA_LOG_COLOR_DISABLE"
|
2009-09-04 16:45:16 -07:00
|
|
|
#define EINA_LOG_ENV_FILE_DISABLE "EINA_LOG_FILE_DISABLE"
|
|
|
|
#define EINA_LOG_ENV_FUNCTION_DISABLE "EINA_LOG_FUNCTION_DISABLE"
|
2012-04-18 17:23:06 -07:00
|
|
|
#define EINA_LOG_ENV_BACKTRACE "EINA_LOG_BACKTRACE"
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-08-24 14:43:48 -07:00
|
|
|
|
|
|
|
// Structure for storing domain level settings passed from the command line
|
|
|
|
// that will be matched with application-defined domains.
|
|
|
|
typedef struct _Eina_Log_Domain_Level_Pending Eina_Log_Domain_Level_Pending;
|
|
|
|
struct _Eina_Log_Domain_Level_Pending
|
|
|
|
{
|
|
|
|
EINA_INLIST;
|
|
|
|
unsigned int level;
|
2010-03-22 23:41:17 -07:00
|
|
|
size_t namelen;
|
2009-08-24 14:43:48 -07:00
|
|
|
char name[];
|
|
|
|
};
|
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
typedef struct _Eina_Log_Timing Eina_Log_Timing;
|
|
|
|
struct _Eina_Log_Timing
|
|
|
|
{
|
|
|
|
const char *phase;
|
|
|
|
Eina_Nano_Time start;
|
|
|
|
Eina_Log_State state;
|
|
|
|
};
|
|
|
|
|
2013-03-28 19:44:48 -07:00
|
|
|
EAPI const char *_eina_log_state_init = "init";
|
|
|
|
EAPI const char *_eina_log_state_shutdown = "shutdown";
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
/*
|
|
|
|
* List of levels for domains set by the user before the domains are registered,
|
|
|
|
* updates the domain levels on the first log and clears itself.
|
|
|
|
*/
|
|
|
|
static Eina_Inlist *_pending_list = NULL;
|
2009-10-28 05:48:04 -07:00
|
|
|
static Eina_Inlist *_glob_list = NULL;
|
2009-08-24 14:43:48 -07:00
|
|
|
|
|
|
|
// Disable color flag (can be changed through the env var
|
|
|
|
// EINA_LOG_ENV_COLOR_DISABLE).
|
|
|
|
static Eina_Bool _disable_color = EINA_FALSE;
|
2009-09-04 16:45:16 -07:00
|
|
|
static Eina_Bool _disable_file = EINA_FALSE;
|
|
|
|
static Eina_Bool _disable_function = EINA_FALSE;
|
2009-09-02 16:28:00 -07:00
|
|
|
static Eina_Bool _abort_on_critical = EINA_FALSE;
|
2013-03-27 05:39:55 -07:00
|
|
|
static Eina_Bool _disable_timing = EINA_TRUE;
|
2009-11-13 09:52:43 -08:00
|
|
|
static int _abort_level_on_critical = EINA_LOG_LEVEL_CRITICAL;
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2012-04-18 17:23:06 -07:00
|
|
|
#ifdef EINA_LOG_BACKTRACE
|
|
|
|
static int _backtrace_level = -1;
|
2012-04-19 05:49:16 -07:00
|
|
|
#endif
|
2012-04-18 17:23:06 -07:00
|
|
|
|
2009-09-02 18:31:26 -07:00
|
|
|
static Eina_Bool _threads_enabled = EINA_FALSE;
|
2010-10-07 15:14:03 -07:00
|
|
|
static Eina_Bool _threads_inited = EINA_FALSE;
|
2009-09-14 09:06:18 -07:00
|
|
|
|
2012-12-31 08:14:40 -08:00
|
|
|
static Eina_Thread _main_thread;
|
2010-07-13 06:51:00 -07:00
|
|
|
|
2012-12-31 08:14:40 -08:00
|
|
|
# define SELF() eina_thread_self()
|
|
|
|
# define IS_MAIN(t) eina_thread_equal(t, _main_thread)
|
2010-07-13 06:51:00 -07:00
|
|
|
# define IS_OTHER(t) EINA_UNLIKELY(!IS_MAIN(t))
|
2010-08-21 22:47:44 -07:00
|
|
|
# define CHECK_MAIN(...) \
|
|
|
|
do { \
|
2012-12-31 08:14:40 -08:00
|
|
|
if (!IS_MAIN(eina_thread_self())) { \
|
2010-08-21 22:47:44 -07:00
|
|
|
fprintf(stderr, \
|
|
|
|
"ERR: not main thread! current=%lu, main=%lu\n", \
|
2012-12-31 08:14:40 -08:00
|
|
|
(unsigned long)eina_thread_self(), \
|
2010-08-21 22:47:44 -07:00
|
|
|
(unsigned long)_main_thread); \
|
|
|
|
return __VA_ARGS__; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
2009-09-14 09:06:18 -07:00
|
|
|
|
2013-10-10 01:24:34 -07:00
|
|
|
static Eina_Spinlock _log_mutex;
|
|
|
|
# define LOG_LOCK() if(_threads_enabled) {eina_spinlock_take(&_log_mutex); }
|
|
|
|
# define LOG_UNLOCK() if(_threads_enabled) {eina_spinlock_release(&_log_mutex); }
|
|
|
|
# define INIT() eina_spinlock_new(&_log_mutex)
|
|
|
|
# define SHUTDOWN() eina_spinlock_free(&_log_mutex)
|
2009-09-02 18:31:26 -07:00
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
// List of domains registered
|
|
|
|
static Eina_Log_Domain *_log_domains = NULL;
|
2013-03-27 05:39:55 -07:00
|
|
|
static Eina_Log_Timing *_log_timing = NULL;
|
2010-02-08 18:13:55 -08:00
|
|
|
static unsigned int _log_domains_count = 0;
|
2010-03-22 23:41:17 -07:00
|
|
|
static size_t _log_domains_allocated = 0;
|
2009-08-24 14:43:48 -07:00
|
|
|
|
|
|
|
// Default function for printing on domains
|
2009-09-02 16:28:00 -07:00
|
|
|
static Eina_Log_Print_Cb _print_cb = eina_log_print_cb_stderr;
|
2009-08-24 14:43:48 -07:00
|
|
|
static void *_print_cb_data = NULL;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
static Eina_Log_Level _log_level = EINA_LOG_LEVEL_DBG;
|
|
|
|
#elif DEBUG_CRITICAL
|
|
|
|
static Eina_Log_Level _log_level = EINA_LOG_LEVEL_CRITICAL;
|
|
|
|
#else
|
|
|
|
static Eina_Log_Level _log_level = EINA_LOG_LEVEL_ERR;
|
|
|
|
#endif
|
|
|
|
|
2010-02-08 17:43:58 -08:00
|
|
|
/* NOTE: if you change this, also change:
|
|
|
|
* eina_log_print_level_name_get()
|
|
|
|
* eina_log_print_level_name_color_get()
|
|
|
|
*/
|
2009-09-02 17:07:25 -07:00
|
|
|
static const char *_names[] = {
|
2010-07-27 19:37:05 -07:00
|
|
|
"CRI",
|
|
|
|
"ERR",
|
|
|
|
"WRN",
|
|
|
|
"INF",
|
|
|
|
"DBG",
|
2009-09-02 17:07:25 -07:00
|
|
|
};
|
|
|
|
|
2010-03-26 01:08:52 -07:00
|
|
|
#ifdef _WIN32
|
2012-08-01 08:34:13 -07:00
|
|
|
/* TODO: query win32_def_attr on eina_log_init() */
|
|
|
|
static int win32_def_attr = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
|
|
|
|
|
|
|
|
/* NOTE: can't use eina_log from inside this function */
|
2010-03-26 01:08:52 -07:00
|
|
|
static int
|
2012-08-01 08:34:13 -07:00
|
|
|
eina_log_win32_color_convert(const char *color, const char **endptr)
|
2010-03-26 01:08:52 -07:00
|
|
|
{
|
2012-08-01 08:34:13 -07:00
|
|
|
const char *p;
|
|
|
|
int attr = 0;
|
|
|
|
|
|
|
|
if (endptr) *endptr = color;
|
|
|
|
|
|
|
|
if (color[0] != '\033') return 0;
|
|
|
|
if (color[1] != '[') return 0;
|
2010-03-26 01:08:52 -07:00
|
|
|
|
2012-08-01 08:34:13 -07:00
|
|
|
p = color + 2;
|
|
|
|
while (1)
|
2010-03-26 01:08:52 -07:00
|
|
|
{
|
2012-08-01 08:34:13 -07:00
|
|
|
char *end;
|
|
|
|
int code = strtol(p, &end, 10);
|
|
|
|
|
|
|
|
if (p == end)
|
2010-07-27 19:37:05 -07:00
|
|
|
{
|
2012-08-01 08:34:13 -07:00
|
|
|
//fputs("empty color string\n", stderr);
|
|
|
|
if (endptr) *endptr = end;
|
|
|
|
attr = 0; /* assume it was not color, must end with 'm' */
|
|
|
|
break;
|
2010-07-27 19:37:05 -07:00
|
|
|
}
|
|
|
|
|
2012-08-01 08:34:13 -07:00
|
|
|
if (code)
|
|
|
|
{
|
|
|
|
if (code == 0) attr = win32_def_attr;
|
|
|
|
else if (code == 1) attr |= FOREGROUND_INTENSITY;
|
|
|
|
else if (code == 4) attr |= COMMON_LVB_UNDERSCORE;
|
|
|
|
else if (code == 7) attr |= COMMON_LVB_REVERSE_VIDEO;
|
|
|
|
else if ((code >= 30) && (code <= 37))
|
|
|
|
{
|
|
|
|
/* clear foreground */
|
|
|
|
attr &= ~(FOREGROUND_RED |
|
|
|
|
FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
|
|
|
|
if (code == 31)
|
|
|
|
attr |= FOREGROUND_RED;
|
|
|
|
else if (code == 32)
|
|
|
|
attr |= FOREGROUND_GREEN;
|
|
|
|
else if (code == 33)
|
|
|
|
attr |= FOREGROUND_RED | FOREGROUND_GREEN;
|
|
|
|
else if (code == 34)
|
|
|
|
attr |= FOREGROUND_BLUE;
|
|
|
|
else if (code == 35)
|
|
|
|
attr |= FOREGROUND_RED | FOREGROUND_BLUE;
|
|
|
|
else if (code == 36)
|
|
|
|
attr |= FOREGROUND_GREEN | FOREGROUND_BLUE;
|
|
|
|
else if (code == 37)
|
|
|
|
attr |= FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
|
|
|
|
}
|
|
|
|
else if ((code >= 40) && (code <= 47))
|
|
|
|
{
|
|
|
|
/* clear background */
|
|
|
|
attr &= ~(BACKGROUND_RED |
|
|
|
|
BACKGROUND_GREEN |
|
|
|
|
BACKGROUND_BLUE);
|
|
|
|
|
|
|
|
if (code == 41)
|
|
|
|
attr |= BACKGROUND_RED;
|
|
|
|
else if (code == 42)
|
|
|
|
attr |= BACKGROUND_GREEN;
|
2012-10-04 02:31:46 -07:00
|
|
|
else if (code == 43)
|
2012-08-01 08:34:13 -07:00
|
|
|
attr |= BACKGROUND_RED | BACKGROUND_GREEN;
|
|
|
|
else if (code == 44)
|
|
|
|
attr |= BACKGROUND_BLUE;
|
|
|
|
else if (code == 45)
|
|
|
|
attr |= BACKGROUND_RED | BACKGROUND_BLUE;
|
|
|
|
else if (code == 46)
|
|
|
|
attr |= BACKGROUND_GREEN | BACKGROUND_BLUE;
|
|
|
|
else if (code == 47)
|
|
|
|
attr |= BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE;
|
|
|
|
}
|
|
|
|
}
|
2010-03-26 01:08:52 -07:00
|
|
|
|
2012-08-01 08:34:13 -07:00
|
|
|
if (*end == 'm')
|
|
|
|
{
|
|
|
|
if (endptr) *endptr = end + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if (*end == ';')
|
|
|
|
p = end + 1;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//fprintf(stderr, "unexpected char in color string: %s\n", end);
|
|
|
|
attr = 0; /* assume it was not color */
|
|
|
|
if (endptr) *endptr = end;
|
|
|
|
break;
|
|
|
|
}
|
2010-03-26 01:08:52 -07:00
|
|
|
}
|
|
|
|
|
2012-08-01 08:34:13 -07:00
|
|
|
return attr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
eina_log_win32_color_get(const char *color)
|
|
|
|
{
|
|
|
|
return eina_log_win32_color_convert(color, NULL);
|
2010-03-26 01:08:52 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-10-06 00:09:05 -07:00
|
|
|
static inline unsigned int
|
|
|
|
eina_log_pid_get(void)
|
|
|
|
{
|
|
|
|
return (unsigned int)getpid();
|
|
|
|
}
|
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
static inline void
|
|
|
|
eina_log_print_level_name_get(int level, const char **p_name)
|
|
|
|
{
|
|
|
|
static char buf[4];
|
2010-02-08 17:43:58 -08:00
|
|
|
/* NOTE: if you change this, also change
|
|
|
|
* eina_log_print_level_name_color_get()
|
|
|
|
* eina_log_level_name_get() (at eina_inline_log.x)
|
|
|
|
*/
|
2009-09-04 16:45:16 -07:00
|
|
|
if (EINA_UNLIKELY(level < 0))
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%03d", level);
|
|
|
|
*p_name = buf;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-02-08 17:43:58 -08:00
|
|
|
else if (EINA_UNLIKELY(level >= EINA_LOG_LEVELS))
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%03d", level);
|
|
|
|
*p_name = buf;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
else
|
2010-07-27 19:37:05 -07:00
|
|
|
*p_name = _names[level];
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
2010-03-26 01:08:52 -07:00
|
|
|
#ifdef _WIN32
|
|
|
|
static inline void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_level_name_color_get(int level,
|
|
|
|
const char **p_name,
|
|
|
|
int *p_color)
|
2010-03-26 01:08:52 -07:00
|
|
|
{
|
|
|
|
static char buf[4];
|
|
|
|
/* NOTE: if you change this, also change:
|
|
|
|
* eina_log_print_level_name_get()
|
|
|
|
*/
|
|
|
|
if (EINA_UNLIKELY(level < 0))
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%03d", level);
|
|
|
|
*p_name = buf;
|
2010-03-26 01:08:52 -07:00
|
|
|
}
|
|
|
|
else if (EINA_UNLIKELY(level >= EINA_LOG_LEVELS))
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%03d", level);
|
|
|
|
*p_name = buf;
|
2010-03-26 01:08:52 -07:00
|
|
|
}
|
|
|
|
else
|
2010-07-27 19:37:05 -07:00
|
|
|
*p_name = _names[level];
|
2010-03-26 01:08:52 -07:00
|
|
|
|
|
|
|
*p_color = eina_log_win32_color_get(eina_log_level_color_get(level));
|
|
|
|
}
|
|
|
|
#else
|
2009-09-04 16:45:16 -07:00
|
|
|
static inline void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_level_name_color_get(int level,
|
|
|
|
const char **p_name,
|
|
|
|
const char **p_color)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
|
|
|
static char buf[4];
|
2010-02-08 17:43:58 -08:00
|
|
|
/* NOTE: if you change this, also change:
|
|
|
|
* eina_log_print_level_name_get()
|
|
|
|
*/
|
2009-09-04 16:45:16 -07:00
|
|
|
if (EINA_UNLIKELY(level < 0))
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%03d", level);
|
|
|
|
*p_name = buf;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-02-08 17:43:58 -08:00
|
|
|
else if (EINA_UNLIKELY(level >= EINA_LOG_LEVELS))
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
snprintf(buf, sizeof(buf), "%03d", level);
|
|
|
|
*p_name = buf;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
else
|
2010-07-27 19:37:05 -07:00
|
|
|
*p_name = _names[level];
|
|
|
|
|
2010-02-08 17:43:58 -08:00
|
|
|
*p_color = eina_log_level_color_get(level);
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-03-26 01:08:52 -07:00
|
|
|
#endif
|
2009-09-04 16:45:16 -07:00
|
|
|
|
2010-07-27 19:37:05 -07:00
|
|
|
#define DECLARE_LEVEL_NAME(level) const char *name; \
|
|
|
|
eina_log_print_level_name_get(level, &name)
|
2010-03-26 01:08:52 -07:00
|
|
|
#ifdef _WIN32
|
2010-07-27 19:37:05 -07:00
|
|
|
# define DECLARE_LEVEL_NAME_COLOR(level) const char *name; int color; \
|
|
|
|
eina_log_print_level_name_color_get(level, &name, &color)
|
2010-03-26 01:08:52 -07:00
|
|
|
#else
|
2010-07-27 19:37:05 -07:00
|
|
|
# define DECLARE_LEVEL_NAME_COLOR(level) const char *name, *color; \
|
|
|
|
eina_log_print_level_name_color_get(level, &name, &color)
|
2010-03-26 01:08:52 -07:00
|
|
|
#endif
|
2009-09-04 16:45:16 -07:00
|
|
|
|
|
|
|
/** No threads, No color */
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_NOthreads_NOcolor_file_func(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
|
|
|
DECLARE_LEVEL_NAME(level);
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s<%u>:%s %s:%d %s() ", name, eina_log_pid_get(),
|
|
|
|
d->domain_str, file, line, fnc);
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_NOthreads_NOcolor_NOfile_func(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
2012-10-05 13:09:47 -07:00
|
|
|
const char *file EINA_UNUSED,
|
2010-07-27 19:37:05 -07:00
|
|
|
const char *fnc,
|
2012-10-05 13:09:47 -07:00
|
|
|
int line EINA_UNUSED)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
|
|
|
DECLARE_LEVEL_NAME(level);
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s<%u>:%s %s() ", name, eina_log_pid_get(), d->domain_str,
|
|
|
|
fnc);
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_NOthreads_NOcolor_file_NOfunc(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
2012-10-05 13:09:47 -07:00
|
|
|
const char *fnc EINA_UNUSED,
|
2010-07-27 19:37:05 -07:00
|
|
|
int line)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
|
|
|
DECLARE_LEVEL_NAME(level);
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s<%u>:%s %s:%d ", name, eina_log_pid_get(), d->domain_str,
|
|
|
|
file, line);
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* No threads, color */
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_NOthreads_color_file_func(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
|
|
|
DECLARE_LEVEL_NAME_COLOR(level);
|
2014-07-13 01:59:40 -07:00
|
|
|
#ifdef _WIN32
|
2010-03-26 01:08:52 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
color);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, "%s", name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, ":");
|
2010-07-27 19:37:05 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
eina_log_win32_color_get(d->domain_str));
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, "%s", d->name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, " %s:%d ", file, line);
|
2010-07-27 19:37:05 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_INTENSITY | FOREGROUND_RED |
|
|
|
|
FOREGROUND_GREEN | FOREGROUND_BLUE);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, "%s()", fnc);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, " ");
|
|
|
|
#else
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s%s<%u>" EINA_COLOR_RESET ":%s %s:%d "
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_COLOR_HIGH "%s()" EINA_COLOR_RESET " ",
|
2010-10-06 00:09:05 -07:00
|
|
|
color, name, eina_log_pid_get(), d->domain_str, file, line, fnc);
|
2010-03-26 01:08:52 -07:00
|
|
|
#endif
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_NOthreads_color_NOfile_func(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
2012-10-05 13:09:47 -07:00
|
|
|
const char *file EINA_UNUSED,
|
2010-07-27 19:37:05 -07:00
|
|
|
const char *fnc,
|
2012-10-05 13:09:47 -07:00
|
|
|
int line EINA_UNUSED)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
|
|
|
DECLARE_LEVEL_NAME_COLOR(level);
|
2014-07-13 01:59:40 -07:00
|
|
|
#ifdef _WIN32
|
2010-03-26 01:08:52 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
color);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, "%s", name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, ":");
|
2010-07-27 19:37:05 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
eina_log_win32_color_get(d->domain_str));
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, "%s", d->name);
|
2010-07-27 19:37:05 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_INTENSITY | FOREGROUND_RED |
|
|
|
|
FOREGROUND_GREEN | FOREGROUND_BLUE);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, "%s()", fnc);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, " ");
|
|
|
|
#else
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s%s<%u>" EINA_COLOR_RESET ":%s "
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_COLOR_HIGH "%s()" EINA_COLOR_RESET " ",
|
2010-10-06 00:09:05 -07:00
|
|
|
color, name, eina_log_pid_get(), d->domain_str, fnc);
|
2010-03-26 01:08:52 -07:00
|
|
|
#endif
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_NOthreads_color_file_NOfunc(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
2012-10-05 13:09:47 -07:00
|
|
|
const char *fnc EINA_UNUSED,
|
2010-07-27 19:37:05 -07:00
|
|
|
int line)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
|
|
|
DECLARE_LEVEL_NAME_COLOR(level);
|
2014-07-13 01:59:40 -07:00
|
|
|
#ifdef _WIN32
|
2010-03-26 01:08:52 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
color);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, "%s", name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, ":");
|
2010-07-27 19:37:05 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
eina_log_win32_color_get(d->domain_str));
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, "%s", d->name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
2010-07-27 19:37:05 -07:00
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
|
2010-03-26 01:08:52 -07:00
|
|
|
fprintf(fp, " %s:%d ", file, line);
|
|
|
|
#else
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s%s<%u>" EINA_COLOR_RESET ":%s %s:%d ",
|
|
|
|
color, name, eina_log_pid_get(), d->domain_str, file, line);
|
2010-03-26 01:08:52 -07:00
|
|
|
#endif
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/** threads, No color */
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_threads_NOcolor_file_func(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
2012-12-31 08:14:40 -08:00
|
|
|
Eina_Thread cur;
|
2010-05-28 11:57:19 -07:00
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
DECLARE_LEVEL_NAME(level);
|
2010-07-13 06:51:00 -07:00
|
|
|
cur = SELF();
|
2009-09-04 16:45:16 -07:00
|
|
|
if (IS_OTHER(cur))
|
|
|
|
{
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s<%u>:%s[T:%lu] %s:%d %s() ",
|
|
|
|
name, eina_log_pid_get(), d->domain_str,
|
|
|
|
(unsigned long)cur, file, line, fnc);
|
2010-07-27 19:37:05 -07:00
|
|
|
return;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s<%u>:%s %s:%d %s() ",
|
|
|
|
name, eina_log_pid_get(), d->domain_str, file, line, fnc);
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_threads_NOcolor_NOfile_func(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
2012-10-05 13:09:47 -07:00
|
|
|
const char *file EINA_UNUSED,
|
2010-07-27 19:37:05 -07:00
|
|
|
const char *fnc,
|
2012-10-05 13:09:47 -07:00
|
|
|
int line EINA_UNUSED)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
2012-12-31 08:14:40 -08:00
|
|
|
Eina_Thread cur;
|
2010-05-28 11:57:19 -07:00
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
DECLARE_LEVEL_NAME(level);
|
2010-07-13 06:51:00 -07:00
|
|
|
cur = SELF();
|
2009-09-04 16:45:16 -07:00
|
|
|
if (IS_OTHER(cur))
|
|
|
|
{
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s<%u>:%s[T:%lu] %s() ",
|
|
|
|
name, eina_log_pid_get(), d->domain_str,
|
|
|
|
(unsigned long)cur, fnc);
|
2010-07-27 19:37:05 -07:00
|
|
|
return;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s<%u>:%s %s() ",
|
|
|
|
name, eina_log_pid_get(), d->domain_str, fnc);
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_threads_NOcolor_file_NOfunc(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
2012-10-05 13:09:47 -07:00
|
|
|
const char *fnc EINA_UNUSED,
|
2010-07-27 19:37:05 -07:00
|
|
|
int line)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
2012-12-31 08:14:40 -08:00
|
|
|
Eina_Thread cur;
|
2010-05-28 11:57:19 -07:00
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
DECLARE_LEVEL_NAME(level);
|
2010-07-13 06:51:00 -07:00
|
|
|
cur = SELF();
|
2009-09-04 16:45:16 -07:00
|
|
|
if (IS_OTHER(cur))
|
|
|
|
{
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s<%u>:%s[T:%lu] %s:%d ",
|
|
|
|
name, eina_log_pid_get(), d->domain_str, (unsigned long)cur,
|
|
|
|
file, line);
|
2010-07-27 19:37:05 -07:00
|
|
|
return;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-10-06 00:09:05 -07:00
|
|
|
|
|
|
|
fprintf(fp, "%s<%u>:%s %s:%d ",
|
|
|
|
name, eina_log_pid_get(), d->domain_str, file, line);
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* threads, color */
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_threads_color_file_func(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
2012-12-31 08:14:40 -08:00
|
|
|
Eina_Thread cur;
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
DECLARE_LEVEL_NAME_COLOR(level);
|
2010-07-13 06:51:00 -07:00
|
|
|
cur = SELF();
|
2009-09-04 16:45:16 -07:00
|
|
|
if (IS_OTHER(cur))
|
|
|
|
{
|
2010-03-26 01:08:52 -07:00
|
|
|
# ifdef _WIN32
|
2010-07-27 19:37:05 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
|
|
|
color);
|
|
|
|
fprintf(fp, "%s", name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, ":");
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
eina_log_win32_color_get(d->domain_str));
|
|
|
|
fprintf(fp, "%s[T:", d->name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "[T:");
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_GREEN | FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "%lu", (unsigned long)cur);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "] %s:%d ", file, line);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_INTENSITY | FOREGROUND_RED |
|
|
|
|
FOREGROUND_GREEN | FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "%s()", fnc);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, " ");
|
2010-03-26 01:08:52 -07:00
|
|
|
# else
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s%s<%u>" EINA_COLOR_RESET ":%s[T:"
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_COLOR_ORANGE "%lu" EINA_COLOR_RESET "] %s:%d "
|
|
|
|
EINA_COLOR_HIGH "%s()" EINA_COLOR_RESET " ",
|
2010-10-06 00:09:05 -07:00
|
|
|
color, name, eina_log_pid_get() ,d->domain_str,
|
|
|
|
(unsigned long)cur, file, line, fnc);
|
2010-03-26 01:08:52 -07:00
|
|
|
# endif
|
2010-07-27 19:37:05 -07:00
|
|
|
return;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-03-26 01:08:52 -07:00
|
|
|
# ifdef _WIN32
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_NOthreads_color_file_func(fp,
|
|
|
|
d,
|
|
|
|
level,
|
|
|
|
file,
|
|
|
|
fnc,
|
|
|
|
line);
|
2010-03-26 01:08:52 -07:00
|
|
|
# else
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s%s<%u>" EINA_COLOR_RESET ":%s %s:%d "
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_COLOR_HIGH "%s()" EINA_COLOR_RESET " ",
|
2010-10-06 00:09:05 -07:00
|
|
|
color, name, eina_log_pid_get(), d->domain_str, file, line, fnc);
|
2010-03-26 01:08:52 -07:00
|
|
|
# endif
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_threads_color_NOfile_func(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
2012-10-05 13:09:47 -07:00
|
|
|
const char *file EINA_UNUSED,
|
2010-07-27 19:37:05 -07:00
|
|
|
const char *fnc,
|
2012-10-05 13:09:47 -07:00
|
|
|
int line EINA_UNUSED)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
2012-12-31 08:14:40 -08:00
|
|
|
Eina_Thread cur;
|
2010-05-28 11:57:19 -07:00
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
DECLARE_LEVEL_NAME_COLOR(level);
|
2010-07-13 06:51:00 -07:00
|
|
|
cur = SELF();
|
2009-09-04 16:45:16 -07:00
|
|
|
if (IS_OTHER(cur))
|
|
|
|
{
|
2010-03-26 01:08:52 -07:00
|
|
|
# ifdef _WIN32
|
2010-07-27 19:37:05 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
|
|
|
color);
|
|
|
|
fprintf(fp, "%s", name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, ":");
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
eina_log_win32_color_get(d->domain_str));
|
|
|
|
fprintf(fp, "%s[T:", d->name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "[T:");
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_GREEN | FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "%lu", (unsigned long)cur);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_INTENSITY | FOREGROUND_RED |
|
|
|
|
FOREGROUND_GREEN | FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "%s()", fnc);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, " ");
|
2010-03-26 01:08:52 -07:00
|
|
|
# else
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s%s<%u>" EINA_COLOR_RESET ":%s[T:"
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_COLOR_ORANGE "%lu" EINA_COLOR_RESET "] "
|
|
|
|
EINA_COLOR_HIGH "%s()" EINA_COLOR_RESET " ",
|
2010-10-06 00:09:05 -07:00
|
|
|
color, name, eina_log_pid_get(), d->domain_str,
|
|
|
|
(unsigned long)cur, fnc);
|
2010-03-26 01:08:52 -07:00
|
|
|
# endif
|
2010-07-27 19:37:05 -07:00
|
|
|
return;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-03-26 01:08:52 -07:00
|
|
|
# ifdef _WIN32
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_NOthreads_color_NOfile_func(fp,
|
|
|
|
d,
|
|
|
|
level,
|
|
|
|
file,
|
|
|
|
fnc,
|
|
|
|
line);
|
2010-03-26 01:08:52 -07:00
|
|
|
# else
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s%s<%u>" EINA_COLOR_RESET ":%s "
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_COLOR_HIGH "%s()" EINA_COLOR_RESET " ",
|
2010-10-06 00:09:05 -07:00
|
|
|
color, name, eina_log_pid_get(), d->domain_str, fnc);
|
2010-03-26 01:08:52 -07:00
|
|
|
# endif
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_threads_color_file_NOfunc(FILE *fp,
|
|
|
|
const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
2012-10-05 13:09:47 -07:00
|
|
|
const char *fnc EINA_UNUSED,
|
2010-07-27 19:37:05 -07:00
|
|
|
int line)
|
2009-09-04 16:45:16 -07:00
|
|
|
{
|
2012-12-31 08:14:40 -08:00
|
|
|
Eina_Thread cur;
|
2010-05-28 11:57:19 -07:00
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
DECLARE_LEVEL_NAME_COLOR(level);
|
2010-07-13 06:51:00 -07:00
|
|
|
cur = SELF();
|
2009-09-04 16:45:16 -07:00
|
|
|
if (IS_OTHER(cur))
|
|
|
|
{
|
2010-03-26 01:08:52 -07:00
|
|
|
# ifdef _WIN32
|
2010-07-27 19:37:05 -07:00
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
|
|
|
color);
|
|
|
|
fprintf(fp, "%s", name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, ":");
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
eina_log_win32_color_get(d->domain_str));
|
|
|
|
fprintf(fp, "%s[T:", d->name);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "[T:");
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_GREEN | FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "%lu", (unsigned long)cur);
|
|
|
|
SetConsoleTextAttribute(GetStdHandle(
|
|
|
|
STD_OUTPUT_HANDLE),
|
|
|
|
FOREGROUND_RED | FOREGROUND_GREEN |
|
|
|
|
FOREGROUND_BLUE);
|
|
|
|
fprintf(fp, "] %s:%d ", file, line);
|
2010-03-26 01:08:52 -07:00
|
|
|
# else
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(fp, "%s%s<%u>" EINA_COLOR_RESET ":%s[T:"
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_COLOR_ORANGE "%lu" EINA_COLOR_RESET "] %s:%d ",
|
2010-10-06 00:09:05 -07:00
|
|
|
color, name, eina_log_pid_get(), d->domain_str,
|
|
|
|
(unsigned long)cur, file, line);
|
2010-03-26 01:08:52 -07:00
|
|
|
# endif
|
2010-07-27 19:37:05 -07:00
|
|
|
return;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-03-26 01:08:52 -07:00
|
|
|
# ifdef _WIN32
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_prefix_NOthreads_color_file_NOfunc(fp,
|
|
|
|
d,
|
|
|
|
level,
|
|
|
|
file,
|
|
|
|
fnc,
|
|
|
|
line);
|
2010-03-26 01:08:52 -07:00
|
|
|
# else
|
2010-07-27 19:37:05 -07:00
|
|
|
fprintf(fp, "%s%s" EINA_COLOR_RESET ":%s %s:%d ",
|
|
|
|
color, name, d->domain_str, file, line);
|
2010-03-26 01:08:52 -07:00
|
|
|
# endif
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
2010-07-27 19:37:05 -07:00
|
|
|
static void (*_eina_log_print_prefix)(FILE *fp, const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level, const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line) =
|
|
|
|
eina_log_print_prefix_NOthreads_color_file_func;
|
2009-09-04 16:45:16 -07:00
|
|
|
|
|
|
|
static inline void
|
|
|
|
eina_log_print_prefix_update(void)
|
|
|
|
{
|
|
|
|
if (_disable_file && _disable_function)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
fprintf(stderr, "ERROR: cannot have " EINA_LOG_ENV_FILE_DISABLE " and "
|
|
|
|
EINA_LOG_ENV_FUNCTION_DISABLE " set at the same time, will "
|
|
|
|
"just disable function.\n");
|
|
|
|
_disable_file = 0;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#define S(NOthread, NOcolor, NOfile, NOfunc) \
|
2010-07-27 19:37:05 -07:00
|
|
|
_eina_log_print_prefix = \
|
|
|
|
eina_log_print_prefix_ ## NOthread ## threads_ ## NOcolor ## color_ ## \
|
|
|
|
NOfile \
|
|
|
|
## file_ ## NOfunc ## func
|
2009-09-04 16:45:16 -07:00
|
|
|
|
|
|
|
if (_threads_enabled)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
if (_disable_color)
|
|
|
|
{
|
|
|
|
if (_disable_file)
|
|
|
|
S(,NO,NO,);
|
|
|
|
else if (_disable_function)
|
|
|
|
S(,NO,,NO);
|
|
|
|
else
|
|
|
|
S(,NO,,);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (_disable_file)
|
|
|
|
S(,,NO,);
|
|
|
|
else if (_disable_function)
|
|
|
|
S(,,,NO);
|
|
|
|
else
|
|
|
|
S(,,,);
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
if (_disable_color)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
if (_disable_file)
|
|
|
|
S(NO,NO,NO,);
|
|
|
|
else if (_disable_function)
|
|
|
|
S(NO,NO,,NO);
|
|
|
|
else
|
|
|
|
S(NO,NO,,);
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
if (_disable_file)
|
|
|
|
S(NO,,NO,);
|
|
|
|
else if (_disable_function)
|
|
|
|
S(NO,,,NO);
|
|
|
|
else
|
|
|
|
S(NO,,,);
|
2009-09-04 16:45:16 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
#undef S
|
|
|
|
}
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
/*
|
|
|
|
* Creates a colored domain name string.
|
|
|
|
*/
|
|
|
|
static const char *
|
|
|
|
eina_log_domain_str_get(const char *name, const char *color)
|
|
|
|
{
|
|
|
|
const char *d;
|
|
|
|
|
|
|
|
if (color)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
size_t name_len;
|
|
|
|
size_t color_len;
|
|
|
|
|
|
|
|
name_len = strlen(name);
|
|
|
|
color_len = strlen(color);
|
|
|
|
d =
|
|
|
|
malloc(sizeof(char) *
|
|
|
|
(color_len + name_len + strlen(EINA_COLOR_RESET) + 1));
|
|
|
|
if (!d)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
memcpy((char *)d, color, color_len);
|
|
|
|
memcpy((char *)(d + color_len), name, name_len);
|
|
|
|
memcpy((char *)(d + color_len + name_len), EINA_COLOR_RESET,
|
|
|
|
strlen(EINA_COLOR_RESET));
|
|
|
|
((char *)d)[color_len + name_len + strlen(EINA_COLOR_RESET)] = '\0';
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
else
|
2010-07-27 19:37:05 -07:00
|
|
|
d = strdup(name);
|
2009-08-24 14:43:48 -07:00
|
|
|
|
|
|
|
return d;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Setups a new logging domain to the name and color specified. Note that this
|
|
|
|
* constructor acts upon an pre-allocated object.
|
|
|
|
*/
|
|
|
|
static Eina_Log_Domain *
|
2013-03-27 05:39:55 -07:00
|
|
|
eina_log_domain_new(Eina_Log_Domain *d, Eina_Log_Timing *t,
|
|
|
|
const char *name, const char *color)
|
2009-08-24 14:43:48 -07:00
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(d, NULL);
|
2009-08-24 14:43:48 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(name, NULL);
|
|
|
|
|
|
|
|
d->level = EINA_LOG_LEVEL_UNKNOWN;
|
2014-02-25 19:59:41 -08:00
|
|
|
d->color = color;
|
2009-08-24 14:43:48 -07:00
|
|
|
d->deleted = EINA_FALSE;
|
|
|
|
|
2011-01-13 19:29:58 -08:00
|
|
|
if ((color) && (!_disable_color))
|
|
|
|
d->domain_str = eina_log_domain_str_get(name, color);
|
2009-08-24 14:43:48 -07:00
|
|
|
else
|
2011-01-13 19:29:58 -08:00
|
|
|
d->domain_str = eina_log_domain_str_get(name, NULL);
|
|
|
|
|
|
|
|
d->name = strdup(name);
|
|
|
|
d->namelen = strlen(name);
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
t->phase = NULL;
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
return d;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Frees internal strings of a log domain, keeping the log domain itself as a
|
|
|
|
* slot for next domain registers.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
eina_log_domain_free(Eina_Log_Domain *d)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(d);
|
|
|
|
|
|
|
|
if (d->domain_str)
|
|
|
|
free((char *)d->domain_str);
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
if (d->name)
|
|
|
|
free((char *)d->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parses domain levels passed through the env var.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
eina_log_domain_parse_pendings(void)
|
|
|
|
{
|
|
|
|
const char *start;
|
|
|
|
|
2010-07-27 19:37:05 -07:00
|
|
|
if (!(start = getenv(EINA_LOG_ENV_LEVELS)))
|
|
|
|
return;
|
2009-08-24 14:43:48 -07:00
|
|
|
|
|
|
|
// name1:level1,name2:level2,name3:level3,...
|
|
|
|
while (1)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
Eina_Log_Domain_Level_Pending *p;
|
|
|
|
char *end = NULL;
|
|
|
|
char *tmp = NULL;
|
|
|
|
long int level;
|
|
|
|
|
|
|
|
end = strchr(start, ':');
|
|
|
|
if (!end)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Parse level, keep going if failed
|
|
|
|
level = strtol((char *)(end + 1), &tmp, 10);
|
|
|
|
if (tmp == (end + 1))
|
|
|
|
goto parse_end;
|
|
|
|
|
|
|
|
// Parse name
|
|
|
|
p = malloc(sizeof(Eina_Log_Domain_Level_Pending) + end - start + 1);
|
|
|
|
if (!p)
|
|
|
|
break;
|
|
|
|
|
|
|
|
p->namelen = end - start;
|
|
|
|
memcpy((char *)p->name, start, end - start);
|
|
|
|
((char *)p->name)[end - start] = '\0';
|
|
|
|
p->level = level;
|
|
|
|
|
|
|
|
_pending_list = eina_inlist_append(_pending_list, EINA_INLIST_GET(p));
|
|
|
|
|
|
|
|
parse_end:
|
|
|
|
start = strchr(tmp, ',');
|
|
|
|
if (start)
|
|
|
|
start++;
|
|
|
|
else
|
|
|
|
break;
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-28 05:48:04 -07:00
|
|
|
static void
|
|
|
|
eina_log_domain_parse_pending_globs(void)
|
|
|
|
{
|
|
|
|
const char *start;
|
|
|
|
|
2010-07-27 19:37:05 -07:00
|
|
|
if (!(start = getenv(EINA_LOG_ENV_LEVELS_GLOB)))
|
|
|
|
return;
|
2009-10-28 05:48:04 -07:00
|
|
|
|
|
|
|
// name1:level1,name2:level2,name3:level3,...
|
|
|
|
while (1)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
Eina_Log_Domain_Level_Pending *p;
|
|
|
|
char *end = NULL;
|
|
|
|
char *tmp = NULL;
|
|
|
|
long int level;
|
|
|
|
|
|
|
|
end = strchr(start, ':');
|
|
|
|
if (!end)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Parse level, keep going if failed
|
|
|
|
level = strtol((char *)(end + 1), &tmp, 10);
|
|
|
|
if (tmp == (end + 1))
|
|
|
|
goto parse_end;
|
|
|
|
|
|
|
|
// Parse name
|
|
|
|
p = malloc(sizeof(Eina_Log_Domain_Level_Pending) + end - start + 1);
|
|
|
|
if (!p)
|
|
|
|
break;
|
|
|
|
|
|
|
|
p->namelen = 0; /* not that useful */
|
|
|
|
memcpy((char *)p->name, start, end - start);
|
|
|
|
((char *)p->name)[end - start] = '\0';
|
|
|
|
p->level = level;
|
|
|
|
|
|
|
|
_glob_list = eina_inlist_append(_glob_list, EINA_INLIST_GET(p));
|
|
|
|
|
|
|
|
parse_end:
|
|
|
|
start = strchr(tmp, ',');
|
|
|
|
if (start)
|
|
|
|
start++;
|
|
|
|
else
|
|
|
|
break;
|
2009-10-28 05:48:04 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-27 00:45:30 -08:00
|
|
|
static inline int
|
|
|
|
eina_log_domain_register_unlocked(const char *name, const char *color)
|
|
|
|
{
|
|
|
|
Eina_Log_Domain_Level_Pending *pending = NULL;
|
2010-03-22 23:41:17 -07:00
|
|
|
size_t namelen;
|
|
|
|
unsigned int i;
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2009-12-27 00:45:30 -08:00
|
|
|
for (i = 0; i < _log_domains_count; i++)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
if (_log_domains[i].deleted)
|
|
|
|
{
|
|
|
|
// Found a flagged slot, free domain_str and replace slot
|
2013-03-27 05:39:55 -07:00
|
|
|
eina_log_domain_new(&_log_domains[i], &_log_timing[i], name, color);
|
2010-07-27 19:37:05 -07:00
|
|
|
goto finish_register;
|
|
|
|
}
|
2009-12-27 00:45:30 -08:00
|
|
|
}
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2009-12-27 00:45:30 -08:00
|
|
|
if (_log_domains_count >= _log_domains_allocated)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
Eina_Log_Domain *tmp;
|
2013-03-27 05:39:55 -07:00
|
|
|
Eina_Log_Timing *tim;
|
2010-07-27 19:37:05 -07:00
|
|
|
size_t size;
|
|
|
|
|
|
|
|
if (!_log_domains)
|
|
|
|
// special case for init, eina itself will allocate a dozen of domains
|
|
|
|
size = 24;
|
|
|
|
else
|
|
|
|
// grow 8 buckets to minimize reallocs
|
|
|
|
size = _log_domains_allocated + 8;
|
|
|
|
|
|
|
|
tmp = realloc(_log_domains, sizeof(Eina_Log_Domain) * size);
|
2013-03-27 05:39:55 -07:00
|
|
|
tim = realloc(_log_timing, sizeof (Eina_Log_Timing) * size);
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
if (tmp && tim)
|
2010-07-27 19:37:05 -07:00
|
|
|
{
|
|
|
|
// Success!
|
|
|
|
_log_domains = tmp;
|
2013-03-27 05:39:55 -07:00
|
|
|
_log_timing = tim;
|
2010-07-27 19:37:05 -07:00
|
|
|
_log_domains_allocated = size;
|
|
|
|
}
|
|
|
|
else
|
2013-03-27 05:39:55 -07:00
|
|
|
{
|
|
|
|
free(tmp);
|
|
|
|
free(tim);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-12-27 00:45:30 -08:00
|
|
|
}
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2009-12-27 00:45:30 -08:00
|
|
|
// Use an allocated slot
|
2013-03-27 05:39:55 -07:00
|
|
|
eina_log_domain_new(&_log_domains[i], &_log_timing[i], name, color);
|
2009-12-27 00:45:30 -08:00
|
|
|
_log_domains_count++;
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2009-12-27 00:45:30 -08:00
|
|
|
finish_register:
|
2010-02-08 18:13:55 -08:00
|
|
|
namelen = _log_domains[i].namelen;
|
2009-12-27 00:45:30 -08:00
|
|
|
|
|
|
|
EINA_INLIST_FOREACH(_pending_list, pending)
|
2010-07-27 19:37:05 -07:00
|
|
|
{
|
|
|
|
if ((namelen == pending->namelen) && (strcmp(pending->name, name) == 0))
|
|
|
|
{
|
|
|
|
_log_domains[i].level = pending->level;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-12-27 00:45:30 -08:00
|
|
|
|
2010-02-08 17:47:52 -08:00
|
|
|
if (_log_domains[i].level == EINA_LOG_LEVEL_UNKNOWN)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_INLIST_FOREACH(_glob_list, pending)
|
|
|
|
{
|
|
|
|
if (!fnmatch(pending->name, name, 0))
|
|
|
|
{
|
|
|
|
_log_domains[i].level = pending->level;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-02-08 17:47:52 -08:00
|
|
|
}
|
|
|
|
|
2009-12-27 00:45:30 -08:00
|
|
|
// Check if level is still UNKNOWN, set it to global
|
|
|
|
if (_log_domains[i].level == EINA_LOG_LEVEL_UNKNOWN)
|
|
|
|
_log_domains[i].level = _log_level;
|
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
eina_log_timing(i, EINA_LOG_STATE_START, EINA_LOG_STATE_INIT);
|
|
|
|
|
2009-12-27 00:45:30 -08:00
|
|
|
return i;
|
|
|
|
}
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2010-02-08 09:53:22 -08:00
|
|
|
static inline Eina_Bool
|
|
|
|
eina_log_term_color_supported(const char *term)
|
|
|
|
{
|
|
|
|
const char *tail;
|
2013-06-08 12:06:08 -07:00
|
|
|
size_t len;
|
2010-02-08 09:53:22 -08:00
|
|
|
|
|
|
|
if (!term)
|
2010-07-27 19:37:05 -07:00
|
|
|
return EINA_FALSE;
|
2010-02-08 09:53:22 -08:00
|
|
|
|
2013-06-09 06:36:58 -07:00
|
|
|
len = strlen(term);
|
2010-02-08 09:53:22 -08:00
|
|
|
tail = term + 1;
|
|
|
|
switch (term[0])
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
/* list of known to support color terminals,
|
|
|
|
* take from gentoo's portage.
|
|
|
|
*/
|
2010-02-08 09:53:22 -08:00
|
|
|
|
2013-06-08 12:06:08 -07:00
|
|
|
case 'x': /* xterm and xterm-(256)color */
|
2010-07-27 19:37:05 -07:00
|
|
|
return ((strncmp(tail, "term", sizeof("term") - 1) == 0) &&
|
|
|
|
((tail[sizeof("term") - 1] == '\0') ||
|
2013-06-08 12:06:08 -07:00
|
|
|
(strcmp(term + len - sizeof("color") + 1, "color") == 0)));
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-02-08 09:53:22 -08:00
|
|
|
case 'E': /* Eterm */
|
|
|
|
case 'a': /* aterm */
|
|
|
|
case 'k': /* kterm */
|
2010-07-27 19:37:05 -07:00
|
|
|
return (strcmp(tail, "term") == 0);
|
|
|
|
|
2010-02-08 09:53:22 -08:00
|
|
|
case 'r': /* xrvt or rxvt-unicode */
|
2010-07-27 19:37:05 -07:00
|
|
|
return ((strncmp(tail, "xvt", sizeof("xvt") - 1) == 0) &&
|
|
|
|
((tail[sizeof("xvt") - 1] == '\0') ||
|
|
|
|
(strcmp(tail + sizeof("xvt") - 1, "-unicode") == 0)));
|
|
|
|
|
2010-02-08 09:53:22 -08:00
|
|
|
case 's': /* screen */
|
2013-06-09 06:36:58 -07:00
|
|
|
return ((strncmp(tail, "creen", sizeof("creen") - 1) == 0) &&
|
|
|
|
((tail[sizeof("creen") - 1] == '\0') ||
|
|
|
|
(strcmp(term + len - sizeof("color") + 1, "color") == 0)));
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-02-08 09:53:22 -08:00
|
|
|
case 'g': /* gnome */
|
2010-07-27 19:37:05 -07:00
|
|
|
return (strcmp(tail, "nome") == 0);
|
|
|
|
|
2010-02-08 09:53:22 -08:00
|
|
|
case 'i': /* interix */
|
2010-07-27 19:37:05 -07:00
|
|
|
return (strcmp(tail, "nterix") == 0);
|
|
|
|
|
2010-02-08 09:53:22 -08:00
|
|
|
default:
|
2010-07-27 19:37:05 -07:00
|
|
|
return EINA_FALSE;
|
2010-02-08 09:53:22 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-08 10:41:05 -07:00
|
|
|
static inline void
|
|
|
|
eina_log_domain_unregister_unlocked(int domain)
|
|
|
|
{
|
|
|
|
Eina_Log_Domain *d;
|
|
|
|
|
|
|
|
if ((unsigned int)domain >= _log_domains_count)
|
|
|
|
return;
|
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
eina_log_timing(domain, EINA_LOG_STATE_STOP, EINA_LOG_STATE_SHUTDOWN);
|
|
|
|
|
2010-09-08 10:41:05 -07:00
|
|
|
d = &_log_domains[domain];
|
|
|
|
eina_log_domain_free(d);
|
|
|
|
d->deleted = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
eina_log_print_unlocked(int domain,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line,
|
|
|
|
const char *fmt,
|
|
|
|
va_list args)
|
|
|
|
{
|
|
|
|
Eina_Log_Domain *d;
|
|
|
|
|
|
|
|
#ifdef EINA_SAFETY_CHECKS
|
|
|
|
if (EINA_UNLIKELY((unsigned int)domain >= _log_domains_count) ||
|
|
|
|
EINA_UNLIKELY(domain < 0))
|
|
|
|
{
|
|
|
|
if (file && fnc && fmt)
|
|
|
|
fprintf(
|
|
|
|
stderr,
|
|
|
|
"CRI: %s:%d %s() eina_log_print() unknown domain %d, original message format '%s'\n",
|
|
|
|
file,
|
|
|
|
line,
|
|
|
|
fnc,
|
|
|
|
domain,
|
|
|
|
fmt);
|
|
|
|
else
|
|
|
|
fprintf(
|
|
|
|
stderr,
|
|
|
|
"CRI: eina_log_print() unknown domain %d, original message format '%s'\n",
|
|
|
|
domain,
|
|
|
|
fmt ? fmt : "");
|
|
|
|
|
|
|
|
if (_abort_on_critical)
|
|
|
|
abort();
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
d = _log_domains + domain;
|
|
|
|
#ifdef EINA_SAFETY_CHECKS
|
|
|
|
if (EINA_UNLIKELY(d->deleted))
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
"ERR: eina_log_print() domain %d is deleted\n",
|
|
|
|
domain);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (level > d->level)
|
|
|
|
return;
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
{
|
|
|
|
char *wfmt;
|
|
|
|
char *tmp;
|
|
|
|
|
|
|
|
wfmt = strdup(fmt);
|
|
|
|
if (!wfmt)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "ERR: %s: can not allocate memory\n", __FUNCTION__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = wfmt;
|
2010-11-29 15:14:35 -08:00
|
|
|
while (strchr(tmp, '%'))
|
2010-09-08 10:41:05 -07:00
|
|
|
{
|
|
|
|
tmp++;
|
|
|
|
if (*tmp == 'z')
|
|
|
|
*tmp = 'I';
|
|
|
|
}
|
|
|
|
_print_cb(d, level, file, fnc, line, wfmt, _print_cb_data, args);
|
|
|
|
free(wfmt);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
_print_cb(d, level, file, fnc, line, fmt, _print_cb_data, args);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (EINA_UNLIKELY(_abort_on_critical) &&
|
|
|
|
EINA_UNLIKELY(level <= _abort_level_on_critical))
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2011-12-05 05:58:09 -08:00
|
|
|
#endif
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
/**
|
|
|
|
* @endcond
|
|
|
|
*/
|
|
|
|
|
2009-12-27 00:45:30 -08:00
|
|
|
|
|
|
|
/*============================================================================*
|
2010-07-27 19:37:05 -07:00
|
|
|
* Global *
|
|
|
|
*============================================================================*/
|
2009-12-27 00:45:30 -08:00
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
/**
|
2009-09-06 15:21:56 -07:00
|
|
|
* @internal
|
2009-08-24 14:43:48 -07:00
|
|
|
* @brief Initialize the log module.
|
|
|
|
*
|
2009-09-06 15:21:56 -07:00
|
|
|
* @return #EINA_TRUE on success, #EINA_FALSE on failure.
|
2009-08-24 14:43:48 -07:00
|
|
|
*
|
|
|
|
* This function sets up the log module of Eina. It is called by
|
2009-09-06 15:21:56 -07:00
|
|
|
* eina_init().
|
2009-09-02 16:28:00 -07:00
|
|
|
*
|
2009-08-24 14:43:48 -07:00
|
|
|
* @see eina_init()
|
2009-09-02 18:31:26 -07:00
|
|
|
*
|
|
|
|
* @warning Not-MT: just call this function from main thread! The
|
|
|
|
* place where this function was called the first time is
|
|
|
|
* considered the main thread.
|
2009-08-24 14:43:48 -07:00
|
|
|
*/
|
2009-09-06 15:21:56 -07:00
|
|
|
Eina_Bool
|
2009-08-24 14:43:48 -07:00
|
|
|
eina_log_init(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-09-03 17:53:19 -07:00
|
|
|
const char *level, *tmp;
|
2010-02-08 09:53:22 -08:00
|
|
|
int color_disable;
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2010-07-27 19:37:05 -07:00
|
|
|
assert((sizeof(_names) / sizeof(_names[0])) == EINA_LOG_LEVELS);
|
2009-09-02 17:07:25 -07:00
|
|
|
|
2012-04-19 05:49:16 -07:00
|
|
|
#ifdef EINA_LOG_BACKTRACE
|
2012-04-18 17:23:06 -07:00
|
|
|
if ((tmp = getenv(EINA_LOG_ENV_BACKTRACE)))
|
|
|
|
_backtrace_level = atoi(tmp);
|
2012-04-19 05:49:16 -07:00
|
|
|
#endif
|
2012-04-18 17:23:06 -07:00
|
|
|
|
2010-02-08 09:53:22 -08:00
|
|
|
if ((tmp = getenv(EINA_LOG_ENV_COLOR_DISABLE)))
|
2010-07-27 19:37:05 -07:00
|
|
|
color_disable = atoi(tmp);
|
2010-02-08 09:53:22 -08:00
|
|
|
else
|
2010-07-27 19:37:05 -07:00
|
|
|
color_disable = -1;
|
2010-02-08 09:53:22 -08:00
|
|
|
|
|
|
|
/* Check if color is explicitly disabled */
|
|
|
|
if (color_disable == 1)
|
2010-07-27 19:37:05 -07:00
|
|
|
_disable_color = EINA_TRUE;
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2010-03-26 01:08:52 -07:00
|
|
|
#ifndef _WIN32
|
2010-02-08 09:53:22 -08:00
|
|
|
/* color was not explicitly disabled or enabled, guess it */
|
|
|
|
else if (color_disable == -1)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
if (!eina_log_term_color_supported(getenv("TERM")))
|
|
|
|
_disable_color = EINA_TRUE;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* if not a terminal, but redirected to a file, disable color */
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (_print_cb == eina_log_print_cb_stderr)
|
|
|
|
fd = STDERR_FILENO;
|
|
|
|
else if (_print_cb == eina_log_print_cb_stdout)
|
|
|
|
fd = STDOUT_FILENO;
|
|
|
|
else
|
|
|
|
fd = -1;
|
|
|
|
|
|
|
|
if ((fd >= 0) && (!isatty(fd)))
|
|
|
|
_disable_color = EINA_TRUE;
|
|
|
|
}
|
2010-02-08 09:53:22 -08:00
|
|
|
}
|
2010-03-26 01:08:52 -07:00
|
|
|
#endif
|
2010-02-08 09:53:22 -08:00
|
|
|
|
2013-03-16 02:46:45 -07:00
|
|
|
#ifdef HAVE_SYSTEMD
|
|
|
|
if (getenv("NOTIFY_SOCKET"))
|
|
|
|
_print_cb = eina_log_print_cb_journald;
|
|
|
|
#endif
|
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
if (getenv("EINA_LOG_TIMING"))
|
|
|
|
_disable_timing = EINA_FALSE;
|
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
if ((tmp = getenv(EINA_LOG_ENV_FILE_DISABLE)) && (atoi(tmp) == 1))
|
2010-07-27 19:37:05 -07:00
|
|
|
_disable_file = EINA_TRUE;
|
2009-09-04 16:45:16 -07:00
|
|
|
|
|
|
|
if ((tmp = getenv(EINA_LOG_ENV_FUNCTION_DISABLE)) && (atoi(tmp) == 1))
|
2010-07-27 19:37:05 -07:00
|
|
|
_disable_function = EINA_TRUE;
|
2009-09-04 16:45:16 -07:00
|
|
|
|
2009-09-02 16:28:00 -07:00
|
|
|
if ((tmp = getenv(EINA_LOG_ENV_ABORT)) && (atoi(tmp) == 1))
|
2010-07-27 19:37:05 -07:00
|
|
|
_abort_on_critical = EINA_TRUE;
|
2009-09-02 16:28:00 -07:00
|
|
|
|
2009-11-13 09:52:43 -08:00
|
|
|
if ((tmp = getenv(EINA_LOG_ENV_ABORT_LEVEL)))
|
2010-07-27 19:37:05 -07:00
|
|
|
_abort_level_on_critical = atoi(tmp);
|
2009-11-13 09:52:43 -08:00
|
|
|
|
2009-09-04 16:45:16 -07:00
|
|
|
eina_log_print_prefix_update();
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
// Global log level
|
|
|
|
if ((level = getenv(EINA_LOG_ENV_LEVEL)))
|
|
|
|
_log_level = atoi(level);
|
2013-03-16 02:46:45 -07:00
|
|
|
#ifdef HAVE_SYSTEMD
|
|
|
|
else if (getenv("NOTIFY_SOCKET") && (_print_cb == eina_log_print_cb_journald))
|
|
|
|
_log_level = EINA_LOG_LEVEL_INFO;
|
|
|
|
#endif
|
2009-08-24 14:43:48 -07:00
|
|
|
|
|
|
|
// Register UNKNOWN domain, the default logger
|
|
|
|
EINA_LOG_DOMAIN_GLOBAL = eina_log_domain_register("", NULL);
|
|
|
|
|
|
|
|
if (EINA_LOG_DOMAIN_GLOBAL < 0)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
fprintf(stderr, "Failed to create global logging domain.\n");
|
|
|
|
return EINA_FALSE;
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
|
2009-10-28 05:48:04 -07:00
|
|
|
// Parse pending domains passed through EINA_LOG_LEVELS_GLOB
|
|
|
|
eina_log_domain_parse_pending_globs();
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
// Parse pending domains passed through EINA_LOG_LEVELS
|
|
|
|
eina_log_domain_parse_pendings();
|
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
eina_log_timing(EINA_LOG_DOMAIN_GLOBAL,
|
|
|
|
EINA_LOG_STATE_STOP,
|
|
|
|
EINA_LOG_STATE_INIT);
|
|
|
|
|
2011-12-05 05:58:09 -08:00
|
|
|
#endif
|
2009-09-06 15:21:56 -07:00
|
|
|
return EINA_TRUE;
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-09-06 15:21:56 -07:00
|
|
|
* @internal
|
2009-08-24 14:43:48 -07:00
|
|
|
* @brief Shut down the log module.
|
|
|
|
*
|
2009-09-06 15:21:56 -07:00
|
|
|
* @return #EINA_TRUE on success, #EINA_FALSE on failure.
|
2009-08-24 14:43:48 -07:00
|
|
|
*
|
|
|
|
* This function shuts down the log module set up by
|
2009-09-06 15:21:56 -07:00
|
|
|
* eina_log_init(). It is called by eina_shutdown().
|
2009-08-24 14:43:48 -07:00
|
|
|
*
|
|
|
|
* @see eina_shutdown()
|
2009-09-02 18:31:26 -07:00
|
|
|
*
|
|
|
|
* @warning Not-MT: just call this function from main thread! The
|
2009-09-06 15:21:56 -07:00
|
|
|
* place where eina_log_init() (eina_init()) was called the
|
|
|
|
* first time is considered the main thread.
|
2009-08-24 14:43:48 -07:00
|
|
|
*/
|
2009-09-06 15:21:56 -07:00
|
|
|
Eina_Bool
|
2009-08-24 14:43:48 -07:00
|
|
|
eina_log_shutdown(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-08-24 14:43:48 -07:00
|
|
|
Eina_Inlist *tmp;
|
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
eina_log_timing(EINA_LOG_DOMAIN_GLOBAL,
|
|
|
|
EINA_LOG_STATE_START,
|
|
|
|
EINA_LOG_STATE_SHUTDOWN);
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
while (_log_domains_count--)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
if (_log_domains[_log_domains_count].deleted)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
eina_log_domain_free(&_log_domains[_log_domains_count]);
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
free(_log_domains);
|
|
|
|
free(_log_timing);
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2013-07-14 18:53:09 -07:00
|
|
|
_log_timing = NULL;
|
2009-08-24 14:43:48 -07:00
|
|
|
_log_domains = NULL;
|
2009-09-07 16:23:03 -07:00
|
|
|
_log_domains_count = 0;
|
|
|
|
_log_domains_allocated = 0;
|
2009-08-24 14:43:48 -07:00
|
|
|
|
2010-02-08 18:51:23 -08:00
|
|
|
while (_glob_list)
|
2009-10-28 05:48:04 -07:00
|
|
|
{
|
|
|
|
tmp = _glob_list;
|
|
|
|
_glob_list = _glob_list->next;
|
|
|
|
free(tmp);
|
|
|
|
}
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
while (_pending_list)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
tmp = _pending_list;
|
|
|
|
_pending_list = _pending_list->next;
|
|
|
|
free(tmp);
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
|
2011-12-05 05:58:09 -08:00
|
|
|
#endif
|
2009-11-01 11:50:18 -08:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
* @brief Activate the log mutex.
|
|
|
|
*
|
|
|
|
* This function activate the mutex in the eina log module. It is called by
|
2010-09-10 05:01:52 -07:00
|
|
|
* eina_threads_init().
|
2009-11-01 11:50:18 -08:00
|
|
|
*
|
2010-09-10 05:01:52 -07:00
|
|
|
* @see eina_threads_init()
|
2009-11-01 11:50:18 -08:00
|
|
|
*/
|
2010-02-08 18:51:23 -08:00
|
|
|
void
|
2009-11-01 11:50:18 -08:00
|
|
|
eina_log_threads_init(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-10-07 15:14:03 -07:00
|
|
|
if (_threads_inited) return;
|
2010-07-13 06:51:00 -07:00
|
|
|
_main_thread = SELF();
|
2010-10-07 15:14:03 -07:00
|
|
|
if (!INIT()) return;
|
|
|
|
_threads_inited = EINA_TRUE;
|
2011-12-05 05:58:09 -08:00
|
|
|
#endif
|
2009-11-01 11:50:18 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @internal
|
|
|
|
* @brief Shut down the log mutex.
|
|
|
|
*
|
2010-02-08 18:51:23 -08:00
|
|
|
* This function shuts down the mutex in the log module.
|
2010-09-10 05:01:52 -07:00
|
|
|
* It is called by eina_threads_shutdown().
|
2009-11-01 11:50:18 -08:00
|
|
|
*
|
2010-09-10 05:01:52 -07:00
|
|
|
* @see eina_threads_shutdown()
|
2009-11-01 11:50:18 -08:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
eina_log_threads_shutdown(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-10-07 15:14:03 -07:00
|
|
|
if (!_threads_inited) return;
|
2010-07-27 19:37:05 -07:00
|
|
|
CHECK_MAIN();
|
|
|
|
SHUTDOWN();
|
|
|
|
_threads_enabled = EINA_FALSE;
|
2010-10-07 15:14:03 -07:00
|
|
|
_threads_inited = EINA_FALSE;
|
2011-12-05 05:58:09 -08:00
|
|
|
#endif
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
|
2009-12-27 00:45:30 -08:00
|
|
|
/*============================================================================*
|
2010-07-27 19:37:05 -07:00
|
|
|
* API *
|
|
|
|
*============================================================================*/
|
2009-12-27 00:45:30 -08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @cond LOCAL
|
|
|
|
*/
|
|
|
|
|
|
|
|
EAPI int EINA_LOG_DOMAIN_GLOBAL = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @endcond
|
|
|
|
*/
|
|
|
|
|
2009-09-02 18:31:26 -07:00
|
|
|
EAPI void
|
|
|
|
eina_log_threads_enable(void)
|
|
|
|
{
|
2012-12-31 08:14:40 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-10-07 15:14:03 -07:00
|
|
|
if (_threads_enabled) return;
|
|
|
|
if (!_threads_inited) eina_log_threads_init();
|
|
|
|
_threads_enabled = EINA_TRUE;
|
2009-09-04 16:45:16 -07:00
|
|
|
eina_log_print_prefix_update();
|
2009-09-02 18:31:26 -07:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
EAPI void
|
|
|
|
eina_log_print_cb_set(Eina_Log_Print_Cb cb, void *data)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_LOCK();
|
2009-08-24 14:43:48 -07:00
|
|
|
_print_cb = cb;
|
|
|
|
_print_cb_data = data;
|
2009-09-04 16:45:16 -07:00
|
|
|
eina_log_print_prefix_update();
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_UNLOCK();
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) cb;
|
|
|
|
(void) data;
|
|
|
|
#endif
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
|
2009-09-02 18:31:26 -07:00
|
|
|
EAPI void
|
2010-02-08 16:52:00 -08:00
|
|
|
eina_log_level_set(int level)
|
2009-08-24 14:43:48 -07:00
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-09-02 18:31:26 -07:00
|
|
|
_log_level = level;
|
2010-02-08 18:14:40 -08:00
|
|
|
if (EINA_LIKELY((EINA_LOG_DOMAIN_GLOBAL >= 0) &&
|
2010-07-27 19:37:05 -07:00
|
|
|
((unsigned int)EINA_LOG_DOMAIN_GLOBAL < _log_domains_count)))
|
|
|
|
_log_domains[EINA_LOG_DOMAIN_GLOBAL].level = level;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) level;
|
|
|
|
#endif
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
|
2010-02-08 16:52:00 -08:00
|
|
|
EAPI int
|
|
|
|
eina_log_level_get(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
return _log_level;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
eina_log_main_thread_check(void)
|
|
|
|
{
|
2012-12-31 08:14:40 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-07-27 19:37:05 -07:00
|
|
|
return ((!_threads_enabled) || IS_MAIN(SELF()));
|
2010-02-08 16:52:00 -08:00
|
|
|
#else
|
|
|
|
return EINA_TRUE;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
eina_log_color_disable_set(Eina_Bool disabled)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2014-02-25 19:59:41 -08:00
|
|
|
Eina_Log_Domain *domain;
|
|
|
|
unsigned int i;
|
|
|
|
|
2010-02-08 16:52:00 -08:00
|
|
|
_disable_color = disabled;
|
2014-02-25 19:59:41 -08:00
|
|
|
|
|
|
|
for (i = 0; i < _log_domains_count; i++)
|
|
|
|
{
|
|
|
|
domain = &_log_domains[i];
|
|
|
|
|
|
|
|
if (domain->domain_str)
|
|
|
|
free((char *)domain->domain_str);
|
|
|
|
|
|
|
|
if ((domain->color) && (!_disable_color))
|
|
|
|
domain->domain_str = eina_log_domain_str_get(domain->name, domain->color);
|
|
|
|
else
|
|
|
|
domain->domain_str = eina_log_domain_str_get(domain->name, NULL);
|
|
|
|
}
|
|
|
|
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) disabled;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
eina_log_color_disable_get(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
return _disable_color;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
return EINA_TRUE;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
eina_log_file_disable_set(Eina_Bool disabled)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
_disable_file = disabled;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) disabled;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
eina_log_file_disable_get(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
return _disable_file;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
return EINA_TRUE;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
eina_log_function_disable_set(Eina_Bool disabled)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
_disable_function = disabled;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) disabled;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
eina_log_function_disable_get(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
return _disable_function;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
return EINA_TRUE;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
eina_log_abort_on_critical_set(Eina_Bool abort_on_critical)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
_abort_on_critical = abort_on_critical;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) abort_on_critical;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI Eina_Bool
|
|
|
|
eina_log_abort_on_critical_get(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
return _abort_on_critical;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
return EINA_FALSE;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
eina_log_abort_on_critical_level_set(int critical_level)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
_abort_level_on_critical = critical_level;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) critical_level;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
|
|
|
eina_log_abort_on_critical_level_get(void)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
return _abort_level_on_critical;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
2009-09-02 18:31:26 -07:00
|
|
|
EAPI int
|
|
|
|
eina_log_domain_register(const char *name, const char *color)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-09-02 18:31:26 -07:00
|
|
|
int r;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(name, -1);
|
|
|
|
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_LOCK();
|
2009-09-02 18:31:26 -07:00
|
|
|
r = eina_log_domain_register_unlocked(name, color);
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_UNLOCK();
|
2009-09-02 18:31:26 -07:00
|
|
|
return r;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) name;
|
|
|
|
(void) color;
|
|
|
|
return 0;
|
|
|
|
#endif
|
2009-09-02 18:31:26 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
eina_log_domain_unregister(int domain)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-09-02 18:31:26 -07:00
|
|
|
EINA_SAFETY_ON_FALSE_RETURN(domain >= 0);
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_LOCK();
|
2009-09-02 18:31:26 -07:00
|
|
|
eina_log_domain_unregister_unlocked(domain);
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_UNLOCK();
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) domain;
|
|
|
|
#endif
|
2009-09-02 18:31:26 -07:00
|
|
|
}
|
|
|
|
|
2010-02-08 16:52:00 -08:00
|
|
|
EAPI void
|
|
|
|
eina_log_domain_level_set(const char *domain_name, int level)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
Eina_Log_Domain_Level_Pending *pending;
|
2010-03-22 23:41:17 -07:00
|
|
|
size_t namelen;
|
|
|
|
unsigned int i;
|
2010-02-08 16:52:00 -08:00
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(domain_name);
|
|
|
|
|
2010-02-08 18:13:55 -08:00
|
|
|
namelen = strlen(domain_name);
|
|
|
|
|
2010-02-08 16:52:00 -08:00
|
|
|
for (i = 0; i < _log_domains_count; i++)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
if (_log_domains[i].deleted)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((namelen != _log_domains[i].namelen) ||
|
|
|
|
(strcmp(_log_domains[i].name, domain_name) != 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
_log_domains[i].level = level;
|
|
|
|
return;
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EINA_INLIST_FOREACH(_pending_list, pending)
|
2010-07-27 19:37:05 -07:00
|
|
|
{
|
|
|
|
if ((namelen == pending->namelen) &&
|
|
|
|
(strcmp(pending->name, domain_name) == 0))
|
|
|
|
{
|
|
|
|
pending->level = level;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2010-02-08 16:52:00 -08:00
|
|
|
|
|
|
|
pending = malloc(sizeof(Eina_Log_Domain_Level_Pending) + namelen + 1);
|
|
|
|
if (!pending)
|
2010-07-27 19:37:05 -07:00
|
|
|
return;
|
|
|
|
|
2010-02-08 16:52:00 -08:00
|
|
|
pending->level = level;
|
2010-02-08 18:13:55 -08:00
|
|
|
pending->namelen = namelen;
|
2010-02-08 16:52:00 -08:00
|
|
|
memcpy(pending->name, domain_name, namelen + 1);
|
|
|
|
|
|
|
|
_pending_list = eina_inlist_append(_pending_list, EINA_INLIST_GET(pending));
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) domain_name;
|
|
|
|
(void) level;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
|
|
|
eina_log_domain_level_get(const char *domain_name)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
Eina_Log_Domain_Level_Pending *pending;
|
2010-03-22 23:41:17 -07:00
|
|
|
size_t namelen;
|
|
|
|
unsigned int i;
|
2010-02-08 16:52:00 -08:00
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(domain_name, EINA_LOG_LEVEL_UNKNOWN);
|
|
|
|
|
2010-02-08 18:13:55 -08:00
|
|
|
namelen = strlen(domain_name);
|
|
|
|
|
2010-02-08 16:52:00 -08:00
|
|
|
for (i = 0; i < _log_domains_count; i++)
|
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
if (_log_domains[i].deleted)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((namelen != _log_domains[i].namelen) ||
|
|
|
|
(strcmp(_log_domains[i].name, domain_name) != 0))
|
|
|
|
continue;
|
2010-02-08 16:52:00 -08:00
|
|
|
|
2010-07-27 19:37:05 -07:00
|
|
|
return _log_domains[i].level;
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EINA_INLIST_FOREACH(_pending_list, pending)
|
2010-07-27 19:37:05 -07:00
|
|
|
{
|
|
|
|
if ((namelen == pending->namelen) &&
|
|
|
|
(strcmp(pending->name, domain_name) == 0))
|
|
|
|
return pending->level;
|
|
|
|
}
|
2010-02-08 16:52:00 -08:00
|
|
|
|
|
|
|
EINA_INLIST_FOREACH(_glob_list, pending)
|
2010-07-27 19:37:05 -07:00
|
|
|
{
|
|
|
|
if (!fnmatch(pending->name, domain_name, 0))
|
|
|
|
return pending->level;
|
|
|
|
}
|
2010-02-08 16:52:00 -08:00
|
|
|
|
|
|
|
return _log_level;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) domain_name;
|
|
|
|
return 0;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI int
|
|
|
|
eina_log_domain_registered_level_get(int domain)
|
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2010-02-08 16:52:00 -08:00
|
|
|
EINA_SAFETY_ON_FALSE_RETURN_VAL(domain >= 0, EINA_LOG_LEVEL_UNKNOWN);
|
2010-02-08 18:13:55 -08:00
|
|
|
EINA_SAFETY_ON_FALSE_RETURN_VAL((unsigned int)domain < _log_domains_count,
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_LOG_LEVEL_UNKNOWN);
|
2010-02-08 16:52:00 -08:00
|
|
|
EINA_SAFETY_ON_TRUE_RETURN_VAL(_log_domains[domain].deleted,
|
2010-07-27 19:37:05 -07:00
|
|
|
EINA_LOG_LEVEL_UNKNOWN);
|
2010-02-08 16:52:00 -08:00
|
|
|
return _log_domains[domain].level;
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) domain;
|
|
|
|
return 0;
|
|
|
|
#endif
|
2010-02-08 16:52:00 -08:00
|
|
|
}
|
|
|
|
|
2014-03-09 20:25:20 -07:00
|
|
|
EAPI void
|
|
|
|
eina_log_domain_registered_level_set(int domain, int level)
|
|
|
|
{
|
|
|
|
#ifdef EINA_ENABLE_LOG
|
|
|
|
EINA_SAFETY_ON_FALSE_RETURN(domain >= 0);
|
|
|
|
EINA_SAFETY_ON_FALSE_RETURN((unsigned int)domain < _log_domains_count);
|
|
|
|
EINA_SAFETY_ON_TRUE_RETURN(_log_domains[domain].deleted);
|
|
|
|
_log_domains[domain].level = level;
|
|
|
|
#else
|
|
|
|
(void) domain;
|
|
|
|
(void) level;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-04-18 17:23:06 -07:00
|
|
|
#ifdef EINA_LOG_BACKTRACE
|
|
|
|
# define DISPLAY_BACKTRACE(File, Level) \
|
|
|
|
if (EINA_UNLIKELY(Level < _backtrace_level)) \
|
|
|
|
{ \
|
|
|
|
void *bt[256]; \
|
|
|
|
char **strings; \
|
|
|
|
int btlen; \
|
|
|
|
int i; \
|
|
|
|
\
|
|
|
|
btlen = backtrace((void **)bt, 256); \
|
|
|
|
strings = backtrace_symbols((void **)bt, btlen); \
|
|
|
|
fprintf(File, "*** Backtrace ***\n"); \
|
|
|
|
for (i = 0; i < btlen; ++i) \
|
|
|
|
fprintf(File, "%s\n", strings[i]); \
|
|
|
|
free(strings); \
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
# define DISPLAY_BACKTRACE(File, Level)
|
|
|
|
#endif
|
|
|
|
|
2009-09-02 16:28:00 -07:00
|
|
|
EAPI void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_cb_stderr(const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line,
|
|
|
|
const char *fmt,
|
2012-10-05 13:09:47 -07:00
|
|
|
EINA_UNUSED void *data,
|
2010-07-27 19:37:05 -07:00
|
|
|
va_list args)
|
2009-09-02 16:28:00 -07:00
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-09-04 16:45:16 -07:00
|
|
|
_eina_log_print_prefix(stderr, d, level, file, fnc, line);
|
2009-09-02 17:07:25 -07:00
|
|
|
vfprintf(stderr, fmt, args);
|
2009-09-02 18:39:45 -07:00
|
|
|
putc('\n', stderr);
|
2012-04-18 17:23:06 -07:00
|
|
|
DISPLAY_BACKTRACE(stderr, level);
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) d;
|
|
|
|
(void) level;
|
|
|
|
(void) file;
|
|
|
|
(void) fnc;
|
|
|
|
(void) line;
|
|
|
|
(void) fmt;
|
|
|
|
(void) data;
|
|
|
|
(void) args;
|
|
|
|
#endif
|
2009-09-02 16:28:00 -07:00
|
|
|
}
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
EAPI void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_cb_stdout(const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line,
|
|
|
|
const char *fmt,
|
2012-10-05 13:09:47 -07:00
|
|
|
EINA_UNUSED void *data,
|
2010-07-27 19:37:05 -07:00
|
|
|
va_list args)
|
2009-08-24 14:43:48 -07:00
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-09-04 16:45:16 -07:00
|
|
|
_eina_log_print_prefix(stdout, d, level, file, fnc, line);
|
2009-08-24 14:43:48 -07:00
|
|
|
vprintf(fmt, args);
|
2009-09-02 18:39:45 -07:00
|
|
|
putchar('\n');
|
2012-04-18 17:23:06 -07:00
|
|
|
DISPLAY_BACKTRACE(stdout, level);
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) d;
|
|
|
|
(void) level;
|
|
|
|
(void) file;
|
|
|
|
(void) fnc;
|
|
|
|
(void) line;
|
|
|
|
(void) fmt;
|
|
|
|
(void) data;
|
|
|
|
(void) args;
|
|
|
|
#endif
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
|
2013-03-16 02:46:45 -07:00
|
|
|
EAPI void
|
|
|
|
eina_log_print_cb_journald(const Eina_Log_Domain *d,
|
|
|
|
Eina_Log_Level level,
|
|
|
|
const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line,
|
|
|
|
const char *fmt,
|
|
|
|
void *data EINA_UNUSED,
|
|
|
|
va_list args)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_SYSTEMD
|
2015-01-13 07:18:20 -08:00
|
|
|
char *file_prefixed = NULL;
|
|
|
|
char *line_str = NULL;
|
|
|
|
char *message = NULL;
|
2013-03-16 02:46:45 -07:00
|
|
|
Eina_Thread cur;
|
2014-01-03 10:13:30 -08:00
|
|
|
int r;
|
2013-03-16 02:46:45 -07:00
|
|
|
|
2015-01-13 07:18:20 -08:00
|
|
|
r = asprintf(&file_prefixed, "CODE_FILE=%s", file);
|
2014-01-03 10:13:30 -08:00
|
|
|
if (r == -1)
|
|
|
|
{
|
2015-01-13 07:18:20 -08:00
|
|
|
fputs("ERR: eina_log_print_cb_journald() asprintf failed\n", stderr);
|
|
|
|
goto finish;
|
2014-01-03 10:13:30 -08:00
|
|
|
}
|
2013-03-16 02:46:45 -07:00
|
|
|
|
2015-01-13 07:18:20 -08:00
|
|
|
r = asprintf(&line_str, "CODE_LINE=%d", line);
|
|
|
|
if (r == -1)
|
|
|
|
{
|
|
|
|
fputs("ERR: eina_log_print_cb_journald() asprintf failed\n", stderr);
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = vasprintf(&message, fmt, args);
|
|
|
|
if (r == -1)
|
|
|
|
{
|
|
|
|
fputs("ERR: eina_log_print_cb_journald() vasprintf failed\n", stderr);
|
|
|
|
goto finish;
|
|
|
|
}
|
2013-03-16 02:46:45 -07:00
|
|
|
|
|
|
|
cur = SELF();
|
|
|
|
|
|
|
|
#ifdef EINA_LOG_BACKTRACE
|
|
|
|
if (EINA_LIKELY(level >= _backtrace_level))
|
|
|
|
#endif
|
2015-01-13 07:18:20 -08:00
|
|
|
sd_journal_send_with_location(file_prefixed, line_str, fnc,
|
2013-03-16 02:46:45 -07:00
|
|
|
"PRIORITY=%i", level,
|
2015-01-13 07:18:20 -08:00
|
|
|
"MESSAGE=%s", message,
|
2013-03-16 02:46:45 -07:00
|
|
|
"EFL_DOMAIN=%s", d->domain_str,
|
|
|
|
"THREAD=%lu", cur,
|
|
|
|
NULL);
|
|
|
|
#ifdef EINA_LOG_BACKTRACE
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Eina_Strbuf *bts;
|
2014-01-03 10:10:16 -08:00
|
|
|
char **strings;
|
2013-03-16 02:46:45 -07:00
|
|
|
void *bt[256];
|
2014-01-03 10:10:16 -08:00
|
|
|
int btlen;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
btlen = backtrace((void **)bt, 256);
|
|
|
|
strings = backtrace_symbols((void **)bt, btlen);
|
|
|
|
|
|
|
|
bts = eina_strbuf_new();
|
|
|
|
for (i = 0; i < btlen; i++)
|
|
|
|
if (i + 1 == btlen)
|
|
|
|
eina_strbuf_append_printf(bts, "[%s]", strings[i]);
|
|
|
|
else
|
|
|
|
eina_strbuf_append_printf(bts, "[%s], ", strings[i]);
|
|
|
|
|
2015-01-13 07:18:20 -08:00
|
|
|
sd_journal_send_with_location(file_prefixed, line_str, fnc,
|
2014-01-03 10:10:16 -08:00
|
|
|
"PRIORITY=%i", level,
|
2015-01-13 07:18:20 -08:00
|
|
|
"MESSAGE=%s", message,
|
2014-01-03 10:10:16 -08:00
|
|
|
"EFL_DOMAIN=%s", d->domain_str,
|
|
|
|
"THREAD=%lu", cur,
|
|
|
|
"BACKTRACE=%s",
|
|
|
|
eina_strbuf_string_get(bts),
|
|
|
|
NULL);
|
|
|
|
eina_strbuf_free(bts);
|
|
|
|
free(strings);
|
2013-03-16 02:46:45 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-01-13 07:18:20 -08:00
|
|
|
finish:
|
|
|
|
free(file_prefixed);
|
|
|
|
free(line_str);
|
|
|
|
free(message);
|
2013-03-16 02:46:45 -07:00
|
|
|
|
|
|
|
#else
|
|
|
|
eina_log_print_cb_stderr(d, level, file, fnc, line, fmt, data, args);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2009-08-24 14:43:48 -07:00
|
|
|
EAPI void
|
2010-07-27 19:37:05 -07:00
|
|
|
eina_log_print_cb_file(const Eina_Log_Domain *d,
|
2012-10-05 13:09:47 -07:00
|
|
|
EINA_UNUSED Eina_Log_Level level,
|
2010-07-27 19:37:05 -07:00
|
|
|
const char *file,
|
|
|
|
const char *fnc,
|
|
|
|
int line,
|
|
|
|
const char *fmt,
|
|
|
|
void *data,
|
|
|
|
va_list args)
|
2009-08-24 14:43:48 -07:00
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2012-10-18 18:49:06 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN(data);
|
2009-09-02 17:17:27 -07:00
|
|
|
FILE *f = data;
|
2009-09-02 18:31:26 -07:00
|
|
|
if (_threads_enabled)
|
|
|
|
{
|
2012-12-31 08:14:40 -08:00
|
|
|
Eina_Thread cur;
|
2010-07-13 06:51:00 -07:00
|
|
|
|
|
|
|
cur = SELF();
|
2010-07-27 19:37:05 -07:00
|
|
|
if (IS_OTHER(cur))
|
|
|
|
{
|
2010-08-21 18:15:47 -07:00
|
|
|
fprintf(f, "%s[T:%lu] %s:%d %s() ", d->name, (unsigned long)cur,
|
|
|
|
file, line, fnc);
|
2010-07-27 19:37:05 -07:00
|
|
|
goto end;
|
|
|
|
}
|
2009-09-02 18:31:26 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-10-06 00:09:05 -07:00
|
|
|
fprintf(f, "%s<%u> %s:%d %s() ", d->name, eina_log_pid_get(),
|
|
|
|
file, line, fnc);
|
2012-04-18 17:23:06 -07:00
|
|
|
DISPLAY_BACKTRACE(f, level);
|
2012-12-31 08:14:40 -08:00
|
|
|
|
2010-07-27 19:37:05 -07:00
|
|
|
end:
|
2009-08-24 14:43:48 -07:00
|
|
|
vfprintf(f, fmt, args);
|
2009-09-02 18:39:45 -07:00
|
|
|
putc('\n', f);
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) d;
|
|
|
|
(void) file;
|
|
|
|
(void) fnc;
|
|
|
|
(void) line;
|
|
|
|
(void) fmt;
|
|
|
|
(void) data;
|
|
|
|
(void) args;
|
|
|
|
#endif
|
2009-08-24 14:43:48 -07:00
|
|
|
}
|
|
|
|
|
2009-09-02 18:31:26 -07:00
|
|
|
EAPI void
|
|
|
|
eina_log_print(int domain, Eina_Log_Level level, const char *file,
|
2010-07-27 19:37:05 -07:00
|
|
|
const char *fnc, int line, const char *fmt, ...)
|
2009-09-02 18:31:26 -07:00
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
2009-09-02 18:31:26 -07:00
|
|
|
va_list args;
|
|
|
|
|
|
|
|
#ifdef EINA_SAFETY_CHECKS
|
2010-08-21 06:52:25 -07:00
|
|
|
if (EINA_UNLIKELY(!file))
|
2009-09-02 18:31:26 -07:00
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
fputs("ERR: eina_log_print() file == NULL\n", stderr);
|
|
|
|
return;
|
2009-09-02 18:31:26 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-08-21 06:52:25 -07:00
|
|
|
if (EINA_UNLIKELY(!fnc))
|
2009-09-02 18:31:26 -07:00
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
fputs("ERR: eina_log_print() fnc == NULL\n", stderr);
|
|
|
|
return;
|
2009-09-02 18:31:26 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-08-21 06:52:25 -07:00
|
|
|
if (EINA_UNLIKELY(!fmt))
|
2009-09-02 18:31:26 -07:00
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
fputs("ERR: eina_log_print() fmt == NULL\n", stderr);
|
|
|
|
return;
|
2009-09-02 18:31:26 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2009-09-02 18:31:26 -07:00
|
|
|
#endif
|
|
|
|
va_start(args, fmt);
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_LOCK();
|
2009-09-02 18:31:26 -07:00
|
|
|
eina_log_print_unlocked(domain, level, file, fnc, line, fmt, args);
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_UNLOCK();
|
2009-09-02 18:31:26 -07:00
|
|
|
va_end(args);
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) domain;
|
|
|
|
(void) level;
|
|
|
|
(void) file;
|
|
|
|
(void) fnc;
|
|
|
|
(void) line;
|
|
|
|
(void) fmt;
|
|
|
|
#endif
|
2009-09-02 18:31:26 -07:00
|
|
|
}
|
2009-09-03 17:57:09 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
eina_log_vprint(int domain, Eina_Log_Level level, const char *file,
|
2010-07-27 19:37:05 -07:00
|
|
|
const char *fnc, int line, const char *fmt, va_list args)
|
2009-09-03 17:57:09 -07:00
|
|
|
{
|
2011-12-05 05:58:09 -08:00
|
|
|
#ifdef EINA_ENABLE_LOG
|
|
|
|
|
2009-09-03 17:57:09 -07:00
|
|
|
#ifdef EINA_SAFETY_CHECKS
|
2010-08-21 06:52:25 -07:00
|
|
|
if (EINA_UNLIKELY(!file))
|
2009-09-03 17:57:09 -07:00
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
fputs("ERR: eina_log_print() file == NULL\n", stderr);
|
|
|
|
return;
|
2009-09-03 17:57:09 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-08-21 06:52:25 -07:00
|
|
|
if (EINA_UNLIKELY(!fnc))
|
2009-09-03 17:57:09 -07:00
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
fputs("ERR: eina_log_print() fnc == NULL\n", stderr);
|
|
|
|
return;
|
2009-09-03 17:57:09 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2010-08-21 06:52:25 -07:00
|
|
|
if (EINA_UNLIKELY(!fmt))
|
2009-09-03 17:57:09 -07:00
|
|
|
{
|
2010-07-27 19:37:05 -07:00
|
|
|
fputs("ERR: eina_log_print() fmt == NULL\n", stderr);
|
|
|
|
return;
|
2009-09-03 17:57:09 -07:00
|
|
|
}
|
2010-07-27 19:37:05 -07:00
|
|
|
|
2009-09-03 17:57:09 -07:00
|
|
|
#endif
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_LOCK();
|
2009-09-03 17:57:09 -07:00
|
|
|
eina_log_print_unlocked(domain, level, file, fnc, line, fmt, args);
|
2009-11-01 12:09:26 -08:00
|
|
|
LOG_UNLOCK();
|
2011-12-05 05:58:09 -08:00
|
|
|
#else
|
|
|
|
(void) domain;
|
|
|
|
(void) level;
|
|
|
|
(void) file;
|
|
|
|
(void) fnc;
|
|
|
|
(void) line;
|
|
|
|
(void) fmt;
|
|
|
|
(void) args;
|
|
|
|
#endif
|
2009-09-03 17:57:09 -07:00
|
|
|
}
|
2012-04-18 02:21:39 -07:00
|
|
|
|
2012-08-01 08:34:13 -07:00
|
|
|
EAPI void
|
|
|
|
eina_log_console_color_set(FILE *fp, const char *color)
|
|
|
|
{
|
|
|
|
#ifdef EINA_ENABLE_LOG
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(fp);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(color);
|
|
|
|
if (_disable_color) return;
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
2012-08-01 08:35:28 -07:00
|
|
|
int attr = eina_log_win32_color_convert(color, NULL);
|
2012-08-01 08:34:13 -07:00
|
|
|
HANDLE *handle;
|
2012-08-01 08:35:28 -07:00
|
|
|
|
|
|
|
if (!attr) return;
|
|
|
|
|
2012-08-01 08:34:13 -07:00
|
|
|
if (fp == stderr)
|
|
|
|
handle = GetStdHandle(STD_ERROR_HANDLE);
|
|
|
|
else if (fp == stdout)
|
|
|
|
handle = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Do we have a way to convert FILE* to HANDLE?
|
|
|
|
* Should we use it?
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
SetConsoleTextAttribute(handle, attr);
|
|
|
|
#else
|
|
|
|
fputs(color, fp);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#else
|
|
|
|
(void)color;
|
|
|
|
#endif
|
|
|
|
}
|
2013-03-27 05:39:55 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
eina_log_timing(int domain,
|
|
|
|
Eina_Log_State state,
|
|
|
|
const char *phase)
|
|
|
|
{
|
|
|
|
Eina_Log_Domain *d;
|
|
|
|
Eina_Log_Timing *t;
|
|
|
|
|
2013-06-20 04:28:18 -07:00
|
|
|
if (_disable_timing) return;
|
2013-03-27 05:39:55 -07:00
|
|
|
|
|
|
|
d = _log_domains + domain;
|
|
|
|
t = _log_timing + domain;
|
|
|
|
#ifdef EINA_SAFETY_CHECKS
|
|
|
|
if (EINA_UNLIKELY(d->deleted))
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
|
|
|
"ERR: eina_log_print() domain %d is deleted\n",
|
|
|
|
domain);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-03-27 06:36:14 -07:00
|
|
|
if (!t->phase && state == EINA_LOG_STATE_STOP)
|
2013-06-20 04:28:18 -07:00
|
|
|
return;
|
2013-03-27 06:36:14 -07:00
|
|
|
|
2013-03-27 05:39:55 -07:00
|
|
|
if (t->phase == EINA_LOG_STATE_INIT &&
|
|
|
|
phase == EINA_LOG_STATE_SHUTDOWN)
|
2013-06-20 04:28:18 -07:00
|
|
|
return;
|
2013-03-27 05:39:55 -07:00
|
|
|
|
|
|
|
if (state == EINA_LOG_STATE_START &&
|
|
|
|
t->phase &&
|
|
|
|
strcmp(t->phase, phase)) // Different phase
|
|
|
|
{
|
|
|
|
fprintf(stderr, "%s vs %s\n", t->phase, phase);
|
|
|
|
eina_log_timing(domain, EINA_LOG_STATE_STOP, t->phase);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (state)
|
|
|
|
{
|
|
|
|
case EINA_LOG_STATE_START:
|
|
|
|
{
|
|
|
|
_eina_time_get(&t->start);
|
|
|
|
t->phase = phase;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case EINA_LOG_STATE_STOP:
|
|
|
|
{
|
|
|
|
Eina_Nano_Time end;
|
|
|
|
long int r;
|
|
|
|
|
|
|
|
_eina_time_get(&end);
|
|
|
|
r = _eina_time_delta(&t->start, &end);
|
|
|
|
EINA_LOG_DOM_INFO(domain, "%s timing: %li", t->phase, r);
|
|
|
|
|
|
|
|
t->phase = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|