Looking for the latest version? Download BlockIt-1.7.3.tar.gz (282.8 kB)
Home / v1.6
Name Modified Size Downloads / Week Status
Parent folder
Totals: 1 Item   257.3 kB 1
BlockIt-1.6.0.tar.gz 2010-12-22 257.3 kB 11 weekly downloads
***** 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 &amp;&amp; __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.
Source: CHANGELOG_README.txt, updated 2012-02-10