assigning bit-field structure

[- Kees van der Bent -]

/* With the following: */
typedef struct
{
unsigned char a : 1;
unsigned char b : 1;
} sss_t;
sss_t sss;
unsigned char ppp;

main()
{
sss = (sss_t)ppp; /* why 'invalid cast expression'? */

sss = *(sss_t*)&ppp; /* why OK? */
}

/*
Used Sun compiler.

Thanks,

Kees
*/

[Rakesh]

- Kees van der Bent - wrote:

/* With the following: */
typedef struct
{
unsigned char a : 1;
unsigned char b : 1;
} sss_t;
sss_t sss;
unsigned char ppp;

main()
{
sss = (sss_t)ppp; /* why 'invalid cast expression'? */
You are trying to convert an unsigned char to an user-defined data
type, that are noway related , as far as the compiler is concerned.

sss = *(sss_t*)&ppp; /* why OK? */

&ppp changes it to UCHAR * , and then you are converting to (sss_t
*) [ it really gets dangerous here, but you are allowed to do it, since
they are addresses after all ] .
Having converted it, you are dereferencing it back. I am assuming you
are writing this for learning purposes only. But as such , such cast
expressions ( changing pointers of a given type to a diff. type ) ought
not to be used in any serious project ;) .

HTH .

[Peter Pichler]

"- Kees van der Bent -" <kv*@mbalance.m oc> wrote in message
news:40******** *************@n ews.xs4all.nl.. .

/* With the following: */
typedef struct
{
unsigned char a : 1;
unsigned char b : 1;
} sss_t;
sss_t sss;
unsigned char ppp;
Why are these global?
main()
{
sss = (sss_t)ppp; /* why 'invalid cast expression'? */
You're not gonna like it, but you can't do it, because... you can't do it!
You cannot cast between a scalar and an aggregate type. Think of it this
way: an aggregate (such as a structure) is an object containing more than
one value (even if the structure contains only one field, we are talking in
general terms here). A scalar only contains one value. How would you convert
from one to another? What sense would it make?
sss = *(sss_t*)&ppp; /* why OK? */
Conversions between pointers are allowed. Whether the result of such
conversion is meaningful, or even a valid pointer, is quite another
question.
}

/*
Used Sun compiler.
Doesn't matter.
Thanks,

Kees
*/

Peter

[Christopher Benson-Manica]

Rakesh <dr************ ******@yahoo.co m> spoke thus:

&ppp changes it to UCHAR * , and then you are converting to (sss_t

^^^^^
ITYM "unsigned char". UCHAR is not a C keyword, although of course
you can typedef it yourself if you're so inclined.

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cybers pace.org | don't, I need to know. Flames welcome.

[Martin Ambuhl]

- Kees van der Bent - wrote:

/* With the following: */
typedef struct
{
unsigned char a : 1;
unsigned char b : 1;
unsigned char is not a valid type for a bit field.
} sss_t;
sss_t sss;
unsigned char ppp;

main()
{
sss = (sss_t)ppp; /* why 'invalid cast expression'? */
ppp is a scalar; the type sss_t isn't.
sss = *(sss_t*)&ppp; /* why OK? */
Because C lets you do all sorts of silly things using pointers.
}

[Rakesh]

Oh yeah :) of course , i meant unsigned char . I was a bit too lazy to
type in that. Thanks for pointing it out, though.

Christopher Benson-Manica wrote:

Rakesh <dr************ ******@yahoo.co m> spoke thus:

