0.8.2 ----- Bug fixes: - Fixed broken distutils extension. 0.8.1 ----- Bug fixes: - Names of structs, unions and enums in external header files were getting mangled when they shouldn't have been. [Norman Shelley ] - Modified distutils extension so that it will stop before compiling the C file if the Pyrex compiler reports errors. [John J Lee ] 0.8 --- New features: - INCOMPATIBLE CHANGE: The type object of an external extension type is now imported at run time using the Python import mechanism. To make this possible, an 'extern' extension type declaration must DECLARE THE MODULE from which the extension type originates. See the new version of the "Extension Types" documentation for details. This change was made to eliminate the need for Pyrex to be told the C name of the type object, or for the Pyrex module to be linked against the object code providing the type object. You will have to update any existing external extension type declarations that you are using. I'm sorry about that, but it was too hard to support both the old and new ways. - Compile-time importing: A Pyrex module can now import declarations from another Pyrex module using the new 'cimport' statement. See the new section on "Sharing Declarations Between Pyrex Modules" in the documentation. Minor improvements: - An error is reported if you declare a struct, union or extension type using 'cdef' in one place and 'ctypedef' in another. - Struct, union and extension types can only be forward- declared using 'cdef', not 'ctypedef' (otherwise invalid C code would be generated). - The 'global' statement can be used at the module level to declare that a name is a module-level name rather than a builtin. This can be used to access module attributes such as __name__ that would otherwise be assumed to be builtins. [Pat Maupin ] - The 'assert' statement now accepts a second argument. [Francois Pinard ] Bug fixes: - When using Python 2.3, "True" or "False" could sometimes turn up in generated code instead of "1" or "0". [Adam Hixson ] - Function return value not always converted to or from a Python object when it should have been. - Certain kinds of error in a function call expression could crash the compiler. ["Edward C. Jones" ] - Fixed memory leak in functions with * or ** args. [Alexander A Naanou ] 0.7.1 ----- Bug fixes: - Calling a function declared as returning an extension type could crash the compiler. - A function call with type errors in the argument list could crash the compiler. - An 'else' clause on a for-from statement could crash the compiler. - Incorrect casting code was generated when a generic object argument of a special method was declared as being of an extension type. [Phillip J. Eby ] - A blank line that couldn't be interpreted wholly as a valid indentation sequence caused a syntax error. In particular, a formfeed character on an otherwise blank line wasn't accepted. [Francois Pinard ] - Parallel assignments were incorrectly optimised. - A bare tuple constructor with an extra comma at the end of a line caused a syntax error. 0.7 --- New features: - Attributes of extension types can be exposed to Python code, either read/write or read-only. - Different internal and external names can be specified for C entities. - None is a compile-time constant, and more efficient code is generated to reference it. - Command line options for specifying directories to search for include files. Enhancements: - More efficient code is generated for access to Python valued C attributes of extension types. - Cosmetic code improvement: Less casting back and forth between extension types and PyObject * when referencing C members of the object struct. - C arguments and variables declared as an extension type can take the value None. - Form feed characters are accepted as whitespace. - Function names in tracebacks are qualified with module name and class name. Bug fixes: - A sufficiently complex expression in a boolean context could cause code to be generated twice for the same subexpression. - Incorrect casting code was generated when passing an extension type to a function expecting a generic Python object. - Executable statements are now disallowed inside a cdef class block (previously they silently caused crazy C code to be generated). - Tracebacks should now report the correct filename for functions defined in files included with the 'include' statement. - The documentation incorrectly claimed that an extension type can't have a __del__ method. In fact, it can, and it behaves as expected. 0.6.1 ----- Bug fixes: - Fixed broken distutils extension. 0.6 --- New features: - Command line options for reporting version number, requesting a listing file and specifying the name of the generated C file. - An 'include' statement allows inclusion of declarations from other Pyrex source files. - If there are any public declarations, a Pyrex include file is generated (as well as a .h file) containing declarations for them. - Extension types can be declared public, so their C attributes are visible to other Pyrex and C code. - Try-except statements can now have an 'else' clause. [Francois Pinard ] - Multiple simple statements can be placed on one line separated by semicolons. - A suite consisting of a simple statement list can now be placed on the same line after the colon in most cases. [Francois Pinard ] - The automatic coercion of a C string to a C char has been removed (it proved to be too error-prone). Instead, there is a new form of literal for C character constants: c'X' - The __get__ special method (used by descriptor objects) now allows for the possibility of the 2nd or 3rd arguments being NULL. Also the __set__ method has been split into two methods, __set__ and __delete__. [Phillip J. Eby ] Bug fixes: - Values unpacked into a non-Python destination variable were not being converted before assignment. [Gareth Watts ] - Hex constants greater than 0x7fffffff caused compiler to crash. [Gareth Watts ] - Type slots are no longer statically initialised with extern function pointers, to avoid problems with some compilers. The hack in the distutils extension to work around this by compiling as C++ has been disabled. [Phillip J. Eby ] - Fixed several more instances of the error-reporting routine being called with arguments in the wrong order. Hoping I've *finally* got all of them now... - Nested for-from loops used the same control variable. [Sebastien de Menten ] - Fixed some other error message related bugs. [Francois Pinard ] - Assigning to slice didn't work. [Francois Pinard ] - Temp variables were being declared as extension types and then being assigned PyObject *'s. All Python temp vars are now declared as PyObject *. [Francois Pinard ] 0.5 --- Bug fixes: - Algorithm for allocating temp variables redesigned to fix various errors concerning temp variable re-use. [Mark Rowe ] - Memory leak occured sometimes when an implicit type test was applied to the result of an expression. [christoph.wiedemann@daimlerchrysler.com] - __set__ method of extension types had wrong signature. [Josh Littlefield ] 0.4.6 ----- Bug fixes: - Indexing multi-dimensional C arrays didn't work. [Gary Dietachmayer ] 0.4.5 ----- New features: - There is now a 'public' declaration for making Pyrex-defined variables and functions available to external C code. A .h file is also generated if there are any public declarations. Enhancements: - Defining __len__/__getitem__ methods in an extension class fills sq_length/sq_item slots as well as mp_length/mp_subscript. [Matthias Baas ] - The Distutils extension now allows .c files to be incorporated along with .pyx files. [Modification to Distutils extension contributed by Darrell Gallion .] Bug fixes: - Float literals without a decimal point work again now. [Mike Rovner ] [Peter Lepage ] - Compiler crashed if exception value didn't match function return type. [Michael JasonSmith ] - The setup.py file should now install the Lexicon.pickle file in the right place. [Patch supplied by David M. Cooke ] - Compiler crashed when compiling a C function that returned an extension type. [David M. Cooke ] - Anonymous enum types did not have C code suppressed inside an extern-from block. [Matthew Mueller ] 0.4.4 ----- Enhancements: - Tracebacks now extend into Pyrex function calls and show line numbers in the Pyrex source file. - Syntax for float literals made more lenient (no longer requires digits both before and after the point). [Peter Lepage ] - Method calls can be made on string literals (e.g. ",".join(x)). [pedro_rodriguez@club-internet.fr] Bug fixes: - Incorrect refcount code generated when a Python function needing argument type tests had local Python variables. [Matthias Baas ] - 'self' parameter of __getitem__ method of extension type had wrong implicit type. [Peter Lepage ] - Repaired breakage introduced by trying to allow an empty parameter list to be written as (void). No longer attempting to allow this (too hard to parse correctly). [Peter Lepage ] - Found bug in Plex 1.1.2 which was the *real* cause of the two-newlines-in-a-row problem. Removed the Opt(Eol)+Str("\n") hacks in the scanner which were working around this before. [pedro_rodriguez@club-internet.fr] - __call__ special method of extension types had wrong signature. [Peter Lepage ] 0.4.3 ----- New language features: - For-from loop for iterating over integer ranges, using pure C loop where possible. Enhancements: - sizeof() can now be applied to types as well as variables. - Improved handling of forward-declared extension types. Bug fixes: - Two newlines in a row in a triple quoted string caused a parse error on some platforms. [Matthias Baas ] - Fixed problem with break and continue in the else-clause of a loop. 0.4.2 ----- New language features: - C functions can be declared as having an exception return value, which is checked whenever the function is called. If an exception is detected inside a C function for which no exception value is declared, a warning message is printed and the exception is cleared. - Cascaded assignments (i.e. a = b = c are now supported. - Anonymous enum declarations are allowed, for when you just want to declare constants. - The C types "long long" and "long double" are now understood. Also, "int" is optional after "short" or "long". Enhancements: - A * argument in a function call can now be any sequence, not just a tuple. - A C char* or char[] will be turned into a char by taking its first character if used in a context where a char is required, thus allowing a string literal to be used as a char literal. - C string * C int or vice versa is now interpreted as Python string replication. - Function arguments are checked for void or incomplete type. Bug fixes: - Non-external extension types show up in the module dict once more (this got broken in 0.4.1). - A spurious decref has been removed from the runtime support code for the "import" statement. Hopefully this will prevent the crashes some people have been experiencing when importing builtin modules. [Mathew Yeates ] 0.4.1 ----- New language features: - "ctypedef struct/union/enum/class" statements added, for use in extern-from blocks when a header file uses a ctypedef to declare a tagless struct, union or enum type. - "pass" allowed in an extern-from block. - "cdef extern from *" for when you don't want to specify an include file name. - Argument names may be omitted in function signatures when they're not needed. - New reserved word NULL for the null C pointer. Compiler enhancements: - Lexicon is now picked in binary format, so startup should be much faster on slower machines. - If Pyrex decides to rebuild the lexicon and then finds that it can't write a pickle file, it now prints a warning and carries on instead of crashing. - Chat about hash codes and lexicon pickling now turned off by default except when creating a new lexicon (which ought never happen now unless you change the scanner). Bug fixes: - Modified the runtime support code for "import" statements, hopefully fixing problem with using a Pyrex module in conjunction with py2exe. - DL_EXPORT now used in both the prototype and definition of the module init function. - Exception state is now saved and restored around calls to an extension type __dealloc__ method, to avoid screwing up if the object is deallocated while an exception is being propagated. - Making an attribute reference to a method of an extension type caused a compiler crash. - Doc string in new-style class definition caused a run-time error. - Insufficient parentheses were put around C type casts. - Constructors for extension types are now read-only C global variables instead of entries in the module dict. This change was needed to prevent Numeric from blowing up due to touching its typeobject before import_numeric() could be called. 0.4 --- New features: - "cdef extern from" statement allows inclusion of C header files to be specified, solving a number of problems including: - Clashes between Pyrex and C declarations, due to "const" and other reasons - Windows-specific features required in function declarations - Helping deal with types such as "size_t" - Helping deal with functions defined as macros - Access to internals of pre-existing extension types is now possible by placing an extension type declaration inside a "cdef extern from" block. Bug fixes: - Error not reported properly when passing wrong number of args to certain special methods of extension types. [Mitch Chapman ] - Compile-time crash when defining an extension type with a __hash__ method. Minor enhancements: - Hashing of the scanner source file made more platform-independent, making spurious regeneration of the pickle less likely. 0.3.4 ----- Bug fixes: - Runtime crash when using * or ** args in a method of an extension type fixed. [Matthew Mueller ] - Compiler crash when using default argument values in a method of a Python class. [Mike Rovner ] Enhancements: - Type slots filled with functions from outside the extension module are now initialised dynamically, which should eliminate at least some of the "initialiser is not constant" problems experienced on Windows. [Marek Baczek ] - On Windows, __declspec(dllexport) is now used for the module init func declaration (or should be -- I haven't tested this). [Marek Baczek ] - The compiler shouldn't attempt to rewrite the Lexicon.pickle file unless the source has been changed (hashing is used now instead of comparing timestamps). So there should be no problem any more with installing Pyrex read-only. [fawcett@uwindsor.ca] 0.3.3 ----- Bug fixes: * A void * can be assigned from any other pointer type. [piers@cs.su.oz.au] * File names in error messages no longer quoted (this was apparently confusing some editors). [donut@azstarnet.com] * Reference to a struct member which is an array is coerced to a pointer. [donut@azstarnet.com] * Default argument values did not work in methods of an extension type. [donut@azstarnet.com] * Single or double quote characters in a triple-quoted string didn't work. [donut@azstarnet.com] * Using *args in a function definition sometimes caused a crash at runtime. [donut@azstarnet.com] * A hack is included which tries to make functions in Python.h which use 'const' accessible from Pyrex. But it doesn't work on all platforms. Thinking about a better solution. New features: * Comment containing Pyrex version number and date/time at top of generated C file. [baas@ira.uka.de] 0.3.2 ----- Bug fixes: * The & operator works again. [matthias.oberlaender@daimlerchrysler.com] [baas@ira.uka.de] * The & operator had incorrect precedence. * "SystemError: 'finally' pops bad exception" under some circumstances when raising an exception. [baas@ira.uka.de] * Calling a Python function sometimes leaked a reference. * Crash under some circumstances when casting a Python object reference to a C pointer type. [mpj17@cosc.canterbury.ac.nz] * Crash when redeclaring a function. [baas@ira.uka.de] * Crash when using a string constant inside a Python class definition. [mike@bindkey.com] * 2-element slice indexing expressions. [mike@bindkey.com] * Crash when encountering mixed tabs and spaces. [mike@bindkey.com] New features: * A wider variety of constant expressions is now accepted for enum values, array dimensions, etc. [mike@bindkey.com] 0.3.1 ----- New features: * More special methods for extension types: __delitem__, __delslice__, __getattr__, __setattr__, __delattr__ * Module-level variable of a Python object type declared with 'cdef' is private to the module, and held in a C variable instead of the module dict. * External C functions with variable argument lists can be declared and called. * Pyrex-defined Python functions can have default argument values and * and ** arguments, and can be called with keyword arguments. * Pointer-to-function types can be declared. * Pyrex now supports a declaration syntax that C doesn't! Example: cdef (int (*)()) foo() # function returning a function ptr * There is now a ctypedef statement. * Extension types can now be forward-declared. * All permutations of (non-Unicode) string literals and escape codes should work now. * Hex and octal integer literals. * Imaginary number literals. * Docstrings are now supported. Bug fixes: * Type tests are performed when using a Python object in a context requiring a particular extension type. * Module-level variable holding the type object of an extension type had incorrect type. 0.3 --- New features: * Extension types! Yay! 0.2.2 ----- Bug fixes: * Fixed error message generation again after a previous bug was accidentally re-indroduced. * Removed the declaration of isspace() from the code generated for print statement support (it's not needed and was conflicting with the system-supplied one on some platforms). 0.2 --- New features: * Executable statements are now allowed at the top level of a module. * Python class definitions are now supported, with the following limitations: - Class definitions are only allowed at the top level of a module, not inside a control structure or function or another class definition. - Assigning a Pyrex-defined Python function to a class attribute outside of the class definition will not create a method (because it's not an interpreted Python function and therefore won't trigger the bound-method creation magic). - The __metaclass__ mechanism and the creation of new-style classes is not (yet) supported. * Casting between Python and non-Python types is better supported. Bug fixes: * Fixed bug preventing for-loops from working. 0.1.1 ----- * I've discovered a flaw in my algorithm for releasing temp variables. Fixing this properly will require some extensive reworking; I've put in a hack in the meantime which should work at the cost of using more temp variables than are strictly necessary. * Fixed bug preventing access to builtin names from working. This should also have fixed the import statement, but I haven't tested it. * Fixed some errors in __Pyx_GetExcValue. * Fixed bug causing boolean expressions to malfunction sometimes.