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.
Change the license to GPL V2.
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.
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,
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
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,
Remove class_DLListEntry from the templates and merged it into the
class_DLList templated modules. Not sure why I separated them in the first
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 <class __OBJECT__, class __OPTIONAL__=integer>
type :: Foo
__OBJECT__ :: a
__OPTIONAL__ :: b
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 :: Foo
type (Foo_), pointer :: data => null()
The default value for PYF95_REF_NAME is shared.
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
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
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.
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:
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
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,
module procedure Buffer_init<integer>
will be properly mangled.
Fixed AutoUse block in blockit.Fortran.blocks to allow templated use
declarations. So, specifications can look like:
can be specified and the AutoUse block will correctly mangle and not add an
extra use declaration for the templated use declarations.
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.
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.
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.
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
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.
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.
Major bug fix in class_DLList pop(...) method. Algorithm rewrite and
unit-test coverage added.
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.
Added CacheManager class to support the new block caching strategy.
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.
Separated Fortran grammars into their own module in
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
Modified class_UnitTest to not rely on the AutoUse block.
This is to facilitate use in different build scenarios which are being
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
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
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.
Removed the F95 package which was replaced with the Fortran package.
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.
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
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
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
A header is now written for all files that are processed by PyF95++.
This info may be used for future stand-alone tools.
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.
Added some more capability to LibTool to list and remove files from the
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.
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.
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).
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.
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.
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.
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.
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
Logic added in topSort() function to issue warning when it detects a
cycle in the graph.
Added function based mergeSort to class_DLList and class_AList.
Added set() function to AList to perform random element insertion into
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.
BUG FIX: Fix syntax bug in error message.
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.
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
BUG FIX: Fixed bug when throwing exceptions for circular dependencies.
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
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.
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
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.
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(...),
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.
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.
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
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
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.
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
Bug in default template specifications in blockit.F95.blocks Template block.
Forgot to allow parenthesis in default template specifications, such as:
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
Added --no-STL flag to generate separate templated modules rather than a
single monolithic STL.F90 file.
Added template specializations through the specification block.
Fixed small bug in blockit.F95.blocks.GarbageCollect class for indenting
code that appears within a GarbageCollect block.
Fixed small bug in class_HashTable.F90T. Had insert specified twice in the
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
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
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
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.
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
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:
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.
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
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
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
Modified to use new pyparsing integration.
Added screen output.
Added a BlockIt and PyF95++ header to CHANGELOG sections to organize where
the changes are made in the project.
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
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.
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.
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.
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(lst, lst2))
It would fail to find the extend templated function above. Appears to be
fixed now. This has reduced performance though.
Added LICENSE files and headers.
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.
Fixed bug in function/subroutine parameter list. Forgot to allow quotes.
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.
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
Added case insensitivity to F90/95 blocks. Hasn't been fully tested, but
appears to be working.
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...
Still trying to improve the README. Left out documentation about setting
the PYTHONPATH environment variable to point to your local python package
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.
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.
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.
Fixed the naming of the STL file. Forgot to prepend the base source
directory name to it.
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.
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.
Fixed typo in README. The environment variables should be PyF95_TEMPLATE_DIR
and PyF95_POD_DIR, not PYF95_POD_DIR and PYF95_TEMPLATE_DIR.
Created new class_Buffer template to replace class_MultiVec template.
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.
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
Added stub() subroutine in UFunctions.F90T template as a filler for the contains
section. This is a hack at the moment.
Forgot to add setup.cfg and setup.py to tarball.
Fixed bug in blockit.F95.pod package. Forgot to import blockit.funcs.