algorithms.c: Add bindings for STROBE.

t/t-algorithms.py (HashBufferTestMixin): Assemble method names dynamically.

Not everything I want to test with this machinery calls its methods
`hashXXX'.

Split 'pyke/' into commit 'e5aa77d831ad8b42167f3205ee290f238003e20a'

git-subtree-dir: pyke
git-subtree-mainline: c719150915e19e1be2a5a315e5e565e1a541921f
git-subtree-split: e5aa77d831ad8b42167f3205ee290f238003e20a

* commit 'e5aa77d831ad8b42167f3205ee290f238003e20a': (102 commits)
  pyke/pyke-mLib.c: Raise `OverflowError' on out-of-range inputs.
  Port to Python 3.
  *.[ch]: Some preparatory reformatting for the Python 3 porting.
  mp.c, catacomb/__init__.py, pyke/: Fix mixed-mode arithmetic involving `float'.
  *.c: Separate string function calls according to text/binary usage.
  *.c: Introduce a new input conversion for binary strings.
  *.c: Use the new `Py_hash_t' type.
  *.c: Use `PyVarObject_HEAD_INIT' to initialize type object headers.
  *.c: Use the new `Py_TYPE' and `Py_SIZE' macros; define them if necessary.
  pyke/mapping.c, key.c: Make the mapping code more intrusive and complete.
  pyke/mapping.c: Introduce macro for unconstifying common keyword list.
  pyke/pyke.c (newtype): Explicitly clear `ht_slots'.
  *.c: Split the constant definitions into the various submodules.
  pyke/pyke.[ch]: Make type skeleton structures be read-only.
  pyke/pyke.h: Add a `MEMBER' variant with explicit member name.
  *.c: Use Python `METH_NOARGS' methods where applicable.
  *.c: Use Python's facilities for defining class and static methods.
  *.c: Make all of the type-definition tables read-only.
  pyke/pyke.c: Check conversions hidden inside `KWLIST' and `KWMETH'.
  pyke/pyke.h, key.c: Rename `INDEXERR' to `MAPERR'.
  ...

