Move all exception classes to except.h, for real this time

Implement a parser mode for JSON files

Move token-to-argument conversion to Statement

Some refactoring of TextParser logic

Move all exception classes to a common header

Store offsets and sizes in PackSource as 64-bit ints

Add a getter for fallback in Collection

Use const sources in Collection

The CollectionSource interface is entirely const anyway.

Chain get_status to fallback collection if one is defined

Remove the loaded flag from PackSource files

It seems to be a relic from ancient times.  It also causes problems in
certain situations where it's desirable to remove and reload items.

Add an unpack option to the data tool

Plug a memory leak

Accept int-to-float conversion in array signature

Add version of add_pack_io with filter

Support adding packs from IO::Seekable objects

This allows using any seekable objects as packs, such as Android assets.

Provide help for datatool's command line options

Also use add_argument instead of the deprecated get_args.

More resiliece against certain corner cases when direct loading

An empty binary file terminated with __end was causing problems as the
very first peek call would return null, causing Loader to fall back to
indirect loading.  However, the __end was already processed by peek, so
the parse call would fail.

Make Loader a virtual base of ObjectLoader to permit diamond inheritance

Useful when creating loader classes through composition.

Fix a class/struct inconsistency

Require sigc++-2.0 since PackSource uses it

The signal connection may be refactored into libmspcore in the future,
but it's required here for now.

Add a flag to control replacement of DirectorySource entries

Use dynamic_cast to support Collection as virtual base class

Fix logic problems when ignoring a statement in the middle of direct load

Each recursive call to parse() was subtracting one from sub_remaining,
causing it to get out of sync with the actual statement hierarchy.

Detect eof from the parser, not input file

Some files have an embedded logical eof, so waiting for the end of the
physical file would (and did) cause an infinite loop.

Expose raw open functionality from Collection

There are several scenarios where streaming or asynchronous loading is
useful.

Invoke creators from get_list

Avoid duplicate names if an item is available from multiple sources

Export file metadata from PackSource

Don't forget to initialize the control statement flag

More efficient way of loading binary files

The Variant array for storing arguments in Statement is too slow.  Bypass
it by passing args directly to the action in a sort of ad-hoc struct.

Move newline eating out of BinaryParser

It's really a feature of the mode change logic, not the binary mode
itself.

Restructure control statement processing

Binary format control statements can no longer occur as substatements, but
that was an accidental feature at best.

Replace local RAII set utility with one from mspcore

Use a common StatementKey structure for Loader and BinaryParser/Writer

Consider full statement signature when dealing with auxiliary loaders

Add a way to combine multiple loaders

Add a two-argument constructor to DerivedObjectLoader

Use correct keyword in forward declaration

clang isn't happy if a struct is forward declared as a class, even though
they are semantically equivalent in that context.

Add accessors for data_error members

Add ability to put raw files in a pack

Miscellaneous cleanups

Use the Sfinae helper struct from mspcore

Comment improvements

Return null instead of throwing if a file is not found in sources

The primary use case for open_from_sources is for creator functions to
open raw files.  This change makes it easier to gracefully skip a non-
existent file and carry on with other ways of loading the item.

Add a virtual destructor to CollectionSource

Add an API to open files from a collection's sources

Use IO::Slice to constrain access to logical files

Pass mode to ZlibCompressed

This makes creating compressed packs work.  The temporary file is opened
with M_RDWR because we want to read the data back from the same handle, so
ZlibCompressed can't autodetect the mode.

Add a method to filter the files loaded from a pack

Add support for fallback collections

Some minor fixes in Collection

Move RemoveConst invovations close to the public interface to reduce the
number of template function instantiations.

Correct access specifiers.

Rework the list and containment queries

Most of the implementations are now in .cpp, and they should deal better
with base classes.

Add some new test cases for Collection

Failures will be fixed a bit later.

Restore the check to avoid deletion if an add call fails

It was lost to a careless rewrite in b1bc256.

Update Collection test cases with source and base class changes

More flexible system for handling base classes in Collection

Items are now stored with their original type, but can be retrieved with
a base class as well.

Turn internal type helpers into structs

Eliminating access specifiers and dummy constructors reduces clutter, and
in most cases pure virtual functions prevent instantiation anyway.  Since
these reside in private or protected sections of other classes, risk of
misuse is negligible.

Move most of Collection::get implementation to collection.cpp

Use an Fmt object to store the float format

Add the target type to lexical_cast invocations

Cache filenames in DirectorySource

Simplify DirectorySource path management

Redesign automatic object loading

Replace the Collection subclasses with a new concept of CollectionSources.
This permits more than one way of loading objects.

Fix comment handling

A comment start sequence inside another comment should not change the
comment type.

Add a test case for comments

Add an intelligent packed collection class

Throw an exception if a future object couldn't be created

Preserve source declarations when transferring a collection

Optionally print all internal statements (useful to see what's happening
inside a binary datafile).

Add a flag to return also internal statements

Add a special keyword to terminate parsing

Improve the API for future objects

add_future is now documented as ignoring names that don't match any type,
and there's a new function to add future objects with a keyword.

Remove the outdated except.h

Add a shortcut for wrapping data for a collection file

Collections are part of the library itself, so there's no reason to
require users to write all the boilerplate to do the wrapping.

Create writers dynamically and delete them before deleting output

This ensures that the IO objects are destroyed in the correct order, and
filters won't try to access deleted objects.

Recognize char pointers as strings

statement.append("literal") was creating a symbol value, which was not
following the principle of least surprise.

Restructure the tool and make it able to handle multiple input files

Simplify loading collection items

The ItemLoader wrapper from DirectoryCollection can be used in the base
Collection::Loader as well.  This removes the need for the kludgy struct
Add and the need for two separate loader functions.  As an added bonus,
the ItemLoader can still be used in DirectoryCollection and future derived
classes as well, further reducing duplication.

More unit tests for Collection, including contains and future objects

Fix some minor mistakes

Give DirectoryCollection the ability to add files as future objects

Minor reorganization

Introduce the concept of future objects

Make Collection::contains check for type

Checking item existence without type information is not particularly
useful, since there's no guarantee that the object can be used for its
intended purpose.

Improve the documentation of Collection

Revert "Convenience function for reporting errors in loaded data"

This reverts commit b0b9af7216560da2a46ea38fe2df959f4dfb126f.

Why did I even add this function.  The Loader catches any exceptions and
rethrows them as data_errors with the correct line number information.

Fix some whitespace errors

Change DerivedObjectLoader to take the base loader as template argument

This makes it much more versatile, as it can now be used to derive from
a protected loader or one with a nonstandard name.

Proper loading of collection-enabled objects in DirectoryCollection

Make DirectoryCollection::lookup_file available to derived classes

Add support for compressed datafiles

Add an abstraction layer for output

More senseful validity checks for keyword and string definitions

I don't see how the original conditions could ever have been triggered,
given that arguments are parsed based on the signature, and those of the
built-in statements are fixed.

Use custom encoding for floats in binary format

This makes the binary format fully machine-independent, and provides
control over the precision of floating point values.

Use negative integers for built-in statements for better extensibility

Use Int64 from inttypes.h, and proper defines

Recognize floating-point literals with an exponent but no decimal point

Update .gitignore

Bump version to 2.0 due to incompatible changes

Update the Build file with new Builder features

Fix tests/Build