When I changed StgDict to StgInfo, it took several commits (and false attempts); to keep it all straight I renamed dict variables to info.
I recommend doing it too, so the names aren't misleading.

Sorry for the extra work :(

(For the record: When there's a need to access __dict__ (attributes of the Python object), I called the new variable attrdict. Nowadays, after the transition, dict is OK for that.)

https://docs.python.org/3/library/ctypes.html#structure-union-alignment-and-byte-order says

By default, Structure and Union fields are aligned in the same way the C compiler does it. It is possible to override this behavior by specifying a pack class attribute in the subclass definition. This must be set to a positive integer and specifies the maximum alignment for the fields. This is what #pragma pack(n) also does in MSVC.

GCC has a suspiciously similarly named __attribute__((packed)) / #pragma pack. But it does something different. To get GCC to give you the behaviour as described in the doc, you also need to enable __attribute__((ms_struct)) / #pragma ms_struct on. And that's what we are doing here.

Note: the behaviour described in the quoted docs that we are implementing here is rather different from what everyone in #19850 seems to have understood.

As far as I can tell in that PR everyone assume that _packed_ = 1 means GCC's __attribute__((packed)).

This misunderstanding might be an argument for changing the docs? However that would be a breaking change.

In general, this PR breaks bug-for-bug compatibility with the past, but does not change documented behaviour.

At the moment, we don't support GCC's version of packed structs. Neither in the existing code nor in this PR.

It's fairly easy to add this behaviour on top of my code; but I would suggest using a new attribute (like _gcc_packed_ or so), instead of changing the documented behaviour of the existing _pack_.

Correction: support for GCC's packing isn't actually as easy as I imagined.

The problem is that GCC's packing can make eg a uint8_t straddle two bytes. In order to support that, we'd need to revamp much more of ctypes.

Here's an example to show the problem:

#include <stdio.h>
#include <stdint.h>
#include <string.h>

typedef struct
__attribute__ ((packed))
{
  uint8_t a: 4;
  uint8_t b: 8;
  uint8_t c: 4;
} Foo;

typedef union {
  Foo foo;
  uint8_t x[sizeof(Foo)];
} U;

int main(int argc, char** argv) {
    printf("%lu\n", __alignof__(Foo));
    printf("%lu\n", sizeof(Foo));

    U u;
    memset(&u, 0, sizeof(U));
    // Set b to all 1s.
    u.foo.b = -1;
    // Because we are on a little endian machine, it makes more sense to print
    // the bytes in reverse order.
    // This prints "0f f0", showing that b straddles a byte.
    for(int i=sizeof(Foo)-1; i>=0; --i) {
        printf("%02x ", u.x[i]);
    }
    printf("\n");
    return 0;
}

I guess the right thing to do here would be to warn when _packed_ is used with the GCC semantics.