.. -*- rest -*-

=========================
 F2PY History
=========================

:Author: Pearu Peterson <pearu@cens.ioc.ee>
:Web-site: http://cens.ioc.ee/projects/f2py2e/
:Date: $Date: 2005/09/16 08:36:45 $
:Revision: $Revision: 1.191 $

.. Contents::

Release 2.46.243
=====================

* common_rules.py

  - Fixed compiler warnings.

* fortranobject.c

  - Fixed another dims calculation bug.
  - Fixed dims calculation bug and added the corresponding check.
  - Accept higher dimensional arrays if their effective rank matches.
    Effective rank is multiplication of non-unit dimensions.

* f2py2e.py

  - Added support for numpy.distutils version 0.4.0.

* Documentation

  - Added example about ``intent(callback,hide)`` usage. Updates.
  - Updated FAQ.

* cb_rules.py

  - Fixed missing need kw error.
  - Fixed getting callback non-existing extra arguments.
  - External callback functions and extra_args can be set via 
    ext.module namespace.
  - Avoid crash when external callback function is not set.

* rules.py

  - Enabled ``intent(out)`` for ``intent(aux)`` non-complex scalars.
  - Fixed splitting lines in F90 fixed form mode.
  - Fixed FORTRANAME typo, relevant when wrapping scalar functions with 
    ``--no-wrap-functions``.
  - Improved failure handling for callback functions.
  - Fixed bug in writting F90 wrapper functions when a line length
    is exactly 66.

* cfuncs.py

  - Fixed dependency issue with typedefs.
  - Introduced ``-DUNDERSCORE_G77`` that cause extra underscore to be
    used for external names that contain an underscore.

* capi_maps.py

  - Fixed typos.
  - Fixed using complex cb functions.

* crackfortran.py

  - Introduced parent_block key. Get ``use`` statements recursively 
    from parent blocks. 
  - Apply parameter values to kindselectors.
  - Fixed bug evaluating ``selected_int_kind`` function.
  - Ignore Name and Syntax errors when evaluating scalars.
  - Treat ``<int>_intType`` as ``<int>`` in get_parameters.
  - Added support for F90 line continuation in fix format mode.
  - Include optional attribute of external to signature file.
  - Add ``entry`` arguments to variable lists.
  - Treat \xa0 character as space.
  - Fixed bug where __user__ callback subroutine was added to its
    argument list.
  - In strict 77 mode read only the first 72 columns.
  - Fixed parsing ``v(i) = func(r)``.
  - Fixed parsing ``integer*4::``.
  - Fixed parsing ``1.d-8`` when used as a parameter value.

Release 2.45.241_1926
=====================

* diagnose.py

  - Clean up output.

* cb_rules.py

  - Fixed ``_cpointer`` usage for subroutines.
  - Fortran function ``_cpointer`` can be used for callbacks.

* func2subr.py

  - Use result name when wrapping functions with subroutines.

* f2py2e.py

  - Fixed ``--help-link`` switch.
  - Fixed ``--[no-]lower`` usage with ``-c`` option.
  - Added support for ``.pyf.src`` template files.

* __init__.py

  - Using ``exec_command`` in ``compile()``.

* setup.py

  - Clean up.
  - Disabled ``need_numpy_distutils`` function. From now on it is assumed
    that proper version of ``numpy_distutils`` is already installed.

* capi_maps.py

  - Added support for wrapping unsigned integers. In a .pyf file
    ``integer(-1)``, ``integer(-2)``, ``integer(-4)`` correspond to
    ``unsigned char``, ``unsigned short``, ``unsigned`` C types,
    respectively.

* tests/c/return_real.py

  - Added tests to wrap C functions returning float/double.

* fortranobject.c

  - Added ``_cpointer`` attribute to wrapped objects.

* rules.py

  - ``_cpointer`` feature for wrapped module functions is not
    functional at the moment.
  - Introduced ``intent(aux)`` attribute. Useful to save a value
    of a parameter to auxiliary C variable. Note that ``intent(aux)``
    implies ``intent(c)``. 
  - Added ``usercode`` section. When ``usercode`` is used in ``python
    module`` block twise then the contents of the second multi-line
    block is inserted after the definition of external routines.
  - Call-back function arguments can be CObjects.

* cfuncs.py

  - Allow call-back function arguments to be fortran objects.
  - Allow call-back function arguments to be built-in functions.

