macro.h

vt6528芯片交换机API函数和文档运行程序

/*
 * File:    macro.h
 *
 * Purpose: Define basic common types and macros
 */


#ifndef __MACRO_H__
#define __MACRO_H__

#if !defined(__TTYPE_H__)
#include "ttype.h"
#endif




/****** Common helper macros *************************************************/

//--------------------------------------
// Macros for various length data split and combine
//--------------------------------------
#if !defined(LONIBBLE)
#define LONIBBLE(b)         ((UINT8)(b) & 0x0F)
#endif

#if !defined(HINIBBLE)
#define HINIBBLE(b)         ((UINT8)(((UINT16)(b) >> 4) & 0x0F))
#endif


#if !defined(LOBYTE)
#define LOBYTE(w)           ((UINT8)(w))
#endif

#if !defined(HIBYTE)
#define HIBYTE(w)           ((UINT8)((UINT16)(w) >> 8))
#endif


#if !defined(LOWORD)
#define LOWORD(d)           ((UINT16)(d))
#endif

#if !defined(HIWORD)
#define HIWORD(d)           ((UINT16)(((UINT32)(d)) >> 16))
#endif


#if !defined(MAKEBYTE)
#define MAKEBYTE(ln, hn)    ((UINT8)(((UINT8)(ln) & 0x0F) | ((UINT8)(hn) << 4)))
#endif

#if !defined(MAKEWORD)
#define MAKEWORD(lb, hb)    ((UINT16)(((UINT8)(lb)) | (((UINT16)((UINT8)(hb))) << 8)))
#endif

#if !defined(MAKEDWORD)
#define MAKEDWORD(lw, hw)   ((UINT32)(((UINT16)(lw)) | (((UINT32)((UINT16)(hw))) << 16)))
#endif


//--------------------------------------
// Macros for swap two data
//--------------------------------------
#ifndef SWAPBYTE
#define SWAPBYTE(a, b)      do { UINT8 tmp; tmp = (a); (a) = (b); (b) = tmp; } while (0)
#endif

#ifndef SWAPWORD
#define SWAPWORD(a, b)      do { UINT16 tmp; tmp = (a); (a) = (b); (b) = tmp; } while (0)
#endif

#ifndef SWAPDWORD
#define SWAPDWORD(a, b)     do { UINT32 tmp; tmp = (a); (a) = (b); (b) = tmp; } while (0)
#endif


//--------------------------------------
// Macros for endian convert
//--------------------------------------
#if !defined(REV_WORD)
    #define REV_WORD(n)         ( (UINT16)((((UINT16)(n)) << 8) | ((UINT16)(n) >> 8)) )
#endif

#if !defined(REV_DWORD)
    #define REV_DWORD(n)        ( (UINT32) (                            \
                                (((UINT32)(n) & 0x000000FFUL) << 24) |  \
                                (((UINT32)(n) & 0x0000FF00UL) << 8) |   \
                                (((UINT32)(n) & 0x00FF0000UL) >> 8) |   \
                                (((UINT32)(n)) >> 24) ))
#endif


// big endian to little endian convert
#if !defined(HTONS)
    #if defined(__BIG_ENDIAN)
    #define HTONS(n)            (n)
    #else
    #define HTONS(n)            REV_WORD(n)
    #endif
#endif /* HTONS */

#if !defined(HTONL)
    #if defined(__BIG_ENDIAN)
    #define HTONL(n)            (n)
    #else
    #define HTONL(n)            REV_DWORD(n)
    #endif
#endif /* HTONL */


#ifndef NTOHS
#define NTOHS               HTONS
#endif
#ifndef NTOHL
#define NTOHL               HTONL
#endif


/* map to known network names */
#ifndef ntohs
#define ntohs(x)            NTOHS(x)
#endif

#ifndef htons
#define htons(x)            HTONS(x)
#endif

#ifndef ntohl
#define ntohl(x)            NTOHL(x)
#endif

#ifndef htonl
#define htonl(x)            HTONL(x)
#endif


//--------------------------------------
// Macros for min, max
//--------------------------------------
#ifndef NOMINMAX

#ifndef max
#define max(a, b)           (((a) > (b)) ? (a) : (b))
#endif

#ifndef min
#define min(a, b)           (((a) < (b)) ? (a) : (b))
#endif

#endif // NOMINMAX




/****** Misc macros **********************************************************/
// unreference argument macro to supress warnings
#define UNUSE_ARG(x)        do { (x) = (x); } while (0)


// calculate element # of array
#define ARRAY_SIZE(array)   (sizeof(array) / sizeof(array[0]))


// macro: uVar = (uVar + 1) % uModulo;
// but not to use % operatoor
#define ADD_ONE_WITH_WRAP_AROUND(uVar, uModulo) do {    \
    if ((uVar) >= ((uModulo) - 1))                      \
        (uVar) = 0;                                     \
    else                                                \
        (uVar)++;                                       \
} while (0)




#endif /* __MACRO_H__ */