Remove the now obsolete SubTool class

Redesign GnuLinker to work without subtools

Don't complain about missing executable if a tool has no command

This is the case for internal tools.

Fix bit shifts to be 64-bit

Capture value evaluation function by value

Otherwise it will go out of scope if a temporary is passed.

File Tool's executable before calling do_prepare

Redesign how tools are run

It also uses functors now.  The run functions access properties of the
tool through the target.  This will allow tool customization without
having to derive from the class, which will be useful for modularization.

Clear the line before printing task info if progress is enabled

Remove redundant task setup from Copy

FileTarget already does this

Refactor InternalTask to take a functor

This way the tools don't all have to implement the same worker thread
boilerplate.

Inline simple constructors

Use default member initializers and constructor delegation

Bump version to 3.0 and update copyright years

I've done some modernization of the code and am about to make the program
modular, so a version bump is warranted.

Refactor logger to do message formatting internally

This shortens the syntax of using it and may also provide a minor
performance improvement since formatting doesn't need to be done for
disabled channels.

Track Android API levels with a bitmask

Replace some sets with vectors as well

In these cases the number of expected elements is small and/or the set
is built up once and then used many times.

Convert all list containers to vectors

Rewrite dependency finding algorithms in a few classes

They no longer depend on iterators to the dependencies list staying valid
when elements are added, allowing conversion to std::vector.

Make data members of Task protected

I'm not sure why they were public, maybe by accident.

Check for empty sources in Tar::create_target

Use dynamic_cast to reference when incorrect type is not acceptable

Adjust build signatures to contain the tool tag

External tools now have a build signature by default.

Guard against build type being missing

Log environment information before preparing the build

Improve architecture name matching

It will now treat x86_64 as a more specific match than just x86.

Use format() when creating strings from more than two parts

Refactor BooleanEvaluator to have overloaded constructors

The signature of the function passed in is now used to determine if
comparison operators are permitted.

Use std::function instead of sigc::slot in BooleanEvaluator

Fix typos

Cache result of parsing $PATH

Refuse to create an empty data pack

This avoids a segfault from trying to access te front element of an
empty list.

Use DataFile::Writer to write package configuration files

Combine the processing of configuration and tool overrides

Remove most container typedefs and refactor others

Use braced initializer lists for map insertions

Use bound loader function arguments for binary component types

Refactor the constructor of SourcePackage::Loader

There isn't much point to have two differnt overloads when it could just
take a nullable pointer.

Use auto type for iterator variables

Mark overridden virtual functions as such

Use shortcut functions for find calls

Replace basic for loops with range-based loops or algorithms

In remaining cases use auto as a shortcut for the iterator type.

Begin converting the code to C++11

Improve help output for the local package

Only output the required packages list if anything is required, and
output an overall header before the package-specific section.

Emit configurations in Visual Studio solutions

Projects other than the main one are marked as not being built, since
builder will build them implicitly as part of the main project.

This also seems to be enough for Visual Studio to not complain about the
solution being modified when closing it.

Add ability to generate Visual Studio solution files

Currently very minimal, and VS treats the solution as modified
immediately after loading it.

Generate GUIDs for Visual C++ project files

Emit include path in vcxproj files

Don't output a PlatformToolset tag in vcxproj files

Visual Studio doesn't seem to actually need it.  It's fairly meaningless
anyway since builder will choose the toolset itself.

Zlib has a different filename in MSVC builds

Detect the latest MSVC tools version

Add the corresponding generated source directory to local include path

This allows generated headers to be used as normal.

Create a directory structure for generated source files

Add support for SSE3 and SSE4.1 FPUs

When combining build info, keep the highest standard versions

More sophisticated handling of language standards

Add language standards to exported build info of source packages

Save caches before starting the build

This causes the config cache file's timestamp to be earlier than any
built file, preventing a spurious second rebuild after changing options.

Reorder functions to match the header

Add logging for some problem situations

Add support for generating compile_commands.json

This file is used by some clang tools to find compile options.

Use -fno-omit-frame-pointer if debug is set with optimizations

Add MSVC-specific library name for sigc++

This is hardcoded for the debug version now, until I come up with a way
to make it conditional on build type.

Additional MSVC fixes

Use getenv from mspcore

Add drivers for the MSVC toolchain

Shared libraries are not yet properly supported.  Import libraries are
not generated and all of my code lacks the necessary attributes anyway.

Use a separate category for import library filename patterns

More flexible way to manage filename patterns

Include the toolchain name in project file build commands

Convert architecture argument to lower case

Tweak VC project files to better match what the software expects

Add the VC project file generator to BuiltinTools

Adapt to changes in mspcore

Detect CPU architecture on Windows

Move system-specific code to a separate file

Make object file names configurable through Architecture

Add a toolchain field to Architecture

Split SystemTools into GnuTools and ClangTools

Add support for generating Visual C++ projects

Basic support for running builder on Windows

Account for install directories when forming displaced dependency paths

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++.