Note that history prior to a172f897f4fdd800b3f70cdfe2140205f6b2f531
(`pyke/, ...: Extract utilities into a sort-of reusable library') is
pared down from the original Catacomb/Python history, but should be
enough for useful blaming and bisection.

algorithms.c: Add a Keccak `set' method now there's upstream support.

Bump dependency on Catacomb.

mp.c: Accept arbitrary iterables as inputs to `MPCRT'.

Both the constructor and the `solve' method.

ec.c (ecptxl_1): Accept any iterable of coordinates.

catacomb.c (mexp_common): Accept an arbitrary iterable.

This means that any iterable producing either (BASE, EXP) pair objects
or alternating BASE/EXP pairs can be used as input to any of the
multiple-exponentiation functions.  Of course, expecting an object with
unpredictable iteration order to produce a useful sequence of BASE/EXP
pairs will probably cause disappointment, but, for example, a dictionary
mapping bases to exponents seems like a reasonable thing to maintain.

catacomb.c, ec.c, group.c, mp.c: Count base/exponent pairs with `size_t'.

Admittedly, if you get even slightly close to the limits of an `int',
the calculation will take an infinite amount of time.

rand.c: Implement the `passes' property of the `DSARand' generator.

This has always been present in the C library, but wasn't surfaced in
Python, which seems like a poor show.

rand.c: Make nonce/IV arguments to cipher-based random generators optional.

In all cases, this defaults to zero.

catacomb/__init__.py: Rewrite `kcdsaprime' to return the correct length.

The old version wouldn't return numbers of the correct length reliably.
This new one, written to follow Catacomb's own algorithm, will.

pgen.c: Add a binding for Catacomb's `primeiter'.

mp.c: Simplify final cleanup in `MPCRT' operations.

mp.c: Fix overly ambitious section header.

mp.c: Accept `0x', `0o' and `0b' prefixes on strings with explicit base.

Python itself does this, so it seems like a good idea.

key.c: Make the `KeyFile' key-lookup methods behave consistently.

Annoyingly, `byid' and `bytag' would raise `KERR_NOTFOUND', while
`bytype' would give you `None'.  Resolve this: add a `fail' keyword
argument to each method, which defaults to true: if `fail' is true then
a failed lookup raises `KERR_NOTFOUND'; if false, then you get `None'.

key.c: Complain about duplicate subkeys passed to `KeyDataStructured'.

This wasn't previously possible (without complicated subterfuge), but
now a keyword argument can duplicate a mapping set in the positional
argument.

key.c: Populate `KeyDataStructured' from the keywords.

Process the keyword arguments as additional mappings to install in the
new object.  In particular, `subkeys' is not special any more.

key.c: Factor out populating a `KeyDataStructured' from a mapping.

Introduce a new function `populate_struct' which does the gruntwork of
iterating over a given mapping and setting the corresponding labels in a
`key_data' object.

No functional change.

key.c: Make `KeyDataStructured' constructor cleanup less bizarre.

Drop the reference to `kd' if it's non-null, rather than inspecting the
apparently unrelated `me'.

algorithms.c: Use `RETURN_ME' rather than doing the job by hand.

*.c: Delete some pointless refcount twiddling.

ec.c, catacomb/__init__.py: Return tail from `parse'; provide `fromstring'.

`ECCurve.parse' was inconsistent with the established nomenclature.
Generally, `parse' reads a prefix of some given string, returning the
denoted value and the unprocessed remainder of the input string;
`fromstring' does the same, except that it returns only the value, and
raises an exception if the remainder of the string is not only
whitespace.

Fix `ECCurve.parse' (which unfortunately is an incompatible change), and
add missing `fromstring' methods to `ECCurve' and `ECInfo'.

ec.c: Accept and discard parentheses around a point when parsing.

The `str' function returns parentheses around the coordinates, so it
seems unfair to reject parentheses on input.

ec.c (ecptxl_1): Preparatory reformatting.

Gentle vertical compression.

ec.c: Dispatch to `ecptxl_3' whether or not we have a curve.

The `ecptxl_3' function has a better error message in the case where
there is no curve.  Indeed, `want sequence of two or three items' is
downright unfair in the case where you did in fact supply a sequence of
three items, and the real problem is that you're trying to construct a
curveless point.

ec.c: Reject strings with trailing junk in the curve-point constructor.

ec.c: Accept field elements in the fast path from `samep' fields.

... as well as from the same field object.

catacomb/__init__.py, mp.c: Use implicit-conversion rules for rationals.

Export the implicit conversions for `MP' and `GF' to Python, and use
them in the `BaseRat' constructor.

ec.c, field.c, group.c: Allow exponents and scalars from prime fields.

The idea is that the unit group of a finite field, and the point group
of an elliptic curve, can usefully be viewed as modules over a suitable
integer quotient ring; and, even more so, prime-order subgroups of these
can be considered as one-dimensional vector spaces over prime-order
fields.  It's therefore helpful to allow elements of the appropriate
field as exponents or scalar multipliers as appropriate.  Unfortunately
it's annoying to check whether we have the /right/ scalar field; we
could check, but that does a lot of computation for little benefit.  So
allow any prime-field element in these positions.

I don't (currently) allow a prime-field element as the exponent in `pow'
applied to `MP' or `GF'; I'm open to representation on whether this is a
good idea.  They are permitted in the exponentiation functions attached
to the various modular-reduction classes, because the exponent operand
in those cases is subject to explicit conversion.

mp.c: Tighten up the `MP' and `GF' implicit conversions.

Allow implicit conversions to `MP' from `PrimeFilter' (for old time's
sake), and anything /other than/ field elements and polynomials which
implements the `__index__' implicit conversion to integer.

Don't allow implicit conversions to `GF' at all.

