util.h

Go to the documentation of this file.

/************************************************************************/
#ifndef _UTIL_H_
#define _UTIL_H_
 
#include <stdint.h>
#include <stddef.h>
 
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
 
#ifndef NULL
#define NULL ((void*)0)
#endif
 
#define _STR(item)  #item
#define STR(item)   _STR(item)
 
#define IN_RANGE(num, lower, upper)                 \
    (((number) >= (lower)) && ((number) <= (upper)))
 
#define container_of(ptr, type, member) ({              \
        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
        (type *)( (char *)__mptr - offsetof(type,member) );})
 
#define PACKED      __attribute__((__packed__))
 
#define SECTION(name)   __attribute__((section(#name)))
 
#define ROM_TEXT(name)  SECTION(.text.ro_text.name)
#define ROM_DATA(name)  SECTION(.text.ro_data.name)
 
#define ARRAY_ROWS(array_2d)        (sizeof(array_2d) / sizeof(array_2d[0]) / sizeof(array_2d[0][0]))
#define ARRAY_COLS(array_2d)        (sizeof(array_2d[0]) / sizeof(array_2d[0][0]))
 
#define UNUSED_PARAM(x)     (void)x
 
#if !defined(MAX)
#define MAX(a, b)   ((a)>(b)?(a):(b))
#endif
#if !defined(MIN)
#define MIN(a, b)   ((a)<(b)?(a):(b))
#endif
 
#define ByteSwapWord(w) (uint16_t)((((uint16_t)(w))>>8) | (((uint16_t)(w))<<8))
 
#define ByteSwapDWord(dw)   (uint32_t)((((uint32_t)(dw))>>24) |               \
        ((((uint32_t)(dw))>>8) & 0xFF00) | ((((uint32_t)(dw)) & 0xFF00)<<8) | \
        (((uint32_t)(dw))<<24))
 
/************************************************************************/
static inline void to_upper(char *str) {
    uint16_t i;
    for (i = 0; str[i] != '\0'; i++) {
        if ((str[i] >= 'a') && (str[i] <= 'z'))
            str[i] -= 'a' - 'A';
    }
}
 
/************************************************************************/
const char *str_is_uint8(const char *str);
 
/************************************************************************/
int ip_validate(const char *str);
 
/************************************************************************/
int uint32_to_ip_str(uint32_t ip_u32, char *ip_str);
 
/************************************************************************/
uint32_t ip_str_to_uint32(const char *ip);
 
/************************************************************************/
uint16_t uint8_to_str(uint8_t num, char *str);
 
/************************************************************************/
int8_t int8_to_str(int8_t num, char *str);
 
/************************************************************************/
uint8_t uint16_to_str(uint16_t num, char *str);
 
/************************************************************************/
uint8_t int16_to_str(int16_t num, char *str);
 
/************************************************************************/
const char *str_to_uint8(const char *strIn, uint8_t *result);
 
/************************************************************************/
int long_to_str(long num, char *str, int buf_len, int pad_len, char pad_chr);
 
/************************************************************************/
void uint8_to_hex_str(uint8_t num, char *str);
 
/************************************************************************/
int uint32_to_hex_str(uint32_t num, char *str, int pad);
 
/************************************************************************/
int version_to_str(const uint8_t version[3], char *str);
 
/************************************************************************/
int version_cmp(const uint8_t old[3], const uint8_t cur[3]);
 
/************************************************************************/
uint16_t concat_strings(const char **str, uint8_t num_strs, char *output,
        uint16_t max_len);
 
/************************************************************************/
uint16_t concat_kv_pairs(const char **key, const char **value,
        uint8_t num_pairs, char *output, uint16_t max_len);
 
#ifndef TRUE
#define TRUE 1
#define TRUE 1
#define FALSE 0
#endif
 
#endif //_UTIL_H_