c-struct | a binary data packing & unpacking library for node.js | Runtime Evironment library

I want to draw rectangles in a window in C. I found the following C++ code I want to convert its classes to C struct to use it in my C project. I want to convert the following C++ class to C struct:

I'm creating a dictionary d of one million of items which are tuples, and ideally I'd like to access them with:

Windows 10, CLISP 2.49, FFI.

I have used the built-in FFI to start a windows loop and a basic windproc callback. The initial windows message WM_PAINT is fine. In some tests, SetWindowPos or minimizing/maximizing the window, all of which call WM_PAINT, are also fine.

But when I, the user, grab the window edge to resize the window, it crashes. There is no lisp error. I've attempted to attach to CLISP via Visual Studio, but there is no windows exception either.

I've added (room) and (ext:gc) to check memory issues. I'm very suspicious that room reports "Bytes available until next GC: 6,510" being pretty low just before the program crashes. Multiple WM_PAINT calls will succeed, but if "bytes available" is low, there's a good (but not 100%) chance of a crash.

The goal is to create a structure that contains 3 fields. One of those fields needs to be a uint32_t union but the flags will be different for each element. I believe the best way to do this is to create a separate union for each peripheral and assign it to a void pointer in the parent struct (somehow).

The Current Plan:

I have a c-structure that I want to return from a c-function to c# and that structure contains an array of int and a length. So basically

Since Go doesn’t support packed struct I found this great article explains everything with examples how to work with packed struct in go. https://medium.com/@liamkelly17/working-with-packed-c-structs-in-cgo-224a0a3b708b

The problem is when I try char * in place of [10]char it's not working. I'm not sure how this conversion works with [10]char and not with char * . Here is example code taken from above article and modified with char * .

The C99 standard tells us:

There may be unnamed padding within a structure object, but not at its beginning.

and

There may be unnamed padding at the end of a structure or union.

I am assuming this applies to any of the C++ standards too, but I have not checked them.

Let's assume a C/C++ application (i.e. both languages are used in the application) running on an ARM Cortex-M would store some persistent data on a local medium (a serial NOR-flash chip for instance), and read it back after power cycling, possibly after an upgrade of the application itself in the future. The upgraded application may have been compiled with an upgraded compiler (we assume gcc).

Let's further assume that the developer is lazy (that's not me, of course), and directly streams some plain C or C++ structs to flash, instead of first serializing them as any paranoid experienced developer would do.

In fact, the developer in question is lazy, but not totally ignorant, since he has read the AAPCS (Procedure Call Standard for the Arm Architecture).

His rationale, besides laziness, is the following:

• He does not want to pack the structs to avoid misalignment problems in the rest of the application.
• The AAPCS specifies a fixed alignment for every single fundamental data type.
• The only rational motivation for padding is to achieve proper alignment.
• Therefore, he thinks, padding (and therefore member offsetof and total sizeof) is fully determined for any C or C++ struct by the AAPCS.
• Therefore, he further reasons, there is no way my application would not be able to interpret some read back data that an earlier version of the same application would have written (assuming, of course, that the offset of the data in flash memory has not changed between writing and reading).

However, the developer has a conscience and he is a little worried:

• The C standard does not mention any reason for padding. Achieving proper alignment may be the only rational reason for padding, but compilers are free to pad as much as they want, according to the standard.
• How can he be sure that his compiler really follows the AAPCS?
• Could his assumptions suddenly be broken by some apparently unrelated compiler flag that he would start using, or by a compiler upgrade?

My question is: how dangerously does that lazy developer live? In other words, how stable is padding in C/C++ structs under the assumptions above?

Two weeks after this question was asked, the only answer that has been received does not really answer the asked question. I have also asked the exact same question on an ARM community forum, but got no answer at all.

I however choose to accept 3246135 as the answer because:

1. I take the absence of proper answer as very relevant information for this case. The correctness of solutions to software problems should be obvious. The assumptions made in my question may be true, but I cannot easily prove it. Additionally, if the assumptions are incorrect, the consequences, in the general case, could be catastrophic.

2. Compared to the risk, the burden on the developer when using the strategy exposed in the answer seems very reasonable. Assuming a constant endianness (which is quite easy to enforce), it is a hundred percent-safe (any deviation will generate an error at compile-time) and it is much lighter than a full-blown serialization. Basically, the strategy exposed in the answer is a mandatory minimum price to pay in order to make one's C/C++ structs persistent independently of any ABI.

If you are a developer asking yourself the question above, please do not be lazy, and use instead the strategy exposed in the accepted answer, or an alternative strategy that guarantees a constant padding across software releases.

I've a dynamic struct created from Ompluscator which contains a nested struct (slices of struct) with foreign key references.

The Parent (User Table) and Child (Credit Card) Tables gets created successfully. Even inserting into User Table is successful, but later it ends up with field value not valid error when processing credit_card table entries.

Here is the complete code:

I'm running in to the exact same problem as explained here. Unfortunately, I don't understand what exactly was changed to fix the situation. Did the OP hint to Swift the size of flexible array member to make it visible in Swift? Did the OP modify the C library? I'd like to avoid doing that.

I'm using a C library in Swift that returns a struct with a flexible array member "mbody" at the end.