6.	Allow explicit code to be provided to implement __repr__, __setitem__,
etc.  Drop support for C++ operators.  See the end of this file for how to do
it.

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
KConfigBase.writeEntry() can never be called) - at the very least detect it
when generating the code.

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).

27.	Detect when sipThis already exists (happens when you try to multiply
inherit).

28.	Does QTabBar::removeTab() need a /TransferBack/ to be implemented?

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.

Add the following class sections: PyMethods, PyNumberMethods, PySequenceMethods
and PyMappingMethods.  Each method is refered to by the name it needs to have
in Python - some names correspond to more than one method (eg. there may be a
__len__ in both the PySequenceMethods and PyMappingMethods sections).  Add a
set of method handlers to siplib and add each of them (or only those actually
used by a module) to the list of methods containing sipRegisterClasses etc.
Each method handler is passed exactly the same arguments that was passed to the
Python wrapper method.  The handler checks the arguments (eg. gets sipThis)
and calls the appropriate Python API function.

One option is the keep C++ operators as a shorthand for corresponding Python
methods (repr, the arithmetic and logical operators, [] etc).

The generic SIP syntax for a method is:

PyMethods:
	__repr__
%MemberCode
		...
%End

These methods have version qualifiers.

The handwritten code is compulsory (or maybe not if there is a sensible default
as there is with repr - maybe instead of the above shorthand).

The following sections describe the different methods, whether there is a
reverse equivalent (which is handled automatically as far as the SIP programmer
is concerned, but there needs to be a corresponding reverse method handler in
siplib), which Python API function each handler calls, which section(s) the
method may appear in and (for each section) which element of which structure
the handwritten code is added to.

Note that there is the choice of using Python to pass down to the underlying
class, rather than using method handlers.

Method:			__cmp__(self,other)
Reverse?:		N
API:			PyObject_Cmp or cmp(self.sipThis,other)
Section/Element:	PyMethods/PyObject.tp_compare

Method:			__repr__(self)
Reverse?:		N
API:			PyObject_Repr or repr(self.sipThis)
Section/Element:	PyMethods/PyObject.tp_repr

Method:			__hash__(self)
Reverse?:		N
API:			PyObject_Hash or hash(self.sipThis)
Section/Element:	PyMethods/PyObject.tp_hash

Method:			__add__(self,other)
Reverse?:		Y
API:			PyNumber_Add or self.sipThis + other
Section/Element:	PySequenceMethods/PySequenceMethods.sq_concat
Section/Element:	PyNumberMethods/PyNumberMethods.nb_add

Method:			__sub__(self,other)
Reverse?:		Y
API:			PyNumber_Subtract or self.sipThis - other
Section/Element:	PyNumberMethods/PyNumberMethods.nb_subtract

Method:			__mul__(self,other)
Reverse?:		Y
API:			PyNumber_Multiply or self.sipThis * other
Section/Element:	PySequenceMethods/PySequenceMethods.sq_repeat
Section/Element:	PyNumberMethods/PyNumberMethods.nb_multiply

Method:			__div__(self,other)
Reverse?:		Y
API:			PyNumber_Divide or self.sipThis / other
Section/Element:	PyNumberMethods/PyNumberMethods.nb_divide

Method:			__mod__(self,other)
Reverse?:		Y
API:			PyNumber_Remainder or self.sipThis % other
Section/Element:	PyNumberMethods/PyNumberMethods.nb_remainder

Method:			__divmod__(self,other)
Reverse?:		Y
API:			PyNumber_Divmod or divmod(self.sipThis,other)
Section/Element:	PyNumberMethods/PyNumberMethods.nb_divmod

Method:			__pow__(self,other,modulo=None)
Reverse?:		Y
API:			PyNumber_Power or pow(self.sipThis,other,modulo)
Section/Element:	PyNumberMethods/PyNumberMethods.nb_power

Method:			__neg__(self)
Reverse?:		N
API:			PyNumber_Negative or -self.sipThis
Section/Element:	PyNumberMethods/PyNumberMethods.nb_negative

Method:			__pos__(self)
Reverse?:		N
API:			PyNumber_Positive or +self.sipThis
Section/Element:	PyNumberMethods/PyNumberMethods.nb_positive

Method:			__abs__(self)
Reverse?:		N
API:			PyNumber_Absolute or abs(self.sipThis)
Section/Element:	PyNumberMethods/PyNumberMethods.nb_absolute

Method:			__nonzero__(self)
Reverse?:		N
API:			PyObject_IsTrue or not not self.sipThis
Section/Element:	PyNumberMethods/PyNumberMethods.nb_nonzero

Method:			__invert__(self)
Reverse?:		N
API:			PyNumber_Invert or ~self.sipThis
Section/Element:	PyNumberMethods/PyNumberMethods.nb_invert

Method:			__lshift__(self,other)
Reverse?:		Y
API:			PyNumber_Lshift or self.sipThis >> other
Section/Element:	PyNumberMethods/PyNumberMethods.nb_lshift

Method:			__rshift__(self,other)
Reverse?:		Y
API:			PyNumber_Rshift or self.sipThis << other
Section/Element:	PyNumberMethods/PyNumberMethods.nb_rshift

Method:			__and__(self,other)
Reverse?:		Y
API:			PyNumber_And or self.sipThis & other
Section/Element:	PyNumberMethods/PyNumberMethods.nb_and

Method:			__xor__(self,other)
Reverse?:		Y
API:			PyNumber_Xor or self.sipThis ^ other
Section/Element:	PyNumberMethods/PyNumberMethods.nb_xor

Method:			__or__(self,other)
Reverse?:		Y
API:			PyNumber_Or or self.sipThis | other
Section/Element:	PyNumberMethods/PyNumberMethods.nb_or

Method:			__coerce__(self,other)
Reverse?:		N
API:			PyNumber_Coerce or coerce(self.sipThis,other)
Section/Element:	PyNumberMethods/PyNumberMethods.nb_coerce

Method:			__int__(self)
Reverse?:		N
API:			PyNumber_Int or int(self.sipThis)
Section/Element:	PyNumberMethods/PyNumberMethods.nb_int

Method:			__long__(self)
Reverse?:		N
API:			PyNumber_Long or long(self.sipThis)
Section/Element:	PyNumberMethods/PyNumberMethods.nb_long

Method:			__float__(self)
Reverse?:		N
API:			PyNumber_Float or float(self.sipThis)
Section/Element:	PyNumberMethods/PyNumberMethods.nb_float

Method:			__oct__(self)
Reverse?:		N
API:			oct(self.sipThis)
Section/Element:	PyNumberMethods/PyNumberMethods.nb_oct

Method:			__hex__(self)
Reverse?:		N
API:			hex(self.sipThis)
Section/Element:	PyNumberMethods/PyNumberMethods.nb_hex

Method:			__complex__(self)
Reverse?:		N
API:			complex(self.sipThis)
Section/Element:	PyNumberMethods/None (should really add __complex__ as
			an attribute of the sipThis type, as this is the only
			way to hook in handwritten code)

I haven't finished this yet.
