Recognize PowerPC architecture

Older versions of OS X don't have clang

Allow overriding tool commands on the command line

Various cleanups

Rudimentary support for compiling things for Android

At the moment programs are compiled as if for a desktop system.  Creating
graphical applications in this way is difficult, as it requires different
build rules to compile the application code as a .so and some boilerplate
to wrap it in a .apk with a NativeActivity.

Deal with absolute paths in tool commands

Add sysroot support for BuildInfo and compilers

Embedded SDKs commonly ship with a sysroot to use with their compilers.
It might also come useful for compiling things for different Linux
distributions.

Add paths to beginning when merging BuildInfo

This is more consistent with how scalars are handled, since earlier
values take predecence.

Add build info to tools and use it to pass runtime libs

This is more flexible and removes the need for the linker to know about
all compilers.

Give targets the ability to gather their own build info

Only use the -m flag on native arch

Better yet would be to figure out whether the target arch supports it,
but that's not trivial.

Refactor version discovery into the base GnuCompiler class

Also prepare transitive dependencies

Mostly to make analyzer report correct results when source files are
given on command line.

Pass a tool hint to VirtualFileSystem::find_header

This makes C++ includes findable again, since they have no suffix and
thus match no tool.

Get the executable in GnuCxxCompiler::do_prepare

It's needed for querying the compiler version, and Tool won't get it
until after do_prepare.

Missed one location with the conditional conversion

Support boolean logic in conditions

Parentheses are missing and a few corner cases trigger obscure errors, but
it's good enough for now.

Generate shorter object file names for generated source files

Move nested build signature creation to FileTarget

This way the same code can be used by different target classes that need
it.  In particular, both Binary and StaticLibrary need nested signatures,
and FileTerget is their closest common base.

Add and improve build signatures for some tools

Properly support multiple choice features

Base config options directly on features

There are no standalone options anymore, so might as well streamline
things a bit.

Don't print the configuration header in help for empty configuration

Check an ObjectFile's dependencies again if a dependency is modified

This is necessary to get generated sources to behave correctly.  Includes
can only be read after they're built for the first time.  The ObjectFile
must then add the necessary dependencies to ensure that required headers
are installed.

Add transitive dependencies for source files

This eliminates a problem where includes in C source files would cause
generates sources to be rebuilt if any of the included files changed.
Includes should only affect the object file built from the source file,
not the source file itself.

Fix some problems with side effect dependencies

Side effects can't depend on the primary, since a generated .c or .cpp
file might use a .h file generated as a side effect.

Add support for generating source files

Use the correct target as root for cleaning

Process paths after merging build info

Hacky support for OS X frameworks

This isn't very elegant, but I need more time to come up with a proper
implementation.

Add target and tools for compiling Objective-C sources

Initial support for building on Darwin (a.k.a. Mac OS X)

Redesign the way commands are set for tools

This is necessary for some future developments.

The mingw port of gcc doesn't recognize -pthread

Group most existing tools in sub-toolchains

Make toolchains hierarchial

This enables eventual tool plugins to give out all of their tools in one
bundle.

Remove deprecated features

All of these have been deprecated for nearly a year, and I don't have any
active projects using them.

Include architecture in Binary build signature

This reduces problems if the same source directory is shared between
computers of different architectures, or if building versions for
different CPUs.

Remove all files in a side effect group when starting a task

Improvements for handling side effects

Propagate rebuild from side effects to the primary target.  This can
happen if the side effect does not exist for whatever reason.  As an
additional safeguard, redirect any build attempts on side effects to
the primary target.

Avoid a double verb in function name

Store problems at their source rather than globally

This allows finer granularity in determining whether problems are
preventing a build.  In some cases it may be desirable to build just one
component of a package, even if others have problems.

Add a utility function for setting the executable for a Tool

Delay locating tool executables until the tool is needed

This solves a problem where the mspdatatool executable is not detected as
built by the mspdatafile package.

