Use dxcommon version of the packing library.

This common code was moved to dxcommon a long time ago, remove our
local copy and reference the common version directly.

Fix silent-rules alignment in recent Automake.

Use compatibility helpers in dxcommon to fix the silent-rules output.
Drop support for ancient (pre-1.11) automake versions.

Fix bootstrapping with recent bits.

I can no longer bootstrap this package on my systems for a few reasons:

- Libtool has changed how nonrecursive libltdl is integrated
- The version of Gnulib in use does not bootstrap with dash
- The dxcommon scripts use Perl modules that I no longer install.

Do the necessary dance to fix all those issues, and resolve all the
resulting fallout.

libupkg: Kill upkg_export_class.

This function was quite broken, and crapped out on a number of the
objects in Engine.u.  Kill it off because we now have the machinery
to do this more properly.

upkg: Pass the UPkg module struct into package_info.

uobject: Make module loader understand exports/imports.

It's possible for a package to have an instance of a class defined in
that same package; therefore the module loader needs to know about this.
Bring the export class index up to the public struct so that it's
possible to tell the difference.

This makes it possible to export the textures defined in Engine.u.
There's still a few vestigial bugs left over here, but we can fix those
later.

uobject: Make logging more generic.

The logging functions can now be used on any GObject, not just UObject
subclasses.  In particular, it should be possible to call it on UPkg
instances which do not derive from UObject.

upkg: Add some error checking around upkg_export_get_class.

This avoids a segfault when it fails.

engine: Implement Engine.Sound.

This one's pretty trivial; but now we can export sounds.

MMM-M-M-M-M-MONSTER KILL!

music: Check data size against actual file size.

Blindly setting the file size to something potentially larger than it
seems outright silly.  All this mucking about with the upkg_file struct
members should probably be eliminated eventually, but may as well do it
sanely for now.

upkg: In info mode, don't fail outright if object load fails.

We can still (potentially) display the file offsets even if the object
itself cannot be loaded, so we should do so.

uobject: Add support for float properties.

Since it's not too hard to add these, do so.  Add the DrawScale property
to Engine.Texture to demonstrate it.

uobject: Improve error handling in property decoding.

Verify that the encoded size is actually correct, and use the proper
logging method to report errors.

uobject: Initial support for object imports.

This is missing a lot of features currently; in particular, imports will
get loaded multiple times, but we can at least resolve them and create
the relevant objects.

Add a DetailTexture property to Engine.Texture to demonstrate.

upkg: Add support for listing package imports.

All we need is a way to get the import struct from libupkg and we can
list all the package imports pretty easily, so add that, and do so.

upkg: Only print object properties if they are non-NULL.

It's valid for a property to be unset, so we should not crash in this
case.

libupkg: Make export parent handling match imports.

It seems pretty clear that this is meant to be a signed quantity like
other object references, although it really doesn't matter since it
should never be negative.  Nevertheless, we may as well keep
import/export handling as similar as possible.

libupkg: Use parent pointers for imports.

This brings the import struct into alignment with the exports.  Move the
struct to the public header, too, as it will be needed.

uobject: Include package names in package fullname.

Now that we have access to the package in deserialize, we can include
its name.

uobject: Make the relevant UPkg available to objects.

Instead of passing around raw "struct upkg" pointers, keep the
GTypeModule implementation around instead (which contains this
information).  This allows access to all package functions; in
particular, it allows access to the package name.

Modify implementations to get the raw "struct upkg" from the upkg_file
reference instead.

upkg: Use proper library routines in package_export.

Not sure why this function contained a complete re-implementation of
u_object_new_from_package, but here we are.  Call the appropriate
library function to eliminate a pile of code.

libupkg: Don't store upkg_priv pointer in struct upkg_file.

If this is going to be stored in a public struct, make it actually
useful to users outside of libupkg by giving them a pointer type that
can actually be used.

libuobject: Store hierarchical object names for UObjects.

Such names are useful for logging and, in general, displaying object
references in a human-readable manner.  This is only a partial
implementation, as package names are not yet available to the
deserialize method.

uobject: Add support for decoding boolean properties.

Boolean properties have an encoded length of zero, but we were failing
spuriously due to an excessively broad error check.  Other than that, we
have already done all the necessary decoding for boolean properties, so
just wire up the appropriate GObject calls to make it happen.

libupkg: Store export parent pointers directly.

