offset macro for bit fields

[Tehn Yit Chin]

Does anyone know of an equivalent macro to offset() that would work
for bit fields?

eg,

struct abc
{
enable: 1;
disable: 1;
speed: 6;
};

enable_bit_position = offset_bit(struct abc, enable);
Thanks in advance for any hints.
Cheers,

[santosh]

Tehn Yit Chin wrote:

Does anyone know of an equivalent macro to offset() that would work
for bit fields?

eg,

struct abc
{
enable: 1;
disable: 1;
speed: 6;
};

enable_bit_position = offset_bit(struct abc, enable);

The address of bit-fields may not be taken. What is it that you actually
want to accomplish? Perhaps there may be a way other than you imagine.

[Tehn Yit Chin]

On Jul 9, 6:24 pm, santosh <[e-mail]:

Tehn Yit Chin wrote:

Does anyone know of an equivalent macro to offset() that would work
for bit fields?

eg,

struct abc
{
enable: 1;
disable: 1;
speed: 6;
};

enable_bit_position = offset_bit(struct abc, enable);

The address of bit-fields may not be taken. What is it that you actually
want to accomplish? Perhaps there may be a way other than you imagine.

I am doing some investigation on ways which the bit field could be
modified.

For example, given a more complex structure such as

struct speed_tag
{
union
{
unsigned int speed;
struct speed_part
{
unsigned int left_wheel:4;
unsigned int right_wheel:4;
}
}
}

struct speed_tag my_car;

/* access the member directly */
my_car.speed_part.left_wheel = current_speed;

/* another way of accessing */
my_car.speed &= 0x0f;
my_car.speed |= current_speed << 4;

/* what I am looking for is */
my_car.speed &= 0x0f;
my_car.speed |= current_speed << offset_bit(struct speed_part, speed);
I realise that this technique is only applicable to the platform it is
targeted for and, at this level, portability is not possible.

Cheers,

[Tehn Yit Chin]

On Jul 10, 9:14 am, Tehn Yit Chin <[e-mail]:

On Jul 9, 6:24 pm, santosh <[e-mail]:

Tehn Yit Chin wrote:

Does anyone know of an equivalent macro to offset() that would work
for bit fields?

eg,

struct abc
{
enable: 1;
disable: 1;
speed: 6;
};

enable_bit_position = offset_bit(struct abc, enable);

The address of bit-fields may not be taken. What is it that you actually
want to accomplish? Perhaps there may be a way other than you imagine.

I am doing some investigation on ways which the bit field could be
modified.

For example, given a more complex structure such as

struct speed_tag
{
union
{
unsigned int speed;
struct speed_part
{
unsigned int left_wheel:4;
unsigned int right_wheel:4;
}
}

}

struct speed_tag my_car;

/* access the member directly */
my_car.speed_part.left_wheel = current_speed;

/* another way of accessing */
my_car.speed &= 0x0f;
my_car.speed |= current_speed << 4;

/* what I am looking for is */
my_car.speed &= 0x0f;
my_car.speed |= current_speed << offset_bit(struct speed_part, speed);

I realise that this technique is only applicable to the platform it is
targeted for and, at this level, portability is not possible.

Cheers,

FWIW, I just came across a patent on this.
http://www.freepatentsonline.com/6938241.html

[Ian Collins]

Tehn Yit Chin wrote:

FWIW, I just came across a patent on this.
http://www.freepatentsonline.com/6938241.html

Who are they kidding?

--
Ian Collins.

[Ben Bacarisse]

Tehn Yit Chin <te***********@gmail.comwrites:

On Jul 9, 6:24 pm, santosh <[e-mail]:

>Tehn Yit Chin wrote:

Does anyone know of an equivalent macro to offset() that would work
for bit fields?

<snip>

I am doing some investigation on ways which the bit field could be
modified.

For example, given a more complex structure such as

struct speed_tag
{
union
{
unsigned int speed;
struct speed_part
{
unsigned int left_wheel:4;
unsigned int right_wheel:4;
}
}
}
struct speed_tag my_car;

/* access the member directly */
my_car.speed_part.left_wheel = current_speed;

/* another way of accessing */
my_car.speed &= 0x0f;
my_car.speed |= current_speed << 4;

/* what I am looking for is */
my_car.speed &= 0x0f;
my_car.speed |= current_speed << offset_bit(struct speed_part, speed);
I realise that this technique is only applicable to the platform it is
targeted for and, at this level, portability is not possible.

It is not a good idea to combine these into a union. You say tou
don't care about portability because you will use one platform, but
the association can change between compiler on the same platform,
between compiler versions of the same compiler and even between
compiler options with the same compiler version.

If you need named access, a bit field will do. If you need access by
position (or some other computed data) you need to use the well-known
shift and mask methods.

--
Ben.

[Richard Bos]

Ian Collins <ia******@hotmail.comwrote:

Tehn Yit Chin wrote:

FWIW, I just came across a patent on this.
http://www.freepatentsonline.com/6938241.html

Who are they kidding?

The US patent office, apparently.

Richard

[rahul]

On Jul 10, 4:26*am, Tehn Yit Chin <[e-mail]:

struct speed_tag
{
* *union
* *{
* * * unsigned int speed;
* * * struct speed_part
* * * {
* * * * * unsigned int left_wheel:4;
* * * * * unsigned int right_wheel:4;
* * * }
* *}

}

my_car.speed_part.left_wheel = current_speed;

Does this snippet compile? speed_part declares the type. You have not
declared a member named speed_part.