mp.c: Use implicit-conversion rules in `coerce'.

Coercion is only used (in `Py_TPFLAGS_CHECKTYPES' classes) in the three-
way comparison function; but that's still relevant in Python 2.

mp.c: Convert shift amounts via `index' to prevent `float' and `str'.

It obviously makes no sense to calculate `MP(4) << "4"' or `MP(9) >>
2.8'.

ec.c, field.c, group.c, mp.c: Fix conversions in `pow' and scalar mul.

The base and modulus (if present) should belong to the base ring; the
exponent or scalar should be an integer; and we should use implicit-
conversion rules for all three.  (Of course, the modulus can also be
`None'.)

This tightening temporarily breaks a test multiplying an elliptic curve
point by a prime-field element Q n.  That used to work, but not for any
especially principled reason; and this wasn't commutative (n Q would
multiply n by the x-coordinate of Q coerced into the scalar field).  We
shall fix this soon.

field.c: Replace `tofe' by `implicitfe', calling `implicit{mp,gf}'.

If something converts to an integer, we allow converting it to a
prime-field element too; similarly, things that convert to polynomials
can convert to binary-field elements.  (Obviously, these conversions use
the canonical homomorphisms.)

pyke/pyke-mLib.c: Raise `OverflowError' on out-of-range inputs.

This seems to match better what Python does under these conditions.

catacomb/__init__.py: Prepare rational classes for upcoming changes.

In the near future, we won't be able to guarantee that all rings allow
implicit conversions of (integer) 0 and 1 to the additive and
multiplicative ring identities, so:

  * define `ZERO' and `ONE' class attributes on the concrete classes to
    hold the respective ring identities;

  * make the `_split_rat' function into a private method of the
    `BaseRat' class and adjust callers to match;

  * compare against `ZERO' to detect an exact element of the base ring;
    and

  * return `ONE' as the implicit denominator for a base-ring element or
    foreign object to be converted.

No functional change.

mp.c: Export `implicitmp' and `implicitgf'.

The next few commits are going to be about shoring up implicit
conversions in generic arithmetic operators, and, in particular, in
forbidding obviously silly conversions, e.g., from floating-point
numbers of strings to integers or polynomials.  This is a first step
towards that.

No new callers yet, and no functional change.

algorithms.c: Hide the `_Poly1305Class' type a bit better.

pyke/pyke-mLib.c: Raise `OverflowError' on out-of-range inputs.

This seems to match better what Python does under these conditions.

algorithms.c (FOO.hashbufN): Consistently raise `ValueError' if too big.

algorithms.c: Implement KMAC in C.

It's longer this way, but significantly less ugly, and it works
consistently with the other algorithms.

algorithms.c: Set `hashsz', `tagsz', and `name' properties on MAC keys.

The generic MAC objects, and Poly1305.

algorithms.c (KeySZSet): Represent the set as an actual (frozen) set.

algorithms.c: Set `KSZ.max' to `None' to indicate no bound.

algorithms.c (ShakeNN.done): Offer a (sensible) default hash size.

algorithms.c (ShakeNN constructor): Support `None' for func/perso args.

buffer.c: Implement `ec2osp' and `os2ecp' as operations on buffers.

buffer.c: Refactor `WriteBuffer.putecptraw'.

This will better match a function to be added soon.  No functional
change.

Port to Python 3.

Most of this is `#ifdef ...' ... `#endif' noise, with a few tweaks
thrown in.

