v3.10.2 22nd May 2004
	The build system now supports MinGW.

v3.10.1 11th March 2004
	Bug fixes only - see the ChangeLog file for details.

v3.10 16th January 2004
	Added the asstring() method to the sip.voidptr type.

v3.9 7th December 2003
	Added the -w flag to sip to enable warning messages.  Added the -j flag
	to sip to concatanated source files.  %Import, %Include and
	%OptionalInclude can now take a relative (UNIX style) pathname.  The
	directory containing the file will also be searched for files that it
	itself includes or imports.  Added %MethodCode and deprecated
	%MemberCode.  Deprecated %Makefile and %ExportedHeaderCode.  Added
	%TypeHeaderCode as a synonym for the deprecated %HeaderCode in type
	definitions.  Added %ModuleHeaderCode as a synonym for the deprecated
	%HeaderCode in module definitions.  Added %ModuleCode as a synonym for
	the deprecated %C++Code in module definitions.  Added %TypeCode as a
	synonym for the deprecated %C++Code in type definitions.  Added
	%PostInitialisationCode as a synonym for the deprecated
	%PostInitialisationC++Code.  Added support for functions that return
	values via pointers and references.  Added support for structs within
	classes.  Added support for %AccessCode and deprecated %VariableCode.
	Added support for %VirtualCatcherCode and deprecated %VirtualCode.
	Added support for explicit C++ signatures.  Added the SIP_SLOT,
	SIP_QOBJECT, SIP_PYCALLABLE, SIP_PYTUPLE, SIP_PYLIST and SIP_PYDICT
	types.  Added /PreHook/ and /PostHook/ to ctors.  Added /TransferBack/
	for function results.  Added /AllowNone/ and /GetWrapper/ to arguments.
	Added sipTrace(), sipBadCatcherResult(), sipParseResult(),
	sipCallMethod(), sipGetWrapper(), sipTransfer(), sipClassName() and
	sipBuildResult() to the module API.  Added SIP_VERSION and SIP_BUILD to
	sip.h.  A new (configure.py) build system has been added which is
	independent of tmake and qmake and installs a sipconfig module.  The
	old (build.py) build system also installs a (different and
	incompatible) sipconfig module.  SIP is now licensed under a single
	Python-like license.

v3.8 17th August 2003
	Added the -k flag to build.py to build the SIP module as a static
	library.  Added support for the __cmp__(), __neg__(), __nonzero__() and
	__repr__() slots (thanks to Torsten Marek).  sip.h now defines
	SIP_VERSION_STR.

v3.7 5th July 2003
	Lazy attributes are now visible when using dir().  Added support for
	__setitem__ and __delitem__ slots.  SIP_SLICE is now deprecated (use
	SIP_PYSLICE instead).  Added sipBadLengthForSlice() to the API.  Added
	'L' to the sipParseArgs() format to handle Python lists.  Added
	support for %VirtualCode for virtual dtors.  Global %C++Code and
	%HeaderCode is now subject to version control.

v3.6 26th April 2003
	The %Module directive now takes an optional version number which is
	ignored (so that SIP v3 can handle .sip files written for SIP v4).
	sip.h now defines SIP_MAJOR_NR so that handwritten code can distinguish
	between SIP v3 and SIP v4.  Added support for /Factory/ and for
	/TransferThis/ in factory methods.  Added the -a flag to generate API
	files for use with Scintilla/QScintilla for call tips and
	auto-completion lists.  Added the 'e' format character to
	sipParseArgs() for enums.  Added the SIP_SLICE pseudo-type to represent 
	extended slices.  Changed the 'x' format character to handle only
	slices rather than slices or integer indices.  Removed the /NonLazy/
	tag as methods that need to be non-lazy (ie. Python slots) are now
	recognised automatically.  Many Python slots (ie. operators) now do not
	need %MemberCode. "true" and "false" can now be used as default values.
	Added the -e flag to enable support for exceptions (thanks to Oliver
	Kohlbacher).

v3.5 11th December 2002
	"unsigned int" is now supported.  Added the 'x' format character to
	sipParseArgs() to convert sequence indices.  Deprecated the 'C' format
	character to sipParseArgs().  Added the 'X' format character to
	sipParseArgs() as an extensible way of adding /Constrained/ support to
	more types.  Added /Constrained/ support to float and double types.
	Added sipConvertFromSequenceIndex().

v3.4 10th September 2002
	The -p flag now specifies the name of a consolidated C++ module rather
	than an alternate name of an individual C++ module.  Added the %License
	and %OptionalInclude keywords.  Added sipAddLicense() to the SIP
	module.  Added support for defining structs.  SIP is now licensed under
	several licenses including the GPL and a commercial license.

v3.3.2 12th July 2002
	Build system fixes.

v3.3.1 9th July 2002
	Support for Qt v3.0.5 added.

v3.3 7th July 2002
	The proxy header file is now moc-ed and linked separately.  This may
	require slightly different Makefile.am files for generated modules.
	Implemented a new build process based on tmake/qmake.  Code is now
	generated for pure virtual methods.  Removed the -f flag and added the
	-x and -z flags.  The helper program is no longer generated (use the
	new -x flag to specify disabled features).

v3.2.4 18th May 2002
	Bug fixes.  Removed MacOS X support - it will have to wait for SIP v4.

v3.2.3 13th May 2002
	Bug fix release only.

v3.2.2 11th May 2002
	Improved MacOS X support.

v3.2.1 5th May 2002
	Bug fix release only.

v3.2 5th May 2002
	Added support for modules registering sub-class convertors for use by
	the module that contains the base class.  Completely redid the thread
	support so that SIP has explicit support for classes that create new
	threads.  /ReleaseLock/ is no longer required.  /CreatesThread/ and
	/NewThread/ have been added.  Fixed the import/export handling for
	Windows to make it easier to use the generated .h files when embedding
	modules in applications.  Allow '!' to be applied to platforms.  Added
	support for SIP_PYOBJECT, including the new 'P' format character to
	sipParseArgs().  Added sipMapStringToClass() and sipMapIntToClass() as
	utility functions for %ConvertToSubClassCode.  Replaced PyCObject with
	sip.voidptr to make it much easier to convert to and from integers.
	configure will now search for Qt v3.0.4.

v3.1 23rd March 2002
	configure will now search for Qt v3.0.1, v3.0.2 and v3.0.3.  Replaced
	%SecondaryVersion with %Platforms and %Feature.  Removed
	%ImportWithTimeline.  Replaced SIP_ARRAY and SIP_UARRAY with /Array/.
	Replaced SIP_ARRAY_SIZE and SIP_ARRAY_USIZE with /ArraySize/.  %If now
	supports logical ors of platforms and/or features.  Replaced
	%VersionCode with %FeatureCode.  Added support for Qt/Embedded.  Added
	the -f switch to explicitly generate the helper program.  Added
	%ExportedFeaturesCode.  Added the $B and $H macros.  The SIP library
	now uses PyObject_Del() rather than PyMem_DEL() for Python v1.6 and
	later.  Class enums are now lazy.  The /AutoGen/ option now takes an
	optional feature name.  The SIP library is now a Python module.  SIP
	now handles protected static methods.  Added the /NonLazy/ option that
	means that all methods with that name in that class will be handles as
	conventional, non-lazy, class methods.  Added the 'n' format character
	to sipParseArgs() to handle non-lazy methods.  Removed all the special
	method handling. Ctors now support /ReleaseLock/.  The method and enum
	tables are now sorted and the SIP module does a binary, rather than
	linear, search.  Individual enum fields are now under version control.
	Upgraded to autoconf-2.53 and automake-1.6.

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.