Add support for the orientation tag in Android manifest

Fix Windows platform checks

Add copy-constructor as required by C++11

Don't block in ExternalTask::do_wait unless requested

Read output from external task while waiting

Waiting for the process to finish first may lead to a deadlock if it
produces more output than can fit in the pipe's buffers.

Add a statement to specify multiple arguments at once for a generator

Support generators that require a switch before output file name

Allow generator commands to reside outside of the package

In particular, this lets system binaries to be used as generators.

Provide a binary package for libmad

It does not provide a .pc file of its own.

Use a more appropriate check for adding -m<bits> flag

The bits check was redundant because it's already included in the native
flag.  On the other hand -m<bits> is not supported on all architectures,
in particular on ARM.

Use a different cross-compile prefix for 64-bit Windows

The i686 version of MinGW won't compile 64-bit binaries even with -m64.

Fix check for appending pattern suffix

If the body is too short to already contain the suffix, it should be
added.

Update deprecated things

Remove the -lmingw32 hack

Libmspcore now implements main() on Windows so it isn't needed anymore.

Don't apply parts of a pattern that are already present

This allows naming a library component "libsomething" without the final
file name having a double lib prefix.

Slight updates to Readme

Add support for statically linking the C++ standard library

It can be requested by setting the libmode for "stdc++" as STATIC.

Use -rpath (or -rpath-link) when linking

It avoids the need to use LD_LIBRARY_PATH when running programs linked
against custom libraries.  The default build types have been amended so
that debug builds use an absolute rpath.  This allows them to be run from
the source tree.  Release builds use a relative rpath to make them more
easily relocatable in the filesystem.

Use const references in BuildInfo::Tracked operators

Silence the cast-function-type warning on GCC 8

It causes problems when function type need to be explicitly converted,
like in sigc++.

Move version discovery back to GnuCompiler

It's needed to determine whether some options are supported

Also store library path in static libraries

Use build info to store static library dependencies

In some cases it's desirable to link a particular library statically but
use dynamic linking for its dependencies.  In particular, libpng and
libvorbis depend on libm, which is considered a part of libc and must be
linked in the same way.  Now all libraries are looked up according to
libmode, making such linking possible.

Don't crash if the executable of a GnuCompiler is not found

Use $sdk_root/ndk-bundle as default path for Android NDK

It's now available for download through the SDK manager, which installs it
in this location.

Recognize and use the common sysroot in newer Android NDKs

Clean up compiler and linker constructors

Now that the system path is populated in do_prepare, it's no longer
necessary to pass the sysroot as a constructor parameter.

Also get the linker system path from the actual linker program

Revert to default system path for GnuCompiler is autodetection fails

Improve problem reporting for the Android toolchain

Rather than throwing exceptions with cryptic messages, add the problems
to the tools' problem lists.

Make AndroidCompiler more robust about detecting the cxx-stl location

On recent NDK versions the toolchain reports its version as 4.9.x but the
cxx-stl directory is still 4.9.

Have SubTool automatically pass calls to the parent tool

Interrogate the compiler for the system path

Rather than trying to guesstimate it from the compiler version.

Improve ExternalTask::run_and_capture_output

Redirect input from /dev/null and allow stderr to be captured as well.

Prepare tools before querying their system path in the VFS

Collapse the language-specific compilers into a single class

There's very little differences between languages of the C family, but on
the other hand different platform SDKs need their own tweaks.  It makes
more sense to abstract by platform rather than by language here.

Combine the gnu and clang toolchains into SystemToolchain

Add FPU specification to Architecture and GnuCompiler

Don't treat using deprecated declarations as errors

They can be impossible to avoid sometimes if a non-deprecated replacement
is not available.

Attach component information to data source files

Compilation fix

Erase with const_iterator is allowed in C++11 so I didn't notice this
before.

Only use source files that are actually files

And not, say, directories.

Support source generators that combine multiple files into one

Some existing tools have processing unit annotations too, but for some of
them it's not clear what the unit should be.

Check for some errors in SourceGenerator

Change the suffix of modules

.m is already used by Objective-C.  It seems there's some precedent of
.dlm as Dynamic Link Module.

Use correct library path for libraries from the containing package

Check DataTransform's directory mtime against cache mtime

Transforms commonly contain wildcard patterns, so the set of source files
may change without the transform itself changing.

Add .lib as a static library suffix for Windows

Explicitly add -lmingw32 before any other libraries

This fixes linking when WinMain() is in a library (such as libmspcore)
and shouldn't be harmful when it isn't.

