printf | fully loaded printf implementation for embedded systems

Since you're already using Docker, I'd suggest using a multi-stage build. Using a standard docker image like golang one can build an executable asset which is guaranteed to work with other docker linux images:

Given this macro:

The following section from this Draft C11 Standard completely refutes the claim made (even with the clarification mentioned in the 'errata', in the comment by GSerg).

6.3.2.3 Pointers

1     A pointer to void may be converted to or from a pointer to any object type. A pointer to any object type may be converted to a pointer to void and back again; the result shall compare equal to the original pointer.

Or, this section from the same draft Standard:

7.20.1.4 Integer types capable of holding object pointers

1    The following type designates a signed integer type with the property that any valid pointer to void can be converted to this type, then converted back to pointer to void, and the result will compare equal to the original pointer:

      intptr_t

Where does the C++ standard forbids to use freely symbols from the C standard library

Latest draft:

[extern.names]

Each name from the C standard library declared with external linkage is reserved to the implementation for use as a name with extern "C" linkage, both in namespace std and in the global namespace.

Each function signature from the C standard library declared with external linkage is reserved to the implementation for use as a function signature with both extern "C" and extern "C++" linkage, or as a name of namespace scope in the global namespace.

when they are not explicitely included in a compilation unit?

If you use the standard library at all, then all name reservations of the standard library are in effect.

If you include any standard header (or, any header whose exact content you don't control and thus may include standard headers), then you may be indirectly including other standard headers, including those inherited from C.

Here’s my sense of how the fastest answers work. I don’t know yet whether Keane can be improved or easily generalized.

Given an integer x ≥ 0, let q = ⌊x/255⌋ (in C, q = x / 255;) and r = x − 255 q (in C, r = x % 255;) so that q ≥ 0 and 0 ≤ r < 255 are integers and x = 255 q + r.

This method evaluates (x + ⌊x/255⌋) mod 2⁸ (in C, (x + x / 255) & 0xff), which equals (255 q + r + q) mod 2⁸ = (2⁸ q + r) mod 2⁸ = r.

Note that x + ⌊x/255⌋ = ⌊x + x/255⌋ = ⌊(2⁸/255) x⌋, where the first step follows from x being an integer. This method uses the multiplier (2⁰ + 2⁻⁸ + 2⁻¹⁶ + 2⁻²⁴ + 2⁻³²) instead of 2⁸/255, which is the sum of the infinite series 2⁰ + 2⁻⁸ + 2⁻¹⁶ + 2⁻²⁴ + 2⁻³² + …. Since the approximation is slightly under, this method must detect the residue 2⁸ − 1 = 255.

The intuition for this method is to compute y = (2⁸/255) x mod 2⁸, which equals (2⁸/255) (255 q + r) mod 2⁸ = (2⁸ q + (2⁸/255) r) mod 2⁸ = (2⁸/255) r, and return y − y/2⁸, which equals r.

Since these formulas don’t use the fact that ⌊(2⁸/255) r⌋ = r, Keane can switch from 2⁸ to 2¹⁰ for two guard bits. Ideally, these would always be zero, but due to fixed-point truncation and an approximation for 2¹⁰/255, they’re not. Keane adds 2 to switch from truncation to rounding, which also avoids the special case in Warren.

This method sort of uses the multiplier 2² (2⁰ + 2⁻⁸ + 2⁻¹⁶ + 2⁻²⁴ + 2⁻³² + 2⁻⁴⁰) = 2² (2⁰ + 2⁻¹⁶ + 2⁻³²) (2⁰ + 2⁻⁸). The C statement x = (((x >> 16) + x) >> 14) + (x << 2); computes x′ = ⌊2² (2⁰ + 2⁻¹⁶ + 2⁻³²) x⌋ mod 2³². Then ((x >> 8) + x) & 0x3ff is x′′ = ⌊(2⁰ + 2⁻⁸) x′⌋ mod 2¹⁰.

I don’t have time right now to do the error analysis formally. Informally, the error interval of the first computation has width < 1; the second, width < 2 + 2⁻⁸; the third, width < ((2 − 2⁻⁸) + 1)/2² < 1, which allows correct rounding.

Regarding improvements, the 2⁻⁴⁰ term of the approximation seems not necessary (?), but we might as well have it unless we can drop the 2⁻³² term. Dropping 2⁻³² pushes the approximation quality out of spec.

Yes, this is possible.

WebAssembly stores objects within linear memory, a contiguous array of bytes that the module can read and write to. The host environment (typically JavaScript within the web browser) can also read and write to linear memory, allowing it to access the objects that the WebAssembly modules stores there.

There are two challenges here:

1. How do you find where your WebAssembly module has stored an object?
2. How is the object encoded?

You need to ensure that you can read and write these objects from both the WebAssembly module and the JavaScript host.

I'd pick a known memory location, and a known serialisation format and use that to read/write from both sides.

This is working as designed. Parameter names in Java APIs are, in general, not something you can rely on to not change; they are an implementation detail, and by default, the compiler will not retain them in the classfile.

For the canonical constructor of a record, the parameter names must match the component names, and those are considered a part of the classes public API, and are therefore considered stable. So the compiler retains them in the classfile and reflection dutifully serves them up. The canonical constructor of a record is mandatory, and its form is specified by the language, so it is special in this way.

For the other constructors, neither the constructors nor the the parameter names have the same significance, so these are treated like ordinary members for purposes of the ParameterNames classfile attribute.

To hold a character outside of the 8-bit range, you need a wchar_t (which isn't necessarily Unicode). Although wchar_t is a fundamental C type, you need to #include to use it, and to use the wide character versions of string and I/O functions (such as putwc shown below).

You also need to ensure that you have activated a locale which supports wide characters, which should be the same locale as is being used by your terminal emulator (if you are writing to a terminal). Normally, that will be the default locale, selected with the string "".

Here's a simple equivalent to your Python code:

The differences you're seeing are in how you print out the data, not in the data itself.

As I see it, we have two problems here. One is that you're not consistently specifying the same precision when you print out the data in each language.

The second is that you're printing the data out to 17 digits of precision, but at least as normally implemented (double being a 64-bit number with a 53-bit significand) a double really only has about 15 decimal digits of precision.

So, while (for example) C and C++ both require that your result be rounded "correctly", once you go beyond the limits of precision it's supposed to support, they can't guarantee much about producing truly identical results in every possible case.

But that's going to affect only how the result looks when you print it out, not how it's actually stored internally.