Errata

The Note states that single quotes are needed around the dash in the following command, so that Python knows it's not the start of a flag:

echo "print 'hi.'" | python '-'

However, those quotes are stripped off by the shell before Python ever sees the dash. The command runs the same with or without the quotes.

Note from the Author or Editor:
Good point.

Fixed by BK.

"Cultivate Robust and Flourishing Macros" suggests enclosing multi-line macros in braces to avoid control flow gotchas, but the suggested construction, e.g.

#define myMacro() { \
... \
}

will break in the case of

if (x)
myMacro();
else
...

The canonical way to define such macros is:

#define myMacro() do { \
... \
} while (0)

Note from the Author or Editor:
I never liked the look of the do-while, but I concede that it is better to have it there.

Additional text added by BK. Also, added a do-while wrapper to the Stopif macro in the book and the sample code.

CFLAGS=`pkg-config --cflags apophenia glib-2.0` -g -wall -std=gnu11 -O3

Wall should be capitalized.

Note from the Author or Editor:
fixed in the repository in october.

On OSX, the c99 command's -W option is used to specify the pointer size (either 32-bit or 64-bit), not to set the warning level.

Note from the Author or Editor:
fixed in the print edition

The program as written:

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
int main(){
srandom(time(NULL)); // Initialize RNG seed.
printf("%li\n", random()); // Make one draw.
}

compiles with warnings, when the generalized makefile is used:

c99 -g -Wall -O3 random_draw.c -o random_draw
random_draw.c: In function ?main?:
random_draw.c:7:3: warning: implicit declaration of function ?srandom? [-Wimplicit-function-declaration]
random_draw.c:8:3: warning: implicit declaration of function ?random? [-Wimplicit-function-declaration]
random_draw.c:8:3: warning: format ?%li? expects argument of type ?long int?, but argument 2 has type ?int? [-Wformat]

-------

The following version will compile without warnings for the same makefile parameters:

#include<time.h>
#include<stdio.h>
#include<stdlib.h>

int main()
{
srand(time(NULL)); // initialize seed
long int x = rand();
printf("%li\n", x);
}

Note from the Author or Editor:
fixed in the print edition.

"2 If the Python variable is set"

The variable is called PYTHON, in capitals.

Note from the Author or Editor:
fixed in repo

The note number 2 reads: The address of the first element, assigned to a new pointer.
The corresponding line of code:
int *positive_evens = &evens[1];
actually addresses to the second element, since array indexes start with 0 and not 1.

Note from the Author or Editor:
Good point. I've reworded the text to correct this.

The sentence claims that five symbols (ordinary identifiers) are added to the global space, directions and the values the enum can take. However, directions is added to the namespace for tags, for structures, unions, and enums, not the global space.

See the C11 standard section 6.2.3(1).

Note from the Author or Editor:
fixed in repo

"But if you think there’s even a remote possibility that you have a variable that might multiply its way up to the billions [...] then you certainly need to use a long int or even a long long int, or else your answer won’t just be imprecise—it’ll be entirely wrong, as C suddenly wraps around from +2.1 billion to -2.1 billion."

The author may want to avoid implying that this overflow behaviour is reliable and can be depended on, since signed integer overflow is Undefined Behaviour.

Note from the Author or Editor:
Reworded in 2nd ed to: "...it’ll be entirely wrong, as most implementations wrap around from +2.1 billion to -2.1 billion"

On that page, in the box "Macro Arguments Are Optional", a macro is described which is implemented like this:
[...] fprintf(stderr, #assertion "failed to be true. \
Returning" #returnval "\n"); [...]

The main string in this macro needs to have spaces at the beginning and at the end, like this:
[...] fprintf(stderr, #assertion " failed to be true. \
Returning " #returnval "\n"); [...]

Otherwise, assuming that #assertion is "a==b" and #retval is "9", The macro will pass a string to fprintf that looks like this:
"a==bfailed to be true. Returning9"
due to the fact that when the preprocessor joins adjacent strings, it does not add spacing between the added string.

Note from the Author or Editor:
Fixed in repo by BK.

In that section the function "at_exit" is introduced, but in reality it doesn't exist. What exists is "atexit" (note the missing underscore in the middle).

"man" and general googling seems to confirm this.

Note from the Author or Editor:
Good catch! The correct names are at_quick_exit and atexit.

The Bauhaus-inspired sample code gets this right (otherwise it wouldn't compile and pass tests), but the text has the incorrect extra underscore.

Fixed by BK in 2nd ed commit b64f8fc.

The first sentence on the page is incorrect, due to the incorrect usage of the term glyph. A glyph can have multiple code points. For example, the glyph &#8721; can be represented by the mathematical U+2211 or the Greek U+03A3. There is not a one-to-one mapping between glyphs and code points.

The sentence is helpful as an introduction, but a footnote is warranted to explain that it is an oversimplification. Or perhaps delete the word "single".

Note from the Author or Editor:
Good point. As per commenter's suggestion, I removed the word "single".

Fixed in repo by BK.

It is claimed that the C99 & C11 standard guarantee CHARBIT to be 8, citing §5.2.4.2.1(1). Yet the paragraph of that section states "The values [including CHAR_BIT] given below shall be replaced by constant expressions [...]", meaning that the values given for these macros are defined by the implementation.

Note from the Author or Editor:
These two points are not contradictory: the compiler is expected to replace the symbol CHAR_BIT with a constant expression, but that constant expression must be "8" or larger.

So it's possible that you could write a compiler where the symbol CHAR_BIT is replaced with "9"! But this is only in the realm of 'technically not impossible'. The intent of this sentence was to counter older texts that took some care to handle 7-bit chars, which are no longer a consideration either in the standard or in practice.

There are no __FUNCTION__, __FILE__, or __LINE__ macros to be expanded in the code referenced. Perhaps they are missing?

Note from the Author or Editor:
Fixed in repo on 3 December

The example function call

//sample usage:
Stopif(x<0 || x>1, "x has value %g, " "but it should be between zero and one.", x);

seems incorrect since the macro requires "error_action" as second argument.

Note from the Author or Editor:
fixed in repository months ago.

The computation of the free fall energy is wrong. The correct formula for the kinetic energy is E=(1/2) *mv^2. So the last but one line of the function should be

out.value = mass*velocity*velocity/2.;

Note from the Author or Editor:
fixed in repository .

Should be: out.rate = in.rate ? in.rate : 4.5;


Fixed by Ben K.

Instead of:

typedef void *(*void_ptr_to_void_ptr)(void *in);
int pthread_create(..., void *ptr, void_ptr_to_void_ptr *fn);

the example should read:

typedef void *(*void_ptr_to_void_ptr)(void *in);
int pthread_create(..., void *ptr, void_ptr_to_void_ptr fn);

"void_ptr_to_void_ptr" is already typedef'd as a pointer to a function. So as written, the "pthread_create" declaration expects a pointer to a pointer to a function.

Note from the Author or Editor:
Fixed in repo by BK

I'm using an ePub version, so my page number is meaningless.

You tell us part way through this section that you can't initialize a variable-length array, and then present:


// A form for filling in from the end of an array. By the pick up
// where you left off rule, this will become {0.1, 0, 0, 0, 0, 1.1, 2.2}:
int len=7;
double list3[len] = {0.1, [len-2]=1.1, 2.2}

Regretfully, neither part of that works. It's gotta be:

double list3[7] = {0.1, [7-2]=1.1, 2.2}

Note from the Author or Editor:
Good point. This form usually appears when the length is a macro symbol, like #define len 7, making list3 a fixed-length array.

Fixed in the repo by BK., by merging this with the previous example.