ccdep.h

用于嵌入式系统的TCP/IP协议栈及若干服务

    #endif /* USE_DATA_MOVE_MACROS */

#endif


/************************************************************************
*                                                                       *
*           16 Bit Host Byte Order to Network Byte Order Conversion     *
*                                                                       *
************************************************************************/
#ifndef HostToNet16

#ifdef USE_DATA_ACCESS_MACROS   /* use data access macros */

#ifdef NONALIGNED_ACCESS        /* Processor allows non-aligned accesses */

#ifdef CPU_IS_BIG_ENDIAN   /* big endian processor definition */
#define HostToNet16(add,val) { *(u16 *)(add) = (val); }
#else               /* little endian processor definition*/
#define HostToNet16(add,val)  { \
    fast u16 htn16_value = val; \
    *(u8 *)(add)=(u8)(((htn16_value) >>8) & 0xff); \
    *((u8 *)(add) +1)=(u8)((htn16_value) & 0xff);}
#endif      /* CPU_IS_BIG_ENDIAN */

#else  /* processor does not allow non-aligned accesses */
#define HostToNet16(add,val)  { \
    fast u16 htn16_value = val; \
    *(u8 *)(add)=(u8)(((htn16_value) >>8) & 0xff); \
    *((u8 *)(add) +1)=(u8)((htn16_value) & 0xff);}

#endif      /* NONALIGNED_ACCESS */

#else       /* use data access functions (default) */

#ifdef COMPILER_INLINE /* Compiler-specific inline directive */
extern COMPILER_INLINE void HostToNet16(u8 *, u16);
#else
extern void HostToNet16(u8 *, u16);
#endif

#endif      /* USE_DATA_ACCESS_MACROS */
#endif      /* HostToNet16 */


/************************************************************************
*                                                                       *
*         16 Bit Network Byte Order To Host Byte Order Conversion       *
*                                                                       *
************************************************************************/
#ifndef NetToHost16

#ifdef USE_DATA_ACCESS_MACROS   /* use data access macros */
#ifdef NONALIGNED_ACCESS        /* Processor allows non-aligned accesses */

#ifdef CPU_IS_BIG_ENDIAN   /* big endian processor definition */
#define NetToHost16(add) *(u16 *)(add)

#else               /* little endian processor definition*/
#define NetToHost16(add)  \
       (u16)( ( (((u16)*(u8 *)(add)) << 8) & 0xFF00) |\
	   ((u16)*(((u8 *)(add)) + 1) & 0xFF) )
#endif      /* CPU_IS_BIG_ENDIAN */

#else               /* processor does not allow non-aligned accesses */
#define NetToHost16(add) \
    (u16)( ( (((u16)*(u8 *)(add)) << 8) & 0xFF00) |\
	   ((u16)*(((u8 *)(add)) + 1) & 0xFF) )

#endif      /* NONALIGNED_ACCESS */

#else       /* use data access functions (default) */

#ifdef COMPILER_INLINE  /* Compiler specific inline directive */
extern COMPILER_INLINE u16 NetToHost16(u8 *);
#else
extern u16 NetToHost16(u8 *);
#endif /* COMPILER_INLINE */


#endif      /* USE_DATA_ACCESS_MACROS */
#endif      /* NetToHost16 */


/************************************************************************
*                                                                       *
*       Move 16 Bit Value in Memory to Variable  (Host Byte Order)      *
*                                                                       *
************************************************************************/
#ifndef HostToMem16

#ifdef USE_DATA_ACCESS_MACROS

#ifdef NONALIGNED_ACCESS
#define HostToMem16(add, val) { *(u16 *)(add) = val; }
#else
#ifdef CPU_IS_BIG_ENDIAN
#define HostToMem16(add, val) { \
    *(u8 *)(add) = (u8)((val >> 8) & 0xFF); \
    *(((u8 *)(add)) + 1) = (u8)(val & 0xFF); \
}

#else               /* little endian */
#define HostToMem16(add, val) { \
    *(u8 *)(add) = (u8)(val & 0xFF); \
    *(((u8 *)(add)) + 1) = (u8)((val >> 8) & 0xFF); \
}

#endif      /* CPU_IS_BIG_ENDIAN */
#endif      /* NONALIGNED_ACCESS */

#else       /* use data access functions (default) */

#ifdef COMPILER_INLINE /* Compiler-specific inline directive */
extern COMPILER_INLINE void HostToMem16 (u8 *, u16);
#else
extern void HostToMem16 (u8 *, u16);
#endif /* COMPILER_INLINE */

