Bit twiddling

[grid]

Hi,
I have written a couple of programs which just prints the bits in
both directions.Woul d appreciate any help to refine them a bit.

1.
#include<stdio. h>
#include<limits .h>
void printbits_rever se(unsigned char a){
int i;
for(i=0 ; i < CHAR_BIT ; i++)
((0x1<<i) & a) ? printf("1") : printf("0"); }
int main()
{
unsigned char a = 0x96;
printbits_rever se(a);
return 0;
}

Now here the loop dosent look the best of code.How can I refine it to
better and generic code ?

2.
#include<stdio. h>
struct twid{
unsigned :24; /* skip bits 31 -> 8 for big-endian machines */
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned bit5:1;
unsigned bit6:1;
unsigned bit7:1;
unsigned bit8:1;
};

void print(struct twid *tw)
{
tw->bit1?printf("1 "):printf(" 0");
tw->bit2?printf("1 "):printf(" 0");
tw->bit3?printf("1 "):printf(" 0");
tw->bit4?printf("1 "):printf(" 0");
tw->bit5?printf("1 "):printf(" 0");
tw->bit6?printf("1 "):printf(" 0");
tw->bit7?printf("1 "):printf(" 0");
tw->bit8?printf("1 "):printf(" 0");
printf("\n");
}

int main()
{
unsigned val = 0x96;
struct twid *tw = (struct twid *) &val ;
print(tw);
return 0;
}

This is not a generic code ( a bit platform specific), but that long
list of printf's in the print function isnt again a very decent way.Can
I use a loop or any construct to print the values ?

TIA,

[pete]

grid wrote:

Hi,
I have written a couple of programs which just prints the bits in
both directions.Woul d appreciate any help to refine them a bit.

1.
#include<stdio. h>
#include<limits .h>
void printbits_rever se(unsigned char a){
int i;
for(i=0 ; i < CHAR_BIT ; i++)
((0x1<<i) & a) ? printf("1") : printf("0"); }
int main()
{
unsigned char a = 0x96;
printbits_rever se(a);
return 0;
}

Now here the loop dosent look the best of code.How can I refine it to
better and generic code ?

#include<stdio. h>
#include<limits .h>

void printbits_rever se(unsigned char a);
void bit_str(char *s1, const void *s2, size_t n);
unsigned char bit_rev(unsigne d char byte);

int main(void)
{
unsigned char a = 0x96;

printbits_rever se(a);
return 0;
}

void printbits_rever se(unsigned char a)
{
char string[CHAR_BIT + 1];

a = bit_rev(a);
bit_str(string, &a, 1);
puts(string);
}

void bit_str(char *s1, const void *s2, size_t n)
{
unsigned mask;
const unsigned char *const byte = s2;

while (n-- != 0) {
mask = ((unsigned char)-1 >> 1) + 1;
do {
*s1++ = (char)(mask & byte[n] ? '1' : '0');
mask >>= 1;
} while (mask != 0);
}
*s1 = '\0';
}

unsigned char bit_rev(unsigne d char byte)
{
unsigned hi_mask, lo_mask;

hi_mask = ((unsigned char)-1 >> 1) + 1;
lo_mask = 1;
do {
if (!(byte & hi_mask) != !(byte & lo_mask)) {
byte ^= hi_mask | lo_mask;
}
hi_mask >>= 1;
lo_mask <<= 1;
} while (hi_mask > lo_mask);
return byte;
}

[Paul Mesken]

On Wed, 01 Jun 2005 20:04:29 +0530, grid <pr******@gmail .com> wrote:

Hi,
I have written a couple of programs which just prints the bits in
both directions.Woul d appreciate any help to refine them a bit.

1.
#include<stdio .h>
#include<limit s.h>
void printbits_rever se(unsigned char a){
int i;
for(i=0 ; i < CHAR_BIT ; i++)
((0x1<<i) & a) ? printf("1") : printf("0"); }
Oh, I don't think it's too bad but an obvious optimization would be to
make a string (instead of printing each digit individually) and then
print that string.

void printbits_rever se(unsigned char a)
{
int i;
char MyBitstring[CHAR_BIT + 1];

for (i = 0; i < CHAR_BIT; ++ i)
{
if (a & 1)
MyBitstring[i] = '1';
else
MyBitstring[i] = '0';
a >>= 1;
}
MyBitstring[CHAR_BIT] = '\0';
printf("%s", MyBitstring);
return;
}

2.
#include<stdio .h>
struct twid{
unsigned :24; /* skip bits 31 -> 8 for big-endian machines */
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned bit5:1;
unsigned bit6:1;
unsigned bit7:1;
unsigned bit8:1;
};

void print(struct twid *tw)
{
tw->bit1?printf("1 "):printf(" 0");
tw->bit2?printf("1 "):printf(" 0");
tw->bit3?printf("1 "):printf(" 0");
tw->bit4?printf("1 "):printf(" 0");
tw->bit5?printf("1 "):printf(" 0");
tw->bit6?printf("1 "):printf(" 0");
tw->bit7?printf("1 "):printf(" 0");
tw->bit8?printf("1 "):printf(" 0");
printf("\n");
}

int main()
{
unsigned val = 0x96;
struct twid *tw = (struct twid *) &val ;
print(tw);
return 0;
}

This is not a generic code ( a bit platform specific), but that long
list of printf's in the print function isnt again a very decent way.Can
I use a loop or any construct to print the values ?

It's ugly, unportable and relies on unspecified behaviour (you cannot
know whether bitfields are laid out from left to right or vice versa).