Target::build is virtual, so put the special case in the appropriate class

Add a convenience function for saving caches in PackageManager

Properly process the command line arguments

Resolve cmdline targets and what-ifs the same way

Update comments to reflect the new roles of classes

Use GetOpt's new features

Separate the command-line interface into its own class

This allows turning most of builder into a library later, and moving
tools into plugins.  Some parts are still rather ugly and require more
work.

Pass the option map through load_build_file and to Loader

This allows passing in options from outside Builder, which is necessary
for a planned split of the CLI part into its own class.

Fix whitespace errors

Set config mtime to current time if an option is changed

This functionality got mistakenly circumvented in commit 3f541fc and then
removed entirely in commit bd61d7f.

Fix bootstrap.sh to work when multiple identically named headers

Previously the overlay -iquote flags for all source directories were
applied to all files, so the compiler included the wrong file.  The fix
is to compile files one by one and only add the flags that are needed
for each.

The temp directory will now be deleted by default.  An option to keep
it was added.

Add a feature for overlay source directories

This allows separation of architecture- or feature-specific source files
in their own directories.

Resolve a scoping problem in InternalTask::Worker

This resulted from adding Msp::Thread::State, which also has a RUNNING
enumerator.

Support gcc's -iquote feature

Sync readme with recent changes

Reimplement datafile building

Header fixes

Reorder functions

Un-abbreviate function names

Implement PackageManager::get_package

Remove some useless member functions

Support conditionals inside components

Move some more functionality into BuildGraph

Refactor build graph into its own class

Move main package tracking to PackageManager

Improve use statement handling

Installed libraries are now linked dynamically.  For non-installed
libraries, the package source path is added to libpath so the library
will be found.

Improve bootstrap.sh to accept cmdline arguments and allow setting prefix

Handle "use"d libraries through build info

Make static library dependencies consistent with what the linker does

Rather than the linker using non-installed paths for static libraries,
the binary target now does this when resolving dependencies.  This avoids
installing static libraries unnecessarily.

Add the target type to a lexical_cast invocation

Fix git URL in readme

Support specifying library modes on a per-library basis

Generate export definitions with dlltool

Having it as a side effect was causing trouble with rebuild check, and
it's cleaner to build each file separately anyway.

Don't add a symlink with the same name as the file

Prevent crashes if a tool's executable cannot be found

Don't try to create links with the same name as the file itself

Install shared libraries on windows to bin, not lib

Linking is done through import libraries, so the dlls are only needed for
running the application.

Build and install import libraries on windows

Give import libraries their own class

Have the linker specify symlinks for installed libraries

Have SourcePackage generate the interface version

It will be needed for import libraries in the near future as well, and it
would be stupid to duplicate the generation code.  This also makes it
possibile for the package author to define a custom interface version.

Add a side effect system for building multiple targets at once

Library search fixes

An outdated check was preventing dynamic libraries from being considered
with libmode==STATIC (as opposed for FORCE_STATIC, which doesn't even
generate the candidate names).

Added a hack to prefer import libraries over real static libraries, and
consider them even in FORCE_DYNAMIC mode.

Let tools have a say in installing their targets

Don't append library version to the end of the filename on Windows

More generic system for installing targets under different names

Route InstalledFile target creation through Builder

Reload includes from CSourceFiles when they are modified

Without this, -W did not cause includes to be read if they were present
in the cache.  It'll also come in handy for generated source files some
time in the future.

It's okay to throw exceptions from Loader functions

DataFile::DerivedObjectLoader was changed

Store lookup failures separately from the package map

This ensures that every pointer in the package map is valid, avoiding the
need to check them and preventing segfaults due to a forgotten check.

This ugly hack for arch-specific binary packages is no longer needed

There's no good reason to abbreviate this

Expand the readme even more

An include directory is needed as well

Make sure that symlinks point to the right place