#endif      /* USE_DATA_ACCESS_MACROS */
#endif      /* HostToMem16 */


/************************************************************************
*                                                                       *
*     Move 16 Bit Variable To Location in Memory (Host Byte Order)      *
*                                                                       *
************************************************************************/
#ifndef MemToHost16

#ifdef USE_DATA_ACCESS_MACROS

#ifdef NONALIGNED_ACCESS
#define MemToHost16(add) *(u16 *)(add)
#else
#ifdef CPU_IS_BIG_ENDIAN
#define MemToHost16(add) \
   ( ((u16)(*(u8 *)(add) & 0xFF) << 8) | \
      ((u16)*(((u8 *)(add)) + 1) & 0xFF) )

#else               /* little endian */
#define MemToHost16(add) \
    ( ((u16)*(u8 *)(add) & 0xFF) | \
     ( ( ( (u16)*((u8 *)(add) + 1) & 0xFF) << 8) ) )

#endif      /* CPU_IS_BIG_ENDIAN */
#endif      /* NONALIGNED_ACCESS */

#else       /* use data access functions (default) */

#ifdef COMPILER_INLINE   /* Compiler-specific inline directive */
extern COMPILER_INLINE u16 MemToHost16 (u8 *);
#else               /* not using inline function, use macro definition  */
extern u16 MemToHost16 (u8 *);
#endif  /* COMPILER_INLINE */

#endif      /* USE_DATA_ACCESS_MACROS */
#endif      /* MemToHost16 */


/************************************************************************
*                                                                       *
*           32 Bit Host Byte Order to Network Byte Order Conversion     *
*                                                                       *
************************************************************************/
#ifndef HostToNet32

#ifdef USE_DATA_ACCESS_MACROS

#ifdef NONALIGNED_ACCESS        /* Processor allows non-aligned accesses */

#ifdef CPU_IS_BIG_ENDIAN   /* big endian processor definition */
#define HostToNet32(add,val) { *(u32 *)(add) = (val); }
#else               /* little endian processor definition*/
#define HostToNet32(add,val)  { \
    fast u32 htn32_value = val; \
    *(u8 *)(add)       = (u8)(((htn32_value) >> 24) & 0xff); \
    *((u8 *)(add) + 1) = (u8)(((htn32_value) >> 16) & 0xff); \
    *((u8 *)(add) + 2) = (u8)(((htn32_value) >> 8) & 0xff); \
	*((u8 *)(add) + 3) = (u8)((htn32_value) & 0xff); }
#endif      /* CPU_IS_BIG_ENDIAN */

#else               /* processor does not allow non-aligned accesses */
#define HostToNet32(add,val)  { \
    fast u32 htn32_value = val; \
    *(u8 *)(add)       = (u8)(((htn32_value) >> 24) & 0xff); \
    *((u8 *)(add) + 1) = (u8)(((htn32_value) >> 16) & 0xff); \
    *((u8 *)(add) + 2) = (u8)(((htn32_value) >> 8) & 0xff); \
	*((u8 *)(add) + 3) = (u8)((htn32_value) & 0xff); }

#endif      /* NONALIGNED_ACCESS */

#else       /* use data access functions (default) */

#ifdef COMPILER_INLINE              /* use user supplied inline data access function */
extern COMPILER_INLINE void HostToNet32(u8 *, u32);
#else               /* not using inline function, use macro definition  */
extern void HostToNet32(u8 *, u32);
#endif /* COMPILER_INLINE */

#endif      /* USE_DATA_ACCESS_FUNCTIONS */
#endif      /* HostToNet32 */


/************************************************************************
*                                                                       *
*         32 Bit Network Byte Order To Host Byte Order Conversion       *
*                                                                       *
************************************************************************/
#ifndef NetToHost32

#ifdef USE_DATA_ACCESS_MACROS

#ifdef NONALIGNED_ACCESS        /* Processor allows non-aligned accesses */

#ifdef CPU_IS_BIG_ENDIAN   /* big endian processor definition */
#define NetToHost32(add) *(u32 *)(add)

#else               /* little endian processor definition*/
#define NetToHost32(add)  \
      ( (((u32)*((u8 *)(add) + 0) << 24) & 0xFF000000) |\
        (((u32)*((u8 *)(add) + 1) << 16) & 0x00FF0000) |\
        (((u32)*((u8 *)(add) + 2) << 8) & 0x0000FF00) |\
	     ((u32)*((u8 *)(add) + 3) & 0x000000FF) )
#endif      /* CPU_IS_BIG_ENDIAN */