Some notes on specific parts of the port.

  * buffer.c: The Python 3 buffer protocol is completely different.
    Read buffers work differently, but aren't problematic; write buffers
    can now be held open for an extended period, so we need the locking
    machinery that was added recently.

  * catacomb.c: Module initialization has changed, but isn't a great
    deal more difficult.

  * catacomb/__init__.py, catacomb/pwsafe.py, pock, pwsafe: There are a
    number of places which need language-version switches, but none of
    them is especially interesting.  This diff is noisier than it should
    be because I couldn't adjust the indentation in advance.

  * mp.c: With the abolition of a separate fixnum type, `mp_frompylong'
    needed to express the fast path from a fixnum in a different way.

  * pwsafe: The hacking to alter the error-handling behaviour associated
    with the `stdout' stream is deeply unpleasant.  Sorry.

  * pyke/pyke.h: Most of the porting work happens here, with alternative
    definitions for the various macros introduced earlier.

  * .gitignore: Ignore Python 3 `__pycache__/' turds.  Python 3 leaves
    its pre-tokenized files in `__pycache__/' directories, which somehow
    manage to be much more objectionable than the loose Python 2 `*.pyc'
    files.  Ignore these.

  * debian/: Add the necessary things to build a Python 3 extension
    package.

Port to Python 3.

Most of this is `#ifdef ...' ... `#endif' noise, with a few tweaks
thrown in.

Some notes on specific parts of the port.

  * buffer.c: The Python 3 buffer protocol is completely different.
    Read buffers work differently, but aren't problematic; write buffers
    can now be held open for an extended period, so we need the locking
    machinery that was added recently.

  * catacomb.c: Module initialization has changed, but isn't a great
    deal more difficult.

  * catacomb/__init__.py, catacomb/pwsafe.py, pock, pwsafe: There are a
    number of places which need language-version switches, but none of
    them is especially interesting.  This diff is noisier than it should
    be because I couldn't adjust the indentation in advance.

  * mp.c: With the abolition of a separate fixnum type, `mp_frompylong'
    needed to express the fast path from a fixnum in a different way.

  * pwsafe: The hacking to alter the error-handling behaviour associated
    with the `stdout' stream is deeply unpleasant.  Sorry.

  * pyke/pyke.h: Most of the porting work happens here, with alternative
    definitions for the various macros introduced earlier.

  * .gitignore: Ignore Python 3 `__pycache__/' turds.  Python 3 leaves
    its pre-tokenized files in `__pycache__/' directories, which somehow
    manage to be much more objectionable than the loose Python 2 `*.pyc'
    files.  Ignore these.

  * debian/: Add the necessary things to build a Python 3 extension
    package.

*.[ch]: Some preparatory reformatting for the Python 3 porting.

Nothing very complicated or profound.  These are intended to make the
upcoming diff easier to check for stupid mistakes.  A lot of this is
whitespace change that disappears in `git show -w'.

*.[ch]: Some preparatory reformatting for the Python 3 porting.

Nothing very complicated or profound.  These are intended to make the
upcoming diff easier to check for stupid mistakes.  A lot of this is
whitespace change that disappears in `git show -w'.

mp.c, catacomb/__init__.py, pyke/: Fix mixed-mode arithmetic involving `float'.

This is a bit embarrassing.

>>> import catacomb as C
>>> x = C.MP(5)
>>> x == 5.1
True
>>> x < 5.1
False
>>> r = x/2
>>> r
5/2
>>> r == 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: an integer is required
>>> r == 2.5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: an integer is required
>>> r*1.0
5/2
>>> r*1.1
5/2
>>> r*2.0
5
>>> r*2.5
5

Fix this nonsense.

  * Change the `obvious' arithmetic operators so that they notice that
    one of the operands is a float.  Handle this by converting to a
    Python bignum and letting Python handle the arithmetic.  The result
    is a float, which seems sensible inexact contagion.

  * Introduce a rich-comparison method which also detects a float
    operand and hands off to Python.  Python seems to get this right,
    comparing the float to the bignum in its full precision, so that's a
    win.

  * Also, modify the `IntRat' code to apply inexact contagion in the
    same way.  Comparisons may be imperfect here, but that's
    surprisingly hard to get right.

The new results:

>>> import catacomb as C
>>> x = C.MP(5)
>>> x == 5.1
False
>>> x < 5.1
True
>>> r = x/2
>>> r
5/2
>>> r == 2
False
>>> r == 2.5
True
>>> r*1.0
2.5
>>> r*1.1
2.75
>>> r*2.0
5.0
>>> r*2.5
6.25

