'bup split' takes a list of filenames on the command line.

'bup split' now outputs any combination of blobs, tree, and commit.

maximum flexibility.

'bup split' can now update a git ref if you give it the -n option.

Automatically handle "--no-" prefix on long options.

Similar to how git does it.

'bup split' now has a -c option to generate a git commit object.

There's no way to set its parent yet, but at least this is all you need if
you want to repack.

Completely revamped option parsing based on git-shell-style.

This is in options.py.  Also added some wvtests for option parsing stuff.

Import wvtestrun and wvtest.py from the wvtest.git project.

Corresponding wvtest commit is db65ff5907571a5004bb3c500efd19421cb06d1a.

Rename datagen.c to randomgen.c, to better reflect its purpose.

Add a '-t' option to 'bup split' and make 'bup join' support it.

This lets you generate a git "tree" object with the list of hashes in a
particular file, so you can treat the file as a directory as far as git is
concerned.  And 'bup join' knows how to take a tree and concatenate it
together to reverse the operation.

Also refactored a bunch of stuff in cmd-split.py.

Get rid of extra CFLAGS/LDFLAGS that I don't understand anyway.

I just copied them from some other python module.  But it's better to keep
things simple, I think.

Add a 'bup' wrapper program.

We're going to use that with some subcommands, git-style.

Remove old hashsplit.c, since hashsplit.py replaces it.

Do less work for objects that occur more than once.

Clean up buffering to reduce number of buffer copies.

Slight performance improvement, but not inspirational.

Use t# instead of et# for hashsplit parameter type.

This lets us work with any kind of buffer object, which means there's no
unnecessary data copying when coming into our module.  Causes a bit of
speedup.

Also refactored the checksum code for easier experimentation.

Hey wow, turning on -O2 gives about a 50% speedup.

Add a C module to do the rolling checksum.

This is about 80x faster than the old speed (27megs/sec instead of 330k/sec)
but still quite a lot slower than the 60+megs/sec I get *without* the
checksum stuff.  There are a few inefficiencies remaining, but not such easy
ones as before...

hashsplit.py: print performance timings to stderr on exit.

datagen.c: a quick program to generate a repeatable series of bytes.

Useful for testing.  Note that we *don't* see the random number generator,
so every time you generate the bytes, you get the same sequence.

This is also vastly faster than /dev/urandom, since it doesn't try to be
cryptographically secure.  It generates about 200 megs/sec on my computer,
which is much faster than a disk and thus useful for testing the speed of
hashsplit.

hashsplit.py: less excessive logging, more suitable for speed tests.

Result of speed tests: it's slow.  Almost entirely because of how slow
splitbuf() is in python (which is no surprise at all).

hashsplit.py: create blob objects by hand, not with 'git hash-object'

Much quicker this way, since we never need to fork anything.

hashsplit.py is now much, much faster than before.

4.8 secs vs. 0.8 secs for testfile1.

Still vastly slower than the C version (0.17 secs including time to fork
git for each blob) but still a significant improvement.

The remaining slowness seems to be entirely from:

- running git hash-object (which we can avoid by hashing the object
  ourselves)

- running the rolling checksum algorithm (which we can speed up using a C
  module)

So it's looking good.

hashsplit.py: a python version of hashsplit.c

It's slow.  Very slow.  But hopefully it won't be too hard to optimize.

Make split condition depend on ~0, not 0.

Otherwise we could end up splitting on one-byte blocks, which is pretty
dumb.

Report the block size when splitting each block.

Add a README

Add some comments so nobody thinks I think fgetc/fputc are fast.

Add a comment to stupidsum_add() so people don't think I'm an idiot.

Yes, I know shift-and-xor is a supremely lame algorithm.

Rename hsplit/hjoin to hashsplit/hashjoin.

Add a trivial hjoin, the reverse of hsplit.

Aha, fixed a bug causing the split points not to resync.

Actually hash stuff, and add a basic 'make test'.

Unfortunately the test fails: after the first difference, it never manages
to resync.

Extremely cheesy initial implementation of rolling-sum-based splitting.

The checksum algorithm is crap, and we don't actually generate the output
files yet, so I'm guessing it's still junk.