Add null pointer check in CustomizedTool::create_target

Include the main package when showing help for all packages

Add a binary package for Vulkan

Support environment variables as hints for binary package locations

Set PATH in Visual Studio projects

This allows the built program to be run without copying DLLs to the
project directory.

Refactor file locating code in BinaryPackage into a separate function

Reinstate the use of sonames for shared libraries

The field was accidentally left empty in 1600cda.  Having an soname is
actually important on Linux and possibly other *nix systems.

Make import libraries transitively depend on the shared library

This ensures the shared libraries are installed when a program is built.

Process transitive dependencies for buildable dependencies too

They may get resolved to an installed location.

Update C++ version in the bootstrap script

Show configuration of all packages with --help --conf-all

Also other tweaks to help output.

Pass the package path to the stage1 binary

Report problems during bootstrap build

Change how library modes are retrieved for binaries again

The change in 6280e72 turned out to be incorrect after all, and I can't
remember of find any bug that it fixed.

Support manually written export definition files on Windows

They are required to compile some third-party libraries with Builder.

Add helper functions to process sources in a uniform way

Always accept an exact match for a source package directory name

This allows packages to be found even if the dependency name contains a
version in it.

Disable warning C4250 on MSVC

It's emitted when a class inherits a virtual base through multiple ways,
and one of those ways overrides a virtual function from the base.  This
feels more annoying than useful; I'll deal with any ambiguities as they
arise.

Allow spaces after # when reading includes from C source files

Enable correct __cplusplus macro on MSVC

Use architecture-dependent filename pattern when looking for binaries

Fix processing of PATH on Windows

Also always add the bin directory of the install prefix.

Disable -Wdanging-reference on warning levels 2 and 3

Don't try to look for Build files in non-directories

My stat implementation on Windows apparently treats this situation as
"file not found", so I did not notice it until now.

Only displace dependencies from the same component

Now that files can be installed into a private staging directory, there's
little reason to include headers from a different component directly.

Include package path in Visual Studio projects

Avoid duplicate entries in package paths

Refactor gathering of package dependencies

While looking for source packages, ignore Build files which are not files

Non-builder packages might contain directories by that name.

Add a command line option to specify package search directories

Add an option to disable installing headers of a binary component

This can be used with a separate install component to control which
headers are installed.

Refactor transitive dependencies to work on all targets

Use a covariant return type for get_real_target in FileTarget

Remove the include path for used local components

Their headers are now installed in the staging directory, which provides
a more robust way of including them.

Some minor touch-up to the bootstrap script

Update the bootstrap to work with recent changes

There's now a separate, simplified frontend for the stage1 binary.

Make it possible to use built-in plugins

Install headers of non-installed components in a staging directory

This allows components to include headers from other local components in
a controlled fashion.

Rearrange generated source paths

Remove the implicit include path for the generated source directory

It doesn't work properly when a source file includes a header from a
different component in the local package and that header tries to include
a generated header in its own component.  Adding the generated source
directories of all used compnents isn't good either, in case multiple
components have generated headers with the same name.

Move some path and filename manipulations into the Component class

Don't busyloop while waiting for an internal task to complete

Report timings of the build

Associate targets with FileTargets instead of paths

Rename some variables to avoid conflicts with C++20 keywords

Allow source packages to specify exported build info

Report which targets participate in a dependency cycle

Avoid spurious dependency loop errors from side effects

If the primary target depends on its own side effect (such as a generated
source file including a header generated by the same command), this could
cause the side effect's prepare() to be entered recursively.

Make sure the name of the build macro is valid

Component names are arbitrary strings, so non-alphanumeric characters
must be dealt with.

Update .gitignore to include build products on Windows

Remove an unnecessary initializer from a constructor

Make PackageManager::run_pkgconfig fail on Windows

... instead of returning an empty string which would be interpreted as a
successful result and used to create bogus binary packages.

Avoid exception if plugins directory is not found

Disable generation of .exp files on MSVC

They don't seem useful outside of circular import situations, which I
don't have.

Move FileTarget's constructors to the .cpp file

This avoids an undefined reference error on MSVC.

Mark side effects for rebuilding together with their primary targets

Explicitly create import libraries from BinaryComponent

They should not be created for modules.  The linker is still used to
create them since the process is quite different between toolchains.

Place incremental link information files in the temp directory

Make the clang and android plugins require gnutools

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