field.c, mp.c: Implement the `nb_index' conversion.

This is Yet Another Integer Conversion added in 2.5, for the purpose of
/implicit/ conversions (since strings and other strange things will
convert explicitly to integers).

It's significant because the `bin' builtin (conversion to base-2 string,
added in 2.6) works by applying the `index' conversion rather than
having a special-purpose method like `hex' and `oct'.  (Indeed, Python 3
abolishes these methods, and `hex' and `oct' convert via `index' too.)

So add conversions somewhat judiciously.

*.c: Separate string function calls according to text/binary usage.

Don't use the `PyString_...' functions directly.  Instead, define two
collections of macros `TEXT_...' and `BIN_...', which can be used on
text and binary strings respectively.  The two sets are slightly
different, because they've been designed to adapt to Python 3's
different interfaces.

There are no `PyString...' calls remaining outside of these macros.

rand.c: Cope with large `range' arguments.

Python 3 will report large numbers as being `int' values, and
`PyInt_AS_LONG' will return nonsense in this case.

*.c: Introduce a new input conversion for binary strings.

One of the major differences in Python 3 is that it firmly distinguishes
between binary and text strings: the former consist of small integers,
while the latter consist of Unicode scalars.  The Python 3 `s#'
conversion's main purpose is to accept text strings, and though it will
also accept binary strings it's not really ideal for the purpose.
Python 3 introduces a new conversion `y#' specifically for binary
strings, though this isn't quite what we want because, for some reason,
it /doesn't/ work with bufferish objects which require explicit release.

The best answer seems to be to introduce our own custom conversion for
binary strings, so we do this here, replacing all of the binary-input
argument conversions.  While we're at it, replace all of the by-steam
argument conversions using `PyObject_AsReadBuffer' too.

rand.c: Some gratuitous reformatting.

*.c: Use the new `Py_hash_t' type.

catacomb/__init__.py, mp.c: Remove `L' suffix from `repr' output.

Python 3 doesn't produce an `L', and it doesn't really help anything.

*.c: Use `PyVarObject_HEAD_INIT' to initialize type object headers.

Define a suitable version if the Python headers don't do it for us.

mp.c, catacomb/__init__.py, pyke/: Fix mixed-mode arithmetic involving `float'.

This is a bit embarrassing.

>>> import catacomb as C
>>> x = C.MP(5)
>>> x == 5.1
True
>>> x < 5.1
False
>>> r = x/2
>>> r
5/2
>>> r == 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: an integer is required
>>> r == 2.5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: an integer is required
>>> r*1.0
5/2
>>> r*1.1
5/2
>>> r*2.0
5
>>> r*2.5
5

Fix this nonsense.

  * Change the `obvious' arithmetic operators so that they notice that
    one of the operands is a float.  Handle this by converting to a
    Python bignum and letting Python handle the arithmetic.  The result
    is a float, which seems sensible inexact contagion.

  * Introduce a rich-comparison method which also detects a float
    operand and hands off to Python.  Python seems to get this right,
    comparing the float to the bignum in its full precision, so that's a
    win.

  * Also, modify the `IntRat' code to apply inexact contagion in the
    same way.  Comparisons may be imperfect here, but that's
    surprisingly hard to get right.

The new results:

>>> import catacomb as C
>>> x = C.MP(5)
>>> x == 5.1
False
>>> x < 5.1
True
>>> r = x/2
>>> r
5/2
>>> r == 2
False
>>> r == 2.5
True
>>> r*1.0
2.5
>>> r*1.1
2.75
>>> r*2.0
5.0
>>> r*2.5
6.25

*.c: Use the new `Py_TYPE' and `Py_SIZE' macros; define them if necessary.

Python 2.6 introduced macros to access object header fields, which is
handy because Python 3 changes the way object headers are
structured.  (I think the binary layout is unchanged, but the C-level
structuring is definitely different.)