* crackfortran.py

  - Fixed detection of a function signature from usage example.
  - Cleaned up -h output for intent(callback) variables.
  - Repair malformed argument list (missing argument name).
  - Warn on the usage of multiple attributes without type specification.
  - Evaluate only scalars ``<initexpr>`` (e.g. not of strings).
  - Evaluate ``<initexpr>`` using parameters name space.
  - Fixed resolving `<name>(<args>)[result(<result>)]` pattern.
  - ``usercode`` can be used more than once in the same context.

Release 2.43.239_1831
=====================

* auxfuncs.py

  - Made ``intent(in,inplace)`` to mean ``intent(inplace)``.

* f2py2e.py

  - Intoduced ``--help-link`` and ``--link-<resource>``
    switches to link generated extension module with system
    ``<resource>`` as defined by numpy_distutils/system_info.py.

* fortranobject.c

  - Patch to make PyArray_CanCastSafely safe on 64-bit machines.
    Fixes incorrect results when passing ``array('l')`` to 
    ``real*8 intent(in,out,overwrite)`` arguments.

* rules.py

  - Avoid empty continuation lines in Fortran wrappers.

* cfuncs.py

  - Adding ``\0`` at the end of a space-padded string, fixes tests
    on 64-bit Gentoo.

* crackfortran.py

  - Fixed splitting lines with string parameters.

Release 2.43.239_1806
=====================

* Tests

  - Fixed test site that failed after padding strings with spaces
    instead of zeros.

* Documentation

  - Documented ``intent(inplace)`` attribute.
  - Documented ``intent(callback)`` attribute.
  - Updated FAQ, added Users Feedback section.

* cfuncs.py

  - Padding longer (than provided from Python side) strings with spaces
    (that is Fortran behavior) instead of nulls (that is C strncpy behavior).

* f90mod_rules.py

  - Undoing rmbadnames in Python and Fortran layers.

* common_rules.py

  - Renaming common block items that have names identical to C keywords.
  - Fixed wrapping blank common blocks.

* fortranobject.h

  - Updated numarray (0.9, 1.0, 1.1) support (patch by Todd Miller).

* fortranobject.c

  - Introduced ``intent(inplace)`` feature.
  - Fix numarray reference counts (patch by Todd).
  - Updated numarray (0.9, 1.0, 1.1) support (patch by Todd Miller).
  - Enabled F2PY_REPORT_ON_ARRAY_COPY for Numarray.

* capi_maps.py

  - Always normalize .f2py_f2cmap keys to lower case.

* rules.py

  - Disabled ``index`` macro as it conflicts with the one defined
    in string.h.
  - Moved ``externroutines`` up to make it visible to ``usercode``.
  - Fixed bug in f90 code generation: no empty line continuation is
    allowed.
  - Fixed undefined symbols failure when ``fortranname`` is used
    to rename a wrapped function.
  - Support for ``entry`` statement.

* auxfuncs.py

  - Made is* functions more robust with respect to parameters that
    have no typespec specified.
  - Using ``size_t`` instead of ``int`` as the type of string
    length. Fixes issues on 64-bit platforms.

* setup.py

  - Fixed bug of installing ``f2py`` script as ``.exe`` file.

* f2py2e.py

  - ``--compiler=`` and ``--fcompiler=`` can be specified at the same time.

* crackfortran.py

  - Fixed dependency detection for non-intent(in|inout|inplace) arguments.
    They must depend on their dimensions, not vice-versa.
  - Don't match ``!!f2py`` as a start of f2py directive.
  - Only effective intent attributes will be output to ``-h`` target.
  - Introduced ``intent(callback)`` to build interface between Python
    functions and Fortran external routines.
  - Avoid including external arguments to __user__ modules.
  - Initial hooks to evaluate ``kind`` and ``selected_int_kind``.
  - Evaluating parameters in {char,kind}selectors and applying rmbadname.
  - Evaluating parameters using also module parameters. Fixed the order
    of parameter evaluation.
  - Fixed silly bug: when block name was not lower cased, it was not
    recognized correctly.
  - Applying mapping '.false.'->'False', '.true.'->'True' to logical
    parameters. TODO: Support for logical expressions is needed.
  - Added support for multiple statements in one line (separated with semicolon).
  - Impl. get_useparameters function for using parameter values from
    other f90 modules.
  - Applied Bertholds patch to fix bug in evaluating expressions 
    like ``1.d0/dvar``.
  - Fixed bug in reading string parameters.
  - Evaluating parameters in charselector. Code cleanup.
  - Using F90 module parameters to resolve kindselectors.
  - Made the evaluation of module data init-expression more robust.
  - Support for ``entry`` statement.
  - Fixed ``determineexprtype`` that in the case of parameters 
    returned non-dictionary objects.
  - Use ``-*- fix -*-`` to specify that a file is in fixed format.

