Merge branch 'release/0.12.1' into develop

* release/0.12.1:
  Bump soversion for 0.12.1
Hide mempool implementation details

The `cork_mempool` type is now completely opaque, which moves us one
step closer to declaring a stable ABI for libcork.  This means that you
can no longer embed a `cork_mempool` directly into your own types.  This
gives us more flexibility in the future to change the implementation
without breaking existing code.

(The main reason for allowing embedded `cork_mempool` objects was to let
us implement `cork_mempool_new_object` as a static inline function.  But
that's not really useful; the performance benefit is negligible, and it
complicates the API.  So that's now a regular CORK_API function.)

As part of this update, the initialization and finalization callbacks
now include a `user_data` parameter, like all good callbacks should.
(We already had function pointer types for these callbacks, we just
needed to use them!)

And lastly, the functions for allocating and freeing an object in the
memory pool have been renamed to `cork_mempool_new_object` and
`cork_mempool_free_object`.  After all, they weren't creating or freeing
the memory pool itself...
Thread-safe subprocesses

The `cork_subprocess` functions now work with multiple threads.  You can
also more easily run a single subprocess; you don't need to create a
one-element subprocess group any more.

The new implementation is also much simpler; before, we were using a
select loop in `cork_subprocess_wait` to sleep until there was something
interesting to do.  We also explicitly handled the `SIGCHLD` signal to
reap any processes that just finished.  We now use a more naive busy
loop; each call to `cork_subprocress_drain` tries to read data from the
subprocess's stdout and stderr streams, and then checks if the
subprocess has exited, both in a non-blocking fashion.  There is then a
busy loop in `cork_subprocess_wait` that drains the subprocess
repeatedly until it's finished.  We use the “hybrid yield strategy” from
[1] to make sure that we don't consume too much CPU if the subprocess
is long running and doesn't produce any output.

[1] http://www.1024cores.net/home/lock-free-algorithms/tricks/spinning
Build check if necessary

RHEL5 provides an older version of check than we need.  We have a git
clone of the latest check, which includes a Buzzy package description,
so that we can satisfy the dependency with a built package on RHEL5.
Remove strict-aliasing warnings on RHEL5
Merge branch 'feature/rhel5' into develop

* feature/rhel5:
  Remove strict-aliasing warnings on RHEL5
  Build check if necessary
Warnings are errors on clang

We were setting -Wall -Werror when compiling with GCC to make sure that
we get rid of all compiler warnings as part of the standard build/test
process.  Now we do that for clang, too, for when we're developing on
Mac OS X.
Merge remote-tracking branch 'template/c-template' into develop

* template/c-template:
  Warnings are errors on clang
Methods to dynamically allocate cork_ring_buffer

This patch includes two new methods, `cork_ring_buffer_new()` and
`cork_ring_buffer_free()`, which allocates a ring buffer on the
heap.
Fix compiler error on 32-bit platforms

Our 32-bit implementation of the big hash functions had a compiler
error.  This should (hopefully) fix them.
Delete known entry from hash table

The new `cork_hash_table_delete_entry` function lets you delete an entry
from hash table more efficiently.  You pass in a `cork_hash_table_entry`
instance, instead of a key value.  This means that we don't have to
search through the hash table for the value to delete; the entry
instance acts as a pointer to the specific entry that we want to delete.
Don't ignore initial hash table size

How about we actually pay attention to the `initial_size` parameter and
allocate that many buckets?
Description of executable programs

I need to print out a nice string representation of a `cork_exec`
instance basically all the damn time, so let's make a helper function
for that.
Merge branch 'feature/ring-buffer-heaped' into develop

* feature/ring-buffer-heaped:
  Methods to dynamically allocate cork_ring_buffer
Updated PowerPC detection macros

The autodetection logic was missing some of the macros listed at [1]
that can be used to detect a PowerPC machine.  This should get them all.

[1] http://sourceforge.net/p/predef/wiki/Architectures/
Unique identifiers

The new `cork_unique_id` type represents a unique identifier that is
visible at compile-time.  You can use these identifiers as keys for
extensible points in a plugin system, for instance; the identifiers
themselves will be unique within a given execution of the program, and
they'll each have a name associated with them to help produce useful
debug and error messages.
Prefixing error messages

You can use the new `cork_error_prefix` function to prepend some
additional text to an existing error message.

This patch also updates the internal implementation to clean up after
itself better.  Before, we would grab a thread-local `cork_error`
instance for each thread, but didn't clean up those instances.  Now, we
maintain a (thread-safe) list of all of the `cork_error` instances that
have been allocated, and register a (process-level) cleanup function
that cleans all of them up.
Access stdin of subprocesses

You can now access the stdin stream of any `cork_subprocess` instance
that you create.  Access is provided via a `cork_stream_consumer`
instance; any data that you write into that stream consumer is sent to
the subprocess's stdin.  We don't do any buffering, or worry in any way
about the buffering of the underlying pipe — you must handle this
yourself if there is any kind of complicated orchestration needed by the
subprocess that you're calling.
Subsecond timestamp format specifier

This patch updates the timestamp formatting functions so that we don't
use the builtin ``strftime`` under the covers.  This limits the number
of standard format specifiers that we support, but we can add more of
them back in as they're needed.  Importantly, this lets us add a new
specifier (%[width]f), not covered by ``strftime``, to include the
fractional seconds portion of the timestamp.

I'm also taking this opportunity to change the signature of the
formatting functions; the result is now rendered into a `cork_buffer`,
instead of into a fixed-size buffer.
Simpler error API

This patch simplifies the libcork error API.  Before, we followed glib's
GError API, where there were separate “classes” and “codes” for each
custom error condition.  The class was meant to identify the library
that the custom error belongs to, and the code only had to be unique
within each class.  GError creates error class values at runtime, using
its GQuark mechanism.  We use hashes of unique strings as error classes.
Error codes were then defined using a simple enum.

This is more cumbersome than it needs to be.  With this new patch, we no
longer have error classes at all.  Individual error codes are now hash
values, usually of the name of the error code's macro.  (I.e., the
value of the `CORK_PARSE_ERROR` error code is the hash of the string
`"CORK_PARSE_ERROR"`.)  This new design also lets us use the existing,
predefined, well-known POSIX `errno` values as error codes directly,
which makes it easier to integrate code that uses the POSIX error
reporting facilities and libcork's error API.