***** Version 1.7.3 *****
**** Notes: ****
**** BlockIt: ****
**** PyF95++: ****
* In RBTree, changed "clear" to "clearTree" to avoid interface clashes
between subroutines and functions. "clear" is now a function and
"clearTree" is the subroutine version. This is compatible with GFortran
4.7.
* Minor modifications to some routines in String and other places for Cray
ftn compiler. It caught several things GFortran did not.
* BUG FIX: Fixed an issue which caused segfaults in IFort and Cray when
using the "pop" method for DLList.
***** Version 1.7.2 *****
**** Notes: ****
**** BlockIt: ****
* BUG FIX: You will no longer be tar-bombed when you download the release
tarball from the web. All of the files are now contained in a "BlockIt"
directory. We apologize for any cycles wasted trying to clean up
directories.
**** PyF95++: ****
* Changed several arguments and internal data members for STL classes to
not be words meaningful to Fortran. Some parsers have started to become
confused by the poor decisions made on variable names.
***** Version 1.7.1 *****
**** Notes: ****
**** BlockIt: ****
* Added some improved error messages.
**** PyF95++: ****
* Added the -i or --std flag to force the inclusion of the directory stored
in PyF95_SRC_DIR and PyF95_TEMPLATE_DIR. This makes it easier for users
to quickly get started.
***** Version 1.7.0 *****
**** Notes: ****
* Change the license to GPL V2.
**** BlockIt: ****
* Fixed blockit.parsers.BlockParser to maintain the original code that has
line continuations. It previously concatenated the lines into one line.
Now it maintains the original formatting. The side effect is now cpp
macros no longer may have continuation characters in them.
* Fixed bug in name mangling strategy of blockit/Fortran/blocks/
FortranBlock.mangle() method. It would still allow names longer than max
length.
**** PyF95++: ****
* BUG FIX: Fixed bug in PyF95++ in the resolveFileName() function. Not sure
if it is a bug in the behavior of os.path.commonprefix() function, but
given:
os.path.commonprefix( ['/foo/bar/', '/foo/boob/' ] )
will return '/foo/b'. So it is not matching only directories, but simply
both path strings. Placed a patch that checks if the returned string is a
directory. If not, then it truncates the string to the first
os.path.linsep from the right.
* BUG FIX: Major bug fix in class_Pair comparison operators.
* Merged the class_DLListEntry into the class_DLList module since there is
no reason to have the two separate files.
* Added some doxygen comments to class_Buffer.
* Remove class_HashEntry from the templates since it is not used.
* BUG FIX: Mem leak bug fix in class_RBTree when storing reference counted
objects. Forgot to call delete on the internal buffer storage for
class_RBTreeNode objects.
* Finished the comparison operators for class_AList. They now truly compare
two ALists just like class_String, element by element as long as the
objects are comparable. Added simple unit test to check it.
* BUG FIX: Fixed bug in class_Plot3D.F90T. Forgot to make certain methods
and types public.
* BUG FIX: Fixed a bug in the string split method in the StringManip module
in the Functions addon. When presented with a string that had a single
character as the last chunk the split would fail to include said chunk.
Thus "1 x y" would return a list of length 2, with components ("1", "x").
* Added an overridden "=" operator for String class so that a user can set
a Fortran character string to be equal to a String object (i.e. the data
is copied into the Fortran character string).
character(len=64) :: myfstring
type (String) :: str
type (BaseError) :: err
err = init(str, " Quite a mighty fine string you've got there, Sally.")
myfstring = str
* Started documenting the template code base with Doxygen, http://
www.doxygen.org.
* Remove class_DLListEntry from the templates and merged it into the
class_DLList templated modules. Not sure why I separated them in the
first place.
* Removed the class_HashEntry template module since it was not used.
* Default template parameters occurring at the end of a the template
parameter specification no longer have to specified with a * in an
instantiation. For example, a template like:
template <class __OBJECT__, class __OPTIONAL__=integer>
type :: Foo
__OBJECT__ :: a
__OPTIONAL__ :: b
end type
end template
can have a template instantiation for Foo of:
type (Foo<real>) :: foo_1
type (Foo<real,*>) :: foo_2
type (Foo<real,integer>) :: foo_3
which are all equivalent. With this capability, an optional
__COMPARABLE__ parameter was added to the AList and DLList template which
specializes the mergeSort() procedure for types that have the overrided
<,> operators.
* Changed the name of the internal pointer for refcounted types from 'data'
to 'shared' since 'data' is a Fortran keyword. The word 'shared' is also
more apparent and intuitive. This effects the PyF95++ macros as well, so
users who use those macros will want to make the appropriate small change
to their code. The only change needed is to define PYF95_REF_NAME
preprocessor directive to the name of the reference counted pointer name.
For example,
#define PYF95_REF_NAME data
would assign data as the name of the internal pointer name for reference
counted type:
type :: Foo
type (Foo_), pointer :: data => null()
end type
The default value for PYF95_REF_NAME is shared.
***** Version 1.6.0 *****
**** Notes: ****
**** BlockIt: ****
* BUG FIX: Fix blockit.parsers.BlockParser was missing a colon for a slice
operation on a string. This was a particular problem when parsing Fortran
code that had continuation characters at the end of lines. It would
improperly parse cpp macros like:
#if define __FOO && __BAR
do something
#endif
It resulted in the #if define being parsed as a Fortran continuation due
to the ampersands.
* BUG FIX: Fix blockit.Fortran.blocks.Interface for operators and
assignments.
* BUG FIX: Fix bug in blockit.Fortran.blocks.Interface grammar. It would
incorrectly find matches in the middle of strings.
* Added capability to specify templated interface in
blockit.Fortran.blocks. For example:
interface foo<integer>
module procedure fooWithChar<integer>
module procedure fooWithString<integer>
end interface
This is useful when the template procedures have the same type signatures
so you must give them separate names, but you can wrap them with a
templated interface name.
* Added new capability to specify templated module procedure statements in
an interface block. This should alleviate the need for an Instantiate
block in mixed modules, i.e. modules that aren't templated but contain
templated procedures. You simply specifiy the templated procedures in an
interface block and they should be instantiated:
interface foo
module procedure foo<integer>
module procedure foo<real>
end interface
Note also, this removes the need for the as clause since you are
explicitly declaring the procedure in the interface. This has a more
native feel to the templating and does not require special blocks like
AutoInterface to be used. It also allows you to have the interface
explicitly declared at the top of the module which aids in code clarity.
* Simplified internal SHOW_GRAMMARS of the
blockit.Fortran.blocks.FortranBlock class and changed the __mangleShow()
method accordingly. The new grammar should now allow lines with multiple
template signatures to be specified in Fortran. Things like:
use class_AList<integer>, only : AList<integer>
will be properly mangled. Before, the grammar was using the template
function, subroutine, etc... grammars, but now it is a simple search for
template tokens and performs the mangling. This also allows the
specification of template tokens in interface declarations so the user
does not have to use the 'as' clause and AutoInterface block. So,
declarations like:
interface init
module procedure Buffer_init<integer>
end interface
will be properly mangled.
Fixed AutoUse block in blockit.Fortran.blocks to allow templated use
declarations. So, specifications can look like:
AutoUse
use class_DLListEntry<integer>
use class_HashTable<String,integer,*>
use class_Pair<String,integer>
use class_Exception
end AutoUse
can be specified and the AutoUse block will correctly mangle and not add an
extra use declaration for the templated use declarations.
**** PyF95++: ****
* Added c_ptr comparison operations and destructor to the Parameters.F90
module. This was necessary since a c_ptr is an intrinsic type in F2003,
but it is declared as type (c_ptr). It also needs to have comparison ops
to be compatible with the STL lists.
* Added macros to PyF95_init.inc and PyF95_delete.inc to support
polymorphic types that are extension of reference counted types. The
macro defines are __POLYTYPE and __TYPE_BOUND. The __POLYTYPE defines the
type to allocate the internal data pointer to in a refcounted type. The
__TYPE_BOUND is to be used when a polymorphic refcounted type has the
destructor as a type bound procedure. This is preparing the STL for
migration to F2003.
* Improved functionality of PyF95_MakeDepend, specifically adding the
capability to recursively parse include dependencies and find extended
dependencies when the first level of dependencies is not compiled.
* Updated StringManip module join to create a single buffer then fill it.
* Improvement to class_Buffer. Added the ability for one buffer to share
just as segment of another buffer, but be it's own unique entity.
* Added more demo pieces to the parallel component unit-testing.
* Added toArray() subroutine to both DLList and AList. This converts the
list to a vector containing the objects. Unit tests written to test this
functionality with a RefObject. All passed.
* Changed the way the Dictionary handles internal errors. Instead of
catching and stopping, they are passed up to the caller. The only
exception is the iterate() procedure since it returns a boolean. The
error handling interface needs to be revamped for the STL.
* Made readHeader() and writeHeader() procedures for class_Plot3DFile
public.
***** Version 1.5.3-2 *****
**** Notes: ****
**** BlockIt: ****
**** PyF95++: ****
* BUG FIX: Fixed bug in String comparison. The logic was never finished
properly. Added unit test for lexigraphical sorting of a list of strings
as a test.
***** Version 1.5.3-1 *****
**** Notes: ****
**** BlockIt: ****
**** PyF95++: ****
* BUG FIX: Fixed bug in class_AList pop(...) function. Used array slice
notation to move elements, but this is not correct for reference counted
types since the overrided assignment(=) operator is by-passed and the
reference counting mechanism fails.
* Added untested append(...) subroutine to class_AList.
***** Version 1.5.3 *****
**** Notes: ****
**** BlockIt: ****
**** PyF95++: ****
* BUG FIX: Fixed bug in Red/Black tree node type (class_RBTreeNode). The
delete(...) function was not calling delete(...) on the item it was
holding, resulting in a mem-leak on reference counted types.
* BUG FIX: Fixed bug in the Buffer class (class_Buffer) changeShape(...)
function. It did not deallocate/reallocate the extents type, i.e. ext(:),
resulting in a bounds check error.
* Changed the comparison functions for Pairs (class_Pair). The comparators
now check that both elements of the pair satisfy the comparison.
* Added the operator(==) for the STL types. This comparison is simply a
performs the same reference check as operator(.is.).
* Added the check-bounds flag to the unit test Makefile
* Modified PyF95_MakeDepend to use "." for the relative path name rather
than "". This allows users to --exclude-dir=. and keep it from running
amok in the full directory tree. Also added -n,--name option so that a
name can be specified for the output.
* Added UnitTest reference counting to ensure that refCounted members are
not lost when people do unexpected things....
* Added UnitTest capability to call setUp and tearDown at the module level.
This is done before any tests: 'call setUp("__MOD__")' and after all
tests: 'call tearDown("__MOD__")'. This can be ignored by most users.
* Converted Option and OptionParser classes to be reference counted. The
API has remained the same. Fixed a memleak associated with a scoping
issue.
* Added additional OptionParser capability and fixed a few memory leaks.
Count, Append, and Append_const now exist. Callback is mostly
implemented.
* Added StringManip module into Functions addon. Split is now a utility.
Iterate and Enumerate have been added for strings as well. String
addition has been added, though a limitation in Fortran makes it
impossible to add more than two strings at once. Join is also now a
utility.
* Added ability to create an XML report from unit-tests.
* Added ability to create an HTML report from unit-tests with optional file
header and footer so that users can insert the HTML report into a page
created by their main function for their own unit-tests.
* Added --std option to specify either 'f90', 'f95' or 'f03' as the
standard to use when creating mangled names. 'f90' and 'f95' are
equivalent in that names will be a max of 31 characters. The 'f03' option
will allow names up to 63 characters long.
* Added a prepod in class_Exception to create overrided assignments for
assigning InitError types to all other exception types. This allows
calling functions within a constructor that return BaseError types and
assigning them to InitError using the ERROR_RETURN macro.
***** Version 1.5.2 *****
**** Notes: ****
**** BlockIt: ****
**** PyF95++: ****
* Major bug fix in PyF95++ "alwayswrite" directive.
* Completed destructor for RBTree addon and added search function.
* Added pop(...) while iterating capability to DLList.
* Added more unit tests for coverage of the RBTree and DLList improvements.
***** Version 1.5.1 *****
**** Notes: ****
**** BlockIt: ****
**** PyF95++: ****
* Major bug fix in class_DLList pop(...) method. Algorithm rewrite and
unit-test coverage added.
***** Version 1.5.0 *****
**** Notes: ****
* This version represents a significant departure from the 1.4.x series of
the BlockIt/PyF95++ code base. The 1.5.x series has dropped the Library
functionality in favor of caching parsed files using the filesystem
through a new CacheManager class. To facilitate this change, all blocks
are now pickleable (serializable) directly. Currently, the block parsing
process in multithreaded with plans to have all phases multithreaded.
There are two multithreaded implementations under the hood of PyF95++.
One uses the threading module available in python 2.5 and higher. The
other uses the multiprocessing module only available in python 2.6 and
higher. You are strongly encouraged to upgrade to python 2.6 since the
multiprocessing module is the superior choice as it will facilitate the
multithreading of all phases. Also, many command line flags have been
deprecated to simplify the interface to the user.
* The make install now forces a make uinstall prior to installation.
**** BlockIt: ****
Added CacheManager class to support the new block caching strategy.
**** PyF95++: ****
Added new caching strategy with the library being deprecated. Now, local hidden
directories whose name is the the name of the file being cached are created.
For instance, if a file name class_HashTable.F90T is being cached after
parsing, a directory named .class_HashTable.F90T is created to store cached
blocks.
***** Version 1.4.4 *****
**** Notes: ****
**** BlockIt: ****
* Separated Fortran grammars into their own module in
blockit.Fortran.grammars.
**** PyF95++: ****
* DEPRECATION: Deprecated the Make.depend capability in PyF95++. Users
should now use the separate PyF95_MakeDepend after PyF95++ to generate
the Make.depend file.
* BUG FIX: Fixed the getAllLibKeys(...) function in the
blockit.Fortran.library module to not rely on the the Python 2.6 set
difference(...) method which can take two or more arguments making it it
compatible with Python 2.5.
* Changed name mangling strategy of template names. The strategy is now to
remove the last character of each template parameter that is appended
until the name fits the Fortran 31 character limit. This makes the
mangled names much more readable. The old strategy is still in the code,
but commented out.
* Modified class_UnitTest to not rely on the AutoUse block. This is to
facilitate use in different build scenarios which are being worked out.
* BUG FIX: Fixed bug in checkFileExtension(...) function in PyF95++. name
was not defined in the scope, so it is now passed in as an argument.
* BUG FIX: Fixed bug in blockit.Fortran.library.getAllLibKeys function. It
was using a Python 2.6 extension to the set difference function. Rewrote
it using Python 2.5 available methods.
* BUG FIX: Forgot to add use Parameters clause in compare function inteface
of mergeSort method for both DLList and AList.
* Modified the HashTable get(...) method as workaround to persistent ifort
compiler bug. New code is better and cleaner in the process.
* Renamed LibTool to PyF95_LibTool.
* BUG FIX: Fixed mem leak introduced in the hasKey(...) method of
class_HashTable. Forgot to delete reference count of the item variable in
the function.
* BUG FIX: Fixed bug in AutoUse block which did not check if the module it
found was the module that AutoUse was in so it would add itself.
* BUG FIX: Fixed bug in checkLib which did not exclude the MAKEDEPEND key.
* The Functions addon was modified by breaking out all the functions
defined in UFunctions.F90T into separate templated modules. Each function
now uses the as clause to hide all instantiated versions of the functions
behind a generic interface. You need to use the Instantiate block now to
force an instantiation of the function you want and then use the generic
name in your procedures. See the testOfLists unit test for an example of
the Instantiate block.
***** Version 1.4.3 *****
**** Notes: ****
* With this version, you will need to do a make uninstall prior to
installing this version. There has been some small directory changes and
such. Also, this will force the rebuild of the STL.lib.
**** BlockIt: ****
* Removed the F95 package which was replaced with the Fortran package.
**** PyF95++: ****
* Reworked blockit.Fortran.blocks module. Added new properties to blocks
and moved many of the dependency grammars out of the FortranBlock class.
Many of the additions are for storing internal type declarations found
within the block. These types are stored internally and can be accessed
via properties of the block.
* Changed the directory layout addons. For each addon there is now a src/
and templates/ directory.
* Significant changes to PyF95++ project management through the library.
The library has new functionality used to determine whether a file has
changed and needs to be re-written. This saves significant time in the
build process after the files have been processed the first time.
* BUG FIX: Fixed long standing bug concerning templated functions/
subroutines. A bug existed where a file that contains templated function/
subroutine does not always get re-written when a file that instantiates
that template changes and instantiates a new template in that file, not
part of the original write. Since the file exists on disk and the hash
has not changed (since the hash is based on the original file),
regardless of template instantiations, the file was not re-written when
it needed to be.
***** Version 1.4.2 *****
**** BlockIt ****
**** PyF95++: ****
* Modified STL HashTable to check for duplicate keys on insertion.
* Modified STL addon Plot3DFile with some code cleanup.
* Added hasKey(...) method to STL HashTable and Dictionary with some code
cleanup.
* BUG FIX: Correctly fixed the way the Buffer class operates. Recasting now
handles casting to a small size than the buffer. Also, ensures that
recasting smaller packs the data contiguously.
* Added the start of a unit test for the Buffer class.
* BUG FIX: Fixed bug in stringcompare_ method of String class. Forgot to
check for null string condition.
* BUG FIX: Fixed type grammar to handle new F2003 'select type' construct.
It was keying on the keyword 'is' in the 'type is' part of the block and
incorrectly assuming a type declaration.
* Renamed 'Error' type in class_Exception to 'BaseError' to fix name
clashes with other codes. Future 2.0 release with 2003 support will phase
out all Error types and create just one error that users can extend.
* Added String conversion to intrinsic character string procedure and unit
test.
* Added a nitems(...) procedure to the class_HashTable and class_Dictionary
STL containers to return the number of items currently stored.
* Made the HashTable and Dictionary classes iterable.
* Added a valid(...) procedure for all reference counted types in the STL
which returns a boolean on whether the type object is valid reference.
* Large speed improvement in template instantiations. Improved logic and
code cleanup was performed.
* Library upgrade now stores file hash data and the symbol table. Now, it
is used to check if files should be re-written to disk by checking the
stored hash value.
* Removal of pods module as it was incorporated into the standard blocks
module. The FortranBlockParser was changed and now the parse() method
must take a starting block. This was done to reorganize the module
dependencies more appropriately.
* A header is now written for all files that are processed by PyF95++. This
info may be used for future stand-alone tools.
***** Version 1.4.1 *****
**** BlockIt ****
**** PyF95++: ****
* Deprecating the F95 package. Created the replacement Fortran package.
* Upgraded the STL to use new template parameter nomenclature of __WORD__
and modified valid names within blockit to begin with underscores.
* Finally deprecated class_ZZ. This module was a workaround for dealing
with intrinsic data types with the templates. It is not needed because
the templated modules now use the 'intrinsicTypeCheck' pod.
* BUG FIX: Fixed mem leak bug in class_Buffer overrided assignment.
Accidentally used intent(out) for 'this' which would result in the
reference in an incorrect reference count.
* BUG FIX: Small bug fix in PyF95_equals macro. Wouldn't be apparent unless
VERBOSE was defined at compile time.
***** Version 1.4.0 *****
**** BlockIt ****
**** PyF95++: ****
* Added some more capability to LibTool to list and remove files from the
library.
* Fixed big bug in class_AList when increasing buffer size. Doing
assignment using the slice operations will not call your overrided
assignment operator. Therefore, reference counted types will not have
their ref counts incremented properly. This must be done with a loop for
the overrided assignment operator to be called.
* Added the 'ELEMENTAL' keyword for functions/subroutines to the parser.
***** Version 1.3.9 *****
**** BlockIt ****
* BUG FIX: Fixed MAJOR bug in the library functionality. Not sure when this
was bug was introduced, but it would fail to properly hash a template
even though it had changed internally. This would lead to the library
improperly finding stale instantiations when the parent file had changed.
The offending code was traced back to commit 544e570a79d1c on Dec 24,
2009. It is recommended that users of the library functionality rebuild
their libraries to be sure.
**** PyF95++: ****
* Added an INSTANTIATION macro to replace replace setup(...) call in
constructors of reference counted types. This was a work around for an
ifort compiler bug (reference issue DPD200150915).
***** Version 1.3.8 *****
**** BlockIt ****
* BUG FIX: Fixed bug in make install where the STL library would not build
if the PyF95_POD_DIR environment variable was not set. This went
unnoticed for quite a while.
**** PyF95++: ****
* BUG FIX: Added changes to INTENT attributes in some functions/subroutines
and modified the add_(...) method for class_DLList to fix errors in
pgfortran and ifort builds. Ifort currently does not build the unit-
tests, but it appears to be a compiler type error involved with scoping.
This still needs to be tracked down.
* BUG FIX: Fixed 'make uninstall' which would not uninstall the standard
persistent storage template library built during install if the users
Python did not have the BDB backend for the library. Without the BDB
backend, three files are created instead of the typical one STL.lib file.
***** Version 1.3.7 *****
**** BlockIt ****
* Removed the 31 character restriction on instantiated Template block names
in blockit.F95.blocks module. Any libraries should be rebuilt, but is not
strictly necessary.
**** PyF95++: ****
* Forgot to merge the addition of the set(...) method in class_AList into
Version 1.3.6. Changes are included in this version.
* Added Vector STL class with simple set/get API. Useful container for
random insertions and extractions.
***** Version 1.3.6 *****
**** BlockIt ****
* BUG FIX: Template Specialization blocks were broken ever since argument
lists for function and subroutine calls became optional. This has been
fixed and the remedy can be read in the git logs.
* BUG FIX: BlockParser failed for languages that do not have line
continuation characters.
* Logic added in topSort() function to issue warning when it detects a
cycle in the graph.
**** PyF95++: ****
* Added function based mergeSort to class_DLList and class_AList.
* Added set() function to AList to perform random element insertion into
the list.
* BUG FIX: The modulo of the hash with the capacity of the table failed to
add 1 to the result for one based indexing in class_HashTable.
* BUG FIX: The AList was resize was broken and allowed a memory leak
because it failed to deallocate the old lists memory.
***** Version 1.3.5 *****
**** BlockIt ****
* BUG FIX: Fix syntax bug in error message.
**** PyF95++: ****
* BUG FIX: When using the library, if all files that a file depends on was
retrieved from the library as well as the file itself and the file
already exists, it will not be re-written. This logic missed a situation
where a file that needed to be re-written also instantiated a new
template, but that template didn't change so it was not re-written.
Therefore, a file is not re-written if the above is true, but also if all
files that depend on it haven't changed either. This is the only way to
guarantee that a new instantiation will be written.
* Added pop(...) function to class_AList and class_DLList containers.
* Added new unit tests for class_Alist container.
***** Version 1.3.4 *****
**** PyF95++: ****
* When using the library, if all files that a file depends on was retrieved
from the library as well as the file itself and the file already exists,
it will not be re-written. This can save significant time in the
processing.
* Implemented a consistent application of overloaded assignment(=) of
reference counted types. If assigning a reference counted object to an
uninitialized reference counted object, then it has affect of deleting
the object.
***** Version 1.3.3 *****
**** BlockIt: ****
* BUG FIX: Fixed bug when throwing exceptions for circular dependencies.
***** Version 1.3.2 *****
**** BlockIt: ****
* BUG FIX: Fixed bug of not being to have mulitple prepods within a block.
Needed to create unique names for the prepods.
* Added a BlockParserError exception class to throw parse exceptions. The
block parser now throws an exception when it encounters a block that was
not properly closed.
* BUG FIX: The 'as' clause had a bug in instances where the AutoPrivate and
AutoInterface blocks were not contained in the template block along with
the function/subroutine that had the 'as' clause. In these causes, the
Auto* blocks would find functions/subroutines in template blocks that
were not instantiated also, thereby generating generic interface with
names of those functions. This has been fixed and they now filter out
those functions/subroutines that are templated.
* BUG FIX: The GarbageCollect block would not find AutoDelete blocks that
were contained within Specialization blocks. It now searchs inside
Specialization blocks within its parent blocks scope for AutoDelete
blocks.
* BUG FIX: Added cyclic dependency exception when build dependency graph.
**** PyF95++: ****
* Added the start of a Dictionary class to the STL. This is really a
HashTable that with strings for a key, but makes it simpler to work with.
* Cleaned the cruft out of the STL, i.e. all the debugging #ifdef
statements. Also implemented a new overrided assignment pattern when
trying to do an assignment to a non-initialized object. The pattern will
now simply do nothing when trying to perform this operation. So, if you
try to do an assignment to an unitialized object, nothing happens.
* The .is. operator is implemented for all the STL containers. Some were
missing it.
* Moved class_DLListIterator and class_Iterator out of the templates folder
and into sandbox since they were just experimental.
* Added an error message function to class_Exception for creating a message
that includes the line number and file name using the __LINE__ and
__FILE__ macros. Started to incorporate into classes.
* Added a print(...) method to class_String. At the moment, just a wrapper
for the show(...) method.
***** Version 1.3.1 *****
**** BlockIt: ****
**** PyF95++: ****
* Simplified PyF95_delete.inc logic and corrected all templated class
delete(...) methods to have NULL_RETURN first.
* Added Prepod block which is like similar to a Pod (Python On Demand)
block but executes during parsing instead of after parsing like the Pod.
This is useful for generating code that should be added to the global
symbol table of the parser, like code that contains derived types and
such.
* Created a new class_TestRunner module to separate the class_UnitTest from
the actual unit tests. This will provides an extra module layer to create
test functions that can be used within your unit tests, i.e. assert(...),
failIfNotEqual, etc...
***** Version 1.3.0 *****
**** BlockIt: ****
* More work on Library. Appears to be stable and working correctly. Added
LibTool as utility to inspect a PyF95++ library and report errors.
Haven't implemented the tool fully yet.
**** PyF95++: ****
* Bug and logic fixes.
* Now have --addons and --addon_dir flags for 'add ons'. These are modules
and methods that depend on the STL, but are not part of the STL. This
allows users to have there own add ons that depend on the STL.
* Added continuation line character recognition for Fortran continuation
markers. It will now correctly parse continuation lines, but you should
try to not exceed the fortran compiler line character limit as PyF95++
simply concatenates into one large line.
* Added parameter list for TestRunner(...) block. You can now specify a
parameter list to call your unit test functions.
***** Version 1.2.6 *****
**** BlockIt: ****
* Made parenthesis optional for function/subroutine argument lists that
contain no arguments in blockit.F95.blocks.F90Block class.
* Added make unit-tests option to Makefile.
* Fixed bug in blockit.F95.blocks.Function.VALID_ASNAME grammar. Forgot to
include * as possible operator symbol.
* Added blockit.library.Library class to have persistent storage of
preparsed templates.
**** PyF95++: ****
* Added logic in PyF95++ to build all sources specified via --sources or --
src_dir flags. This is to write source files even if they only depend on
themselves.
* Changed how files are processed in PyF95++. You have to explicitly set --
template_dir=IGNORE to ignore all the STL files. Otherwise, they are
prepended to the --templates string.
* Modified Makefile install process to build $(PYF95_PREFIX)/lib/pyf95++/
STL.lib library file of standard templates automatically during install.
***** Version 1.2.5 *****
**** BlockIt: ****
* For blockit.F95.blocks.AType added optional :: to the grammar for new
derived type specifications in F2003: type :: myType
* Fixed DECIMAL_NUM grammar and added ENGINEERING_NUM grammar to
blockit.F95.blocks module.
* Bug in default template specifications in blockit.F95.blocks Template
block. Forgot to allow parenthesis in default template specifications,
such as: template
**** PyF95++: ****
* Bug in PyF95++. Did not clear global symbol table an repopulate it if an
STL file was not built. The symbol table would fail to have all symbols
in this case. For instance, if you just had a templated function in a
module that you were instantiating and that's all, then after the call to
realizeTemplates() the symbol table would not be updated with the new
templated function symbol. It would be contained within the parent
block's _children table, but not in the global symbol table. The
table.clear() call and the table.registerAll(FileTable) call were thus
moved out of the 'if STL' conditional which fixes this problem, i.e.
table.clear() and table.registerAll(table) should always be called, even
if an STL file is not generated.
* Added --no-STL flag to generate separate templated modules rather than a
single monolithic STL.F90 file.
* Added template specializations through the specification block.
***** Version 1.2.4 *****
**** BlockIt: ****
* Fixed small bug in blockit.F95.blocks.GarbageCollect class for indenting
code that appears within a GarbageCollect block.
**** PyF95++: ****
* Fixed small bug in class_HashTable.F90T. Had insert specified twice in
the public interface.
***** Version 1.2.3 *****
**** BlockIt: ****
* Added the AutoDelete and GarbageCollect blocks to blockit.F95.blocks.
* Fixed default specifications with recursive template parameters. This was
broken since the prototype and forgotten. For example, specifications
like this: type (Foo*>>) :: myFoo where the default '*' was embedded
within another templated type. This appears to be fixed now.
* Added the include of PyF95_macros.inc to the STL.F90 file in
blockit.F95.funcs.buildSTL(...) function.
**** PyF95++: ****
* Added ability to specify .inc files with the --sources or -s flag without
them being included in the generated Make.depend file.
* Renamed include files in PyF95++/inc to have the PyF95_ prefix and
renamed them as follows: setup.inc -> PyF95_init.inc decRef.inc -
> PyF95_delete.inc equals.inc -> PyF95_equals.inc Also added
PyF95_macros.inc for include macro definitions.
* Modified the catch(...) function in class_Exception to take an optional
boolean argument to halt the program if an exception is detected.
* Registered the new AutoDelete and GarbageCollect blocks with the block
parser.
***** Version 1.2.2 *****
**** BlockIt: ****
* Fixed small bug in blockit.funcs.realizeTemplates function. The
leafTempBlocks table was incorrect. If a templated function had a
contains section with another function, then it would be masked, i.e. not
a leaf. Therefore, had to use (And(isTemplated, Not(isTemplate))) pattern
for filtering.
* Fixed bug in Makefile for making test cases; added -m -x flag.
* Fixed bug in Function/Subroutine block VALID_ASNAME grammar. Forgot to
include +- symbols.
* Fixed grammar for TEMPLATE_DECL. Forgot to add ability to specify real
(dp) as a template parameter. For instance: DLListdp)> Did this by
modifying VALIDNAME to include () and gave it the name
VALIDNAME_WITH_PAREN in blockit.F95.blocks.
* Added dimension parameter specification for TEMPLATE_TYPE in
blockit.F95.F90Block class through the DIMENSION grammar.
**** PyF95++: ****
Added .is. operator to most templated classes.
Added experiment (+) operator to class_DLList and added unit test.
Fixed bug in universal extend(...) function; forgot to use a pod to determine
delete(...) call in garbage collection.
Added another dimensional pointer to VarPtrs derived type.
Added cast5D(...) method to class_Buffer.
Fixed small bug if STL file was not generated when comparing a block name with
the STL file name. - if f.name() == STL.name(): continue + if f.name() == (STL
and STL.name() or None): continue
***** Version 1.2.1 *****
**** BlockIt: ****
**** PyF95++: ****
* Small rework on PyF95++ flags and directory handling. You can now specify
--sources with the --final_dir flag. The common prefix is found between
the --sources files and the --final_dir and files are created as:
final_dir/(original file name minus common prefix)
* Added --template_dir="IGNORE" flag option to entirely ignore the globally
installed templates.
***** Version 1.2.0 *****
**** BlockIt: ****
* pyparsing integration complete: - BlockParser now uses new blocks and
pyparsing - All Block classes use pyparsing - pyparsing added under
blockit.external package
* Removed templated functions from blockit package and placed in
blockit.F95 package. Also, changed them to use pyparsing.
* Removed certain methods that deal with templates from blockit.blocks
class and placed in blockit.F95.F90Block class
* Fixed unit tests in blockit.tests to reflect changes
**** PyF95++: ****
* Modified to use new pyparsing integration.
* Added screen output.
***** Version 1.1.12 *****
**** BlockIt: ****
* Added a BlockIt and PyF95++ header to CHANGELOG sections to organize
where the changes are made in the project.
* Added Doxyfile.
* Started PyC++
* Added prune=False flag in call to topoSort in blockit.F95.funcs.buildSTL
(...) function. The problem was that certain templated modules would not
be include in STL.F90 because they depended on nothing and vice versa.
This flag makes all templated modules included in STL.F90.
* Removed 'table' parameter from constructor of all F90Blocks and made it
optional for blockit.blocks.Block class. Added a setTable(...) method to
the blockit.blocks.Block class. This is for integration with pyparsing.
**** PyF95++: ****
* Added a unit test for DLList length test.
* Fixed small bug in file name existence when writing pre-processed files.
Should have included a path join to the finalDir for the check.
* Added filter in PyF95++ when walking through the directory tree when
specifying the --src_dir flag. It now only filters and reads files which
contain '.f90' or '.F90' extensions.
* Fixed small bug when reading source files. Had an unecessary os.path.join
(...) call from a cut and paste.
***** Version 1.1.11 *****
**** PyF95++: ****
* Fixed bug in class_Stack. Forgot to remove the private declaration for
the equals_ subroutine since the class now uses the autoprivate block.
* Remove the following deprecated templates: class_Dict.F90T -> superceded
by class_HashTable.F90T class_DictEntry.F90T -> not need since class_Dict
is gone class_MultiVect.F90T -> superceded by class_Buffer.F90T
* Implemented request by Matthias to have a --sources flag to input a list
of source files instead of having a specified source directory. The
behaviour is to have either a --sources flag or a --src_dir flag, but not
both. The PyF95++_TEMPLATE_DIR environment variable is still used in
either case. You can also specify pure template files with the --
templates flag. Internally though, PyF95++ does not make a distinction
between the --sources and --templates except to parse the --templates
first and then the --sources.
* Added support for '.f90' or '.F90' file extensions in PyF95++ as per
Matthias Moeller's patch.
* Added templated zip function to UFunctions.F90T. Able to zip to lists of
different types that contain different types into a list of pairs.
* Added unit test for testing zip function and the unit testing framework
appears to be working!
* Must use the -m flag to generate the Make.depend file now.
***** Version 1.1.10 *****
**** PyF95++: ****
* Added extend function to UFunctions to append one list container to
another.
* Fixed regex bug in templated subroutine/function declarations in F90Block
class. It cound not find statements like: anErr = catch(extend bar>(lst,
lst2)) It would fail to find the extend templated function above. Appears
to be fixed now. This has reduced performance though.
**** BlockIt: ****
* Added LICENSE files and headers.
***** Version 1.1.9 *****
**** PyF95++: ****
* Found major bug in class_String and class_DLList. The overloaded
assignment operators for reference counted objects must have INTENT
(INOUT) for the left value. This was done in all the other classes, but
for some reason was overlooked in class_String and class_DLList.
* Changed template signature of enumerate in UFunctions.
* Cleaned up some logic in class_HashTable.
***** Version 1.1.8 *****
**** BlockIt: ****
* Fixed bug in function/subroutine parameter list. Forgot to allow quotes.
**** PyF95++: ****
* Refactor PyF95++/templates/class_UnitTest.F90 into an operational unit
test framework. See PyF95++/unit-tests directory for examples.
* Added PyF95++/unit-tests for unit testing.
***** Version 1.1.7 *****
**** BlockIt: ****
* Start of adding unit tests.
* Found inconsistency in child naming in blockit.blocks.Block class. The
addChild() method did not use the childString() method, so an
incosistency could result.
* Added case insensitivity to F90/95 blocks. Hasn't been fully tested, but
appears to be working.
***** Version 1.1.6 *****
**** PyF95++: ****
* Changed template signature for class_HashTable. All that is needed for
the Chain template parameter is a container that satisfies the list API,
i.e. push, popBack, etc...
**** BlockIt: ****
* Still trying to improve the README. Left out documentation about setting
the PYTHONPATH environment variable to point to your local python package
installs.
***** Version 1.1.5 *****
**** BlockIt: ****
* Fixed templated function/subroutine regex to include % in parameter list
for defined types used in the parameter list.
* Added Makefile bug fix from Matthias Moeller. Thanks Matthias!
* Bug fix in blockit.F95.blocks.F90Block.resolveinternal function. Did not
update the code listing in the while loop for the current block _blk.
* Modified the blockit.F95.blocks.AutoUse block to search instantiated
templates for 'as' clause functions/subroutines. Likewise modified the
AutoPrivate block to do the same.
* Bug fix in blockit.F95.blocks.AutoUse. Improperly used
symmetric_difference_update instead of difference_update method of the
modSet.
**** PyF95++: ****
Added the removal of "special" directories like .git, .svn, etc.. in PyF95++
when walking the directory trees.
Changes the PyF95++ banner at the top of the files.
Fixed bug in PyF95++ if there are no templated modules. This buildSTL would
return None. Now PyF95++ checks for None and moves on.
***** Version 1.1.4 *****
**** BlockIt: ****
* Found bug in how the autouse block in blockit.F95.blocks was implemented.
It now searches removes any use declarations in the parent block from the
dependency set when building the block in the show() method.
**** PyF95++: ****
* Fixed the naming of the STL file. Forgot to prepend the base source
directory name to it.
***** Version 1.1.3 *****
**** BlockIt: ****
* Major bug fix. Forgot to reset the state of tempBlk in the _instantiate
recursive function in the F95.Template class. This resulted in ambiguous
block names when populating the symbol tables since both the realized and
non-realized blocks would have the same name.
**** PyF95++: ****
* Templated modules are now built from their files and added to an STL.F90
file in a proper build order. This is due to the fact that in certain
situations, their could be a circular dependency between files. For
instance, if you had the following: class_AList.F90 : AList<integer>,
AList<Pair<string, integer>> class_Pair.F90 : Pair<string, integer>,
Pair<Alist<integer>,integer> Then file class_AList.F90 needs a
Pair<string, integer> so it depends on class_Pair.F90, while
class_Pair.F90 needs an AList<integer> so depends on class_AList.F90. The
actual dependencies are exclusive, but the dependencies between files is
circular. Therefore, it is best to order the modules properly within one
file, called STL.F90.
* Fixed small mem leak introduced in class_Hashtable's findKeyValue_
method. Forgot to garbage collect the key_ string type within the
function.
* Added class_Buffer to replace class_MultiVec.
* Added new getText() method to class_String.
***** Version 1.1.2 *****
**** BlockIt: ****
* Fixed typo in README. The environment variables should be
PyF95_TEMPLATE_DIR and PyF95_POD_DIR, not PYF95_POD_DIR and
PYF95_TEMPLATE_DIR.
**** PyF95++: ****
* Created new class_Buffer template to replace class_MultiVec template.
***** Version 1.1.1 *****
**** BlockIt: ****
* Moved 'use' declaration check in addLine() method out of the Module block
and into the F90Block in the blockit.F95.blocks module since 'use'
declarations may appear in blocks other than modules.
***** Version 1.1.0 *****
**** BlockIt: ****
* Fixed bug in AutoUse block in the blockit.F95.blocks module. The logic
did only found templated modules for the autouse statement. It now finds
all modules, not just templated ones. For this, a _use attribute was
added to the F90Block class to store use declarations and the useDecl
regex was modified. This still needs some work.
**** PyF95++: ****
* Added stub() subroutine in UFunctions.F90T template as a filler for the
contains section. This is a hack at the moment.
***** Version 1.0.5 *****
**** BlockIt: ****
* Forgot to add setup.cfg and setup.py to tarball.
* Fixed bug in blockit.F95.pod package. Forgot to import blockit.funcs.
