fastlog.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#include <predef.h>
#include <stdint.h>
#include <stdarg.h>
#include <nbrtos.h>
#include <string.h>
 
#ifndef FASTLOG_BUFSIZ
#define FASTLOG_BUFSIZ (0x80000)
#endif
//#define ENABLE_FASTLOG
 
extern "C" {
 int NBFastLog(void *logger, uint16_t fileId, uint16_t lineNum, const char *format, ...);
 void NBFastLogDump(void *l, bool clearAfter, int type);
}
 
int loggerputchars(void *data, const char *c, int n);
namespace fastlog {
 
typedef enum {
 eEntryType_Empty,
 eEntryType_ULong,
 eEntryType_String,
 eEntryType_BinPtr,
} eEntryType_t;
 
class logger {
private:
 class CritObj {
 logger *pLogger;
 public:
 CritObj(logger *l)
 : pLogger(l)
 {
// USER_ENTER_CRITICAL()
// return;
 if (pLogger->useFromIsr)
 {
 USER_ENTER_CRITICAL()
 }
 else
 {
 pLogger->crit.Enter();
 }
 }
 ~CritObj()
 {
// USER_EXIT_CRITICAL()
// return;
 if (pLogger->useFromIsr)
 {
 USER_EXIT_CRITICAL()
 }
 else
 {
 pLogger->crit.Leave();
 }
 }
 };
 struct entry_t {
 uint16_t tickOffset;
 uint16_t line;
 uint16_t fileId;
 uint8_t tcb_idx;
 eEntryType_t type;
 union {
 uint32_t data_ulong;
 struct {
 uint16_t dataLen;
 uint8_t data_bin[];
 }__attribute__((packed));
 struct {
 uint16_t strLen;
 char data_str[];
 }__attribute__((packed));
 };
 uint32_t getSize() const;
 } __attribute__((packed));
public:
 class fileEntry {
 fileEntry *pNext;
 const char *fileName;
 uint16_t id;
 public:
 fileEntry(const char *fileName);
 inline uint16_t getId() const { return id; }
 inline const char *getFilename() const { return fileName; }
 inline const fileEntry *getNext() const { return pNext; }
 inline static const fileEntry *getFirst()
 { return fileIds; }
 
 private:
 static fileEntry * fileIds;
 static uint16_t count;
 };
 
 enum eFullAction_t {
 eFull_Roll,
 eFull_Drop,
 eFull_DumpAndClear
 };
private:
 int logFd;
 uint32_t start;
 uint32_t end;
 uint32_t rollovers;
 tick_t startTick;
 tick_t endTick;
 OS_CRIT crit;
 bool useFromIsr;
 bool empty;
 eFullAction_t fullAction;
 uint32_t sentinel;
 uint8_t logBuf[FASTLOG_BUFSIZ];
 
 bool getNextByte(uint32_t *idx, uint8_t *b);
 bool DoFull(uint32_t entrySize);
 bool allocateEntry(uint32_t newEnd, uint32_t entrySize);
 void createEntry(entry_t &e);
 const char *getFileName(uint16_t id);
 
 void dumpBin(uint32_t idx, uint16_t len);
 void dumpstr(uint32_t idx, uint16_t len);
 bool getEntry(uint32_t *idx, entry_t *e);
 void dumpEntry(tick_t prevTick, entry_t &e, uint32_t *dataStart);
 
 int log_vsprintf(uint16_t fileId, uint16_t lineNum, const char *format, va_list &vl);
public:
 logger(int logFd = 1, eFullAction_t fullAction = eFull_Roll, bool useFromIsr = false);
 
 void log(uint16_t fileId, uint16_t lineNum, uint16_t len, uint8_t *pdata, eEntryType_t t);
 
 inline void log_line(uint16_t fileId, uint16_t lineNum)
 { log(fileId, lineNum, 0, NULL, eEntryType_Empty); }
 inline void log_ulong(uint16_t fileId, uint16_t lineNum, uint32_t val)
 { log(fileId, lineNum, sizeof(val), (uint8_t*)&(val), eEntryType_ULong); }
 
 inline void log_bin(uint16_t fileId, uint16_t lineNum, uint16_t len, uint8_t *pdata)
 { log(fileId, lineNum, len, pdata, eEntryType_BinPtr); }
 
 inline void log_str(uint16_t fileId, uint16_t lineNum, const char *s)
 { log(fileId, lineNum, strlen(s), (uint8_t*)s, eEntryType_String); }
 
 int log_sprintf(uint16_t fileId, uint16_t lineNum, const char *format, ...);
 
 void dumpLog(bool clearAfter = true, int type = -1);
 void clear();
 void setLogFd(int fd) { logFd = fd; }
 
 friend int ::loggerputchars(void *data, const char *c, int n);
 friend int ::NBFastLog(void *logger, uint16_t fileId, uint16_t lineNum, const char *format, ...);
};
 
}
 
extern fastlog::logger FastStdLogger;
 
#ifdef ENABLE_FASTLOG
#define FASTLOG_INIT_FILE() \
static fastlog::logger::fileEntry _fastlog_ThisFile(__FILE__)
 
#define FASTLOG_LINE(_logger) (_logger).log_line(_fastlog_ThisFile.getId(), __LINE__)
#define FASTLOG_ULONG(_logger, val) (_logger).log_ulong(_fastlog_ThisFile.getId(), __LINE__, (val))
#define FASTLOG_BINARY(_logger, len, data) (_logger).log_bin(_fastlog_ThisFile.getId(), __LINE__, (len), (data))
#define FASTLOG_STRING(_logger, s) (_logger).log_str(_fastlog_ThisFile.getId(), __LINE__, (s))
#define FASTLOG_SPRINTF(_logger, ...) (_logger).log_sprintf(_fastlog_ThisFile.getId(), __LINE__, __VA_ARGS__)
 
#define FASTLOG_SHOWLOG(_logger) (_logger).dumpLog()
#else
#define FASTLOG_INIT_FILE()
 
#define FASTLOG_LINE(_logger)
#define FASTLOG_ULONG(_logger, val)
#define FASTLOG_BINARY(_logger, len, data)
#define FASTLOG_STRING(_logger, s)
#define FASTLOG_SPRINTF(_logger, ...)
 
#define FASTLOG_SHOWLOG(_logger)
#endif