This is the very very last command that executes in the Cygwin build, since the next line is disabled. Of course, changing a directory is irrelevant. But that directory doesn't exist after the Cygwin build. So it fails. So the build failed ON THE LAST LINE THAT DIDN'T MATTER ANYWAY.

This reverts commit a5628e469240c3a607758ad39af40500ebb55fd2.

Apparently, this is compatible with older versions of cmake, while having the same effect. Apparently, the cmake people spent some time refuling to let people specify C++ standard versions and instead insisted that they specify specific features instead. They did not see the light until cmake 3.8, but that's too new for us to require yet, I guess.

super-test.sh tests building the samples with cmake. Without installing a cygwin-specific cmake, it ends up invoking the Windows-native cmake which doesn't work at all.

Windows -- including Cygwin -- return a NaN representation with the sign bit set, whereas other platforms return one without the sign bit set. This results in different binary output in the JSON-to-binary part of capnp-test.sh.

This was uncovered since we're now runing capnp-test.sh for Cygwin builds, but the problem actually applies to *all* Windows builds. We just weren't running this test for the other builds before.

Interestingly, I *had* run this test with a MinGW cross-compile build running on WINE, and it passed there. Seemingly, WINE's strtod() directly wraps the host system's without trying to emulate Windows differences.

Admittedly this is a strict simplification to the code.

VS 2017 is fine either way.

I don't know why we've been installing our own. According to this these are already installed: https://www.appveyor.com/docs/build-environment/#mingw-msys-cygwin

Also use super-test.sh to test Cygwin; get rid of appveyor-cygwin.sh which tests the wrong thing.

This is true even if the pointer-to-member is never actually used, but only has its type matched, which was what kj::size() was trying to do.

Oh well, define some damned constants instead.

It apparently cannot compile properly against libstdc++.

This is stupid, but the GCC maintainers refused to change it:

    https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425

For some reason, KJ's uses of (void) did not warn with GCC 5 but do warn with GCC 7. Supposedly, GCC *never* supported silencing with (void), so there must have been some other bug that caused GCC to fail to trigger the warning previously -- maybe related to the fact that the values being returned are non-trivial types?

C++17 introduces `[[nodiscard]]` which is defined as being squelchable using `(void)`, but we're still on C++14, and KJ_UNUSED_RESULT is a post-declaration attribute so can't be defined in terms of the new C++17 attribute even if the compiler supports it. Sigh.

If we were using C++17, we could use [[fallthrough]] instead... but we are not.

So far this is only a small subset of all the STL uses.

I also modified the test runner to print how long each test takes to run, useful for comparing benchmarks.

Hash-based (unordered) and tree-based (ordered) indexing are provided.

kj::Table offers advantages over STL:
- A Table can have multiple indexes (allowing lookup by multiple keys). Different indexes can use different algorithms (e.g. hash vs. tree) and have different uniqueness constraints.
- The properties on which a Table is indexed need not be explicit fields -- they can be computed from the table's row type.
- Tables use less memory and make fewer allocations than STL, because rows are stored in a contiguous array.
- The hash indexing implementation uses linear probing rather than chaining, which again means far fewer allocations and more cache-friendliness.
- The tree indexing implementation uses B-trees optimized for cache line size, whereas STL uses cache-unfriendly and allocation-heavy red-black binary trees. (However, STL trees are overall more cache-friendly; see below.)
- Most of the b-tree implementation is not templated. This reduces code bloat, at the cost of some performance due to virtual calls.

On an ad hoc benchmark on large tables, the hash index implementation appears to outperform libc++'s `std::unordered_set` by ~60%. However, libc++'s `std::set` still outperforms the B-tree index by ~70%. It looks like the B-tree implementation suffers in part from the fact that keys are not stored inline in the tree nodes, forcing extra memory indirections. This is a price we pay for lower memory usage overall, and the ability to have multiple indexes on one table. The b-tree implementation also suffers somewhat from not being 100% templates, compared to STL, but I think this is a reasonable trade-off. The most performance-critical use cases will use hash indexes anyway.

You need to use a different constructor function, `refTuple()`, to opt into references. Otherwise, it's too easy to construct a tuple of references by mistake.

indexOfType<T, Tuple<...>>() searches the Tuple for a member of type T and returns its index. It fails to compile if there is not exactly one match.

TypeOfIndex<i, Tuple<...>> evaluates to the type of the Tuple member at the given index.

I'm tired of working around missing features that were added in C++14. It's four years old now, compilers should support it.

Ignore ECHILD in UnixEventPort::ChildSet::checkExits

If no child process has changed state, waitpid() returns zero. But if there
are no more child processes at all, it returns -1 and sets errno to ECHILD.
Since checkExits calls waitpid() in a loop, it must ignore ECHILD.

+Unit test modified to exhibit the unexpected behaviour.