Make it possible for plugins to require other plugins

This is used to ensure correct ordering if one plugin customizes tools
from another.

Avoid exception if a directory in the package path does not exist

Adjust plugin dependencies

Mspcrypto dependency has been moved to msvctools, since the base program
doesn't need it.

Make symbols hidden by default on Linux

This will encourage me to add the visibility decorations where necessary
and reduce work needed for porting to Windows.

Add visibility decorations to the library and plugins

Avoid double deletion of the module if a plugin fails to load

The destructor of LoadedPlugin will delete it.

Remove automatic export/import of symbols from GNU tools on Windows

MSVC can't do this, so I'm finally going to add the necessary decorations
to my libraries.

Add shell32 to libraries on Windows

It's needed for SHGetKnownFolderPath

Make sure the main target of a side effect is prepared

Tool invocation is formed from the main target.

Disable some warnings related to dllexport on MSVC

Create import libraries with MSVC linker

Define a macro to indicate which component is being built

This can be used in libraries to export or import functions across a DLL
interface as appropriate.

Explicitly set import library name with MSVC linker

Also disable import library if one does not exist in the build.

Remove the now obsolete install_filename from FileTarget

Correctly fetch libmode when looking for dependencies of Binary

Don't use a versioned name for import libraries

Windows doesn't have symlinks so the import library would not be found.
In fact, the import library is kind of like an soname symlink.

Build shared libraries directly to a versioned name

The MSVC linker does not have an equivalent to the GNU linker's soname
option, so the build filename must match the one the library will be
loaded with at runtime.

Use the architecture's patterns to remove prefix from libname

With the MSVC toolchain a lib prefix is not added automatically when
searching for libraries, so removing it could result in a mismatch.

Remove ExportDefinitions from ImportLibrary's constructor

It's not necessary with the MSVC toolchain.

Comment cleanup and other cosmetic fixes

Optimize Binary::collect_build_info

It's likely that all object files are built with very few different
tools, evne just one.  Updating the build info multiple times from the
same tool is pointless.

Avoid observing the same header twice in ObjectFile

This is a bit crude since the dependencies are not sorted, but still
avoids a massive slowdown from updating dependencies many times when a
header is generated.

Rewrite BinaryComponent::create_targets in a more general way

Instead of assuming a generator-compiler-linker chain, with generators
only coming from the package, it now applies tools until it arrives at
object files, which are then fed to the linker.  This allows global
generator tools and also allows multiple generators to be chained, with
the caveat that if the chain contains more than one step operating on
a directory or a component, the results may be unpredictable.

If a binary package is not found, briefly describe what was missing

Correct MSVC tools' input suffixes

Improve package brokenness checks and problem reporting

Packages are now considered broken if any required packages are broken,
and problems are reported for required packages as well.

Check for existence of Android NDK in AndroidLinker

Replace the stdc++ library with gnustl_static on Android

Avoid preparing packages multiple times

Reject nonexistent sources

Convert the remaining tools into actual plugins

Allow new component types to be registered at runtime

Move the VS project and solution generators to the MSVC plugin

Rename builtintools to basetools

It doesn't make much sense to call it "builtin" if it's actually a
plugin.

Convert builtin tools into a plugin

Allow plugins to create additional targets in SourcePackages

Convert the simpler toolchains into plugins

These have no references to them from the main library and were the
easiest to convert.

Add an interface for dynamically loaded plugins

Avoid some failures from MicrosoftTools when running on Linux

Don't try to run vswhere.exe if it isn't found.  If running on WSL, map
its result to the mount location to the Windows drive.

Refactor VsSolutionFile::find_dependencies as recursive

This avoids an issue with inserting elements into a vector while
iterating over it.

Disallow two components with the same name

Collapse the component loading functions in SourcePackage::Loader

Rename the library component as libbuilder

Using the same name for the program and the library components causes
some trouble especially with MSVC, since the pdb and ilk files overlap.

Remove a lib prefix from the libname of built SharedLibraries

It may be useful to have the prefix in a library component name to
differentiate it from a program component.

Rearrange sources into subdirectories

Add gcc's private library directory to ClangLinker's system path

It's needed for libstdc++.

Refactor the use of external tasks in tools

The run functions now just return the arguments, and a wrapper in the
Tool class creates the task object.

Initialize AndroidCompiler's build info in do_prepare

Add a customized linker tool to ClangTools

Also remove the GnuArchiver from it, beacuse the GNU and clang toolchains
can now be active at the same time.

Use GnuCompiler's build info to link libstdc++

Gather more system path information for GnuLinker

Improve prefix management

An automatically set prefix is now updated when the default toolchain
is selected.  Setting the architecture won't override prefix if it was
already explicitly set.

Prepare early dependencies of a target before finding more

AndroidCompiler supplies build information for the C++ standard library,
which is consumed by Binary through ObjectFiles.  The compiler needs to
be prepared before Binary is, or the C++ stdlib won't be found.

Further tweak GnuCompiler::query_version

Some compilers return non-numeric version components, like 4.9.x.  This
change keeps values of all the initial numeric components.

Fix initialization of Android tools' commands

Add a sanity check for derived tool commands

It doesn't seem correct to copy the command in CustomizedTool, since
often the derived class will want to use a different command anyway.

Make sure the extra_data of GnuCompiler is initialized

Initialize AndroidDevKit::supported_api_levels in the declaration

Avoid zeroing version of -dumpfullversion doesn't return anything

Clang doesn't seem to recognize it.  This is a bit of a hack and it
would be better if ClangCompiler could handle the version check somehow,
but it's not obvious how to do that.

Don't load a cross prefix for a native architecture

Use a cross prefix for the new unified GnuLinker driver

Avoid a memory leak if Builder::set_architecture is called again

Use CustomizedTool for tools which derive from other tools

Fix logic issues with Tool::prepare

CustomizedTool's do_prepare will call the parent tool's prepare with
itself as argument, so the prepared flag shouldn't be checked in this
case.

The command and executable checks are also better to do in the outer
call to avoid doing them twice, since they don't depend on the base
tool's logic.

Use priorities to determine the default toolchain

Reject architecture specification conflicts for all fields

This gives errors for nonsensical stuff like linux-windows-32-64-gnu-msvc,
which was previously accepted.

Allow architecture specifications to be refined after creation

Fix a shadowed variable warning

Add a helper class for tool customization

Rework Tool::prepare to be able to work on other objects than self

This is another piece required for inheritance-less tool customization.

Refactor GnuCompiler::prepare_version a bit

Change Tool's protected constructor to take a pointer to Architecture

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