v3.0 17th November 2001
	The first parameter of sipConvertFrom_*() for a mapped type is no
	longer const.  Added the /AutoGen/ option for automatically generated
	methods.  Static and non-static class methods can now have the same
	name.  sipParseArgs() now returns the number of arguments parsed on a
	successful parse, as well as an unsuccessful one.  Removed the '-' and
	'I' and added the 'N', 'Q', 'q', 'Y', 'y', 'J', 'M', 'm', 'p' and 't'
	format flags to sipParseArgs() and changed the code generator to use
	the new flags.  The way of specifying Python special methods has
	changed slightly to allow ordinary methods to have leading and trailing
	"__".  Removed the %CanConvertTypeToCode directive.  Added the
	%PostInitialisationC++Code directive.  The runtime library now uses the
	C API for weak references for Python v2.2 and later.  configure now
	handles Qt-mt.  Upgraded to autoconf-2.52, automake-1.5 and
	libtool-1.4.1.

v2.5 11th August 2001
	Minor configuration changes.  Fixed problems when default arguments are
	function calls.  Added support for QObject.sender() to be able to be
	implemented properly.  Fixed problem with a slot disconnecting itself.
	Python signals are now blocked if Qt signals are blocked.  Added the
	/Constraint/ option to prevent Python converting integers to floats.
	className() and tr() methods are automatically generated for classes
	derived from QObject mimicing moc's behaviour.  Added support for
	C-style comments in .sip files (thanks to Wilken Boie).  Removed the
	dependency on getopts().  Some Windows portability changes.  The SIP
	code generator should now compile under Windows (thanks to Wilken
	Boie).  SIP should now compile under Windows with the Borland compiler
	(thanks to Simon Cusack).  configure now looks for Qt v2.3.1.  Removed
	the Version keyword so that it can be used as a class name.  Added
	support for namespaces and nested classes.  Added %MappedType so that
	more complicated types (particularly templates) can be mapped.  Added
	SIP_SIGNAL to specify a signal that is passed at run-time (needed by
	KToolBar).  Got rid of a lot of Py_XDECREF() calls by using "N" instead
	of "O" in calls to Py_BuildValue().  Replaced %Version and
	%PrimaryVersions with %Timeline and %SecondaryVersion.  Added
	%ImportWithTimeline.  sipConvertFrom_*() for mapped types no longer
	tests sipCpp for NULL and leaves it to the handwritten code to handle.

v2.4 22nd April 2001
	Fixed a bug sipCommonDtor() where it assumed it had the Python lock but
	might not have done. configure now uses the Python executable to
	determine where Python is installed.  Added support for Python 2.0
	in-place operators and Python 2.1 rich comparison operators.  The SIP
	library now tidies itself up when Py_Finalize() is called.  Starting
	with Python 2.1, Python slots are now wrapped in weak references which
	means that when the programmer forgets to keep a slot alive then it
	won't core dump.  Upgraded automake to v1.4d and libtool to v1.3d.
	configure now checks for Qt v2.3.0.

v2.3 4th February 2001
	Much improved error reporting when incorrect arguments are passed to
	wrapped functions and methods.  (This requires an incompatible change
	to sipParseArgs(), so any handwritten code needs updating.)  configure
	now checks for Qt 2.2.4 and Python 2.1.  Added pre- and post-hooks, and
	sipCallHook().  When ownership of an instance is transferred to C/C++,
	a reference to the Python object is also taken - this means that the
	Python object will stay alive, even if there is no explicit reference
	kept in the Python program.  Added the -p switch and the $m macro to
	allow the generated C++ module to have a different name than the Python
	module.

v2.2 6th November 2000
	Minor compile fixes for RedHat.  Added the %Copying directive for
	embedding license terms in generated code.  Clarified the license to
	try to make it even clearer that SIP imposes no restrictions on
	generated code.  Added the $P macro for embedded code.  Made the
	wrapper class dtor virtual to avoid compiler warnings.  Fixed proxy
	class generation for modules that don't define any new signals.

v2.1 18th October 2000
	Slots can be called expecting fewer arguments than a signal is
	providing.  Added the ability to provide handwritten code for dtors.
	Added sipGetThisWrapper().  A wrapped class instance is deleted only
	after all other instance variables have been deleted.  Other bug fixes
	(see ChangeLog).

v2.0.1 14th September 2000
	Fixed a problem where a moc file was being included with the
	distribution - more of a hack than a fix.