Update cross prefix for windows architecture

Adjust the find command line

The list syntax is a GNU extension, so use -false and -o to achieve the
same effect.

Set the debuggable flag in Android manifest if debug is set in build info

Allow Android application permissions to be set in Build file

Minor cleanup to the BuildInfo class

Pass language standards throuhg ALL dependencies

Not just direct ones.  I really don't know why I put it in the !=CHAINED
block.

Allow features to be exported

While overlay directories are generally preferred, sometimes it's not
worth the effort for a small feature.  In those cases the -D switch needs
to be applied to any package that might use the library's headers.

Recent versions of sigc++ require C++11

Pass language standards through dependencies

If a library uses a particular standard in its headers, all packages that
depend on it should use that standard as well (unless overridden at the
package).

Fix bootstrap to handle overlays in a more generic way

Include the threads flag if a static library needs it

Deal with static build flags for binary packages

Some libraries have internal dependencies to other libraries, which are
automatically pulled in with dynamic linking, but need to be manually
specified to the linker when linking statically.

Fix DataCollection dependencies

Since DataTransform is not buildable, it won't get a rebuild flag even if
its dependencies change.  Thus the dependencies must also be added to
DataCollection.

Use parameterless system path accessors

Since the -C option causes a chdir early in the initialization, an argv[0]
of "./builder" could break things.

Remove some unused #includes

Allow specifying fixed arguments for source generators

Currently, the fixed arguments are placed at the front of the command
line, with the template file coming last.

Support conditionals inside source generator definitions

Move conditionals into helper classes

Add a list of symbols to keep in the binary to BuildInfo

The linker normally does not pull unnecessary symbols from static
libraries, which can cause problems if those symbols are meant to be
referenced externally.

Better algorithm for ordering static libraries

Put each static library dependency immediately after the library that
required it.  This way, if a tool includes a static library in its own
build_info (such as gnustl_static for AndroidCxxCompiler), it will be
placed last and be available for all other static libraries.

Provide the AR tool on Android

Force shared linking on Android

Android applications are not run as standalone programs, but instead
loaded as native libraries into the Java VM.

Only use files from the first overlay that has them

This allows special-casing pieces of code for some platforms without
fragmenting the directory structure too badly.

Make use of Task's file affinity and unlinking capabilities in Copy

A bunch of new tools and targets to build Android packages

Currently can only build apks using NativeActivity and debug key, and
will probably break if the package has a version.  Still, it's useful
in certain configurations so I'll commit this version now and continue
improving it.

Add some logging to AndroidTools

Only get DataTransform directory contents when needed

Better incpath logic in AndroidCxxCompiler

Don't expose the private directory through system_path, since programs
are not suppose to #include those files directly.  Also use architecture
to determine which subdir to pick.

Introduce a helper function in Architecture to pick the best matching name

Don't generate filenames with double dash for versionless packages

Add a field for a human-readable name for packages

Not all devices have libgnustl_shared.so, so better link the static one

Support "installing" files to a private staging area

Use C++ include path from sysroot

Add utility class for executing chains of tasks

Support redirecting ExternalTask's stdin/stdout from/to a file

A bunch of minor cleanups

Rewrite ExternalTask to use Msp::Process

Use qualified name in base class initializer

Also default to clang on FreeBSD

Add more recognized architectures

Aliases can now resolve to multiple parts, so words like x86_64 or win32
can do the right thing.

The pc type was changed to x86, because that more accurately describes
the processor archetype.

Add a binary package for zlib

Not all systems ship it with a .pc file

Move the bpk files into a subdirectory and install them

Use frameworks instead of raw libraries for OpenGL and OpenAL on OS X

Add support for specifying the language standard to use

Drop support for generic tarball components

I originally envisioned using them for creating binary release tarballs,
but that turns out to be a less than spectacular idea.  Tarballs only
really work as a distribution format on Linux.  Other platforms either
use a different archive format or require more complicated preparations.

Split Component into several subclasses

The create_targets function in particular was rather unwieldy and
contained four completely separate branches.  Having distinct component
types in different classes will also enhance modularity.

Don't use soname for modules

Don't rely on component type in determining whether to use -fPIC

Instead let SharedLibrary set a flag in ObjectFiles and use that.

Collect libpath for static library dependencies from the libs themselves

Also fixes Binary::find_dependencies which broke in 3f0f721.

Add options for custom compiler and debug build to bootstrap.sh

These are not expected to be used normally, but may help in an initial
port to a new platform.