Release 2.39.235_1693
=====================

* fortranobject.{h,c}

  - Support for allocatable string arrays.

* cfuncs.py

  - Call-back arguments can now be also instances that have ``__call__`` method
    as well as instance methods.

* f2py2e.py

  - Introduced ``--include_paths <path1>:<path2>:..`` command line
    option.
  - Added ``--compiler=`` support to change the C/C++ compiler from
    f2py command line.

* capi_maps.py

  - Handle ``XDY`` parameter constants.

* crackfortran.py

  - Handle ``XDY`` parameter constants.

  - Introduced formatpattern to workaround a corner case where reserved 
    keywords are used in format statement. Other than that, format pattern
    has no use.

  - Parameters are now fully evaluated.

* More splitting of documentation strings.

* func2subr.py - fixed bug for function names that f77 compiler
  would set ``integer`` type.

Release 2.39.235_1660
=====================

* f2py2e.py

  - Fixed bug in using --f90flags=..

* f90mod_rules.py

  - Splitted generated documentation strings (to avoid MSVC issue when
    string length>2k)

  - Ignore ``private`` module data.

Release 2.39.235_1644
=====================

:Date:24 February 2004

* Character arrays:

  - Finished complete support for character arrays and arrays of strings.
  - ``character*n a(m)`` is treated like ``character a(m,n)`` with ``intent(c)``.
  - Character arrays are now considered as ordinary arrays (not as arrays
    of strings which actually didn't work).

* docs

  - Initial f2py manpage file f2py.1.
  - Updated usersguide and other docs when using numpy_distutils 0.2.2
    and up.

* capi_maps.py

  - Try harder to use .f2py_f2cmap mappings when kind is used.

* crackfortran.py

  - Included files are first search in the current directory and
    then from the source file directory.
  - Ignoring dimension and character selector changes.
  - Fixed bug in Fortran 90 comments of fixed format.
  - Warn when .pyf signatures contain undefined symbols.
  - Better detection of source code formats. Using ``-*- fortran -*-``
    or ``-*- f90 -*-`` in the first line of a Fortran source file is 
    recommended to help f2py detect the format, fixed or free,
    respectively, correctly.

* cfuncs.py

  - Fixed intent(inout) scalars when typecode=='l'.
  - Fixed intent(inout) scalars when not using numarray.
  - Fixed intent(inout) scalars when using numarray.

* diagnose.py

  - Updated for numpy_distutils 0.2.2 and up.
  - Added numarray support to diagnose.

* fortranobject.c

  - Fixed nasty bug with intent(in,copy) complex slice arrays.
  - Applied Todd's patch to support numarray's byteswapped or
    misaligned arrays, requires numarray-0.8 or higher.

* f2py2e.py

  - Applying new hooks for numpy_distutils 0.2.2 and up, keeping
    backward compatibility with depreciation messages.
  - Using always os.system on non-posix platforms in f2py2e.compile
    function.

* rules.py

  - Changed the order of buildcallback and usercode junks.

* setup.cfg

  - Added so that docs/ and tests/ directories are included to RPMs.

* setup.py

  - Installing f2py.py instead of f2py.bat under NT.   
  - Introduced ``--with-numpy_distutils`` that is useful when making
    f2py tar-ball with numpy_distutils included.

Release 2.37.233-1545
=====================

:Date: 11 September 2003

* rules.py

  - Introduced ``interface_usercode`` replacement. When ``usercode``
    statement is used inside the first interface block, its contents
    will be inserted at the end of initialization function of a F2PY
    generated extension module (feature request: Berthold Höllmann).
  - Introduced auxiliary function ``as_column_major_storage`` that
    converts input array to an array with column major storage order
    (feature request: Hans Petter Langtangen).

* crackfortran.py

  - Introduced ``pymethoddef`` statement.

* cfuncs.py

  - Fixed "#ifdef in #define TRYPYARRAYTEMPLATE" bug (patch thanks
    to Bernhard Gschaider)

* auxfuncs.py

  - Introduced ``getpymethod`` function.
  - Enabled multi-line blocks in ``callprotoargument`` statement.

* f90mod_rules.py

  - Undone "Fixed Warning 43 emitted by Intel Fortran compiler" that
    causes (curios) segfaults.

* fortranobject.c

  - Fixed segfaults (that were introduced with recent memory leak
    fixes) when using allocatable arrays.
  - Introduced F2PY_REPORT_ON_ARRAY_COPY CPP macro int-variable. If defined 
    then a message is printed to stderr whenever a copy of an array is
    made and arrays size is larger than F2PY_REPORT_ON_ARRAY_COPY.

Release 2.35.229-1505
=====================

:Date: 5 August 2003

* General

  - Introduced ``usercode`` statement (dropped ``c_code`` hooks).

* setup.py

  - Updated the CVS location of numpy_distutils.

* auxfuncs.py

  - Introduced ``isint1array(var)`` for fixing ``integer*1 intent(out)``
    support.

* tests/f77/callback.py

  Introduced some basic tests.

* src/fortranobject.{c,h}

  - Fixed memory leaks when getting/setting allocatable arrays.
    (Bug report by Bernhard Gschaider)

  - Initial support for numarray (Todd Miller's patch). Use -DNUMARRAY
    on the f2py command line to enable numarray support. Note that
    there is no character arrays support and these hooks are not
    tested with F90 compilers yet.

* cfuncs.py

  - Fixed reference counting bug that appeared when constructing extra
    argument list to callback functions.
  - Added ``PyArray_LONG != PyArray_INT`` test.

* f2py2e.py

  Undocumented ``--f90compiler``.

* crackfortran.py

  - Introduced ``usercode`` statement.
  - Fixed newlines when outputting multi-line blocks.
  - Optimized ``getlincoef`` loop and ``analyzevars`` for cases where
    len(vars) is large.
  - Fixed callback string argument detection.
  - Fixed evaluating expressions: only int|float expressions are
    evaluated succesfully.

* docs

  Documented -DF2PY_REPORT_ATEXIT feature.

* diagnose.py

  Added CPU information and sys.prefix printout.

* tests/run_all.py

  Added cwd to PYTHONPATH.

* tests/f??/return_{real,complex}.py

  Pass "infinity" check in SunOS.

* rules.py

  - Fixed ``integer*1 intent(out)`` support
  - Fixed free format continuation of f2py generated F90 files.

* tests/mixed/

  Introduced tests for mixing Fortran 77, Fortran 90 fixed and free
  format codes in one module.

* f90mod_rules.py

  - Fixed non-prototype warnings.
  - Fixed Warning 43 emitted by Intel Fortran compiler.
  - Avoid long lines in Fortran codes to reduce possible problems with
    continuations of lines.

Public Release 2.32.225-1419
============================

:Date: 8 December 2002

* docs/usersguide/

  Complete revision of F2PY Users Guide  

* tests/run_all.py

  - New file. A Python script to run all f2py unit tests.

* Removed files: buildmakefile.py, buildsetup.py.

* tests/f77/

  - Added intent(out) scalar tests.

* f2py_testing.py

  - Introduced. It contains jiffies, memusage, run, cmdline functions
    useful for f2py unit tests site.

* setup.py

  - Install numpy_distutils only if it is missing or is too old
    for f2py.

* f90modrules.py

  - Fixed wrapping f90 module data.
  - Fixed wrapping f90 module subroutines.
  - Fixed f90 compiler warnings for wrapped functions by using interface
    instead of external stmt for functions.

* tests/f90/

  - Introduced return_*.py tests.

* func2subr.py

  - Added optional signature argument to createfuncwrapper.
  - In f2pywrappers routines, declare external, scalar, remaining
    arguments in that order. Fixes compiler error 'Invalid declaration'
    for::

      real function foo(a,b)
      integer b
      real a(b)
      end

* crackfortran.py

  - Removed first-line comment information support.
  - Introduced multiline block. Currently usable only for
    ``callstatement`` statement.
  - Improved array length calculation in getarrlen(..).
  - "From sky" program group is created only if ``groupcounter<1``. 
    See TODO.txt. 
  - Added support for ``dimension(n:*)``, ``dimension(*:n)``. They are
    treated as ``dimesnion(*)`` by f2py.
  - Fixed parameter substitution (this fixes TODO item by Patrick
    LeGresley, 22 Aug 2001).

* f2py2e.py

  - Disabled all makefile, setup, manifest file generation hooks.
  - Disabled --[no]-external-modroutines option. All F90 module
    subroutines will have Fortran/C interface hooks.
  - --build-dir can be used with -c option.
  - only/skip modes can be used with -c option.
  - Fixed and documented `-h stdout` feature.
  - Documented extra options.
  - Introduced --quiet and --verbose flags.

* cb_rules.py

  - Fixed debugcapi hooks for intent(c) scalar call-back arguments
    (bug report: Pierre Schnizer).
  - Fixed intent(c) for scalar call-back arguments.
  - Improved failure reports.

* capi_maps.py

  - Fixed complex(kind=..) to C type mapping bug. The following hold
    complex==complex(kind=4)==complex*8, complex(kind=8)==complex*16
  - Using signed_char for integer*1 (bug report: Steve M. Robbins).
  - Fixed logical*8 function bug: changed its C correspondence to
    long_long.
  - Fixed memory leak when returning complex scalar.

* __init__.py

  - Introduced a new function (for f2py test site, but could be useful
    in general) ``compile(source[,modulename,extra_args])`` for
    compiling fortran source codes directly from Python.

* src/fortranobject.c

  - Multi-dimensional common block members and allocatable arrays 
    are returned as Fortran-contiguous arrays.
  - Fixed NULL return to Python without exception.
  - Fixed memory leak in getattr(<fortranobj>,'__doc__').
  - <fortranobj>.__doc__ is saved to <fortranobj>.__dict__ (previously
    it was generated each time when requested).
  - Fixed a nasty typo from the previous item that caused data
    corruption and occasional SEGFAULTs.
  - array_from_pyobj accepts arbitrary rank arrays if the last dimension
    is undefined. E.g. dimension(3,*) accepts a(3,4,5) and the result is
    array with dimension(3,20).
  - Fixed (void*) casts to make g++ happy (bug report: eric).
  - Changed the interface of ARR_IS_NULL macro to avoid "``NULL used in
    arithmetics``" warnings from g++.

* src/fortranobject.h

  - Undone previous item. Defining NO_IMPORT_ARRAY for
    src/fortranobject.c (bug report: travis)
  - Ensured that PY_ARRAY_UNIQUE_SYMBOL is defined only for
    src/fortranobject.c (bug report: eric).

* rules.py

  - Introduced dummy routine feature.
  - F77 and F90 wrapper subroutines (if any) as saved to different
    files, <modulename>-f2pywrappers.f and <modulename>-f2pywrappers2.f90,
    respectively. Therefore, wrapping F90 requires numpy_distutils >= 
    0.2.0_alpha_2.229.
  - Fixed compiler warnings about meaningless ``const void (*f2py_func)(..)``.
  - Improved error messages for ``*_from_pyobj``.
  - Changed __CPLUSPLUS__ macros to __cplusplus (bug report: eric).
  - Changed (void*) casts to (f2py_init_func) (bug report: eric).
  - Removed unnecessary (void*) cast for f2py_has_column_major_storage
    in f2py_module_methods definition (bug report: eric).
  - Changed the interface of f2py_has_column_major_storage function:
    removed const from the 1st argument.

* cfuncs.py

  - Introduced -DPREPEND_FORTRAN.
  - Fixed bus error on SGI by using PyFloat_AsDouble when ``__sgi`` is defined.
    This seems to be `know bug`__ with Python 2.1 and SGI.
  - string_from_pyobj accepts only arrays whos elements size==sizeof(char).
  - logical scalars (intent(in),function) are normalized to 0 or 1.
  - Removed NUMFROMARROBJ macro.
  - (char|short)_from_pyobj now use int_from_pyobj.
  - (float|long_double)_from_pyobj now use double_from_pyobj.
  - complex_(float|long_double)_from_pyobj now use complex_double_from_pyobj.
  - Rewrote ``*_from_pyobj`` to be more robust. This fixes segfaults if
    getting * from a string. Note that int_from_pyobj differs 
    from PyNumber_Int in that it accepts also complex arguments 
    (takes the real part) and sequences (takes the 1st element). 
  - Removed unnecessary void* casts in NUMFROMARROBJ.
  - Fixed casts in ``*_from_pyobj`` functions.
  - Replaced CNUMFROMARROBJ with NUMFROMARROBJ.

.. __: http://sourceforge.net/tracker/index.php?func=detail&aid=435026&group_id=5470&atid=105470

* auxfuncs.py

  - Introduced isdummyroutine().
  - Fixed islong_* functions.
  - Fixed isintent_in for intent(c) arguments (bug report: Pierre Schnizer).
  - Introduced F2PYError and throw_error. Using throw_error, f2py 
    rejects illegal .pyf file constructs that otherwise would cause
    compilation failures or python crashes.
  - Fixed islong_long(logical*8)->True.
  - Introduced islogical() and islogicalfunction().
  - Fixed prototype string argument (bug report: eric).

* Updated README.txt and doc strings. Starting to use docutils.

* Speed up for ``*_from_pyobj`` functions if obj is a sequence.

* Fixed SegFault (reported by M.Braun) due to invalid ``Py_DECREF`` 
  in ``GETSCALARFROMPYTUPLE``.

Older Releases
==============

::

 *** Fixed missing includes when wrapping F90 module data.
 *** Fixed typos in docs of build_flib options.
 *** Implemented prototype calculator if no callstatement or
    callprotoargument statements are used. A warning is issued if
    callstatement is used without callprotoargument.
 *** Fixed transposing issue with array arguments in callback functions.
 *** Removed -pyinc command line option.
 *** Complete tests for Fortran 77 functions returning scalars.
 *** Fixed returning character bug if --no-wrap-functions.
 *** Described how to wrap F compiled Fortran F90 module procedures
    with F2PY. See doc/using_F_compiler.txt.
 *** Fixed the order of build_flib options when using --fcompiler=...
 *** Recognize .f95 and .F95 files as Fortran sources with free format.
 *** Cleaned up the output of 'f2py -h': removed obsolete items,
    added build_flib options section. 
 *** Added --help-compiler option: it lists available Fortran compilers
    as detected by numpy_distutils/command/build_flib.py. This option
    is available only with -c option.


:Release: 2.13.175-1250
:Date: 4 April 2002

::

 *** Fixed copying of non-contigious 1-dimensional arrays bug. 
    (Thanks to Travis O.).


:Release: 2.13.175-1242
:Date: 26 March 2002

::

 *** Fixed ignoring type declarations.
 *** Turned F2PY_REPORT_ATEXIT off by default.
 *** Made MAX,MIN macros available by default so that they can be
    always used in signature files. 
 *** Disabled F2PY_REPORT_ATEXIT for FreeBSD.


:Release: 2.13.175-1233
:Date: 13 March 2002

::

 *** Fixed Win32 port when using f2py.bat. (Thanks to Erik Wilsher).
 *** F2PY_REPORT_ATEXIT is disabled for MACs.
 *** Fixed incomplete dependency calculator.


:Release: 2.13.175-1222
:Date: 3 March 2002

::

 *** Plugged a memory leak for intent(out) arrays with overwrite=0.
 *** Introduced CDOUBLE_to_CDOUBLE,.. functions for copy_ND_array.
    These cast functions probably work incorrectly in Numeric.


:Release: 2.13.175-1212
:Date: 23 February 2002

::

 *** Updated f2py for the latest numpy_distutils.
 *** A nasty bug with multi-dimensional Fortran arrays is fixed
    (intent(out) arrays had wrong shapes). (Thanks to Eric for 
    pointing out this bug).
 *** F2PY_REPORT_ATEXIT is disabled by default for __WIN32__.


:Release: 2.11.174-1161
:Date: 14 February 2002

::

 *** Updated f2py for the latest numpy_distutils.
 *** Fixed raise error when f2py missed -m flag.
 *** Script name `f2py' now depends on the name of python executable.
    For example, `python2.2 setup.py install' will create a f2py
    script with a name `f2py2.2'.
 *** Introduced 'callprotoargument' statement so that proper prototypes
    can be declared. This is crucial when wrapping C functions as it
    will fix segmentation faults when these wrappers use non-pointer
    arguments (thanks to R. Clint Whaley for explaining this to me). 
    Note that in f2py generated wrapper, the prototypes have
    the following forms: 
       extern #rtype# #fortranname#(#callprotoargument#);
    or
       extern #rtype# F_FUNC(#fortranname#,#FORTRANNAME#)(#callprotoargument#);
 *** Cosmetic fixes to F2PY_REPORT_ATEXIT feature.


:Release: 2.11.174-1146
:Date: 3 February 2002

::

 *** Reviewed reference counting in call-back mechanism. Fixed few bugs.
 *** Enabled callstatement for complex functions.
 *** Fixed bug with initializing capi_overwrite_<varname>
 *** Introduced intent(overwrite) that is similar to intent(copy) but
    has opposite effect. Renamed copy_<name>=1 to overwrite_<name>=0.
    intent(overwrite) will make default overwrite_<name>=1.
 *** Introduced intent(in|inout,out,out=<name>) attribute that renames
    arguments name when returned. This renaming has effect only in
    documentation strings. 
 *** Introduced 'callstatement' statement to pyf file syntax. With this
    one can specify explicitly how wrapped function should be called
    from the f2py generated module. WARNING: this is a dangerous feature
    and should be used with care. It is introduced to provide a hack
    to construct wrappers that may have very different signature
    pattern from the wrapped function. Currently 'callstatement' can
    be used only inside a subroutine or function block (it should be enough
    though) and must be only in one continuous line. The syntax of the
    statement is:    callstatement <C-expression>;
    

:Release: 2.11.174
:Date: 18 January 2002

::

 *** Fixed memory-leak for PyFortranObject.
 *** Introduced extra keyword argument copy_<varname> for intent(copy)
    variables. It defaults to 1 and forces to make a copy for
    intent(in) variables when passing on to wrapped functions (in case
    they undesirably change the variable in-situ). 
 *** Introduced has_column_major_storage member function for all f2py
    generated extension modules. It is equivalent to Python call
    'transpose(obj).iscontiguous()' but very efficient.
 *** Introduced -DF2PY_REPORT_ATEXIT. If this is used when compiling,
    a report is printed to stderr as python exits. The report includes
    the following timings: 
    1) time spent in all wrapped function calls; 
    2) time spent in f2py generated interface around the wrapped
    functions. This gives a hint whether one should worry
    about storing data in proper order (C or Fortran).
    3) time spent in Python functions called by wrapped functions
    through call-back interface.
    4) time spent in f2py generated call-back interface.
    For now, -DF2PY_REPORT_ATEXIT is enabled by default. Use 
    -DF2PY_REPORT_ATEXIT_DISABLE to disable it (I am not sure if
    Windows has needed tools, let me know). 
    Also, I appreciate if you could send me the output of 'F2PY
    performance report' (with CPU and platform information) so that I
    could optimize f2py generated interfaces for future releases.
 *** Extension modules can be linked with dmalloc library. Use
    -DDMALLOC when compiling.
 *** Moved array_from_pyobj to fortranobject.c.
 *** Usage of intent(inout) arguments is made more strict -- only
    with proper type contiguous arrays are accepted. In general,
    you should avoid using intent(inout) attribute as it makes
    wrappers of C and Fortran functions asymmetric. I recommend using
    intent(in,out) instead.
 *** intent(..) has new keywords: copy,cache.
    intent(copy,in) - forces a copy of an input argument; this
      may be useful for cases where the wrapped function changes
      the argument in situ and this may not be desired side effect.
      Otherwise, it is safe to not use intent(copy) for the sake
      of a better performance. 
    intent(cache,hide|optional) - just creates a junk of memory. 
      It does not care about proper storage order. Can be also
      intent(in) but then the corresponding argument must be a
      contiguous array with a proper elsize.
 *** intent(c) can be used also for subroutine names so that
    -DNO_APPEND_FORTRAN can be avoided for C functions.

 *** IMPORTANT BREAKING GOOD ... NEWS!!!: 

    From now on you don't have to worry about the proper storage order
    in multi-dimensional arrays that was earlier a real headache when
    wrapping Fortran functions. Now f2py generated modules take care
    of the proper conversations when needed. I have carefully designed
    and optimized this interface to avoid any unnecessary memory usage
    or copying of data. However, it is wise to use input arrays that
    has proper storage order: for C arguments it is row-major and for
    Fortran arguments it is column-major. But you don't need to worry
    about that when developing your programs. The optimization of
    initializing the program with proper data for possibly better
    memory usage can be safely postponed until the program is working.

    This change also affects the signatures in .pyf files. If you have
    created wrappers that take multi-dimensional arrays in arguments,
    it is better to let f2py re-generate these files. Or you have to
    manually do the following changes: reverse the axes indices in all
    'shape' macros. For example, if you have defined an array A(n,m)
    and n=shape(A,1), m=shape(A,0) then you must change the last
    statements to n=shape(A,0), m=shape(A,1).


:Release: 2.8.172
:Date: 13 January 2002

::

 *** Fixed -c process. Removed pyf_extensions function and pyf_file class.
 *** Reorganized setup.py. It generates f2py or f2py.bat scripts
    depending on the OS and the location of the python executable.
 *** Started to use update_version from numpy_distutils that makes
    f2py startup faster. As a side effect, the version number system
    changed.
 *** Introduced test-site/test_f2py2e.py script that runs all
    tests.
 *** Fixed global variables initialization problem in crackfortran 
    when run_main is called several times.
 *** Added 'import Numeric' to C/API init<module> function.
 *** Fixed f2py.bat in setup.py.
 *** Switched over to numpy_distutils and dropped fortran_support.
 *** On Windows create f2py.bat file.
 *** Introduced -c option: read fortran or pyf files, construct extension
    modules, build, and save them to current directory. 
    In one word: do-it-all-in-one-call.
 *** Introduced pyf_extensions(sources,f2py_opts) function. It simplifies
    the extension building process considerably. Only for internal use.
 *** Converted tests to use numpy_distutils in order to improve portability:
    a,b,c
 *** f2py2e.run_main() returns a pyf_file class instance containing
    information about f2py generated files.
 *** Introduced `--build-dir <dirname>' command line option.
 *** Fixed setup.py for bdist_rpm command.
 *** Added --numpy-setup command line option.
 *** Fixed crackfortran that did not recognized capitalized type
    specification with --no-lower flag.
 *** `-h stdout' writes signature to stdout.
 *** Fixed incorrect message for check() with empty name list.


:Release: 2.4.366
:Date: 17 December 2001

::

 *** Added command line option --[no-]manifest.
 *** `make test' should run on Windows, but the results are not truthful.
 *** Reorganized f2py2e.py a bit. Introduced run_main(comline_list) function
    that can be useful when running f2py from another Python module.
 *** Removed command line options -f77,-fix,-f90 as the file format
    is determined from the extension of the fortran file
    or from its header (first line starting with `!%' and containing keywords
    free, fix, or f77). The later overrides the former one.
 *** Introduced command line options --[no-]makefile,--[no-]latex-doc.
    Users must explicitly use --makefile,--latex-doc if Makefile-<modulename>,
    <modulename>module.tex is desired. --setup is default. Use --no-setup
    to disable setup_<modulename>.py generation. --overwrite-makefile
    will set --makefile.
 *** Added `f2py_rout_' to #capiname# in rules.py.
 *** intent(...) statement with empty namelist forces intent(...) attribute for
    all arguments.
 *** Dropped DL_IMPORT and DL_EXPORT in fortranobject.h.
 *** Added missing PyFortran_Type.ob_type initialization.
 *** Added gcc-3.0 support.
 *** Raising non-existing/broken Numeric as a FatalError exception.
 *** Fixed Python 2.x specific += construct in fortran_support.py.
 *** Fixed copy_ND_array for 1-rank arrays that used to call calloc(0,..)
    and caused core dump with a non-gcc compiler (Thanks to Pierre Schnizer
    for reporting this bug).
 *** Fixed "warning: variable `..' might be clobbered by `longjmp' or `vfork'":
  - Reorganized the structure of wrapper functions to get rid of 
    `goto capi_fail' statements that caused the above warning.


:Release: 2.3.343
:Date: 12 December 2001

::

 *** Issues with the Win32 support (thanks to Eric Jones and Tiffany Kamm):
  -  Using DL_EXPORT macro for init#modulename#.
  -  Changed PyObject_HEAD_INIT(&PyType_Type) to PyObject_HEAD_INIT(0).
  -  Initializing #name#_capi=NULL instead of Py_None in cb hooks.
 *** Fixed some 'warning: function declaration isn't a prototype', mainly
    in fortranobject.{c,h}.
 *** Fixed 'warning: missing braces around initializer'.
 *** Fixed reading a line containing only a label.
 *** Fixed nonportable 'cp -fv' to shutil.copy in f2py2e.py.
 *** Replaced PyEval_CallObject with PyObject_CallObject in cb_rules.
 *** Replaced Py_DECREF with Py_XDECREF when freeing hidden arguments.
    (Reason: Py_DECREF caused segfault when an error was raised)
 *** Impl. support for `include "file"' (in addition to `include 'file'')
 *** Fixed bugs (buildsetup.py missing in Makefile, in generated MANIFEST.in)


:Release: 2.3.327
:Date: 4 December 2001

::

 *** Sending out the third public release of f2py.
 *** Support for Intel(R) Fortran Compiler (thanks to Patrick LeGresley).
 *** Introduced `threadsafe' statement to pyf-files (or to be used with
    the 'f2py' directive in fortran codes) to force
    Py_BEGIN|END_ALLOW_THREADS block around the Fortran subroutine
    calling statement in Python C/API. `threadsafe' statement has
    an effect only inside a subroutine block.
 *** Introduced `fortranname <name>' statement to be used only within
    pyf-files. This is useful when the wrapper (Python C/API) function
    has different name from the wrapped (Fortran) function.
 *** Introduced `intent(c)' directive and statement. It is useful when
    wrapping C functions. Use intent(c) for arguments that are
    scalars (not pointers) or arrays (with row-ordering of elements).


:Release: 2.3.321
:Date: 3 December 2001

::

 *** f2py2e can be installed using distutils (run `python setup.py install').
 *** f2py builds setup_<modulename>.py. Use --[no-]setup to control this
    feature. setup_<modulename>.py uses fortran_support module (from SciPy),
    but for your convenience it is included also with f2py as an additional
    package. Note that it has not as many compilers supported as with
    using Makefile-<modulename>, but new compilers should be added to 
    fortran_support module, not to f2py2e package.
 *** Fixed some compiler warnings about else statements.