v2.0 14th September 2000
	Added TransferBack.  Fixed a code generation bug on big endian machines
	(thanks to Pete Ware).  Re-wrote the versioning system so that it is
	more restricted but much simpler to implement and actually works
	properly.  Removed %SecondaryVersions.  Enums are now implemented in
	C++ rather than Python and a class corresponding to the enum name is no
	longer created (this will generate incompatible bindings).  Added
	sipAddEnumInstances().  Added the -s switch to specify the suffix used
	for C++ source files.  Dropped support for C++ operators.  Added
	support for the __repr__, __str__, __cmp__, __hash__ and __call__
	methods.  Added support for the __add__, __sub__, __mul__, __div__,
	__mod__, __divmod__, __pow__, __neg__, __pos__, __abs__, __nonzero__,
	__invert__, __lshift__, __rshift__, __and__, __xor__, __or__,
	__coerce__, __int__, __long__, __float__, __oct__ and __hex__ numeric
	methods.  Added support for the __len__, __add__, __mul__, __getitem__,
	__setitem__, __getslice__, __setslice__ and __contains__ sequence
	methods.  Added support for the __len__, __getitem__ and __setitem__
	mapping methods.  The SIP library will now build under Windows.
	Changed the Makefile generation to be template based so that it no
	longer assumes an autoconf/automake based environment.  Added support
	for opaque structs.  Classes with private abstract functions cannot be
	created.  Global handwritten code can now be versioned.  Changes for
	Python 1.6 and 2.0.

v0.12 18th May 2000
	Added a run-time check for None being passed as an argument for a class
	pointer when we know that the pointer will be dereferenced.  Added the
	SIP_ARRAY, SIP_UARRAY,  SIP_ARRAY_SIZE and SIP_ARRAY_USIZE pseudo-types.
	Clarified the software license.

v0.11.1 1st April 2000
	Fixed the code generation so as not to discard consts without a cast.
	Fixed a bug when siplib re-sizes it's hash table.

v0.11 28th March 2000
	Changed the configuration to find Qt v2.x.  Added the --with-qt-dir
	option.  Fixed bug in siplib that caused an infinite loop when trying
	to wrap too many objects (thanks to Pieter Nagel).  Literal values can
	now be expressions.  Added support for simple static class variables.
	Added support for typedefs in classes.  Added version qualifiers to
	enums.  Added ctor calls as a type of value.  Abstract functions no
	longer have to be virtual.  Templates now support any types.  Signals
	can now be version dependent.  Slots no longer have to return void.
	Added %VersionCode and the generation of the sip_helper program.  Added
	%PrimaryVersions and %SecondaryVersions (probably only temporarily).
	Default copy ctors are automatically generated when needed.  C++
	addresses will be used if their class is a sub-class of the class being
	looked for.  Added TransferThis for ctor arguments.  Removed the
	caching of class variables.  The non-Qt parts of siplib are now C
	rather than C++.  Removed the %CompareWithClassCode directive.

v0.10.1 21st January 2000
	The Python/C++ hash table can now cope with multiple objects (of
	different class) with the same address.  The repr() function converts a
	a NULL pointer to None.

v0.10 19th December 1999
	Added the directories Red Hat puts Qt in to the list searched by
	configure.  Added the rpm .spec file.  Generated header files renamed
	so they can't clash with sipQt.h.  Implemented version dependent
	typedefs.  Added version qualifiers to classes.  Fixed a bug where the
	parser was changing modules too soon.  Changed the library API
	(sipClassDef and sipModuleDef structures, and sipRegisterClasses(),
	sipAddBoolInstances(), sipAddCharInstances(), sipAddClassInstances(),
	sipAddDoubleInstances(), sipAddFunctions(), sipAddLongInstances(),
	sipAddStringInstances()).  Renamed sipMapThisToCpp() to sipGetCppPtr().
	Added sipGetComplexCppPtr().  Made everything more resilient to C++
	instances being deleted while the Python wrapper still hangs around.
	Added support for void *.  Changed version qualifiers to use the
	%Version directive and %If...%End.  Added the %ExposedFunctions
	directive.  Added the ability to specify destructors (specifically
	non-public ones).  Fixed a bug where C++ instances returned from
	virtual functions were being deleted too soon - but now they aren't
	deleted at all.  Fixed a number of bugs related to enums.  Fixed a bug
	where slot proxies (and the Python objects they were proxying for)
	didn't get deleted (thanks to Toby J Sargeant).  Added Toby J
	Sargeant's hash table code to get rid of the dubious reference count
	fiddling with the old C++/Python mapping dictionary.  Changed the
	implementation of signals and slots to not use Python dictionaries and
	lists.  Changed the implementation of the method cache not to increase
	reference counts.  It is no longer necessary to get the format of
	signal/slot names exactly right (spaces are ignored).  Added support
	for quoted characters as default parameter values.  Added support for
	class instance to char * operators.  Allowed Python to C++ convertors
	to be specified for all classes, not just mapped ones.  The #line is
	restored after including handwritten code.  Fixed the format to
	sipParseArgs() for static member functions.  Some member renaming for
	IRIX.