Making users handle the package member directly leads to some fairly
ridiculous and somewhat tricky code.  Resolve them all at package load
time and store pointers directly in the upkg_export structure, which
should help simplify the callers.

At this point, we codify the "exports cannot have packages which are
imports" assumption, which appears to be valid.  It's not obvious how
name lookup could possibly succeed if this were not the case.

upkg: Display object names in property listings.

Not particularly useful right now since we can only display the last
component of the name, but it's a start.

build: Enable Gnulib conditional-dependencies.

This slightly improves configure time; may help more down the road if we
enable more modules.

build: Punt BUNDLED_LIBLDTL conditional.

Now that fix-ltdl removes the unconditional builds of the bundled
libltdl, instead relying on normal prerequisites, there is no need for
this Automake conditional.

engine: Fix off-by-one in PCX run-length encoder.

Runs of 64 bytes are invalid, but the encoder would emit them anyway
(which get subsequently interpreted as a run of 0).  This obviously
causes some textures to export incorrectly.

We can now export all of UTtech2.utx!

engine: Add a unit test for the PCX run-length encoder.

Since there ended up being an off-by-one bug here, we should test it.
We use the same hex decoder as decodeindex, so move that into a common
test library.

libupkg: Fix minor type error in decodeindex test.

sopts is a string, so it should be a char[] rather than unsigned char[].

libupkg: Make decodeindex test accept an empty string.

This test app should not reject empty input outright, because it should
be properly rejected by the function under test.

libupkg: Actually fail if the index-decode test fails...

Oops.

build: Fix makefile rules for decode-index test program.

libupkg.la got moved as a result of the non-recursive build changes, but
it wasn't changed here.  Also fix a typo in the Gnulib prerequisites.

build: Non-recursively build the rest of the package.

build: Integrate libltdl non-recursively using fix-ltdl.

engine: Add missing header to Makefile.am

build: Integrate Gnulib non-recursively using fix-gnulib.

gnulib: Update to latest version.

misc: Fix up paths in top-level .gitignore.

Make paths explicitly match files in the top-level directory so that
similar paths in subdirectories are not unintentionally excluded.

uobject: First stab at a generic logging mechanism.

Let's build something on top of Glib's logging facilities which probably
work well enough for what we want to do.  Add a couple calls to the
texture class for starters.

texture: Add initial support for texture exports.

After almost 3 years, we can finally export at least some textures!

upkg: Improve messaging a bit.

uobject: Overhaul the UObject property decoding code.

Mostly a total rewrite, this version actually handles struct and array
properties (read: advances something resembling the correct number of
bytes instead of trying to start the next property somewhere in the
middle of the last).  This version also has (hopefully) much clearer
tracking of file offsets.

upkg: Print out object file offsets at high verbosity levels.

When debugging deserialize methods, it can be useful to see the actual
location within the package file of the object being deserialized.  Add
a mode to print out these raw offsets when displaying object info at
high (-vvv) verbosity levels.

libupkg: Add const qualifier to upkg_decode_index input buffer.

docs: Add a README

The main purpose of adding this now is to document where users can get
the patched GObject Builder tool required to build upkg.

libupkg: Fix spurious success in upkg_decode_index.

Make the upkg_decode_index function fail if the input is truncated,
rather than successfully returning a bogus value.  As an added bonus,
this actually simplifies the code.

tests: Test some corner cases of upkg_decode_index.

It turns out that upkg_decode_index does not fail when there is not
a complete index encoding in the available data.  Add a test case (which
currently does not pass) to verify that the function fails in that
situation.

music: Fix obvious use of uninitialized variable.

upkg: Fix missing return statement.

upkg: Add support for exporting individual objects.

palette: Clean up deserialize a bit.

upkg: Handle errors from u_object_export_name.

As opposed to blindly proceeding with a nonsense filename...

upkg: Print full object name when exporting.

license: Make autotools stuff available under WTFPL2.

uobject: Make interface functions take UObjects directly.

This makes implementing the functions a little cleaner.

music: Migrate to GOB2.

uobject: Rename some interface-related identifiers.

More changes to align with GOB2's expectations.

texture: Migrate to GOB2.

engine: Start using GOB2 to generate GObject classes.

GOB2 allows us to eliminate a lot of boilerplate.  Unfortunately,
current versions of GOB2 don't directly support dynamic types, so you
will need a patched version of GOB2 as of this writing.  For now, just
the Palette class is built using GOB2.

