Annotate deprecated identifiers as such

Use a larger buffer size when transferring pack contents

Respect the TMPDIR environment variable when creating data packs

Prefer exact type match when looking for Loader actions

Previosuly the first matching action in alphabetical signature order was
taken, which causes a float overload to be chosen for an int value even
if an int overload was also available.

Add a test case for Loader overload resolution

Update Collection terminology

Mostly in test cases but there was one lingering reference to "future"
objects in the actual header as well.

Fix test cases so they compile again

Add more flexible versions of the load function

Firstly there's a variadic version of the basic load function.  Secondly
and perhaps more importantly there are versions which can load an object
from a file stored in a collection.  All of these are only implemented
for C++11 for now, since supporting the old version seems increasingly
irrelevant.

Move NeedsCollection into its own header and adjust for new Sfinae struct

Use automatic base detection when parsing integers

Add a missing include

Add a source class for builtin data

Provide access to the keyword of the current statement

Replace files from earlier packs with those from the newly added one

Prioritize matching suffixes when looking for a type

Merge remote-tracking branch 'origin/master'

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

Don't use deprecated typedefs

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.