[Paul Mesken]

On Wed, 01 Jun 2005 17:32:37 +0200, Paul Mesken <us*****@eurone t.nl>
wrote:

void printbits_rever se(unsigned char a)
{
int i;
char MyBitstring[CHAR_BIT + 1];

for (i = 0; i < CHAR_BIT; ++ i)
{
if (a & 1)
MyBitstring[i] = '1';
else
MyBitstring[i] = '0';
a >>= 1;
}
MyBitstring[CHAR_BIT] = '\0';
printf("%s", MyBitstring);
return;
}

By the way, just for fun :

for (i = 0; i < CHAR_BIT; ++ i)
{
MyBitstring[i] = '0' + (a & 1);
a >>= 1;
}

But I don't know whether '1' is 1 greater than '0' in every character
set that C supports (but it's okay for both EBCDIC and ASCII).

[Walter Roberson]

In article <2v************ *************** *****@4ax.com>,
Paul Mesken <us*****@eurone t.nl> wrote:

But I don't know whether '1' is 1 greater than '0' in every character
set that C supports (but it's okay for both EBCDIC and ASCII).

Yes, that is a requirement in the standard. Sequentially increasing
digits is the -only- ordering requirements that the C89 standard
imposes on the character set.

--
Usenet is like a slice of lemon, wrapped around a large gold brick.

[Paul Mesken]

On 1 Jun 2005 17:23:09 GMT, ro******@ibd.nr c-cnrc.gc.ca (Walter
Roberson) wrote:

In article <2v************ *************** *****@4ax.com>,
Paul Mesken <us*****@eurone t.nl> wrote:

But I don't know whether '1' is 1 greater than '0' in every character
set that C supports (but it's okay for both EBCDIC and ASCII).

Yes, that is a requirement in the standard. Sequentially increasing
digits is the -only- ordering requirements that the C89 standard
imposes on the character set.

Yes, you're right :

5.2.1 Character Sets

..... In both the source and execution basic character sets, the value
of each character after '0' in the above list of decimal digits shall
be one greater than the value of the previous....

Well, in that case : go for the second solution, Grid :-)

[CBFalconer]

Paul Mesken wrote:

grid <pr******@gmail .com> wrote:

I have written a couple of programs which just prints the bits in
both directions.Woul d appreciate any help to refine them a bit.

.... snip ...
Oh, I don't think it's too bad but an obvious optimization would be
to make a string (instead of printing each digit individually) and
then print that string.

It's just printing a number in base 2. In the last day or two I
posted a routine to output numbers to streams in various bases.
Search for unum2txt.

--
"I conclude that there are two ways of constructing a software
design: One way is to make it so simple that there are obviously
no deficiencies and the other way is to make it so complicated
that there are no obvious deficiencies." -- C. A. R. Hoare

[Old Wolf]

Paul Mesken wrote:

grid wrote:

#include<stdi o.h>
#include<limi ts.h>
void printbits_rever se(unsigned char a){
int i;
for(i=0 ; i < CHAR_BIT ; i++)
((0x1<<i) & a) ? printf("1") : printf("0"); }

Oh, I don't think it's too bad but an obvious optimization would be to
make a string (instead of printing each digit individually) and then
print that string.

Is that really an optimisation? It uses more memory, and stdout
is probably buffered anyway.

This solution 'optimises' by using putchar instead of printf (surely
that must be at least as fast), and is still as concise as the
original:

for (i = 0; i < CHAR_BIT; i++)
putchar( ((1 << i) & a) ? '1' : '0' );
putchar('\n');

[Paul Mesken]

On 1 Jun 2005 18:52:47 -0700, "Old Wolf" <ol*****@inspir e.net.nz>
wrote:

Paul Mesken wrote:

grid wrote:

#include<std io.h>
#include<lim its.h>
void printbits_rever se(unsigned char a){
int i;
for(i=0 ; i < CHAR_BIT ; i++)
((0x1<<i) & a) ? printf("1") : printf("0"); }
Oh, I don't think it's too bad but an obvious optimization would be to
make a string (instead of printing each digit individually) and then
print that string.

Is that really an optimisation? It uses more memory, and stdout
is probably buffered anyway.

Reducing the amount of calls (especially to big ones, like printf) is,
typically, an optimization (reducing the overhead that may accompany
the calls). Although this might not hold for functions that are very
small and are inlined by the compiler but I don't believe printf is
inlined. I wouldn't worry too much about the extra memory used by an
array of CHAR_BIT + 1 chars :-)
This solution 'optimises' by using putchar instead of printf (surely
that must be at least as fast), and is still as concise as the
original:

for (i = 0; i < CHAR_BIT; i++)
putchar( ((1 << i) & a) ? '1' : '0' );
putchar('\n');

This is better than the OPs printf function, but IMHO not better than
my second version (adding "a & 1" to '0') which eliminates the
implicit "if-else" of the "?:" operator and only one call to printf.

[grid]

> void print(struct twid *tw)

{
tw->bit1?printf("1 "):printf(" 0");
tw->bit2?printf("1 "):printf(" 0");
tw->bit3?printf("1 "):printf(" 0");
tw->bit4?printf("1 "):printf(" 0");
tw->bit5?printf("1 "):printf(" 0");
tw->bit6?printf("1 "):printf(" 0");
tw->bit7?printf("1 "):printf(" 0");
tw->bit8?printf("1 "):printf(" 0");
printf("\n");

Is there any way to traverse through the member bitfields with a loop or
is there a consise way to write the above stuff.

TIA