Appendix A. History

More relaxed scanner: Silently ignore private member variable and non-public enums. Allow C style comments in .sip files. Ported sip to Windows, set up MS DevStd project files.

Fixed a bug sipCommonDtor() where it assumed it had the Python lock but might not have done.

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.

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.

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

Fixed a problem where a moc file was being included with the distribution - more of a hack than a fix.

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

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.

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

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.

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

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.

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

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[].

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.

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.

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.

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.

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

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.

Support for access to protected member functions, overloading in Python of virtual member functions, late wrapping of simple C++ objects. Many other changes.

First release.