This is the start of Python 3 porting work.

ec.c, field.c: Remove redundant `FOO_pyrichcompare' methods.

The abstract base classes already have the necessary comparison methods,
so there's nothing to be gained by repeating the same methods on
subclasses.  (Indeed, Python might pointlessly allocate more memory for
the corresponding Python-level descriptors, but I haven't checked.)  But
there is something to be lost: Python 3 explicitly clobbers the
`__hash__' methods of subclasses which declare new equality methods.  We
could add duplicates of the hash methods throughout the subclass graph,
but it seems better to delete the pointless equality methods which are
causing the problem.

pyke/mapping.c, key.c: Make the mapping code more intrusive and complete.

Previously, mapping classes would implement a minimum of Python-level
operations, such as iterating over keys and mapping lookups, and the
generic mapping code would just synthesize missing operations in terms
of these.

Instead, introduce a mapping-specific vtable pointer in object
structures which describes the mapping operations in a form similar to
mLib's `sym' interface, which is rather more efficient in terms of hash
probes, and have the generic mapping code synthesize all of the Python-
level operations from these.

Needless to say, this is very messy.  Sorry.

catacomb/__init__.py: Implement equality and hashing for `KeyData' objects.

Equality is determined by value, so don't use `KeyData' objects as
hashtable keys and then mutate them.

pyke/mapping.c: Introduce macro for unconstifying common keyword list.

key.c: Add hashing and comparison for `Key' objects.

pyke/pyke.c (newtype): Explicitly clear `ht_slots'.

This makes things go very badly wrong in Python 3.  I'm not sure why it
doesn't go wrong in Python 2...

key.c, catacomb/__init__.py: Split key file I/O into Python and C pieces.

The new Catacomb `key_mergeline' and `key_extractline' functions were
specifically added to interface with language-specific I/O systems which
couldn't easily present as a `FILE *'.  Expose these new functions, and
implement the old file-oriented methods in terms of the new bindings.

*.c: Split the constant definitions into the various submodules.

key.c: Make `None' be the default report-function designator.

Now we can pass it in from Python as an explicit argument.

pyke/pyke.[ch]: Make type skeleton structures be read-only.

We couldn't do this before because `INITTYPE_META' would write the
direct superclass to the `tp_base' slot in the skeleton before calling
`inittype'.  To make this work, then, we adjust `inittype' to take the
direct superclass as an extra argument and plug it into the newly
created heap-type; and `INITTYPE_META' needs adjusting to pass this
argument rather than trying to write to the skeleton directly.

Of course, then we need to actually mark the type skeletons as `const'.

buffer.c: Publish the internal structure of buffer objects.

pyke/pyke.h: Add a `MEMBER' variant with explicit member name.

buffer.c: Add a lock count which pins a write-buffer's backing store.

Python 3's buffer protocol allows a long-term acquisition of a buffer's
backing-store address.  It would be Bad if one of our `WriteBuffer'
objects were to reallocate its backing store while something still
thought it had the old address, so keep track of how many times the
buffer has been referenced in this way.

Nothing actually makes use of this machinery yet, but its time will come.

*.c: Use Python `METH_NOARGS' methods where applicable.

Rather than rolling our own.  We need a little extra machinery to insert
the table entries, especially for the generic mapping support, but this
still saves 95 lines of code.

The `CONVERT_CAREFULLY' macro recently added will check that we haven't
messed things up too badly.

buffer.c: Funnel control through a common exit point.

I'm not going on a rampage to fix this throughout the code (yet?), but
while I'm here I might as well.

*.c: Use Python's facilities for defining class and static methods.

These weren't available when this library was first written, but the
workaround is rather ugly and no longer necessary.

buffer.c: Handle curve object as `PyObject *'.

I've not checked, but I think this is the only place where a
pre- existing curve object was handled as `PyTypeObject *'.

*.c: Make all of the type-definition tables read-only.

