The standard ctype.h variants will make you go insane if you
contemplate them for too long.

isspace() and isdigit() want an unsigned value.

tolower(), toupper() and isupper want an unsigned value.  Also, fix
lazy cost-discarding inside strrchr for extra safety.

If we detect any mention of a problematic string function, try compiling
the entire module with string debugging enabled.

In the former case, we were bitten by the fact that you don't pass a char
to isalpha() et al: you pass an int.  This means on most platforms you want
to do:

   if (isalpha((unsigned char)c)) ...

Insane?  Yes, but I assure you I'm not making this up.

Similarly, I've always wanted strstr, strchr and strrchr to return
const char * when given a const char * argument to search, to avoid
constness leak.

In both cases, the actual versions from the headers may be macros, so
we need to be very careful overriding them.  The result is that they
become out-of-line functions which is unacceptable for general
performance.

So we only activate these when CCAN_STR_DEBUG is defined.

Same thing (a BUILD_ASSERT which evaluates to zero), but there's a
strong preference for all modules to stick with their own names as
prefixes.

They're often out-of-date, and we're about to do special things to the
str module compile flags, so we don't *ever* want the default.

It doesn't add much to build times, and it eliminates a nasty source
of weird errors.

We need to flush stdout before forking.

Also add a note about a possible segfault.

We don't use it for the moment, but Brad Hards noted that assigning to
dest ten continuing was pointless, revealing this bug.

We only ever write to this variable, so can just be removed.

This is always overwritten later in the function.

obe is always overwritten later.

last is unconditionally set to zero later in this function.

lp_bits was only ever written to.

asprintf is a PITA to use, and it's not in POSIX anyway.  Provide
replacements, and also provide a nicer-to-use afmt() wrapper.

tools/ccan_depends --compile ccan/module (without a trailing slash)
results in a segfault.

(Patched forward by Rusty)

We get a point for every run or api test, rather than 1 point for all of them,
so be consistent.

cast package has all negative tests, plus testable examples.

Thanks to Andreas Schlick, we have a nicer test for when gcc warns about
trampolines (gcc 4.6's -Wtrampolines).  This works at any optimization level,
and means when that warning is enabled we recognize that we shouldn't allow
nested functions.

Increase from:
	1985 of 2553 lines covered
to:
	2020 of 2552 lines covered

Increase from:
	1985 of 2553 lines covered
to:
	2018 of 2552 lines covered

Increase from:
	1962 of 2553 lines covered
to:
	1985 of 2553 lines covered

The "ret < n" was done as an unsigned comparison, so it didn't work as
expected when ret was negative.

Simplest fix is to do an equals comparison everywhere, which is also
slightly stricter.

You can always specify the TDB_NOLOCK flag along with O_RDONLY for the old
behaviour.

If benchmarking indicates a problem later, we can restore it.

Mostly a fairly simple transformation, since 0 still means success.

One new twist is that tdb_nextkey now frees the .dptr of the key; this
us usually what we want but does cause issues for our weird test code.

Of course, we leave the API the same, but percolate error codes all the
way back to tdb_check().

In particular, tdb_needs_recovery() can now indicate an error occurred,
rather than returning true.