Just adding `-g' to list of CFLAGS doesn't make gcc to generate debug
information required for macro expansion during debugging. Replacing
it with `-g3 -ggdb' rectifies this.

(configurator.c commit folded by Rusty)

Nice for distributed option declaration.

Also add #include to AUTODATA_TYPE example, so ccanlint doesn't try to
put it inside a function (which works, for this, but gives a warning
about unused variables).

Makes things a bit neater.

eg. "See also" can match "see-also".

Gets rid of generated file.

This is a more portable variant of the ELF section trick.

Very slow, but sometimes you need to know without crashing.

It's much easier to simply say "keep all", and it simplifies the code
quite a bit.

I use --target far more than --timeout.

Rather than using a separate index of tetst to skip, make sure tests
we don't want to run are removed from the graph of tests to start
with.

This means that the "skip" field is only set when we fail a test (and
thus must be reset when we test the next module).

Rather than walking the list of tests manually, use
dgraph_traverse_to() to run the tests.

Instead of a linked list of tests, we use dgraph and strmap.

Make info_exists() call add_info_options() directly, rather than detecting
that we've found _info inside the loop of tests.

It means targeting is now a global, which is a bit sucky.

This way, we can debug really early failures (eg. during option
parsing).

It's reduced to a flag which means we stop processing the module.  We have
to enhance our dependencies a bit, but they've always been quite good.

This simplifies things quite a bit.

Parsing options like --verbose and --debug can be a pain.  You need to
have everything set up before invoking parse_args(), but that may be a
significant amount of work, for which you may want verbose or
debugging enabled.

Thus the concept of "early" args: you can nominate arguments to be
parse before anything else, using opt_early_parse().

Make a false return abort the iteration, not true.

The old way makes sense for search functions (true == I found it), but
other kinds of iteration are more common (brute force search is
probably dumb).

strset_set -> strset_add
strset_clear -> strset_del
strset_test -> strset_get
strset_destroy -> strset_clear

Testing code still using it.

With the type canary, it's unnecessary.  Though the implementation is
a bit more awkward since they longer map directly through to list_top/tail.

Just like container_of() (with typechecking, etc), but return the offset
to the enclosing structure.

This means we know they're there in future, and what restrictions they
carry.

This allows even more extensibility in future: in particular, the top
bits of each capability tell us what to do if we don't understand it:
fail the open, fail to open for write, or don't try to check the
format.

tdb_check needs to understand the capability list so it can know to
skip over it: each element in the list is prefixed with the type tag
and the length.

Neater API.

This will be used shortly to indicate that a TDB2 file indicates it
cannot be checked.

The current mix of writing to an fd doesn't mix as well with
stderr/stdout.  And writing to a FILE * is more portable.

This gives a much deeper insight into what failtest is doing; good for
debugging failtest itself.