0.9.9
-----

New features:

  - C++ struct declarations, 'new' operator, and del for C++ delete.
  
  - As well as the 'not None' modifier for extension type arguments, there
    is now 'or None' to explicitly allow passing None. It is planned to make
    'not None' the default in a future version. For now, a warning is issued
    (once per Pyrex run) if you do not specify one or the other.
  
  - Extension types may have a 'nogc' option to suppress GC support.

Modifications:

  - Exceptions caught by an except clause are no longer put into the thread
    state and cannot be retrieved using sys.exc_info(). To access the caught
    exception, it must be bound to a name in the except clause. A third name
    can be supplied to capture the traceback.

  - PyString_InternFromString is now exposed under the name 'cintern' because
    it is not a complete substitute for 'intern' (it can't handle strings
    containing null bytes). [John Arbash Meinel]
  
  - Disabled size check for cimported types because it was generating too
    many false positives in the field.
    
  - Added __fastcall calling convention. Also no longer assuming that an
    unspecified calling convention is the same as __cdecl.
  
  - Operations between signed and unsigned ints of the same size now have
    an unsigned result.
  
  - Py_ssize_t now ranked between long and long long.
  
  - Declaration of __new__ in an extension type is now an error, in
    preparation for introducing new semantics.
  
  - Added size_t type, and made sizeof() return it.

Bug fixes:

  - When casting the result of a function call to a Python type, the
    function could be called twice. [David Martinez]
  
  - __Pyx_GetException was not taking account of the fact that the traceback
    could be NULL.
  
  - sizeof(module.typename) did not work. [Daniele Pianu]


0.9.8.6
-------

Enhancements:

  - Check for gil when calling a function declared 'execpt *' or 'except ?'.
    Acquire gil when reporting unraisable exception.
  
  - Added iter2() function for 2-argument form of iter().

Bug fixes:

  - Compiler crashed if base class of extension type was incompletely
    defined.
  
  - Compiler crash on misspelled method name in property declaration.
    [Stefan Behnel]
  
  - Fixed deprecation warnings in 2.6
  
  - Always preserve explicit type casts for non-Python types.
    [Alexander Belchenko]
  
  - Added workaround for threading initialisation bug in Python 2.3.
    [Lisandro Dalcin]
  
  - Deleting dict item with integer key did not work. [Titus Brown]
  
  - Header files for cimported modules included in wrong order.
    [Stephane Drouard]
  
  - Don't allow a member of a ctypedef struct to reference itself.
    [Tim Wakeham]
  
  - Compiler crash due to attribute reference in compile-time expression.
    [Hoyt Koepke]
  
  - Public extension type attribute with cname didn't work.
    [Mark Ellis]
  
  - Memory leak related to exporting C functions. [Lisandro Dalcin]
  
  - Compiler crash on return outside function. [Kurt Smith]
  
  - Scope problem with extension types declared in pxd. [KS Sreeram]
  
  - Calling a builtin method of a subclass of a builtin class did not work.
  
  - Builtin hash() function had wrong return type. [John Arbash Meinel]


Modifications:

  - Added 'tags' to .hgignore file. [Kirill Smelkov]
  
  - Disallow overriding a builtin method in a subclass of a builtin class.


0.9.8.5
-------

Bug fixes:

  - Function export code was erroneously generated for 'extern' functions
    declared in a .pxd file. [Sebastian Sable]
  
  - The 'api' option was not recognised with 'ctypedef public class'.
    [Lisandro Dalcin]
  
  - MACOSX_DEPLOYMENT_TARGET is no longer set unless the undocumented -X
    option is being used. Hopefully this will prevent complaints about it
    from distutils. [Martin Field]
  
  - Recognize MS_WINDOWS as well as WIN32. [Alexander Belchenko]
  
  - Hexadecimal compile-time constants did not work. [Devan]

Enhancements:

  - Dependency files (.dep) are only created when compiling with timestamp
    checking or recursion enabled.

Deprecations:

  - The features introducted in 0.9.8 and 0.9.8.1 for cross-forward-declaring
    extension types between .pxd files turn out to be unnecessary, since
    the circular import problems they are aimed at can be avoided using
    ordinary forward delcarations in the .pxd files ahead of any cimports.


