feat: 使用更多的宏来操控log的输出

include/tool/log.h

@@ -3,6 +3,7 @@
 #include <setjmp.h>
 #include "aFunToolExport.h"
 #include "macro.h"
+#include "log_macro.h"
 
 enum LogLevel {
     log_track = 0,
@@ -49,24 +50,54 @@ AFUN_TOOL_EXPORT int writeFatalErrorLog_(Logger *logger, char *file, int line, c
 #define file_line (char *)"xx", (int)__LINE__
 #endif
 
-#if aFunDEBUG
+#if aFunWriteTrack
 #define writeTrackLog(logger, ...) writeTrackLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
 #else
 #define writeTrackLog(logger, ...) (NULL)
 #endif
 
+#if aFunWriteDebug
 #define writeDebugLog(logger, ...) writeDebugLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
+#define assertDebugLog(c, logger, ...) ((c) || writeDebugLog(logger, "Assert " #c " error : " __VA_ARGS__))
+#else
+#define writeDebugLog(logger, ...) (NULL)
+#define assertDebugLog(c, logger, ...) (c)
+#endif
+
+#if aFunWriteInfo
 #define writeInfoLog(logger, ...) writeInfoLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
+#define assertInfoLog(c, logger, ...) ((c) || writeInfoLog(logger, "Assert " #c " error : " __VA_ARGS__))
+#else
+#define writeInfoLog(logger, ...) (NULL)
+#define assertInfoLog(c, logger, ...) (c)
+#endif
+
+#if !aFunIgnoreWarning
 #define writeWarningLog(logger, ...) writeWarningLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
+#define assertWarningLog(c, logger, ...) ((c) || writeWarningLog(logger, "Assert " #c " error : " __VA_ARGS__))
+#else
+#define writeWarningLog(logger, ...) (NULL)
+#define assertWarningLog(c, logger, ...) (c)
+#endif
+
+#if !aFunIgnoreError
 #define writeErrorLog(logger, ...) writeErrorLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
+#define assertErrorLog(c, logger, ...) ((c) || writeErrorLog(logger, "Assert " #c " error : " __VA_ARGS__))
+#else
+#define writeErrorLog(logger, ...) (NULL)
+#define assertErrorLog(c, logger, ...) (c)
+#endif
+
+#if !aFunOFFAllLog
 #define writeSendErrorLog(logger, ...) writeSendErrorLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
 #define writeFatalErrorLog(logger, exit_code, ...) writeFatalErrorLog_(logger, file_line, (char *)__FUNCTION__, exit_code, __VA_ARGS__)
-
-#define assertDebugLog(c, logger, ...) ((c) || writeDebugLog(logger, "Assert " #c " error : " __VA_ARGS__))
-#define assertInfoLog(c, logger, ...) ((c) || writeInfoLog(logger, "Assert " #c " error : " __VA_ARGS__))
-#define assertWarningLog(c, logger, ...) ((c) || writeWarningLog(logger, "Assert " #c " error : " __VA_ARGS__))
-#define assertErrorLog(c, logger, ...) ((c) || writeErrorLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #define assertSendErrorLog(c, logger, ...) ((c) || writeSendErrorLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #define assertFatalErrorLog(c, logger, exit_code, ...) ((c) || writeFatalErrorLog(logger, exit_code, "Assert " #c " error : " __VA_ARGS__))
+#else
+#define writeSendErrorLog(logger, ...) (NULL)
+#define writeFatalErrorLog(logger, exit_code, ...) (NULL)
+#define assertSendErrorLog(c, logger, ...) (c)
+#define assertFatalErrorLog(c, logger, exit_code, ...) (c)
+#endif
 
 #endif //AFUN_LOG_H

include/tool/log_macro.h

@@ -0,0 +1,144 @@
+#ifndef AFUN_LOG_MACRO_H
+#define AFUN_LOG_MACRO_H
+
+#if (defined aFunOFFAllLog || defined aFunOFFLog)
+
+#undef aFunWriteTrack
+#define aFunWriteTrack 0  /* 必须忽略Track */
+
+#undef aFunWriteTrack
+#define aFunWriteDebug 0  /* 必须忽略Debug */
+
+#undef aFunWriteTrack
+#define aFunWriteInfo 0  /* 必须忽略Info */
+
+#undef aFunWriteTrack
+#define aFunIgnoreWarning 0  /* 必须忽略Warning */
+
+#undef aFunWriteTrack
+#define aFunIgnoreError 0  /* 必须忽略Error */
+
+#undef aFunWriteTrack
+#define aFunIgnoreSendError 0  /* 必须忽略SendError */
+
+#undef aFunWriteTrack
+#define aFunIgnoreFatalError 0  /* 必须忽略FatalError */
+
+#undef aFunWriteTrack
+#define aFunIgnoreFatalError 0  /* 必须忽略FatalError */
+
+#elif defined aFunDEBUG
+
+#ifndef aFunWriteTrack
+#define aFunWriteTrack 1  /* 是否记录Track */
+#endif
+
+#ifndef aFunWriteDebug
+#define aFunWriteDebug 1  /* 是否记录Debug */
+#endif
+
+#ifndef aFunWriteInfo
+#define aFunWriteInfo 1  /* 是否记录Info */
+#endif
+
+#ifndef aFunIgnoreWarning
+#define aFunIgnoreWarning 0  /* 是否忽略Warning */
+#endif
+
+#ifndef aFunIgnoreError
+#define aFunIgnoreError 0  /* 是否忽略Error */
+#endif
+
+#ifndef aFunIgnoreSendError
+#define aFunIgnoreSendError 0  /* 是否忽略SendError */
+#endif
+
+#ifndef aFunIgnoreFatalError
+#define aFunIgnoreFatalError 0  /* 是否忽略FatalError */
+#endif
+
+#else
+
+#undef aFunWriteTrack
+#define aFunWriteTrack 0  /* 必须忽略Track */
+
+#ifndef aFunWriteDebug
+#define aFunWriteDebug 1  /* 是否记录Debug */
+#endif
+
+#undef aFunConsoleDebug
+#define aFunConsoleDebug 0
+
+#ifndef aFunWriteInfo
+#define aFunWriteInfo 1  /* 是否记录Info */
+#endif
+
+#undef aFunConsoleInfo
+#define aFunConsoleInfo 0
+
+#ifndef aFunIgnoreWarning
+#define aFunIgnoreWarning 0  /* 是否忽略Warning */
+#endif
+
+#ifndef aFunIgnoreError
+#define aFunIgnoreError 0  /* 是否忽略Error */
+#endif
+
+#ifndef aFunIgnoreSendError
+#define aFunIgnoreSendError 0  /* 是否忽略SendError */
+#endif
+
+#ifndef aFunIgnoreFatalError
+#define aFunIgnoreFatalError 0  /* 是否忽略FatalError */
+#endif
+
+#endif
+
+#if (!aFunWriteTrack || !defined aFunConsoleTrack)
+#undef aFunConsoleTrack
+#define aFunConsoleTrack 0
+#endif
+
+#if !aFunWriteDebug
+#undef aFunConsoleDebug
+#define aFunConsoleDebug 0
+#elif !defined aFunConsoleDebug
+#define aFunConsoleDebug 1
+#endif
+
+#if !aFunWriteInfo
+#undef aFunConsoleInfo
+#define aFunConsoleInfo 0
+#elif !defined aFunConsoleInfo
+#define aFunConsoleInfo 1
+#endif
+
+#if aFunIgnoreWarning
+#undef aFunConsoleWarning
+#define aFunConsoleWarning 0
+#elif !defined aFunConsoleWarning
+#define aFunConsoleWarning 1
+#endif
+
+#if aFunIgnoreError
+#undef aFunConsoleError
+#define aFunConsoleError 0
+#elif !defined aFunConsoleError
+#define aFunConsoleError 1
+#endif
+
+#if aFunIgnoreSendError
+#undef aFunConsoleSendError
+#define aFunConsoleSendError 0
+#elif !defined aFunConsoleSendError
+#define aFunConsoleSendError 1
+#endif
+
+#if aFunIgnoreFatalError
+#undef aFunConsoleFatalError
+#define aFunConsoleFatalError 0
+#elif !defined aFunConsoleFatalError
+#define aFunConsoleFatalError 1
+#endif
+
+#endif //AFUN_LOG_MACRO_H

src/tool/log.c

@@ -204,78 +204,87 @@ static int writeLog_(Logger *logger, bool pc, LogLevel level, char *file, int li
 #define CHECK_LOGGER() do {if (logger == NULL) {logger = &(log_factory.sys_log);} \
                            if (logger == NULL || logger->id == NULL) return -1;} while(0)
 
-#ifdef aFunDEBUG
-#define INFO_PRINT_CONSOLE true
-#else
-#define INFO_PRINT_CONSOLE false
-#endif
-
 int writeTrackLog_(Logger *logger, char *file, int line, char *func, char *format, ...) {
-#ifdef aFunDEBUG
+#if aFunWriteTrack
     CHECK_LOGGER();
 
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, false, log_track, file, line, func, format, ap);
+    return writeLog_(logger, aFunConsoleTrack, log_track, file, line, func, format, ap);
 #endif
 }
 
 int writeDebugLog_(Logger *logger, char *file, int line, char *func, char *format, ...) {
+#if aFunWriteDebug
     CHECK_LOGGER();
 
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, INFO_PRINT_CONSOLE, log_debug, file, line, func, format, ap);
+    return writeLog_(logger, aFunConsoleDebug, log_debug, file, line, func, format, ap);
+#endif
 }
 
 int writeInfoLog_(Logger *logger, char *file, int line, char *func, char *format, ...) {
+#if aFunWriteInfo
     CHECK_LOGGER();
 
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, INFO_PRINT_CONSOLE, log_info, file, line, func, format, ap);
+    return writeLog_(logger, aFunConsoleInfo, log_info, file, line, func, format, ap);
+#endif
 }
 
 int writeWarningLog_(Logger *logger, char *file, int line, char *func, char *format, ...) {
+#if !aFunIgnoreWarning
     CHECK_LOGGER();
 
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, INFO_PRINT_CONSOLE, log_warning, file, line, func, format, ap);
+    return writeLog_(logger, aFunConsoleWarning, log_warning, file, line, func, format, ap);
+#endif
 }
 
 int writeErrorLog_(Logger *logger, char *file, int line, char *func, char *format, ...) {
+#if !aFunIgnoreError
     CHECK_LOGGER();
 
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, INFO_PRINT_CONSOLE, log_error, file, line, func, format, ap);
+    return writeLog_(logger, aFunConsoleError, log_error, file, line, func, format, ap);
+#endif
 }
 
 int writeSendErrorLog_(Logger *logger, char *file, int line, char *func, char *format, ...) {
+#ifndef aFunOFFAllLog
     CHECK_LOGGER();
-
+#if !aFunIgnoreSendError
     va_list ap;
     va_start(ap, format);
     jmp_buf *buf = logger->buf;
+    writeLog_(logger, aFunConsoleSendError, log_send_error, file, line, func, format, ap);
+#endif
 
-    writeLog_(logger, true, log_send_error, file, line, func, format, ap);
     if (buf != NULL) {
         initLogger(logger, NULL, 0);  // 清零
         longjmp(*buf, 1);
     } else
         exit(EXIT_FAILURE);
+#endif
 }
 
 int writeFatalErrorLog_(Logger *logger, char *file, int line, char *func, int exit_code, char *format, ...) {
+#ifndef aFunOFFAllLog
     CHECK_LOGGER();
 
+#if !aFunIgnoreFatal
     va_list ap;
     va_start(ap, format);
-    writeLog_(logger, true, log_fatal_error, file, line, func, format, ap);
+    writeLog_(logger, aFunConsoleFatalError, log_fatal_error, file, line, func, format, ap);
+#endif
 
     if (exit_code == EXIT_SUCCESS)
         abort();
     else
         exit(exit_code);
+#endif
 }