#else               /* processor does not allow non-aligned accesses */
#define NetToHost32(add) \
      ( (((u32)*((u8 *)(add) + 0) << 24) & 0xFF000000) |\
        (((u32)*((u8 *)(add) + 1) << 16) & 0x00FF0000) |\
        (((u32)*((u8 *)(add) + 2) << 8) & 0x0000FF00) |\
	     ((u32)*((u8 *)(add) + 3) & 0x000000FF) )

#endif      /* NONALIGNED_ACCESS */

#else       /* use data access functions (default) */

#ifdef COMPILER_INLINE   /* Compiler-specific inline directive */
extern COMPILER_INLINE u32 NetToHost32(u8 *);
#else               /* not using inline function, use macro definition  */
extern u32 NetToHost32(u8 *);
#endif      /* COMPILER_INLINE */

#endif      /* USE_DATA_ACCESS_FUNCTIONS */
#endif      /* NetToHost32 */


/************************************************************************
*                                                                       *
*       Move 32 Bit Value in Memory to Variable  (Host Byte Order)      *
*                                                                       *
************************************************************************/
#ifndef HostToMem32

#ifdef USE_DATA_ACCESS_MACROS

#ifdef NONALIGNED_ACCESS
#define HostToMem32(add, val) { *(u32 *)(add) = val; }
#else
#ifdef CPU_IS_BIG_ENDIAN
#define HostToMem32(add, val) { \
    *(u8 *)(add)         = (u8)((val >> 24) & 0xFF); \
    *(((u8 *)(add)) + 1) = (u8)((val >> 16) & 0xFF); \
    *(((u8 *)(add)) + 2) = (u8)((val >> 8) & 0xFF); \
    *(((u8 *)(add)) + 3) = (u8)(val & 0xFF); }

#else               /* little endian */
#define HostToMem32(add, val) { \
    *(u8 *)(add)         = (u8)(val & 0xFF); \
    *(((u8 *)(add)) + 1) = (u8)((val >> 8) & 0xFF); \
    *(((u8 *)(add)) + 2) = (u8)((val >> 16) & 0xFF); \
    *(((u8 *)(add)) + 3) = (u8)((val >> 24) & 0xFF); \
}

#endif      /* CPU_IS_BIG_ENDIAN */
#endif      /* NONALIGNED_ACCESS */

#else       /* use data access functions (default) */

#ifdef COMPILER_INLINE              /* use user supplied inline data access function */
extern COMPILER_INLINE void HostToMem32 (u8 *, u32);
#else               /* not using inline function, use macro definition  */
extern void HostToMem32 (u8 *, u32);
#endif      /* COMPILER_INLINE */

#endif      /* USE_DATA_ACCESS_FUNCTIONS */
#endif      /* HostToMem32 */


/************************************************************************
*                                                                       *
*     Move 32 Bit Variable To Location in Memory (Host Byte Order)      *
*                                                                       *
************************************************************************/
#ifndef MemToHost32

#ifdef USE_DATA_ACCESS_MACROS

#ifdef NONALIGNED_ACCESS
#define MemToHost32(add) *(u32 *)(add)
#else
#ifdef CPU_IS_BIG_ENDIAN
#define MemToHost32(add) \
        ( (((u32)*((u8 *)(add) + 0) & 0xFF) << 24) | \
          (((u32)*((u8 *)(add) + 1) & 0xFF) << 16) | \
          (((u32)*((u8 *)(add) + 2) & 0xFF) << 8) | \
           ((u32)*((u8 *)(add) + 3) & 0xFF) )

#else               /* little endian */
#define MemToHost32(add) \
         ( ((u32)*((u8 *)(add) + 0) & 0xFF) | \
          (((u32)*((u8 *)(add) + 1) & 0xFF) << 8) | \
          (((u32)*((u8 *)(add) + 2) & 0xFF) << 16) | \
          (((u32)*((u8 *)(add) + 3) & 0xFF) << 24) )

#endif      /* CPU_IS_BIG_ENDIAN */
#endif      /* NONALIGNED_ACCESS */
#else       /* use data access functions (default) */

#ifdef COMPILER_INLINE              /* use user supplied inline data access function */
extern COMPILER_INLINE u32 MemToHost32 (u8 *);
#else               /* not using inline function, use macro definition  */
extern u32 MemToHost32 (u8 *);
#endif      /* COMPILER_INLINE */

#endif      /* USE_DATA_ACCESS_FUNCTIONS */
#endif      /* MemToHost32 */

#define cheql                   md_cheql

#define a48eql(a1,a2) cheql((char *)a1, (char *)a2, sizeof(a48))


#endif  /*_CCDEP_*/