Added ev_log

Signed-off-by: Robear Selwans <robear.selwans@outlook.com>

buildfiles/ev_log.c

@@ -0,0 +1,2 @@
+#define EV_LOG_IMPLEMENTATION
+#include "../ev_log.h"

ev_log.h

@@ -0,0 +1,202 @@
+#ifndef EV_HEADERS_LOG_H
+#define EV_HEADERS_LOG_H
+
+#define EV_LOG_USE_COLOR
+
+#include "ev_internal.h"
+
+#include "stdarg.h"
+#include "stdbool.h"
+#include "stdio.h"
+#include "time.h"
+
+typedef struct {
+  va_list ap;
+  const char* fmt;
+  const char* file;
+  struct tm* time;
+  void* udata;
+  int line;
+  int level;
+} ev_log_event_t;
+
+typedef void (*ev_log_log_fn)(ev_log_event_t* ev);
+typedef void (*ev_log_lock_fn)(bool lock, void* udata);
+
+typedef enum {
+  EV_LOG_TRACE,
+  EV_LOG_DEBUG,
+  EV_LOG_INFO ,
+  EV_LOG_WARN ,
+  EV_LOG_ERROR,
+  EV_LOG_FATAL,
+} ev_log_level;
+
+#define ev_log_trace(...) ev_log(EV_LOG_TRACE, __FILE__, __LINE__, __VA_ARGS__)
+#define ev_log_debug(...) ev_log(EV_LOG_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
+#define ev_log_info(...)  ev_log(EV_LOG_INFO , __FILE__, __LINE__, __VA_ARGS__)
+#define ev_log_warn(...)  ev_log(EV_LOG_WARN , __FILE__, __LINE__, __VA_ARGS__)
+#define ev_log_error(...) ev_log(EV_LOG_ERROR, __FILE__, __LINE__, __VA_ARGS__)
+#define ev_log_fatal(...) ev_log(EV_LOG_FATAL, __FILE__, __LINE__, __VA_ARGS__)
+
+const char* ev_log_level_string(ev_log_level level);
+void ev_log_set_lock(ev_log_lock_fn fn, void* udata);
+void ev_log_set_level(ev_log_level level);
+void ev_log_set_quiet(bool enable);
+i32 ev_log_add_callback(ev_log_log_fn fn, void* udata, ev_log_level level);
+i32 ev_log_add_fp(FILE *fp, ev_log_level level);
+
+void ev_log(ev_log_level level, const char* file, u32 line, const char* fmt, ...);
+
+#ifdef EV_LOG_IMPLEMENTATION
+#undef EV_LOG_IMPLEMENTATION
+
+#define MAX_CALLBACKS 32
+
+typedef struct {
+  ev_log_log_fn fn;
+  void* udata;
+  ev_log_level level;
+} ev_log_callback_t;
+
+struct {
+  void* udata;
+  ev_log_lock_fn lock;
+  ev_log_level level;
+  bool quiet;
+  ev_log_callback_t callbacks[MAX_CALLBACKS];
+} G;
+
+static const char* level_strings[] = {
+  "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"
+};
+
+static const char* level_colors[] = {
+  "\x1b[94m", "\x1b[36m", "\x1b[32m", "\x1b[33m", "\x1b[31m", "\x1b[35m"
+};
+
+static void ev_log_stdout_callback(ev_log_event_t* ev)
+{
+  char buf[16];
+  buf[strftime(buf, sizeof(buf), "%H:%M:%S", ev->time)] = '\0';
+#ifdef EV_LOG_USE_COLOR
+  fprintf(
+    ev->udata, "%s %s%-5s\x1b[0m \x1b[90m%s:%d:\x1b[0m ",
+    buf, level_colors[ev->level], level_strings[ev->level],
+    ev->file, ev->line);
+#else
+  fprintf(
+    ev->udata, "%s %-5s %s:%d: ",
+    buf, level_strings[ev->level], ev->file, ev->line);
+#endif
+  vfprintf(ev->udata, ev->fmt, ev->ap);
+  fprintf(ev->udata, "\n");
+  fflush(ev->udata);
+}
+
+static void ev_log_file_callback(ev_log_event_t* ev) 
+{
+  char buf[64];
+  buf[strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ev->time)] = '\0';
+  fprintf(
+    ev->udata, "%s %-5s %s:%d: ",
+    buf, level_strings[ev->level], ev->file, ev->line);
+  vfprintf(ev->udata, ev->fmt, ev->ap);
+  fprintf(ev->udata, "\n");
+  fflush(ev->udata);
+}
+
+static void lock(void)
+{
+  if(G.lock)
+    G.lock(true, G.udata);
+}
+
+static void unlock(void)
+{
+  if(G.lock)
+    G.lock(false, G.udata);
+}
+
+const char* ev_log_level_string(ev_log_level level) 
+{
+  return level_strings[level];
+}
+
+void ev_log_set_lock(ev_log_lock_fn fn, void* udata) 
+{
+  G.lock = fn;
+  G.udata = udata;
+}
+
+
+void ev_log_set_level(ev_log_level level) 
+{
+  G.level = level;
+}
+
+void ev_log_set_quiet(bool enable) 
+{
+  G.quiet = enable;
+}
+
+i32 ev_log_add_callback(ev_log_log_fn fn, void* udata, ev_log_level level) 
+{
+  for (i32 i = 0; i < MAX_CALLBACKS; i++) {
+    if (!G.callbacks[i].fn) {
+      G.callbacks[i] = (ev_log_callback_t) { fn, udata, level };
+      return 0;
+    }
+  }
+  return -1;
+}
+
+
+i32 log_add_fp(FILE *fp, ev_log_level level) 
+{
+  return ev_log_add_callback(ev_log_file_callback, fp, level);
+}
+
+
+static void init_event(ev_log_event_t* ev, void* udata) 
+{
+  if (!ev->time) {
+    time_t t = time(NULL);
+    ev->time = localtime(&t);
+  }
+  ev->udata = udata;
+}
+
+void ev_log(ev_log_level level, const char* file, u32 line, const char* fmt, ...) 
+{
+  ev_log_event_t ev = {
+    .fmt   = fmt,
+    .file  = file,
+    .line  = line,
+    .level = level,
+  };
+
+  lock();
+
+  if (!G.quiet && level >= G.level) {
+    init_event(&ev, stderr);
+    va_start(ev.ap, fmt);
+    ev_log_stdout_callback(&ev);
+    va_end(ev.ap);
+  }
+
+  for (i32 i = 0; i < MAX_CALLBACKS && G.callbacks[i].fn; i++) {
+    ev_log_callback_t* cb = &G.callbacks[i];
+    if (level >= cb->level) {
+      init_event(&ev, cb->udata);
+      va_start(ev.ap, fmt);
+      cb->fn(&ev);
+      va_end(ev.ap);
+    }
+  }
+
+  unlock();
+}
+
+#endif
+#endif

