From 0e800cbbc92d91fe129805dd11ecc067cff7f966 Mon Sep 17 00:00:00 2001 From: Jussi Vatjus-Anttila Date: Tue, 15 Sep 2015 19:57:49 +0300 Subject: [PATCH 1/2] object C version --- mbed-client-trace/mbed_client_trace.h | 149 ++++++++------ source/mbed_client_trace.c | 267 ++++++++++++++------------ test/Test.cpp | 171 +++++++++-------- 3 files changed, 326 insertions(+), 261 deletions(-) diff --git a/mbed-client-trace/mbed_client_trace.h b/mbed-client-trace/mbed_client_trace.h index 0f25c9e..c4e527d 100644 --- a/mbed-client-trace/mbed_client_trace.h +++ b/mbed-client-trace/mbed_client_trace.h @@ -28,11 +28,12 @@ * #define TRACE_GROUP "main" * * int main(void){ - * mbed_client_trace_init(); // initialize trace library + * mbed_client_trace_init(0); // initialize trace library * tr_debug("this is debug msg"); //print debug message to stdout: "[DBG] * tr_err("this is error msg"); * tr_warn("this is warning msg"); * tr_info("this is info msg"); + * mbed_client_trace_free(0); * return 0; * } * \endcode @@ -54,10 +55,18 @@ extern "C" { #include "ns_types.h" #endif +struct trace_t; + #ifndef MBED_CLIENT_TRACE_FEA_IPV6 #define MBED_CLIENT_TRACE_FEA_IPV6 1 #endif +#ifndef MBED_CLIENT_TRACE_MANAGEMENT +// if C++ TraceManager is in use, we don't +// need this global tracing obejct +extern trace_t *g_trace; +#endif + /** 3 upper bits are trace modes related, and 5 lower bits are trace level configuration */ @@ -100,33 +109,51 @@ extern "C" { #define TRACE_LEVEL_CMD 0x01 //usage macros: -#define tr_info(...) mbed_tracef(TRACE_LEVEL_INFO, TRACE_GROUP, __VA_ARGS__) //!< Print info message -#define tr_debug(...) mbed_tracef(TRACE_LEVEL_DEBUG, TRACE_GROUP, __VA_ARGS__) //!< Print debug message -#define tr_warning(...) mbed_tracef(TRACE_LEVEL_WARN, TRACE_GROUP, __VA_ARGS__) //!< Print warning message -#define tr_warn(...) mbed_tracef(TRACE_LEVEL_WARN, TRACE_GROUP, __VA_ARGS__) //!< Alternative warning message -#define tr_error(...) mbed_tracef(TRACE_LEVEL_ERROR, TRACE_GROUP, __VA_ARGS__) //!< Print Error Message -#define tr_err(...) mbed_tracef(TRACE_LEVEL_ERROR, TRACE_GROUP, __VA_ARGS__) //!< Alternative error message -#define tr_cmdline(...) mbed_tracef(TRACE_LEVEL_CMD, TRACE_GROUP, __VA_ARGS__) //!< Special print for cmdline. See more from TRACE_LEVEL_CMD -level +#define tr_info(...) mbed_tracef(g_trace, TRACE_LEVEL_INFO, TRACE_GROUP, __VA_ARGS__) //!< Print info message +#define tr_debug(...) mbed_tracef(g_trace, TRACE_LEVEL_DEBUG, TRACE_GROUP, __VA_ARGS__) //!< Print debug message +#define tr_warning(...) mbed_tracef(g_trace, TRACE_LEVEL_WARN, TRACE_GROUP, __VA_ARGS__) //!< Print warning message +#define tr_warn(...) mbed_tracef(g_trace, TRACE_LEVEL_WARN, TRACE_GROUP, __VA_ARGS__) //!< Alternative warning message +#define tr_error(...) mbed_tracef(g_trace, TRACE_LEVEL_ERROR, TRACE_GROUP, __VA_ARGS__) //!< Print Error Message +#define tr_err(...) mbed_tracef(g_trace, TRACE_LEVEL_ERROR, TRACE_GROUP, __VA_ARGS__) //!< Alternative error message +#define tr_cmdline(...) mbed_tracef(g_trace, TRACE_LEVEL_CMD, TRACE_GROUP, __VA_ARGS__) //!< Special print for cmdline. See more from TRACE_LEVEL_CMD -level + +#if defined(BACKWARD_COMPATIBLE) +#define trace_last(...) (g_trace, __VA_ARGS__) +#define tracef(...) (g_trace, __VA_ARGS__) +#define trace_array(...) (g_trace, __VA_ARGS__) +#if MBED_CLIENT_TRACE_FEA_IPV6 == 1 +#define trace_ipv6(...) (g_trace, __VA_ARGS__) +#define trace_ipv6_prefix(...) (g_trace, __VA_ARGS__) +#endif +#endif /** Possible to skip all traces in compile time */ -#if defined(YOTTA_CFG_MBED_CLIENT_TRACE) +#if defined(YOTTA_CFG_TRACE) #if defined __GNUC__ || defined __CC_ARM + +/** + * Get Yotta component version + * @return version number as string (e.g. "0.1.0") + */ +const char* mbed_client_trace_get_version(void); /** - * Initialize trace functionality - * @return 0 when all success, otherwise non zero + * Create trace instance and initialize trace functionality + * @param this NULL when global + * @return trace object when all success, otherwise zero + * */ -int mbed_client_trace_init( void ); +trace_t* mbed_client_trace_init( trace_t* self ); /** * Free trace memory */ -void mbed_client_trace_free( void ); +trace_t* mbed_client_trace_free( trace_t* self ); /** * Set trace configurations * Possible parameters: * * TRACE_MODE_COLOR - * TRACE_MODE_PLAIN (this exclude color mode) + * TRACE_MODE_PLAIN (self exclude color mode) * TRACE_CARRIAGE_RETURN (print CR before trace line) * * TRACE_ACTIVE_LEVEL_ALL - to activate all trace levels @@ -140,14 +167,14 @@ void mbed_client_trace_free( void ); * @param config Byte size Bit-mask. Bits are descripted above. * usage e.g. * @code - * mbed_client_trace_config_set( TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_COLOR ); + * mbed_client_trace_config_set(g_trace, TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_COLOR ); * @endcode */ -void mbed_client_trace_config_set(uint8_t config); +void mbed_client_trace_config_set( trace_t* self, uint8_t config); /** get trace configurations * @return trace configuration byte */ -uint8_t mbed_client_trace_config_get(void); +uint8_t mbed_client_trace_config_get( trace_t* self); /** * Set trace prefix function * pref_f -function return string with null terminated @@ -156,120 +183,122 @@ uint8_t mbed_client_trace_config_get(void); * char* trace_time(){ return "rtc-time-in-string"; } * mbed_client_trace_prefix_function_set( &trace_time ); */ -void mbed_client_trace_prefix_function_set( char* (*pref_f)(size_t) ); +void mbed_client_trace_prefix_function_set( trace_t* self, char* (*pref_f)(size_t) ); /** * Set trace suffix function * suffix -function return string with null terminated * Can be used for e.g. time string * e.g. * char* trace_suffix(){ return " END"; } - * mbed_client_trace_suffix_function_set( &trace_suffix ); + * mbed_client_trace_suffix_function_set(g_trace, &trace_suffix ); */ -void mbed_client_trace_suffix_function_set(char* (*suffix_f)(void) ); +void mbed_client_trace_suffix_function_set( trace_t* self, char* (*suffix_f)(void) ); /** * Set trace print function * By default, trace module print using printf() function, - * but with this you can write own print function, + * but with self you can write own print function, * for e.g. to other IO device. */ -void mbed_client_trace_print_function_set( void (*print_f)(const char*) ); +void mbed_client_trace_print_function_set( trace_t* self, void (*print_f)(const char*) ); /** * Set trace print function for tr_cmdline() */ -void mbed_client_trace_cmdprint_function_set( void (*printf)(const char*) ); +void mbed_client_trace_cmdprint_function_set( trace_t* self, void (*printf)(const char*) ); /** * When trace group contains text in filters, * trace print will be ignored. * e.g.: - * mbed_client_trace_exclude_filters_set("mygr"); - * mbed_tracef(TRACE_ACTIVE_LEVEL_DEBUG, "ougr", "This is not printed"); + * mbed_client_trace_exclude_filters_set(g_trace, "mygr"); + * mbed_tracef(g_trace, TRACE_ACTIVE_LEVEL_DEBUG, "ougr", "This is not printed"); */ -void mbed_client_trace_exclude_filters_set(char* filters); +void mbed_client_trace_exclude_filters_set( trace_t* self, char* filters); /** get trace exclude filters */ -const char* mbed_client_trace_exclude_filters_get(void); +const char* mbed_client_trace_exclude_filters_get( trace_t* self); /** * When trace group contains text in filter, * trace will be printed. * e.g.: - * set_trace_include_filters("mygr"); - * mbed_tracef(TRACE_ACTIVE_LEVEL_DEBUG, "mygr", "Hi There"); - * mbed_tracef(TRACE_ACTIVE_LEVEL_DEBUG, "grp2", "This is not printed"); + * set_trace_include_filters(g_trace, "mygr"); + * mbed_tracef(g_trace, TRACE_ACTIVE_LEVEL_DEBUG, "mygr", "Hi There"); + * mbed_tracef(g_trace, TRACE_ACTIVE_LEVEL_DEBUG, "grp2", "This is not printed"); */ -void mbed_client_trace_include_filters_set(char* filters); +void mbed_client_trace_include_filters_set( trace_t* self, char* filters); /** get trace include filters */ -const char* mbed_client_trace_include_filters_get(void); +const char* mbed_client_trace_include_filters_get( trace_t* self); /** * General trace function * This should be used every time when user want to print out something important thing * Usage e.g. - * mbed_tracef( TRACE_LEVEL_INFO, "mygr", "Hello world!"); + * mbed_tracef( g_trace, TRACE_LEVEL_INFO, "mygr", "Hello world!"); * * @param dlevel debug level * @param grp trace group * @param fmt trace format (like printf) * @param ... variable arguments related to fmt */ -void mbed_tracef(uint8_t dlevel, const char* grp, const char *fmt, ...) __attribute__ ((__format__(__printf__, 3, 4))); +void mbed_tracef( trace_t* self, uint8_t dlevel, const char* grp, const char *fmt, ...) __attribute__ ((__format__(__printf__, 4, 5))); /** * Get last trace from buffer */ -const char* mbed_trace_last(void); +const char* mbed_trace_last(trace_t* self); #if MBED_CLIENT_TRACE_FEA_IPV6 == 1 /** * tracef helping function for convert ipv6 * table to human readable string. * usage e.g. * char ipv6[16] = {...}; // ! array length is 16 bytes ! - * mbed_tracef(TRACE_LEVEL_INFO, "mygr", "ipv6 addr: %s", trace_ipv6(ipv6)); + * mbed_tracef(g_trace, TRACE_LEVEL_INFO, "mygr", "ipv6 addr: %s", trace_ipv6(g_trace, ipv6)); * * @param add_ptr IPv6 Address pointer * @return temporary buffer where ipv6 is in string format */ -char* mbed_trace_ipv6(const void *addr_ptr); +char* mbed_trace_ipv6( trace_t* self, const void *addr_ptr); /** * tracef helping function for print ipv6 prefix * usage e.g. * char ipv6[16] = {...}; // ! array length is 16 bytes ! - * mbed_tracef(TRACE_LEVEL_INFO, "mygr", "ipv6 addr: %s", trace_ipv6_prefix(ipv6, 4)); + * mbed_tracef(g_trace, TRACE_LEVEL_INFO, "mygr", "ipv6 addr: %s", trace_ipv6_prefix(g_trace, ipv6, 4)); * * @param prefix IPv6 Address pointer * @param prefix_len prefix length * @return temporary buffer where ipv6 is in string format */ -char* mbed_trace_ipv6_prefix(const uint8_t *prefix, uint8_t prefix_len); +char* mbed_trace_ipv6_prefix( trace_t* self, const uint8_t *prefix, uint8_t prefix_len); #endif /** * tracef helping function for convert hex-array to string. * usage e.g. * char myarr[] = {0x10, 0x20}; - * mbed_tracef(TRACE_LEVEL_INFO, "mygr", "arr: %s", trace_array(myarr, 2)); + * mbed_tracef(g_trace, TRACE_LEVEL_INFO, "mygr", "arr: %s", trace_array(myarr, 2)); * * @param buf hex array pointer * @param len buffer length * @return temporary buffer where string copied */ -char* mbed_trace_array(const uint8_t* buf, uint16_t len); +char* mbed_trace_array( trace_t* self, const uint8_t* buf, uint16_t len); #else //__GNUC__ || __CC_ARM -int mbed_client_trace_init( void ); -void mbed_client_trace_free( void ); -void mbed_client_trace_config_set(uint8_t config); -void mbed_client_trace_prefix_function_set( char* (*pref_f)(size_t) ); -void mbed_client_trace_suffix_function_set(char* (*suffix_f)(void) ); -void mbed_client_trace_print_function_set( void (*print_f)(const char*) ); -void mbed_client_trace_cmdprint_function_set( void (*printf)(const char*) ); -void mbed_client_trace_exclude_filters_set(char* filters); -const char* mbed_client_trace_exclude_filters_get(void); -void mbed_client_trace_include_filters_set(char* filters); -const char* mbed_client_trace_include_filters_get(void); -void mbed_tracef(uint8_t dlevel, const char* grp, const char *fmt, ...); -const char* mbed_trace_last(void); -char* mbed_trace_array(const uint8_t* buf, uint16_t len); +const char* mbed_client_trace_get_version(void); +trace_t* mbed_client_trace_init( trace_t* self ); +trace_t* mbed_client_trace_free( trace_t* self ); +void mbed_client_trace_config_set( trace_t* self, uint8_t config); +void mbed_client_trace_prefix_function_set( trace_t* self, char* (*pref_f)(size_t) ); +void mbed_client_trace_suffix_function_set( trace_t* self, char* (*suffix_f)(void) ); +void mbed_client_trace_print_function_set( trace_t* self, void (*print_f)(const char*) ); +void mbed_client_trace_cmdprint_function_set( trace_t* self, void (*printf)(const char*) ); +void mbed_client_trace_exclude_filters_set( trace_t* self, char* filters); +const char* mbed_client_trace_exclude_filters_get( trace_t* self); +void mbed_client_trace_include_filters_set( trace_t* self, char* filters); +const char* mbed_client_trace_include_filters_get( trace_t* self); +void mbed_tracef( trace_t* self, uint8_t dlevel, const char* grp, const char *fmt, ...); +const char* mbed_trace_last( trace_t* self); +char* mbed_trace_ipv6(trace_t* self, const void *addr_ptr); +char* mbed_trace_array(trace_t* self, const uint8_t* buf, uint16_t len); #if MBED_CLIENT_TRACE_FEA_IPV6 == 1 -char* mbed_trace_ipv6(const void *addr_ptr); -char* mbed_trace_ipv6_prefix(const uint8_t *prefix, uint8_t prefix_len); +char* mbed_trace_ipv6(trace_t* self, const void *addr_ptr); +char* mbed_trace_ipv6_prefix(trace_t* self, const uint8_t *prefix, uint8_t prefix_len); #endif #endif @@ -291,11 +320,13 @@ char* mbed_trace_ipv6_prefix(const uint8_t *prefix, uint8_t prefix_len); #define mbed_trace_last(...) ((void) 0) #define mbed_tracef(...) ((void) 0) -#define mbed_trace_ipv6(...) ((void) 0) #define mbed_trace_array(...) ((void) 0) +#if MBED_CLIENT_TRACE_FEA_IPV6 == 1 +#define mbed_trace_ipv6(...) ((void) 0) #define mbed_trace_ipv6_prefix(...) ((void) 0) +#endif -#endif //YOTTA_CFG_MBED_CLIENT_TRACE +#endif // __GNUC__ || __CC_ARM #ifdef __cplusplus } diff --git a/source/mbed_client_trace.c b/source/mbed_client_trace.c index 195bc31..0d86205 100644 --- a/source/mbed_client_trace.c +++ b/source/mbed_client_trace.c @@ -26,15 +26,20 @@ #if MBED_CLIENT_TRACE_FEA_IPV6 == 1 #include "mbed-client-trace/mbed_client_trace_ip6string.h" #endif - #if defined(_WIN32) || defined(__unix__) || defined(__unix) || defined(unix) || defined(YOTTA_CFG) +// typedef +#include +#include + #ifndef MEM_ALLOC #define MEM_ALLOC malloc #endif #ifndef MEM_FREE #define MEM_FREE free #endif + #else // _WIN32|__unix__|__unix|unix + #include "nsdynmemLIB.h" #ifndef MEM_ALLOC #define MEM_ALLOC ns_dyn_mem_alloc @@ -42,6 +47,7 @@ #ifndef MEM_FREE #define MEM_FREE ns_dyn_mem_free #endif + #endif #define VT100_COLOR_ERROR "\x1b[31m" @@ -90,145 +96,169 @@ typedef struct trace_s { void (*cmd_printf)(const char *); } trace_t; -static trace_t m_trace = { - .filters_exclude = 0, - .filters_include = 0, - .line = 0, - .tmp_data = 0, - .prefix_f = 0, - .suffix_f = 0, - .printf = 0, - .cmd_printf = 0 -}; +#define YOTTA_CFG_TRACE +#include "mbed-client-trace/mbed_client_trace.h" +#if MBED_CLIENT_TRACE_FEA_IPV6 == 1 +#include "mbed-client-trace/mbed_client_trace_ip6string.h" +#endif + + +trace_t *g_trace; -int mbed_client_trace_init(void) +const char* mbed_client_trace_get_version(void) { - m_trace.trace_config = TRACE_MODE_COLOR | TRACE_ACTIVE_LEVEL_ALL | TRACE_CARRIAGE_RETURN; - m_trace.line_length = DEFAULT_TRACE_LINE_LENGTH; - if (m_trace.line == NULL) { - m_trace.line = MEM_ALLOC(m_trace.line_length); + return YOTTA_COMPONENT_VERSION; +} + +trace_t* mbed_client_trace_init(trace_t *self) +{ + if( !self ){ + g_trace = malloc(sizeof(trace_t)); + if( !g_trace ) { + return NULL; + } + self = g_trace; + } + self->filters_exclude = 0; + self->filters_include = 0; + self->line = 0; + self->tmp_data = 0; + self->prefix_f = 0; + self->suffix_f = 0; + self->printf = 0; + self->cmd_printf = 0; + + self->trace_config = TRACE_MODE_COLOR | TRACE_ACTIVE_LEVEL_ALL | TRACE_CARRIAGE_RETURN; + self->line_length = DEFAULT_TRACE_LINE_LENGTH; + if (self->line == NULL) { + self->line = MEM_ALLOC(self->line_length); } - m_trace.tmp_data_length = DEFAULT_TRACE_TMP_LINE_LEN; - if (m_trace.tmp_data == NULL) { - m_trace.tmp_data = MEM_ALLOC(m_trace.tmp_data_length); + self->tmp_data_length = DEFAULT_TRACE_TMP_LINE_LEN; + if (self->tmp_data == NULL) { + self->tmp_data = MEM_ALLOC(self->tmp_data_length); } - m_trace.tmp_data_ptr = m_trace.tmp_data; - m_trace.filters_length = DEFAULT_TRACE_FILTER_LENGTH; - if (m_trace.filters_exclude == NULL) { - m_trace.filters_exclude = MEM_ALLOC(m_trace.filters_length); + self->tmp_data_ptr = self->tmp_data; + self->filters_length = DEFAULT_TRACE_FILTER_LENGTH; + if (self->filters_exclude == NULL) { + self->filters_exclude = MEM_ALLOC(self->filters_length); } - if (m_trace.filters_include == NULL) { - m_trace.filters_include = MEM_ALLOC(m_trace.filters_length); + if (self->filters_include == NULL) { + self->filters_include = MEM_ALLOC(self->filters_length); } - if (m_trace.line == NULL || - m_trace.tmp_data == NULL || - m_trace.filters_exclude == NULL || - m_trace.filters_include == NULL) { + if (self->line == NULL || + self->tmp_data == NULL || + self->filters_exclude == NULL || + self->filters_include == NULL) { //memory allocation fail - mbed_client_trace_free(); - return -1; + self = mbed_client_trace_free(self); + return self; } - memset(m_trace.tmp_data, 0, m_trace.tmp_data_length); - memset(m_trace.filters_exclude, 0, m_trace.filters_length); - memset(m_trace.filters_include, 0, m_trace.filters_length); - memset(m_trace.line, 0, m_trace.line_length); + memset(self->tmp_data, 0, self->tmp_data_length); + memset(self->filters_exclude, 0, self->filters_length); + memset(self->filters_include, 0, self->filters_length); + memset(self->line, 0, self->line_length); - m_trace.prefix_f = 0; - m_trace.suffix_f = 0; - m_trace.printf = mbed_client_trace_default_print; - m_trace.cmd_printf = 0; + self->prefix_f = 0; + self->suffix_f = 0; + self->printf = mbed_client_trace_default_print; + self->cmd_printf = 0; - return 0; + return self; } -void mbed_client_trace_free(void) +trace_t* mbed_client_trace_free(trace_t *self) { - MEM_FREE(m_trace.line); - m_trace.line_length = 0; - m_trace.line = 0; - MEM_FREE(m_trace.tmp_data); - m_trace.tmp_data = 0; - m_trace.tmp_data_ptr = 0; - MEM_FREE(m_trace.filters_exclude); - m_trace.filters_exclude = 0; - MEM_FREE(m_trace.filters_include); - m_trace.filters_include = 0; - m_trace.filters_length = 0; - m_trace.prefix_f = 0; - m_trace.suffix_f = 0; - m_trace.printf = mbed_client_trace_default_print; - m_trace.cmd_printf = 0; + if(!self){ + self = g_trace; + } + if(!self){ + return NULL; + } + MEM_FREE(self->line); + self->line_length = 0; + self->line = 0; + MEM_FREE(self->tmp_data); + self->tmp_data = 0; + self->tmp_data_ptr = 0; + MEM_FREE(self->filters_exclude); + self->filters_exclude = 0; + MEM_FREE(self->filters_include); + self->filters_include = 0; + self->filters_length = 0; + free(self); + self = NULL; + return self; } /** @TODO do we need dynamically change trace buffer sizes ? // reconfigure trace buffer sizes void set_trace_buffer_sizes(int lineLength, int tmpLength) { - REALLOC( m_trace.line, dataLength ); - REALLOC( m_trace.tmp_data, tmpLength); - m_trace.tmp_data_length = tmpLength; + REALLOC( self->line, dataLength ); + REALLOC( self->tmp_data, tmpLength); + self->tmp_data_length = tmpLength; } */ -void mbed_client_trace_config_set(uint8_t config) +void mbed_client_trace_config_set( trace_t* self, uint8_t config) { - m_trace.trace_config = config; + self->trace_config = config; } -uint8_t mbed_client_trace_config_get(void) +uint8_t mbed_client_trace_config_get( trace_t* self) { - return m_trace.trace_config; + return self->trace_config; } -void mbed_client_trace_prefix_function_set(char *(*pref_f)(size_t)) +void mbed_client_trace_prefix_function_set( trace_t* self, char *(*pref_f)(size_t)) { - m_trace.prefix_f = pref_f; + self->prefix_f = pref_f; } -void mbed_client_trace_suffix_function_set(char *(*suffix_f)(void)) +void mbed_client_trace_suffix_function_set( trace_t* self, char *(*suffix_f)(void)) { - m_trace.suffix_f = suffix_f; + self->suffix_f = suffix_f; } -void mbed_client_trace_print_function_set(void (*printf)(const char *)) +void mbed_client_trace_print_function_set( trace_t* self, void (*printf)(const char *)) { - m_trace.printf = printf; + self->printf = printf; } -void mbed_client_trace_cmdprint_function_set(void (*printf)(const char *)) +void mbed_client_trace_cmdprint_function_set( trace_t* self, void (*printf)(const char *)) { - m_trace.cmd_printf = printf; + self->cmd_printf = printf; } -void mbed_client_trace_exclude_filters_set(char *filters) +void mbed_client_trace_exclude_filters_set( trace_t* self, char *filters) { if (filters) { - (void)strncpy(m_trace.filters_exclude, filters, m_trace.filters_length); + (void)strncpy(self->filters_exclude, filters, self->filters_length); } else { - m_trace.filters_exclude[0] = 0; + self->filters_exclude[0] = 0; } } -const char *mbed_client_trace_exclude_filters_get(void) +const char *mbed_client_trace_exclude_filters_get( trace_t* self) { - return m_trace.filters_exclude; + return self->filters_exclude; } -const char *mbed_client_trace_include_filters_get(void) +const char *mbed_client_trace_include_filters_get( trace_t* self) { - return m_trace.filters_include; + return self->filters_include; } -void mbed_client_trace_include_filters_set(char *filters) +void mbed_client_trace_include_filters_set( trace_t* self, char *filters) { if (filters) { - (void)strncpy(m_trace.filters_include, filters, m_trace.filters_length); + (void)strncpy(self->filters_include, filters, self->filters_length); } else { - m_trace.filters_include[0] = 0; + self->filters_include[0] = 0; } } -static int8_t mbed_client_trace_skip(int8_t dlevel, const char *grp) +static int8_t mbed_client_trace_skip( trace_t* self, int8_t dlevel, const char *grp) { if (dlevel >= 0 && grp != 0) { // filter debug prints only when dlevel is >0 and grp is given - /// @TODO this could be much better.. - if (m_trace.filters_exclude[0] != '\0' && - strstr(m_trace.filters_exclude, grp) != 0) { + /// @TODO self could be much better.. + if (self->filters_exclude[0] != '\0' && + strstr(self->filters_exclude, grp) != 0) { //grp was in exclude list return 1; } - if (m_trace.filters_include[0] != '\0' && - strstr(m_trace.filters_include, grp) == 0) { + if (self->filters_include[0] != '\0' && + strstr(self->filters_include, grp) == 0) { //grp was in include list return 1; } @@ -239,31 +269,31 @@ static void mbed_client_trace_default_print(const char *str) { puts(str); } -void mbed_tracef(uint8_t dlevel, const char *grp, const char *fmt, ...) +void mbed_tracef( trace_t* self, uint8_t dlevel, const char *grp, const char *fmt, ...) { - m_trace.line[0] = 0; //by default trace is empty - if (mbed_client_trace_skip(dlevel, grp) || fmt == 0 || grp == 0) { + self->line[0] = 0; //by default trace is empty + if (mbed_client_trace_skip(self, dlevel, grp) || fmt == 0 || grp == 0) { return; } - if ((m_trace.trace_config & TRACE_MASK_LEVEL) & dlevel) { - bool color = (m_trace.trace_config & TRACE_MODE_COLOR) != 0; - bool plain = (m_trace.trace_config & TRACE_MODE_PLAIN) != 0; - bool cr = (m_trace.trace_config & TRACE_CARRIAGE_RETURN) != 0; + if ((self->trace_config & TRACE_MASK_LEVEL) & dlevel) { + bool color = (self->trace_config & TRACE_MODE_COLOR) != 0; + bool plain = (self->trace_config & TRACE_MODE_PLAIN) != 0; + bool cr = (self->trace_config & TRACE_CARRIAGE_RETURN) != 0; - int retval = 0, bLeft = m_trace.line_length; - char *ptr = m_trace.line; + int retval = 0, bLeft = self->line_length; + char *ptr = self->line; if (plain == true || dlevel == TRACE_LEVEL_CMD) { va_list ap; va_start(ap, fmt); //add trace data retval = vsnprintf(ptr, bLeft, fmt, ap); va_end(ap); - if (dlevel == TRACE_LEVEL_CMD && m_trace.cmd_printf) { - m_trace.cmd_printf(m_trace.line); - m_trace.cmd_printf("\n"); + if (dlevel == TRACE_LEVEL_CMD && self->cmd_printf) { + self->cmd_printf(self->line); + self->cmd_printf("\n"); } else { //print out whole data - m_trace.printf(m_trace.line); + self->printf(self->line); } } else { if (color) { @@ -307,14 +337,14 @@ void mbed_tracef(uint8_t dlevel, const char *grp, const char *fmt, ...) } } - if (bLeft > 0 && m_trace.prefix_f) { + if (bLeft > 0 && self->prefix_f) { va_list ap; va_start(ap, fmt); //find out length of body size_t sz = 0; sz = vsnprintf(NULL, 0, fmt, ap) + retval + (retval ? 4 : 0); //add prefix string - retval = snprintf(ptr, bLeft, "%s", m_trace.prefix_f(sz)); + retval = snprintf(ptr, bLeft, "%s", self->prefix_f(sz)); if (retval >= bLeft) { retval = 0; } @@ -366,9 +396,9 @@ void mbed_tracef(uint8_t dlevel, const char *grp, const char *fmt, ...) va_end(ap); } - if (retval > 0 && bLeft > 0 && m_trace.suffix_f) { + if (retval > 0 && bLeft > 0 && self->suffix_f) { //add suffix string - retval = snprintf(ptr, bLeft, "%s", m_trace.suffix_f()); + retval = snprintf(ptr, bLeft, "%s", self->suffix_f()); if (retval >= bLeft) { retval = 0; } @@ -390,22 +420,23 @@ void mbed_tracef(uint8_t dlevel, const char *grp, const char *fmt, ...) } } //print out whole data - m_trace.printf(m_trace.line); + self->printf(self->line); } //return tmp data pointer back to the beginning - m_trace.tmp_data_ptr = m_trace.tmp_data; + self->tmp_data_ptr = self->tmp_data; } } -const char *mbed_trace_last(void) +const char *mbed_trace_last(trace_t* self) { - return m_trace.line; + return self->line; } /* Helping functions */ -#define tmp_data_left() m_trace.tmp_data_length-(m_trace.tmp_data_ptr-m_trace.tmp_data) +#define tmp_data_left() self->tmp_data_length-(self->tmp_data_ptr-self->tmp_data) + #if MBED_CLIENT_TRACE_FEA_IPV6 == 1 -char *mbed_trace_ipv6(const void *addr_ptr) +char *mbed_trace_ipv6(trace_t* self, const void *addr_ptr) { - char *str = m_trace.tmp_data_ptr; + char *str = self->tmp_data_ptr; if (str == NULL) { return ""; } @@ -417,12 +448,12 @@ char *mbed_trace_ipv6(const void *addr_ptr) } str[0] = 0; mbed_client_trace_ip6tos(addr_ptr, str); - m_trace.tmp_data_ptr += strlen(str) + 1; + self->tmp_data_ptr += strlen(str) + 1; return str; } -char *mbed_trace_ipv6_prefix(const uint8_t *prefix, uint8_t prefix_len) +char *mbed_trace_ipv6_prefix(trace_t* self, const uint8_t *prefix, uint8_t prefix_len) { - char *str = m_trace.tmp_data_ptr; + char *str = self->tmp_data_ptr; int retval, bLeft = tmp_data_left(); char tmp[40]; uint8_t addr[16] = {0}; @@ -451,15 +482,15 @@ char *mbed_trace_ipv6_prefix(const uint8_t *prefix, uint8_t prefix_len) return ""; } - m_trace.tmp_data_ptr += retval + 1; + self->tmp_data_ptr += retval + 1; return str; } #endif -char *mbed_trace_array(const uint8_t *buf, uint16_t len) +char *mbed_trace_array(trace_t* self, const uint8_t *buf, uint16_t len) { int i, retval, bLeft = tmp_data_left(); char *str, *wptr; - str = m_trace.tmp_data_ptr; + str = self->tmp_data_ptr; if (str == NULL) { return ""; } @@ -483,6 +514,6 @@ char *mbed_trace_array(const uint8_t *buf, uint16_t len) if (wptr > str) { *(wptr - 1) = 0; //null to replace last ':' character } - m_trace.tmp_data_ptr = wptr; + self->tmp_data_ptr = wptr; return str; } diff --git a/test/Test.cpp b/test/Test.cpp index 08a7ff1..7a7ad71 100644 --- a/test/Test.cpp +++ b/test/Test.cpp @@ -16,7 +16,7 @@ #include "mbed-cpputest/CppUTest/CommandLineTestRunner.h" #define MBED_CLIENT_TRACE_FEA_IPV6 1 -#define YOTTA_CFG_MBED_CLIENT_TRACE +#define YOTTA_CFG_TRACE #include "mbed-client-trace/mbed_client_trace.h" int main(int ac, char **av) @@ -29,35 +29,38 @@ void myprint(const char* str) { strcpy(buf, str); } - TEST_GROUP(trace) { void setup() { - - mbed_client_trace_init(); - mbed_client_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL); - mbed_client_trace_print_function_set( myprint ); + mbed_client_trace_init(0); + mbed_client_trace_config_set(g_trace, TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL); + mbed_client_trace_print_function_set( g_trace, myprint ); } void teardown() { - mbed_client_trace_free(); + mbed_client_trace_free(g_trace); } }; +TEST(trace, version) +{ + STRCMP_EQUAL("0.1.0", mbed_client_trace_get_version(g_trace) ); +} + /* Unity test code starts */ TEST(trace, Array) { unsigned char longStr[200] = {0x66}; for(int i=0;i<200;i++) {longStr[i] = 0x66; } - mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", mbed_trace_array(longStr, 200) ); + mbed_tracef(g_trace, TRACE_LEVEL_DEBUG, "mygr", "%s", mbed_trace_array(longStr, 1000) ); } TEST(trace, LongString) { char longStr[1000] = {0x36}; for(int i=0;i<999;i++) {longStr[i] = 0x36; } - mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", longStr ); + mbed_tracef(g_trace, TRACE_LEVEL_DEBUG, "mygr", longStr ); } TEST(trace, TooLong) @@ -67,8 +70,8 @@ TEST(trace, TooLong) char longStr[TOO_LONG_SIZE] = {0}; for(int i=0;i][DBG ][mygr]: test", buf); //TEST_ASSERT_EQUAL_INT(4, time_length); - mbed_client_trace_config_set(TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_PLAIN); - mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test"); + mbed_client_trace_config_set(g_trace, TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_PLAIN); + mbed_tracef(g_trace, TRACE_LEVEL_DEBUG, "mygr", "test"); STRCMP_EQUAL("test", buf); - mbed_client_trace_config_set(TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_COLOR); - mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "test"); + mbed_client_trace_config_set(g_trace, TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_COLOR); + mbed_tracef(g_trace, TRACE_LEVEL_ERROR, "mygr", "test"); STRCMP_EQUAL("\x1b[31m[