v0.9 6th September 1999
	The SIP library is now a real library.  The -I switch can now be given
	any number of times.  If the -I switch isn't given then included files
	are assumed to be in the current directory rather than the directory
	containing the main module file.  Removed the -n, -p and -f switches.
	Added the -c and -m switches.  Changed the meaning of the -d switch.
	Removed %PostDoc, %DocFile and %Package.  Added %ExportedDoc, %Import,
	%PrePythonCode, %ExportedHeaderCode and %ConvertToSubClassCode.
	%HeaderCode can now be specified in class descriptions.  Re-structuring
	of the generated code to reduce its compile time.  Fixed a couple of
	bugs with virtual functions.  Allowed ctors to be private.  Added
	support for releasing the Python interpreter lock.  Fixed a bug where a
	lazy cached class attribute was being used in preference to a lazy
	non-cached instance attribute.  Added support for floating point
	default values.  Re-introduced SLOT() so that connections can be made
	directly to Qt slots.  Added support for disconnecting signals
	(including in generated code).

v0.8 29th May 1999
	No longer create copies of class instances if a reference is returned.
	NULL values returned by C++ are converted to None.  None values passed
	by Python are converted to NULL.  Replaced PyArg_ParseTuple() with
	sipParseArgs().  Removed support for (unsigned) char[].

v0.7.1 3rd May 1999
	Replaced %DocExtension with %DocFile.  Fixed bug where pointers to
	mapped classes returned from a function where deleted.  Re-did the
	way lazy class attributes are handled so that Class.Method(self,...)
	works again.  Fixed a problem with virtual loops.  Member functions'
	arguments are now parsed in the same order as they appear in the .sip
	file.  Functions that return char * have the return value checked for
	NULL and converted to None.

v0.7 16th April 1999
	Added the %DocExtension and %PostDoc directives.  Added support for
	class variables, and added the %CompareWithClassCode directive.
	Changed the way Python renaming is specified and generalised it to
	support other flags.  A bit of function renaming went on which might
	affect handwritten code.  Fixed a bug where if a previously wrapped
	object was being returned, then the object passed back to Python was
	"this" rather than "self".  Removed the %PostPythonCode directive.
	Moved to using __getattr__ for accessing member functions and static
	functions.  Static functions are now proper class builtins - but they
	cannot have the same name as ordinary member functions (one or the
	other must be renamed).  Added the ability to specify that ownership
	for a class instance (ie. who deletes it) is transferred to C++.  All
	slots must now be Python callable objects - SLOT() has been removed.
	The Python module dictionary is populated directly, rather than going
	through the C++ module dictionary.  Added support for const global
	variables.  Added version qualifiers to variables, constructors and
	member functions.  Added support for ordinary functions.

v0.6 20th February 1999
	No signal/slot support code is generated if signals/slots are not
	used.  Changed the -i switch to -I.  Fixed a memory leak where copies
	made of objects returned by C++ wouldn't be deleted.  Added support for
	automatic type conversions.  Added support for opaque classes.  Started
	to prepare for supporting layered bindings by putting the C++ code for
	a class in a file by itself.  Added the -d and -f switches.  The
	generated C++ functions are now called through other tables rather than
	appearing as module functions and methods.  Added the %PostPythonCode
	directive.  Added some macro processing (ie. $C) to handwritten code.
	Fixed serious problems with protected functions and casting pointers
	for classes that use multiple inheritance.  The signal proxy can now
	handle any argument types.  Added support for automatic generation of
	slot handling code.

v0.5 21st January 1999
	SIP is built with automake/autoconf.  SIP generates code that is
	expected to be built with automake/libtool/autoconfig.  Added the
	%Package and %Makefile directives.  Changed the handling of enums to
	be closer to C++ and allow unnamed enums.  Support global class
	instances and added the %GlobalCode directive.

v0.4 9th January 1999
	Some changes to the implementation of signals so that keyboard
	accelerators and menus work.  All C++ objects can now be wrapped late
	(though complex ones lose a little functionality).  Wrapper classes no
	longer need to be moc'ed (if they ever really did).

v0.3 9th December 1998
	First release to be publically announced.  The classes needed for all
	the Qt tutorials can now be generated (except for keyboard
	accelerators).  Fixed a problem with Python reference counts, and
	another where undefined classes weren't reported properly.

v0.2 5th December 1998
	Support for access to protected member functions, overloading in Python
	of virtual member functions, late wrapping of simple C++ objects.  Many
	other changes.

v0.1 1st November 1998
	First release.