The hard part is a new collection of macros which strip the `const'
qualifier from the actual table definitions, after checking that they
actually have the correct type.

And then there's the slog of actually changing all of the definitions
and using the new macros.

buffer.c: Delete pointless initialization.

The variable `cobj' will be set by `PyArg_ParseTuple' anyway.

pyke/pyke.c: Check conversions hidden inside `KWLIST' and `KWMETH'.

Introduce a new macro `CONVERT_CAREFULLY' which checks (via a rather
sleazy hack) that its operand is of the expected type before converting
it to some other type.  This is protected by an `#ifdef' guard because
I'm thinking about adding it to a version of mLib, but I want to keep
the Pyke core independent of mLib.

Use this new macro to build better versions of `KWLIST' and `KWMETH',
which have casts hidden inside them, so that we can now be certain that
the method table entries match up with the functions.  (Spoiler: they
didn't, quite, and commit 19bff42f99d41cd9b8953ff61edfe35380b54d88,
backported onto the 1.1.x branch, fixes the bug that was found by this
change.)

pock: Use floor division on integers.

Python 3 wants to give me a float here, which is obviously wrong.

pyke/pyke.h, key.c: Rename `INDEXERR' to `MAPERR'.

The name `INDEXERR' was pointlessly confusing, given the existing
`IXERR' which actually raises Python's `IndexError'.  It's important,
though, that `KEYERR' be reserved for Catacomb's `KeyError' exception,
which really is an error about (cryptographic) keys.  So `MAPERR' it is.

pock: Probe for the fixnum width by enquiring the largest fixnum value.

Python 3 doesn't distinguish fixnums from bignums at the type level, so
this would run forever.  Instead, get (a guess at) the largest fixnum
value, and use that.

pyke/, ...: Extract utilities into a sort-of reusable library.

This commit changes no code, but it moves a lot of it about.  Tidying up
will come later.

pock: Use `MPMul' so that we can avoid `reduce'.

For some reason, Python 3 hides `reduce' away in some library module.
Anyway, we have a very efficient mass-multiplier so we might as well use
it.

catacomb-python.h: Delete a stray trailing `\'.

This doesn't actually hurt anything because of the following blank line,
but, umm, ...

pwsafe: Trim an overly-long section boundary.

catacomb-python.h: Add a macro to declare module init functions.

catacomb/pwsafe.py: Use `binascii' for Base64 conversion.

The `.encode()' and `.decode()' string methods were apparently too
convenient, so Python 3 doesn't do Base64 conversion like this.
Instead, we have to use the steam-powered `binascii'.  And, to make
things even better, encoding produces `bytes' rather than `str' because,
err, it's not really text or something?  No idea.  Stoats.

util.c: Replace mLib `DISCARD' with a plain `(void)' cast.

catacomb/pwsafe.py: Hack around the change in metaclass syntax.

Python 2 (all versions) want you to set `__metaclass__' within the class
body.  Python 3 ignores this, treating it like an ordinary class
attribute, and wants you to say `metaclass = ...' in the direct-
superclass list; but the latter is a syntax error to Python 2.

Instead, add a hack which constructs a anonymous class with the right
metaclass to use as a direct superclass.  It's awful, but it works.

util.c: Rewrite `addmethods' to remove dependency on <mLib/darray.h>.

catacomb/pwsafe.py: Mark abstract storage-backend classes as lacking `NAME'.

Previously, they'd have a name of `None'.  This will make a later hack
work better.

catacomb.c: Use a less awful version comparison.

catacomb/pwsafe.py: Hack around the difference in octal literal syntax.

Python 2.5 wants `0DIGITS', while Python 3 insists on `0oDIGITS'.  The
latter is prettier, but the difference is annoying.  We only need these
for Unix permissions, so just set up the ones we want in advance using
an explicit conversion from strings.

catacomb.c, util.c: Export `modname' and set it in main entry point.

This is preliminary work in splitting out the Catacomb-independent
utilities so that they can be used by other projects.