log_test.c

@@ -0,0 +1,9 @@
+#define EV_LOG_IMPLEMENTATION
+#include "ev_log.h"
+
+
+int main()
+{
+  ev_log_trace("Trace Log");
+  return 0;
+}

meson.build

@@ -24,26 +24,32 @@ endif
 str_lib = static_library('ev_str', files('buildfiles/ev_str.c'), c_args: evh_c_args)
 vec_lib = static_library('ev_vec', files('buildfiles/ev_vec.c'), c_args: evh_c_args)
 helpers_lib = static_library('ev_helpers', files('buildfiles/ev_helpers.c'), c_args: evh_c_args)
+log_lib = static_library('ev_log', files('buildfiles/ev_log.c'), c_args: evh_c_args)
 
 str_dep = declare_dependency(link_with: str_lib, include_directories: headers_include)
 vec_dep = declare_dependency(link_with: vec_lib, include_directories: headers_include)
 helpers_dep = declare_dependency(link_with: helpers_lib, include_directories: headers_include)
+log_dep = declare_dependency(link_with: log_lib, include_directories: headers_include)
 
 headers_dep = declare_dependency(
   dependencies: [
     str_dep,
     vec_dep,
     helpers_dep,
+    log_dep
   ]
 )
 
 # Tests
 str_test = executable('str_test', 'str_test.c', dependencies: [str_dep], c_args: evh_c_args)
 test('evstr', str_test)
+log_test = executable('log_test', 'log_test.c', dependencies: [log_dep], c_args: evh_c_args)
+test('evlog', log_test)
 
 if meson.version().version_compare('>= 0.54.0')
   meson.override_dependency('ev_vec', vec_dep)
   meson.override_dependency('ev_str', str_dep)
   meson.override_dependency('ev_helpers', helpers_dep)
+  meson.override_dependency('ev_log', log_dep)
   meson.override_dependency('evol-headers', headers_dep)
 endif