bits_n_bytes.h

Go to the documentation of this file.

/*
** Copyright (C) 2002 Russell Leighton
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/


#ifndef  __AW_BYTES__
#define  __AW_BYTES__

/* ############################ bytes ############################ */
#define SWAPBYTES16(word) (\
(((word)&0x00ff) << 8) | \
(((word)&0xff00) >> 8) \
)

#define SWAPBYTES32(word) (\
(((word)&0x000000ff) << 24)| \
(((word)&0x0000ff00) << 8) | \
(((word)&0x00ff0000) >> 8) | \
(((word)&0xff000000) >> 24) \
)

/* non-zero if byteasword is in word, where byte is held to far right 8bits */
#define BYTEINWORD32(word, byteasword)(\
(((word)&0x000000ff)         == (byteasword)) || \
((((word)&0x0000ff00) >> 8)  == (byteasword)) || \
((((word)&0x00ff0000) >> 16) == (byteasword)) || \
((((word)&0xff000000) >> 24) == (byteasword)) \
)

/* ############################ bits ############################ */


/***********************************************************************\
|macro:         COUNTBITS16                                             |
|purpose:       count the bits that are 1 in a 16 bit lvalue            |
|usage:         COUNTBITS16( bits );                                    |
|   or:         count = COUNTBITS16( bits );                            |
|note:          the lvalue argument always ends up with the result      |
\***********************************************************************/
#define COUNTBITS16(b) (\
        (b)=(((b)>> 1)&0x5555)+((b)&0x5555),\
        (b)=(((b)>> 2)&0x3333)+((b)&0x3333),\
        (b)=(((b)>> 4)&0x0707)+((b)&0x0707),\
        (b)=(((b)>> 8)&0x000f)+((b)&0x000f),\
        (b))

/***********************************************************************\
|macro:         COUNTBITS32                                             |
|purpose:       count the bits that are 1 in a 32 bit lvalue            |
|usage:         COUNTBITS32( bits );                                    |
|   or:         count = COUNTBITS32( bits );                            |
|note:          the lvalue argument always ends up with the result      |
\***********************************************************************/
#define COUNTBITS32(b) (\
        (b)=(((b)>> 1)&0x55555555)+((b)&0x55555555),\
        (b)=(((b)>> 2)&0x33333333)+((b)&0x33333333),\
        (b)=(((b)>> 4)&0x07070707)+((b)&0x07070707),\
        (b)=(((b)>> 8)&0x000f000f)+((b)&0x000f000f),\
        (b)=(((b)>>16)&0x0000001f)+((b)&0x0000001f),\
        (b))

/***********************************************************************\
|macro:         COUNTBITS64                                             |
|purpose:       count the bits that are 1 in a 64 bit lvalue            |
|usage:         COUNTBITS64( bits );                                    |
|   or:         count = COUNTBITS64( bits );                            |
|note:          the lvalue argument always ends up with the result      |
\***********************************************************************/
#define COUNTBITS64(b) (\
        (b)=(((b)>> 1)&0x5555555555555555)+((b)&0x5555555555555555),\
        (b)=(((b)>> 2)&0x3333333333333333)+((b)&0x3333333333333333),\
        (b)=(((b)>> 4)&0x0707070707070707)+((b)&0x0707070707070707),\
        (b)=(((b)>> 8)&0x000f000f000f000f)+((b)&0x000f000f000f000f),\
        (b)=(((b)>>16)&0x0000001f0000001f)+((b)&0x0000001f0000001f),\
        (b)=(((b)>>32)&0x000000000000003f)+((b)&0x000000000000003f),\
        (b))

/***********************************************************************\
|macro:         REVERSEBITS16                                           |
|purpose:       reverse the bit order in a 16 bit lvalue                |
|usage:         REVERSEBITS16( bits );                                  |
|   or:         value = REVERSEBITS16( bits );                          |
|note:          the lvalue argument always ends up with the result      |
\***********************************************************************/
#define REVERSEBITS16(b) (\
        (b)=(((b)>> 1)&0x5555)|(((b)&0x5555)<< 1),\
        (b)=(((b)>> 2)&0x3333)|(((b)&0x3333)<< 2),\
        (b)=(((b)>> 4)&0x0f0f)|(((b)&0x0f0f)<< 4),\
        (b)=(((b)>> 8)&0x00ff)|(((b)&0x00ff)<< 8),\
        (b))

/***********************************************************************\
|macro:         REVERSEBITS32                                           |
|purpose:       reverse the bit order in a 32 bit lvalue                |
|usage:         REVERSEBITS32( bits );                                  |
|   or:         value = REVERSEBITS32( bits );                          |
|note:          the lvalue argument always ends up with the result      |
\***********************************************************************/
#define REVERSEBITS32(b) (\
        (b)=(((b)>> 1)&0x55555555)|(((b)&0x55555555)<< 1),\
        (b)=(((b)>> 2)&0x33333333)|(((b)&0x33333333)<< 2),\
        (b)=(((b)>> 4)&0x0f0f0f0f)|(((b)&0x0f0f0f0f)<< 4),\
        (b)=(((b)>> 8)&0x00ff00ff)|(((b)&0x00ff00ff)<< 8),\
        (b)=(((b)>>16)&0x0000ffff)|(((b)&0x0000ffff)<<16),\
        (b))

/***********************************************************************\
|macro:         REVERSEBITS64                                           |
|purpose:       reverse the bit order in a 64 bit lvalue                |
|usage:         REVERSEBITS64( bits );                                  |
|   or:         value = REVERSEBITS64( bits );                          |
|note:          the lvalue argument always ends up with the result      |
\***********************************************************************/
#define REVERSEBITS64(b) (\
        (b)=(((b)>> 1)&0x5555555555555555)|(((b)&0x5555555555555555)<< 1),\
        (b)=(((b)>> 2)&0x3333333333333333)|(((b)&0x3333333333333333)<< 2),\
        (b)=(((b)>> 4)&0x0f0f0f0f0f0f0f0f)|(((b)&0x0f0f0f0f0f0f0f0f)<< 4),\
        (b)=(((b)>> 8)&0x00ff00ff00ff00ff)|(((b)&0x00ff00ff00ff00ff)<< 8),\
        (b)=(((b)>>16)&0x0000ffff0000ffff)|(((b)&0x0000ffff0000ffff)<<16),\
        (b)=(((b)>>32)&0x00000000ffffffff)|(((b)&0x00000000ffffffff)<<32),\
        (b))

#endif

Aware 0.11.1 Copyright (C) 1998-2005 Russell Leighton (russ@elegant-software.com)