0.9.8.4
-------

Bug fixes:

  - Incorrect code generated for Python indexing with an unsigned int.
    [Christopher Williams]


0.9.8.3
-------

Bug fixes:

  - Compiling multiple source files at once should work as advertised
    now.
  
  - Assignment of a nogil function to a non-nogil function pointer
    is now allowed.
  
  - Applying += or -= to a pointer and an integer did not work.
    [Arc Riley]
  
  - Compiling a .pyx file whose name is not a valid module name now
    reports an error instead of generating invalid C code.
    [Robert Bradshaw]
  
  - Integer indexing optimisation now performed only for signed
    index types, to avoid change of semantics with index values
    greater than the maximum positive signed int value. [Robert
    Bradshaw]
  
  - Non-void function declared 'except *' could produce C compiler
    warning about uninitialised variable. [Lisandro Dalcin]


0.9.8.2
-------

Enhancements:

  - A block of external functions can be declared nogil at once.
  
      cdef extern from "somewhere.h" nogil:
        ...

Bug fixes:
  
  -	The nogil attribute was not being checked for a match when
    comparing function signatures.
  
  - Improved error message for C method signature mismatch between
    a class and its base class.

Bug workarounds:

  - Multiple source files passed to Main.compile are being compiled
    in separate contexts for the time being until I can sort out a
    problem. You probably won't notice any difference except that
    there will be no speed advantage over compiling them separately.


0.9.8.1
-------

Enhancements:

  - It is no longer necessary to specify the base class of an
    extension type in a forward declaration. Also, if the class is
    defined in a .pxd file, the base class only needs to be specified
    in the .pxd file, not the .pyx file.
    [Arc Riley]
  
  - There's now an even easier way to forward-declare a struct, union
    or extension type in another module:
    
    	from blarg cimport class Foo
    	
    This simultaneously cimports the name Foo and forward-declares
    it as an extension type. As well as 'class', you can also use
    'struct' or 'union'.

Modifications:

  - Casting a non-Python pointer type to a Python type no longer
    generates an incref, unless one is required for other reasons.
    [Arc Riley]
  
  - More checks added for gil-requiring operations performed without
    holding the gil.


0.9.8
-----

