the floating point naming explosion

The recent integration of the floating point technical specifications (TS) has had a disastrous effect on the set of reserved identifiers in C. If C2x would go through as it currently stands about 1700 identifiers that were completely unprotected and unannounced would enter the global name space and nasty conflicts with user code would become unavoidable. There have been several attempts in history to introduce scoped identifiers to C, but we can’t wait for such miracles to happen before C2x is supposed to come out.

Therefore, in a paper for WG14 that will be debated in the next meeting in Ithaca, I propose to take emergency measures and rename most of these new identifiers before they hit the public. On a complementary aspect, we propose decent names for the newly introduced floating point types.

N2426 Jens Gustedt, Contain the floating point naming explosion

Modern C, Second Edition

A new edition of the book Modern C and much more are now available under a CC license via the following page

 This edition is the result of a collaboration with Manning, and improves a lot over the previous edition; material has been rewritten and reordered, a lot of graphics have been added. Manning has a nicely formatted print and eBook versions of this,  there are links and information how to purchase this through the central link above, even with a limited 50% price reduction. Or a click on the cover may directly take you to Manning.




The C committee (AKA WG14) has now moved to construct the next real revision of the C standard. This is commonly referred to “C2x”, where the “x” is supposed to represent the digit of the year in which this new standard will appear. The whole procedure is ruled by the C2x Charter that describes and fixes what kind of additions and improvements we want to see in C2x.

We regularly publish working drafts that includes the changes that have been added so far. Other than for the C17 process, that was a pure bug fix release, such working papers introduce normative changes and are public and so I will keep up links to the ones that I find relevant, here. The first of these  is still mostly C17, with only a few additions:

The most recent ones can be found here:

We keep a list of changes and their status here

For discussion of all of these changes and other possible features that you like (or don’t) to be included in C2x, please refer to the appropriate channels. The best is to get involved in the standard’s process by adhering to your national standards body, come to the WG14 meetings and/or subscribing to the committee’s mailing list. Please have in mind that all contributions should be constructive, we aren’t fans of abusive language, insults or denigration.

Comments for this page are switched off. If you have spotted errors or omissions, please contact me directly via mail. Plain mail, please, no twitter or alike, this is your Turing test.

Possible future additions to the C standard

There are many other ideas and documents floating around for inclusion into C2x. The following list is certainly not complete and biased by my personal preferences:

    • Ease the definition of extended integer types, see N2303
    • Add wide or bignum integer types
    • Add type generic interfaces for string functions to the C library, see N2068
    • Add general constants for all data types
    • Extend the concept of integer constant expressions (ICE)
    • Remove ATOMIC_VAR_INIT, see n2390 
    • Revise atomics, see n2389
    • Revise threads, see n2391
    • Revise the memory model, see N2294
    • Remove K&R function declarations and definitions
    • Remove one’s complement and sign-magnitude representations of signed integers, see N2218
    • Remove the * form of VLA function parameter declarations
    • Improve array bound propagation and checks
    • Add a new calling conventions with error return for library functions that avoids the use of errno
    • New string representations for NaNs, see N2290
    • Extend specifications for enum types, see N2008
    • Remove or deprecate Annex K, see N1969
    • Add a type aware print utility with format specification syntax similar to python
    • Add multibyte/wide string conversion functions, see N2282
    • char8_t: A type for UTF-8 characters and strings, see N2231
    • Adding the u8 character prefix, see N2198
    • Harmonizing left-shift behavior with C++, see N2161
    • __has_include for C, see N2101
    • add more TIME_ variants to timespec_get, integrate POSIX time conversion functions, see N2402
    • Add wchar_t and FILE to all headers that use them
    • Revise spelling of keywords and make them feature tests, see N2392
    • Make false and true first-class language features, see N2393
    • Add a simple specification of nullptr, similar to C++, see N2394
    • upgrade C library headers with [static 1]
    • type deduction from initializer, similar as C++’s auto
    • constexpr to evaluate expressions at compile time as in C++
    • __VA_ARGS__ comma omission and comma deletion, see N2160
    • TS 18661-3 as annex, see N2342
    • Improved Rules for Tag Compatibility, see N2366
    • Remove support for storage-class specifiers not in first position
    • Remove support for tentative definitions
    • Inline variables
    • Initializers for selection statement
    • Allow to not name parameters in function definitions

Spurious failures of thread functions

C11’s thread interface was not very clear on failure conditions that some functions might encounter. It was not clear that wait functions for conditional variables (cnd_t) and tentative locking of mutexes (mtx_t) may fail spuriously, that is with not apparent reason for the caller. By lack of such a specification, it was not clear how C11 threads could be realized by POSIX threads, e.g.

Allowing spurious wakeups is particularly important for the wait functions, because it makes implementing the cnd_t type much easier, in particular for the special case that the caller of cnd_signal or cnd_broadcast does not hold the lock on the corresponding mutex. On the other hand, from an application point of view this does not change much. Even without spurious wakeups, a thread that called `cnd_wait`, e.g, must in any case check the real condition they are interested in.

Continue reading “Spurious failures of thread functions”

compare exchange compares memory and not value

In C11,, introduces atomic_compare_exchange generic functions. These are precious tools when using atomics: they allow to conditionally store new data in an atomic variable and to retrieve a previous value of it, eventually. You can see that as a generalization of atomic_fetch_and_add where we are also able to retrieve a counter value and change it at the same time.

C11 stated that the value would be taken into account for the conditional part, that is that the existing value would be compared to a desired value. This works well for arithmetic types, where value and object representation are mostly the same. It works less well if the atomic type is a structure because struct types simply have no equality operator.

Continue reading “compare exchange compares memory and not value”

C17: reformulations for atomic_flag

In C11, there was a problem with the fact that atomic_flag is one of the rare types that is not considered to have a value, but it only has state (clear and set) which is changed via function calls. (mtx_t and cnd_t are other examples of such types.) There was no established relation between these states and the return value of the atomic_flag_test_and_set functions (which is bool).

C17 clears that up by prescribing the return values of atomic_flag_test_and_set

Continue reading “C17: reformulations for atomic_flag”