&ppp changes it to UCHAR * , and then you are converting to (sss_t

^^^^^
ITYM "unsigned char". UCHAR is not a C keyword, although of course
you can typedef it yourself if you're so inclined.

--

--
Rakesh Kumar
** Remove nospamplz from my email address for my real email **

[- Kees van der Bent -]

Martin Ambuhl <ma*****@earthl ink.net> wrote in message news:<c6******* *****@ID-227552.news.uni-berlin.de>...

- Kees van der Bent - wrote:

/* With the following: */
typedef struct
{
unsigned char a : 1;
unsigned char b : 1;
unsigned char is not a valid type for a bit field.

Yes I read this in K&R and wondered why the compiler did not
warn at all. What do you think?

} sss_t;

[- Kees van der Bent -]

"Peter Pichler" <pi*****@pobox. sk> wrote in message news:<40******* *@mk-nntp-2.news.uk.tisca li.com>...

"- Kees van der Bent -" <kv*@mbalance.m oc> wrote in message
news:40******** *************@n ews.xs4all.nl.. .

/* With the following: */
typedef struct
{
unsigned char a : 1;
unsigned char b : 1;
} sss_t;
sss_t sss;
unsigned char ppp;
Why are these global?

I quickly typed in a small piece of code that gave the
same results as my real code. I don't like globals either.

main()
{
sss = (sss_t)ppp; /* why 'invalid cast expression'? */
You're not gonna like it, but you can't do it, because... you can't do it!
You cannot cast between a scalar and an aggregate type. Think of it this
way: an aggregate (such as a structure) is an object containing more than
one value (even if the structure contains only one field, we are talking in
general terms here). A scalar only contains one value. How would you convert
from one to another? What sense would it make?

I like to view a bit-field structure as a special case of of scalar:
a regular scalar with the added convenience of being able to 'address'
certain bits. Isn't this how bit-fields are used in hardware device
drivers (mapping certain registers)?

In my case my input data is of type unsigned char which needs to be
mapped/assigned on/to a bit-field structure. Instead of writing out
all the nuts al bolts (with ... >> 4 & 0x3 ...) I want C to help me
out here and let the compiler do the work for me.

sss = *(sss_t*)&ppp; /* why OK? */
Conversions between pointers are allowed. Whether the result of such
conversion is meaningful, or even a valid pointer, is quite another
question.

I agree with you. But this seems to be the only way to get the result
I want. Although I'm confident that this will work in practice, the
question remains if this works according to the C standard. How is bit-
field structure allignment specified in the C spec?

}

/*
Used Sun compiler.

Doesn't matter.

Thanks,

Kees
*/

Peter

[Martin Ambuhl]

- Kees van der Bent - wrote:

Martin Ambuhl <ma*****@earthl ink.net> wrote in message news:<c6******* *****@ID-227552.news.uni-berlin.de>...

- Kees van der Bent - wrote:

/* With the following: */
typedef struct
{
unsigned char a : 1;
unsigned char b : 1;

unsigned char is not a valid type for a bit field.

Yes I read this in K&R and wondered why the compiler did not
warn at all. What do you think?

That you either don't have the diagnostic level set properly or that you
are not invoking your compiler in conforming mode.

[Chris Torek]

In article <news:f5******* *************** **@posting.goog le.com>
- Kees van der Bent - <kv*****@mail.c om> writes:

I like to view a bit-field structure as a special case of of scalar:
a regular scalar with the added convenience of being able to 'address'
certain bits. Isn't this how bit-fields are used in hardware device
drivers (mapping certain registers)?
Some people write code like that. Others write code that survives
changing compilers. :-)
In my case my input data is of type unsigned char which needs to be
mapped/assigned on/to a bit-field structure. Instead of writing out
all the nuts al bolts (with ... >> 4 & 0x3 ...) I want C to help me
out here and let the compiler do the work for me.
Unfortunately, as Dennis Ritchie himself once put it, C's bitfields
are "a botch and a blemish". For instance:
How is bit-field structure allignment specified in the C spec?

It is not.

Much worse, however, is the fact that two different compilers FOR THE
SAME MACHINE may reverse the order of the bits in some bitfield:

/* device connected to motorola 68010; C compiler has 16-bit int */
struct hardware_reg {
unsigned int go:1; /* set to 1 to make device run */
unsigned int cmd:3; /* command */
unsigned int ctl:4; /* control bits */
unsigned int dma:1; /* set to 1 to use DMA */
unsigned int :3; /* unused */
unsigned int status:4; /* device status */
unsigned int addr; /* DMA address */
};

Compiled with Compiler A, the "go" bit is (as desired) the high bit
of the first 16-bit word, but compiled with Compiler B, the "go" bit
becomes the *low* bit of that word.

Using "unsigned short csr, addr;" and defining bits for the control
and status register works on every compiler you will find for that
68010-based system (even those with 32-bit ints). C gives you (the
programmer) no control whatsoever of where the bits in the bitfield
wind up. If you want to write this sort of code, you might consider
Ada, which has the necessary construct (the "representa tion clause").
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.