New features:

  * Augmented assignment operators (+=, etc.) are now supported.
  
  * Package directories
  
    Modules in packages no longer need to have dotted names. Instead,
    a Python-like package directory structure can be used, with
    package dirs marked by containing an __init__.py or __init__.pyx.
    
    Top-level package directories are found by searching the include
    directories specified by -I options (analogous to PYTHONPATH).
   
  * Dependency tracking
  
    The Pyrex compiler records information about other source files cimported
    or included, and can automatically compile all the modules a given module
    depends on, with timestamp checking.
    
    This is enabled by a -r (recursive) option to the compiler, e.g.
    
      pyrexc -r mainmodule.pyx
    
    There are also two other new command-line options:
    
      -t   Enable timestamp checking. This is implied with -r.
      
      -f   Overrides implied -t when using -r and forces all
           dependent modules to be compiled regardless of timestamps.
  
  * Nogil restrictions relaxed
  
    C functions declared nogil can now have Python objects as arguments.
    The argument names are read-only inside the function when this is done.
    
    Among other things, this allows C methods to be declared nogil (this
    couldn't be done before because 'self' is always an object argument).
  
  * Circular cimports
  
    There is now a way of forward-declaring a struct, union or extension type
    into another module. This allows two .pxd files to define extension types
    that refer to each other without running into circular import problems.
    For example:
    
      cimport blarg
      cdef class blarg.Blarg # Forward declaration
      
      cdef class Foo:
        cdef blarg.Blarg blg


0.9.7.2
-------

  Bug fixes:
  
  - Another integer indexing problem fixed.


0.9.7.1
-------

  Bug fixes:
  
  - The optimisation for indexing using a C int failed when the
    object being indexed was a mapping rather than a sequence.
    [Arc Riley]
  
  Modifications:
  
  - Old integer for-loop syntax is no longer deprecated.


0.9.7
-----

New features:

  - Builtin constants and types are known, and are referenced directly
    with no dictionary lookup.
  
  - Direct calls are made to certain methods of lists and dicts when
    their type is statically known.
  
  - New builtin functions 'typecheck' and 'issubtype' added, providing
    safer type checking than isinstance and issubclass (which can be
    overridden).

Enhancements:

  - Redundant type test eliminated when assigning the result of an
    extension type constructor call to a variable of the same type.
  
  - No tp_traverse and tp_clear functions generated for types
    without Python attributes.
  
  - Safer code generated in tp_clear. [Stefan Behnel]
  
  - Indexing with a C int type generates calls to PySequence_GetItem
    and PySequence_SetItem.
  
  - Integer for-loop syntax streamlined to 'for x < i < y'.

  - Appropriate C code generated for compile-time expressions
    evaluating to float nan, inf and -inf. [Stefan Behnel]

Bug fixes:

  - Value raised by assert statement now only evaluated if the
    assertion fails. [Stefan Behnel]
  
  - Comparing a value of an enum type with another value of a type
    which is ctypedefed to the same enum type gave a spurious type
    error. [Matt Hammond]
  
  - Comparing an int with a float resulted in the float being cast
    to an int before comparison. [Robin Becker]
  
  - Compiler crashed on an invalid argument to a 'with nogil' statement.
    [Stefan Behnel]
  
  - Incorrect code generated for function with keyword only args
    and no * or ** args. [Stefan Behnel]
  
  - GC type with non-GC base type caused crash due to trying to call
    non-existent base tp_traverse and tp_clear functions. [Stefan Behnel]
  
  - Compile-time IF with no ELSE clause crashed compiler. [Kirk McDonald]
  
  - Values in enum declaration were not being checked for appropriate type.
    [Simon Burton]
  
  - Improved the error message from attempting to declare a struct or
    union member as a function. [Yong Sun]
  
  - Referring to an undefined name in a compile-time constant crashed
    the compiler. [Stefan Behnel]


0.9.6.4
-------

Bug fixes:

  - Errors in setup.py corrected.
  
  - Incorrect error checking code generated for builtin functions
    and type slots with return type Py_ssize_t. [Robert Bradshaw]
  
  - A counted reference was not kept to the module, so if the entry
    in sys.modules was replaced, the module was freed prematurely.
    [Franck Pommerau]
  
  - A cimport statement inside a function crashed the compiler.
    [Robert Bradshaw]
  
  - __Pyx_ImportModule routine wasn't protected from multiple
    definition when including _api.h files. [Stefan Behnel]
  
  - Temp variables holding exception values were not being set to
    NULL after use in an except clause. [Robert Bradshaw]
  
  - Protect __stdcall and __cdecl from redefinition. [Jim Kleckner]
  
  - A temp var was not being set to NULL after api function import
    code. [Stefan Behnel]
  
  - __Pyx_ImportFunction was incorrectly decrefing a borrowed
    reference. [Stefan Behnel]
  
Enhancements:

  - Functions declared with_gil and external functions declared nogil
    are now allowed to have Python arguments and return types.


0.9.6.3
-------

Enhancements:

  - C API now only uses a single name in the module namespace
    instead of one for each exported C function. [Stefan Behnel]
  
  - Multiple declarations with the same visibility and api options
    can now be grouped into a 'cdef' block.
  
  - The 'api' keyword can now be used on extension types to cause
    generation of an api.h file when there are no exported C functions.
  
  - Added a getattr3() builtin for the three-argument form of getattr.
  
Bug fixes:

  - Setup.py no longer uses an import to get the version number
    being installed, to avoid a problem with setuptools.
  
  - If a struct or union was forward-declared, certain types of error
    message misleadingly referenced the source location of the forward
    declaration rather than the definition.
  
  - Calling convention specifier was being emitted in function
    prototypes but not the corresponding definitions. [Atsuo Ishimoto]
  
  - Added support for the --force option to Pyrex.Distutils.
    [Alexander Belchenko]
  
  - Compile-time "==" operator did not work. [Simon King]

  - Header files generated for public and api declarations now
    only contain types declared as 'public', instead of all types
    defined in the module. [Stefan Behnel]


0.9.6.2
-------

Bug fixes:

  - Corrected a problem with declaration ordering in generated C
    code involving forward-declared struct, union or extension types.

  - New distutils extension: Only compile .pyx if it is newer
    than the corresponding .c file.


0.9.6.1
-------

Bug fixes:

  - Changed os.uname to platform.uname for portability.
    [Alexander Belchenko]
  
  - Fixed C compiler warning about incompatible types in 2.5.
    [Alexander Belchenko]
  
  - Also fixed a few other 2.5 problems.

  - Fixed problem with the Extension class in the new Pyrex.Distutils
    module.


0.9.6
-----

New Features:

  - Top-level C functions defined in one module can now be used in
    another via cimport, and a C API can be produced to allow them
    to be used from C code without linking to the extension module.
    See "Interfacing with External C Code" and "Sharing Declarations
    between Pyrex Modules" in the Language Overview. [Stefan Behnel]
  
  - Facilities added for releasing the GIL around a section of code
    and acquiring it on entry to a C function. See "Acquiring and
    Releasing the GIL under "Interfacing with External C Code" in
    the Language Overview. [Ulisses Furquim, Stefan Behnel]
  
  - Some conditional compilation facilities have been added. See
    "Conditional Compilation" under "Language Basics" in the
    Language Overview. [Sam Rushing]

Language Changes:

  - The __new__ special method of extension types is being renamed
    to "__cinit__". For now, you will get a warning whenever you
    declare a __new__ method for an extension type, and it will
    automatically be renamed to __cinit__ for you. In the next
    release, the warning will become an error and no renaming will
    occur. In some later release, the __new__ method may be
    re-introduced with different semantics. It is recommended that
    you begin updating your sources now to use __cinit__.
  
  - A 'raise' statement with no arguments (i.e. to re-raise the
    last exception caught) is now required to be lexically within
    the 'except' clause which caught the exception. This change was
    necessary to efficiently support preserving the exception if an
    intervening call raises and catches a different exception.
  
  - The following new reserved words have been added:
  
      with, DEF, IF, ELIF, ELSE

Enhancements:

  - Calls to many of the builtin functions are now compiled as
    direct calls to Python/C API routines.

  -	A C type explicitly declared as 'signed' is represented as
    such in the generated code, to acommodate platforms where
    'char' is unsigned by default. [Francesc Altet]
  
  - Python function can now have an argument of type "unsigned
    char". [Alexander Belchenko]
  
  - A new Pyrex.Distutils implementation has been added, which
    exports an Extension type supporting the following options:
    
      pyrex_include_dirs - list of dirs to search for Pyrex header files
      pyrex_create_listing_file - bool - write errs to listing file
      pyrex_cplus - bool - generate C++ code
      pyrex_c_in_temp - bool - put generated C files in temp dir
      pyrex_gen_pxi - bool - generate .pxi file for public declarations
    
    [Contributed by Billie G. Allie]
  
  - Assert statements can be compiled out by arranging for
    PYREX_WITHOUT_ASSERTIONS to be #defined at C compilation time.
    [Contributed by Stefan Behnel]
  
  - Support for __index__ slot added to extension types.
    [William Stein]
  
  - Exception types now properly checked according to pre or post
    2.5 rules as appropriate.
  
  - Py_ssize_t support added. [Stefan Behnel]
  
  - Windows __stdcall and __cdecl qualifiers now supported.
    [Suggested by Eric Devolder]
  
  - Keyword-only argument support added. [Suggested by Stefan Behnel]
  
  - An 'include' statement can now appear anywhere that another kind
    of statement or declaration can appear, instead of being restricted
    to the top level. [Caio Marcelo]
  
  - Unnecessary PyErr_Occurred() call to check result of
    PyString_AsString() no longer made.
  
  - Complicated C types are displayed more readably in error messages.

Modifications:

  - A Python function argument declared as "char" or "unsigned
    char" now expects a Python integer rather than a string of
    length 1, for consistency with the way automatic conversions
    are done elsewhere.
  
  - Support for string and tuple exceptions dropped.

Bug fixes:

  - If an external ctypedef type was used as the type of an
    argument to a Python function, a declaration was generated
    using the underlying type rather than the typedef name.
    [Francesc Altet]
  
  - Some problems with int/enum and pointer/array compatibility
    fixed. [Eric Huss, Stefan Behnel, Jiba]
  
  - Eliminated C compiler warning when comparing an extension
    type reference to None using 'is' or 'is not'
  
  - Eliminated C compiler warnings about docstrings of C functions
    and special methods being unused. [Francesc Altet]
  
  - When compiling with -O, raising an exception in a C function
    that couldn't propagate exceptions produced a compiler
    warning about the return value possibly being uninitialised.
  
  - Fixed warning about function declaration not being a prototype
    caused by C method table initialisation code.
  
  - Spurious initialisation was generated for unused local variable.
    [Helmut Jarausch]
  
  - Declaration of a non-extern C function without definition
    was not detected. [Lenard Lindstrom]
  
  - Applying ** directly to two C int types is now disallowed due
    to ambiguity (it's not clear whether to use C pow() or convert
    to Python ints). [Didier Deshommes]

  - Traverse and clear code was being inadvertently generated for
    the __weakref__ slot of a weakly-referenceable extension type.
    [Peter Johnson]
  
  - Statements other than def inside a property declaration were
    crashing the compiler. [Sven Berkvens]
  
  - Defining an extension type with different visibility from its
    declaration in a .pxd file crashed the compiler.
    [Alex Coventry]
  
  - Instantiating an exception type whose base class __new__ method
    raises an exception caused a segfault. [Gustavo Sverzut Barbieri]
  
  - The 'import pkg.module as name' form of import statement did not
    work correctly. [Dan]
  
  - Fixed error-checking typo in __Pyx_GetStarArgs(). [Eric Huss]
  
  - Trailing comma now allowed on argument list. [Jim Kleckner]
  
  - Behaviour of reraise made to match Python more closely. 
    [Eric Huss]
  
  - An empty C variable declaration crashed the compiler.
  
  - Now includes math.h instead of generating own declaration
    of pow(). [Leif Strand]
  
  - Missing import of sys in LinuxSystem.py added. [Scott Jackson]
  
  - Typecasts using a ctypedef type were not using the ctypedef
    name. [Alexander Belchenko]
  
  - Workaround added to setup.py for a problem with bdist_wininst.
    [Alexander Belchenko]
  
  - Subtle error in parsing empty function declarators corrected.
  
  - Checks added for some type combinations that are illegal in C:
    array of functions, function returning function or array, cast
    to a function.


0.9.5.1a
--------

Bug fixes:

  - Package list now calculated dynamically in setup.py so that
    it will work with or without the testing framework installed.


0.9.5.1
-------

Bug fixes:

  - Comparing two values of the same enum type incorrectly
    produced an error. [Anders Gustafsson]
  
  - Compiler crash caused by assigning a Python value to
    a variable of an enum type. [Peter Johnson]
  
  - Comparison between pointer and array incorrectly produced
    a type mismatch error. [Helmut Jarausch]
  
  - Unused local Python variable had spurious init/cleanup code
    generated for it, causing C compilation errors. [Helmut Jarausch]
  
  - Updated list of packages in setup.py.

Modifications:

  - NULL in Pyrex source now translated into NULL instead of 0
    in C code, to allow for the possibility of calling something
    not defined with a prototype in an external header. [Adapted Cat]


0.9.5
-----

Enhancements:

  - Exception return values may now be specified by arbitrary
    constant expressions of appropriate type, not just literals.
    [Stefan Behnel]
  
  - Redundant type check now omitted when passing a literal None
    to a function expecting an extension type. [Patch by Sam Rushing]
    
  - New-style classes now allowed as exceptions for compatibility
    with Python 2.5 (inheritance from BaseException not currently
    checked). [Stefan Behnel]
  
  - Sequence unpacking is now done using the iterator protocol
    instead of indexing.
  
  - Allocation of an empty tuple is avoided when making a
    Python call with no arguments. [Stefan Behnel]
  
  - Most warnings about unused variables and labels have been
    eliminated.
  
  - Support for running the test suite on Linux added but not
    yet fully tested. [Based in part on patch by Eric Wald].
  
  - Makefile included for compiling the patched Carbon File module
    used by the MacOSX test code.

Modifications:
  
  - Type rules for enums tightened for compatibility with C++.
  
  - Direct assignment from float to int disallowed to prevent
    C++ compilation warnings.
  
  - Hex literals left as hex in C code to avoid warnings from
    the C compiler about decimal constants becoming unsigned.
  
Bug fixes:

  - Exception raised during argument conversion could cause crash
    due to uninitialised local variables. [Konrad Hinsen]
  
  - Assignment to a C attribute of an extension type from a
    different type could generate C code with a pointer type
    mismatch. [Atsuo Ishimoto]
  
  - Backslash in a string literal before a non-special character
    was not handled correctly. [Yuan Mang]
  
  - Temporary vars used by del statement not being properly
    released, sometimes leading to double decrefs. [Jiba]
  
  - A return statement whose expression raises an exception
    inside a try-except that catches the exception could cause
    a crash. [Anders Gustafsson]
  
  - Fixed type compatibility checking problem between pointers
    and arrays. [Lenard Lindstrom]

  - Circular imports between modules defining extension types
    caused unresolvable import order conflicts. [Mike Wyatt]
  
  - Cimporting multiple submodules from the same package caused
    a redefined name error for the top level name. [Martin Albrecht]
  
  - Incorrect reference counting when assigning to an element of an
    array that is a C attribute of an extension type. [Igor Khavkine]
  
  - Weak-referenceable extension types were not implemented
    properly. [Chris Perkins, Peter Johnson]
  
  - Crash if C variable declared readonly outside an extension
    type definition. [Eric Huss]

Doc updates:

  - Expanded discussion of the need for type declarations to enable
    access to attributes of extension types.
  
  - Added a section "Source Files and Compilation" explaining the
    rules for naming of source files of modules residing in packages,
    and instructions for using the compiler and distutils extension.


0.9.4.1
-------

Bug fixes:

  - Fixed indentation problem in Pyrex.Distutils.build_ext.
    [Oliver Grisel]


0.9.4
-----

Improvements:

  - All use of lvalue casts has been eliminated, for
    compatibility with gcc4.
  
  - PyMODINIT_FUNC now used to declare the module init function.
  
  - Generated code should be compilable as either C or C++.
    When compiling as C++, "extern C" is used where appropriate
    to preserve linkage semantics.
  
  - An extension type can be made weak-referenceable by
    giving it a C attribute of type object called __weakref__.
  
  - Source files opened in universal newlines mode.
  
  - Support for public extension type C attributes of type
    long long and unsigned long long added (but not tested).
    [Sam Rushing]
  
  - Distutils include directories now passed to Pyrex compiler.
    [Konrad Hinsen]
  
  - Integer constants with an "L" suffix are now allowed
    and are converted to Python long integers. [Rainer Deyke]
  
  - A broken .c file is no longer left behind if there are
    compilation errors.
  
  - Using the result of a Python indexing or attribute access
    operation as a char * is no longer considered an error in
    most cases, as the former behaviour proved to be more
    annoying than helpful.
  
Bug fixes:

  - Fixed problems with conversion from Python integers to
    C unsigned longs. Now use PyInt_AsUnsignedLongMask and
    PyInt_AsUnsignedLongLongMask instead of the PyLong_*
    functions (which only work on Python longs). [Wim Vree]
  
  - C unsigned ints now converted to/from Python longs intead
    of Python ints to avoid overflow problems. [Heiko Wundram]
  
  - Correct PyArg_ParseTuple format characters now used for
    unsigned types. [Jeff Bowden]
  
  - Nonzero return value from a base class tp_traverse call
    is handled.
  
  - Taking sizeof an incomplete type caused a crash while
    producing an error message. [Drew Perttula]
  
  - If a module cimported itself, definitions of global variables
    were generated twice. [Parzival Herzog]
  
  - Distutils extension updated to handle changed signature of
    swig_sources(). [David M. Cooke]
  
  - Incorrect C code generated for a raw string containing a double
    quote preceded by a backslash. [Thomas Drake]
  
  - Declaration of public C function with an exception value written
    to generated .pxi file without the except clause. [Robby Dermody]
  
  - __delitem__ method of an extension type with no __setitem__
    did not get called. [Richard Boulton]
  
  - A spurious Py_INCREF was generated when a return statement
    required a type test. [Jonathan Doda]
  
  - Casting a value to a function pointer and then immediately
    calling it generated a cast to a function instead of a cast
    to a function pointer. [Simon Burton]
  
  - Py_TPFLAGS_HAVE_GC was not being set on an extension type that
    inherited from an external extension type that used GC but did
    not itself have any PyObject* attributes.
    [Michael Hordijk]
  
  - A return statement inside a for statement leaked a reference
    to the loop's iterator.
    [Jürgen Kartnaller]
  
  - Full module name now appears in __module__ attribute of classes
    and extension types, provided a correct dotted name is used
    for the .pyx file. [Giovanni Bajo]

  - Public extension type with no C attributes produced an
    invalid .pxi file. [Simon Burton]
  
  - Using a dict constructor as the second operand of a boolean
    expression crashed the Pyrex compiler.
    [Stefan Behnel]
  
  - A C declaration list ending with a comma resulted in invalid
    C code being generated. [Alex Coventry]
  
  - A raw string containing two consecutive backslashes produced
    incorrect C code. [Helmut Jarausch]
  
  - An error is reported if you attempt to declare a special
    method of an extension type using 'cdef' instead of 'def'.
    [Sam Rushing]

0.9.3
-----

Enhancements:

  - Types defined with a ctypedef in a 'cdef extern from' block
    are now referred to by the typedef name in generated C code,
    so it is no longer necessary to match the type in the C
    header file exactly.

  - Conversion to/from unsigned long now done with
    PyLong_AsUnsignedLong and PyLong_FromUnsignedLong. [Dug Song]
  
  - A struct, union or enum definition in a 'cdef extern from'
    block may now be left empty (using 'pass'). This can be useful
    if you need to declare a variable of that type, but don't need
    to refer to any of its members.
  
  - More flexible about ordering of qualifiers such as 'long' and
    'unsigned'. ["John (J5) Palmieri"]


Bug fixes:

  - Non-interned string literals used in a Python class
    definition did not work. [Atsuo Ishimoto, Andreas Kostyrka]
  
  - Return types of the buffer interface functions for extension
    types have been corrected. [Dug Song]
  
  - Added 'static' to declarations of string literals. [Phil Frost]
  
  - Float literals are now copied directly to the C code as written,
    to avoid problems with loss of precision. [Mario Pernici]
  
  - Inheriting from an extension type with C methods defined in
    another Pyrex module did not work. [Itamar Shtull-Trauring]

0.9.2.1
-------

Bug fixes:

  - Corrected an import statement setup.py, and made it
    check for a unix platform in a more reliable way.

0.9.2
-----

Enhancements:

  - Names of Python global variables and attributes are now
    interned, and PyObject_GetAttr/SetAttr are used instead
    of PyObject_GetAttrString/SetAttrString. String literals
    which resemble Python identifiers are also interned.
  
  - String literals are now converted to Python objects only
    once instead of every time they are used.
  
  - NUL characters are now allowed in Python string literals.

  - Added some missing error checking code to the beginning
    of module init functions. It's unlikely the operations
    involved would ever fail, but you never know.

Bug fixes:

  - Corrected some problems introduced by moving the Plex
    package.

0.9.1.1
-------

Bug fixes:

  - Corrected a problem in the setup.py (pyrexc script incorrectly
    named).
  
  - Updated the distutils extension to match changes in the
    Pyrex compiler calling interface.
  
  - Doing 'make clean' in Demos/callback was removing a little too
    much (that's why cheesefinder.c kept disappearing).

0.9.1
-----

Enhancements:

  - A C method can now call an inherited C method by the usual
    Python technique. [Jiba]
  
  - The __modname__ of a Python class is now set correctly. [Paul Prescod]
  
  - A MANIFEST.in file has been added to the distribution to
    facilitate building rpms. [contributed by Konrad Hinsen]

Bug fixes:

  - Conditional code now generated to allow for the renaming of LONG_LONG
    to PY_LONG_LONG that occurred between Python 2.2 and 2.3.

  - Header files referenced in cimported modules were not being included.
