12.	Make the parser aware of Python keywords so they can't be used as
member function names.

18.	Mapped classes can all use the same dealloc function.

19.	Try and tighten up the recognition of function signatures - Python
can't distinguish as well as C++ can (eg. some variants of
QWMatrix.map() can never be called) - at the very least detect it
when generating the code. SIP should be clever enough to distinguish between
types that are only likely to be used because that's what the programmer means
(eg. floats) and those that can be used by accident (eg. a bool gets converted
to an int). In the case of QWMatrix.map(), SIP should explicitly test for
floats (and call the right variant), but (if they aren't floats) rely on the
implicit convertions to ints (and call the different variane).  Note, this
still doesn't get round the int/bool problem.

20.	Implement the transfer of ownership for function results and variables
as well.  Also need to consider class variables.

25.	Add support for template classes.  I don't think a template class can
ever have an object created in Python (or a Python sub-classed from one).  It
would only be useful if the C++ library contained sub-classes of it (see
QwPositionedSprite and QwSprite).

30.	Fix versions so that they really work with imported modules.

31.	Allow handwritten code for static class variables (like
KTMainWindow.memberList).  The problem is intercepting references to it
(__getattr__ and __setattr__ aren't good enough) - probably extending the
lazy function mechanism.

32.	Add support for references and pointers in function arguments - assume
they are being used to return values.

33.	Consider using ConvertToSubClassCode for QObject so that the correct
Python type for an instance created by Qt can be used.  Or use RTTI and let SIP
generate the necessary code automatically.  In either case, have to consider
how to deal with sub-classes defined in other modules (need a way of a module
registering sub-classes with the original class).

34.	Add support for handwritten code for signals (eg.
QNetworkProtocol::newChildren).

35.	Fix the hack for private abstract functions.  If they are virtual we
probably want them to look for a Python method (even though they are private),
see QCanvasItem::collidesWith().

36.	Generate code that tests whether bool is implemented properly or is
just an int. In some places treating bools as ints will work - in others they
will cause a signature clash (eg. proxySlot()).
