C standard allows compiler to put bit-fields in any order. There is no reliable and portable way to determine the order. If you need to know the exact bit positions, it is better use plain unsigned variable and bit masking. Here’s one possible alternative to using bit-fields: #include <stdio.h> #define MASK_A 0x00FF #define MASK_B 0x3F00 … Read more
You should never use plain int as the bitfield type if you’re expecting something about the value besides that it can hold n bits – according to the C11 standard it is actually implementation-defined whether int in a bit-field is signed or unsigned 6.7.2p5: 5 Each of the comma-separated multisets designates the same type, except … Read more
Because a and c are not contiguous, they each reserve a full int’s worth of memory space. If you move a and c together, the size of the struct becomes 8 bytes. Moreover, you are telling the compiler that you want a to occupy only 1 bit, not 1 byte. So even though a and … Read more
Thanks everyone! Based on this information, I reduced this to : RBits = record public BaseMid: BYTE; private Flags: WORD; function GetBits(const aIndex: Integer): Integer; procedure SetBits(const aIndex: Integer; const aValue: Integer); public BaseHi: BYTE; property _Type: Integer index $0005 read GetBits write SetBits; // 5 bits at offset 0 property Dpl: Integer index $0502 … Read more
No, you can’t. There is an open issue about supporting bitfields, which doesn’t seem to be active. In the issue, @retep998 explains how bitfields are handled in winapi. That might be helpful if you need to handle bitfields in C interface. OP seems to aim at C interoperation, but if you just need bitfields functionality, … Read more
Bit-fields are typically only used when there’s a need to map structure fields to specific bit slices, where some hardware will be interpreting the raw bits. An example might be assembling an IP packet header. I can’t see a compelling reason for an emulator to model a register using bit-fields, as it’s never going to … Read more
You use a zero-length bitfield as a hacky way to get your compiler to lay out a structure to match some external requirement, be it another compiler’s or architecture’s notion of the layout (cross-platform data structures, such as in a binary file format) or a bit-level standard’s requirements (network packets or instruction opcodes). A real-world … Read more
It is the order that matters. The following code will give Output: 8 #include<stdio.h> typedef struct size { unsigned int b:32; unsigned int a:1; unsigned int c:1; }mystruct; int main(int argc, char const *argv[]) { mystruct a; printf(“\n %lu \n”,sizeof(a)); return 0; } Unsigned int is a 32 bit integer, occupying 4 bytes. Memory is … Read more
If you mainly want to be able to name your bit fields and easily manipulate them, e.g. to work with flags represented as single bits in a communications protocol, then you can use the standard Structure and Union features of ctypes, as described at How Do I Properly Declare a ctype Structure + Union in … Read more
I’d probably knock together something using attributes, then a conversion class to convert suitably attributed structures to the bitfield primitives. Something like… using System; namespace BitfieldTest { [global::System.AttributeUsage(AttributeTargets.Field, AllowMultiple = false)] sealed class BitfieldLengthAttribute : Attribute { uint length; public BitfieldLengthAttribute(uint length) { this.length = length; } public uint Length { get { return length; … Read more