engine: Include object headers as <engine/xyz.h>.

This will work with VPATH builds even if the .h file is in the build
tree while the .c file is in the source tree, and vice versa.  For
non-VPATH builds, there should be no change in behaviour.

uobject: Rename U_OBJECT_TYPE to U_TYPE_OBJECT.

Other tools, such as gob2, expect this naming convention.

uobject: Add initial support for object properties.

texture: Add missing integer properties.

The limits for these properties were made up on the spot.

uobject: Add a helper function to load objects from packages.

upkg: Print object properties in info mode.

texture: Fix typo in get_property.

These properties are unsigned ints, not booleans...

upkg: Print class name in listings.

engine: Implement Engine.Palette.

upkg: Add an option to list packages.

This new option will eventually replace the dual-purpose "info" option.

license: Update copyright notices.

upkg: Add support for querying specific objects.

upkg: Embed struct upkg into the private structure.

This avoids the need to store a pointer to the private struct inside the
public struct and simplifies some code.

uobject: Don't access upkg_file's pkg member.

The same information is already stored in the UObject class.  Use that
instead.

music: Remove file member from private struct.

The UObject class already has a file member.  Use that.

uobject: Remove the file parameter from deserialize.

The UObject class already has a file member; restructure the code to use
that instead.

uobject: Remove pkg_idx field.

Nothing used this.

build: Rename autogen.sh to bootstrap.

build: Use autoreconf for bootstrapping.

There is no need to re-invent autoreconf, badly.

build: Import libmodplug test macros from autoconf-dx.

uobject: Add missing header to Makefile.am.

libupkg: Split the upkg_export struct into public/private parts.

This eliminates the need for dedicated functions to extract the name
and flag fields from the export struct.  It should now be easy to convey
export information to applications.

upkg: Resolve hierarchical object references.

This doesn't actually do anything useful yet, but it's a start.

libupkg: Make upkg_export_find less useless.

Add a 'parent' parameter which should allow objects to be uniquely
specified.

libupkg: Simplify handling of format assertions.

upkg: Add support for controlling which package is acted upon.

Instead of using the last -f option, allow the user to specify one or
more packages explicitly.  This will eventually be extended to allow
specifying individual objects.

upkg: Improve error reporting during package load.

gnulib: Update to latest version.

upkg: Update man page.

engine: Define the exit method.

Apparently, libltdl falls back to looking up the "unadorned" symbol
names if the _LTX_ symbols are not found.  This means it finds exit in
the C library instead of returning an error, with obvious consequences.

gnulib: Remove link-warning.h from repository.

This was committed by accident earlier.

build: Abort configure if specified module library is not found.

If the user specifies, say, --with-modlib=modplug, it is not right to
use any other module library.  We also avoid checking for unrequested
module libraries.

upkg: Don't crash if the specified package does not exist.

Currently, g_type_module_use(pkg) will succeed even if the package does
not exist, due to the existence of shared-object-only packages.  So the
caller must look inside the UPkg structure to see if anything was
actually opened.  In the future, pending tools to create the things,
such packages probably won't exist and this hack can be removed.

music: Add simple file type detection to the dummy module.

The dummy module can be a bit smarter so that the file extension of
exported data is correct.  Add support for xm, it and s3m.

upkg: Specify package files as options.

Now, one must run "upkg -f foo.u" where previously one would run "upkg
foo.u".  This new syntax allows multiple packages to be specified on the
command line for purposes of dependency resolution and (soon) extraction
of specific objects.

The package operated upon is the last one specified in this manner.

upkg: Don't unref packages, since gobject does not allow this.

libupkg: Add explicit conversions to stdio wrappers.

Some C libraries provide a macro version of feof which does not convert
the provided pointer to FILE * before dereferencing it.  Ordinarily,
this conversion would occur automatically since feof's prototype
specifies FILE *, but this is suppressed in the macro case.

It is not clear to me whether this behaviour is consistent with the
requirements of the C standard.  However, after encountering at least
two implementations which do this, explicit conversions seem simple
enough.

build: Don't use a semicolon after sed's 't' command.

Some (namely, FreeBSD's) sed implementations fail when a semicolon is
used after a 't' command.  This behaviour appears to be acceptable
according to POSIX, so appease these implementations by passing extra
-e options to sed.

package: Move package search code to the VFS.