c4e_algo32.h (Version 551)

Go to the documentation of this file.

/****************************** -*- mode: C -*- ******************************/
#ifndef C4E_ALGO32_H
#define C4E_ALGO32_H


/* INCLUDES ******************************************************************/

#include "c4e_sys.h"


#ifdef  __cplusplus
extern "C" {
#endif


/* DEFINES *******************************************************************/


#define C4E_ALGO32_DIGIT_SIZE   sizeof(C4eAlgo32Digit)


/* MACRO *********************************************************************/
#if (C4E_ARCH_DIGIT_SIZE == 4U)
#define C4E_ALGO32_DIGITS_PTR(pvar32)   (pvar32)
#elif (C4E_ARCH_DIGIT_SIZE < 4U)
#define C4E_ALGO32_DIGITS_PTR(pvar32)   ((pvar32)->digits)

#define C4E_ALGO32_NUM_DIGITS           (4U / C4E_ARCH_DIGIT_SIZE)

#endif



/* TYPEDEFS ******************************************************************/

#if (C4E_ARCH_DIGIT_SIZE == 4U)

    typedef C4eArchDigit C4eAlgo32Uint;         
#elif (C4E_ARCH_DIGIT_SIZE < 4U)

    typedef struct
    {
        C4eArchDigit digits[C4E_ALGO32_NUM_DIGITS];
    } C4eAlgo32Uint;

#elif defined(C4E_HAVE_UINT32)

    typedef C4eArchUint32 C4eAlgo32Uint;

#else
#error "Cannot determine a 32-bit unsigned integer datatype."
#endif


#ifdef C4E_ALGO32_DIGITS_PTR /* size of C4eArchDigit less/equal than 32-bit ? */
    typedef C4eAlgo32Uint C4eAlgo32Digit;
#else
#error "Currently there is no support for a 64-bit type of C4eArchDigit."
    typedef C4eArchDigit C4eAlgo32Digit;
#endif




/* MACROS ********************************************************************/


/* MACRO *********************************************************************/
/* MACRO *********************************************************************/
#ifdef C4E_ALGO32_DIGITS_PTR /* size of C4eArchDigit less/equal than 32-bit ? */
#define C4E_ALGO32_CAST_DIGITS(p)      C4E_ALGO32_DIGITS_PTR(p)
#define C4E_ALGO32_CAST_UINT(p)        (p)
#else
#define C4E_ALGO32_CAST_DIGITS(p)      (p)
#define C4E_ALGO32_CAST_UINT(p)        C4E_SYS_CAST(C4eAlgo32Uint*, (p))
#endif  /* C4E_ALGO32_DIGITS_PTR */


/* MACRO *********************************************************************/
#define C4E_ALGO32_DIGITS_NUM(size)     C4E_SYS_DIV_CEIL((size), C4E_ALGO32_DIGIT_SIZE)



#ifndef C4E_ALGO32_NUM_DIGITS      /* C4eAlgo32Uint NOT emulated by digits ? */

/* MACRO *********************************************************************/
#define C4E_ALGO32_INIT(msb, midh, midl, lsb)                   \
    C4E_SYS_CAST(C4eAlgo32Uint,                                 \
                 (C4E_SYS_CAST(C4eAlgo32Uint, (msb)) << 24U) |  \
                 (C4E_SYS_CAST(C4eAlgo32Uint, (midh)) << 16U) | \
                 (C4E_SYS_CAST(C4eAlgo32Uint, (midl)) << 8U) |  \
                 C4E_SYS_CAST(C4eAlgo32Uint, (lsb)))


/* MACRO *********************************************************************/
#define C4E_ALGO32_ASGN(var32, msb, midh, midl, lsb)            \
    ((var32) = C4E_ALGO32_INIT((msb), (midh), (midl), (lsb)))



/* MACRO *********************************************************************/
#define C4E_ALGO32_BYTE(var32, pos) \
    C4E_SYS_CAST(C4eArchUint8, ((var32) >> ((pos) * 8U)) & C4E_SYS_DIGIT_LSBYTE)


/* MACRO *********************************************************************/
#define C4E_ALGO32_INC(var32)   (++(var32))



/* MACRO *********************************************************************/
#define C4E_ALGO32_ADD(var32a, var32b)   ((var32a) + (var32b))


/* MACRO *********************************************************************/
#define C4E_ALGO32_AND(var32a, var32b)  ((var32a) & (var32b))


/* MACRO *********************************************************************/
#define C4E_ALGO32_OR(var32a, var32b)   ((var32a) | (var32b))


/* MACRO *********************************************************************/
#define C4E_ALGO32_NOT(var32)   C4E_SYS_CAST(C4eAlgo32Uint, ~(var32))


/* MACRO *********************************************************************/
#define C4E_ALGO32_XOR(var32a, var32b)  ((var32a) ^ (var32b))


/* MACRO *********************************************************************/
#define C4E_ALGO32_ROL(var32, n)                                               \
    C4E_SYS_CAST(C4eAlgo32Uint, ((var32) << (n)) | ((var32) >> (32U - (n))))


/* MACRO *********************************************************************/
#define C4E_ALGO32_ROR(var32, n)                                               \
    C4E_SYS_CAST(C4eAlgo32Uint, ((var32) >> (n)) | ((var32) << (32U - (n))))


/* MACRO *********************************************************************/
#define C4E_ALGO32_SHL(var32, n, lsb)               \
    C4E_SYS_CAST(C4eAlgo32Uint, ((var32) << (n)) | (lsb))


/* MACRO *********************************************************************/
#define C4E_ALGO32_SHR(var32, n)                \
    C4E_SYS_CAST(C4eAlgo32Uint, (var32) >> (n))



#else  /* C4E_ALGO32_NUM_DIGITS: C4eAlgo32Uint emulated on digits */

#if (C4E_ARCH_DIGIT_SIZE == 2U) /* digit size is 16-bit? */

#define C4E_ALGO32_INIT(msb, midh, midl, lsb)                           \
{                                                                       \
    .digits =                                                           \
    {                                                                   \
        C4E_SYS_CAST(C4eArchDigit,                                      \
                     (C4E_SYS_CAST(C4eArchDigit, (midl)) << 8U) |       \
                     C4E_SYS_CAST(C4eArchDigit, (lsb))),                \
        C4E_SYS_CAST(C4eArchDigit,                                      \
                     (C4E_SYS_CAST(C4eArchDigit, (msb)) << 8U) |        \
                     C4E_SYS_CAST(C4eArchDigit, (midh)))                \
    }                                                                   \
}


#define C4E_ALGO32_ASGN(var32, msb, midh, midl, lsb)                    \
    do                                                                  \
    {                                                                   \
        (var32).digits[0] = C4E_SYS_CAST(C4eArchDigit, (midl) << 8U) |  \
                            C4E_SYS_CAST(C4eArchDigit, (lsb));          \
        (var32).digits[1] = C4E_SYS_CAST(C4eArchDigit, (msb) << 8U) |   \
                            C4E_SYS_CAST(C4eArchDigit, (midh));         \
    }                                                                   \
    while (C4E_FALSE)


#define C4E_ALGO32_BYTE(var32, pos) \
    C4E_SYS_CAST(C4eArchUint8, (((var32).digits[(pos) >> 1U] >> \
                                 (((pos) & 1U) * 8U)) & C4E_SYS_DIGIT_LSBYTE))

#elif (C4E_ARCH_DIGIT_SIZE == 1U) /* digit size is 8-bit? */

#define C4E_ALGO32_INIT(msb, midh, midl, lsb)   \
{                                               \
    .digits =                                   \
    {                                           \
        C4E_SYS_CAST(C4eArchDigit, (lsb)),      \
        C4E_SYS_CAST(C4eArchDigit, (midl)),     \
        C4E_SYS_CAST(C4eArchDigit, (midh)),     \
        C4E_SYS_CAST(C4eArchDigit, (msb))       \
    }                                           \
}


#define C4E_ALGO32_ASGN(var32, msb, midh, midl, lsb)            \
    do                                                          \
    {                                                           \
        (var32).digits[0] = C4E_SYS_CAST(C4eArchDigit, (lsb));  \
        (var32).digits[1] = C4E_SYS_CAST(C4eArchDigit, (midl)); \
        (var32).digits[2] = C4E_SYS_CAST(C4eArchDigit, (midh)); \
        (var32).digits[3] = C4E_SYS_CAST(C4eArchDigit, (msb));  \
    }                                                           \
    while (C4E_FALSE)


#define C4E_ALGO32_BYTE(var32, pos) \
    C4E_SYS_CAST(C4eArchUint8, (var32).digits[(pos)] & C4E_SYS_DIGIT_LSBYTE)

#else
#error
#endif


#define C4E_ALGO32_INC(var32)           c4e_algo32_inc(&(var32))
#define C4E_ALGO32_ADD(var32a, var32b)  c4e_algo32_add((var32a), (var32b))
#define C4E_ALGO32_AND(var32a, var32b)  c4e_algo32_and((var32a), (var32b))
#define C4E_ALGO32_OR(var32a, var32b)   c4e_algo32_or((var32a), (var32b))
#define C4E_ALGO32_NOT(var32)           c4e_algo32_not(var32)
#define C4E_ALGO32_XOR(var32a, var32b)  c4e_algo32_xor((var32a), (var32b))
#define C4E_ALGO32_ROL(var32, n)        c4e_algo32_rol((var32), (n))
#define C4E_ALGO32_ROR(var32, n)        c4e_algo32_ror((var32), (n))
#define C4E_ALGO32_SHL(var32, n, lsb)   c4e_algo32_shl((var32), (n), (lsb))
#define C4E_ALGO32_SHR(var32, n)        c4e_algo32_shr((var32), (n))


#endif  /* defined(C4E_ALGO32_NUM_DIGITS) */



/* PROTOTYPES ****************************************************************/


#ifdef C4E_ALGO32_NUM_DIGITS

/* FUNCTION ******************************************************************/
    C4eAlgo32Uint c4e_algo32_not(C4eAlgo32Uint var32);


/* FUNCTION ******************************************************************/
C4eAlgo32Uint c4e_algo32_xor(C4eAlgo32Uint a, C4eAlgo32Uint b);


/* FUNCTION ******************************************************************/
C4eAlgo32Uint c4e_algo32_or(C4eAlgo32Uint a, C4eAlgo32Uint b);


/* FUNCTION ******************************************************************/
C4eAlgo32Uint c4e_algo32_and(C4eAlgo32Uint a, C4eAlgo32Uint b);


/* FUNCTION ******************************************************************/
    void c4e_algo32_inc(C4eAlgo32Uint* var32);



/* FUNCTION ******************************************************************/
    C4eAlgo32Uint c4e_algo32_add(C4eAlgo32Uint a, C4eAlgo32Uint b);


/* FUNCTION ******************************************************************/
    C4eAlgo32Uint c4e_algo32_shl(C4eAlgo32Uint var32, C4eArchUint shift,
                                 C4eArchUint8 lsb);


/* FUNCTION ******************************************************************/
    C4eAlgo32Uint c4e_algo32_shr(C4eAlgo32Uint var32, C4eArchUint shift);


/* FUNCTION ******************************************************************/
    C4eAlgo32Uint c4e_algo32_rol(C4eAlgo32Uint var32, C4eArchUint shift);


/* FUNCTION ******************************************************************/
    C4eAlgo32Uint c4e_algo32_ror(C4eAlgo32Uint var32, C4eArchUint shift);



#endif  /* defined(C4E_ALGO32_NUM_DIGITS) */



#ifdef  __cplusplus
}
#endif


#endif /* C4E_ALGO32_H */


/******************************************************************************/
/* END OF FILE                                                                */
/******************************************************************************/

---