This file lists the major changes and improvements made to AspectC++ and the PUMA framework. Version 0.7.2 (2003-08-19) * some minor bug fixes * fixed bug #128. This bug was introduced in 0.7: For specific kinds of methods the call advice was broken. * fixed a bug in code generation for order aspects which caused an error when woven code was compiled with BorlandC++ (Bug #126) Version 0.7.1 (2003-08-08) (internal release only) * some minor bug fixes * ordering of aspects improved * docu updated Version 0.7 (2003-07-01) * source released under GPL * fixed bug introduced in 0.7pre3 which causes aspect matching outside of project file failures Version 0.7pre3 (2003-06-19) * last version before stable release (see below) * improved template handling + many STLs working - tested: gcc 2.xx STL, Microsoft Visual Studio STL + gcc 3.x STL requires workaround see README for more information * improved performance - it is now possible to instruct ac++ to skip analysis of function bodies which are not inside the project. * new command line options: -r when given the -r option ac++ generates an XML file with information which aspects have been applied where. Please note, XML file format is likely to be changed in near future. --version :-) * documentation improved - beside the quick reference a compiler usage manual and a language reference (with many examples) are available * bug fixes: - most of the bugs reported by users could be fixed (about 80) * bugzilla: - See and report bugs here: http://www.aspectc.org/bugzilla or https://www.aspectc.org/bugzilla * renaming: - 'thisJoinPoint' was renamed to 'tjp' - 'aspectOf' was renamed to 'aspectof' - using the old names is still allowed but not recommended as they might become unsupported in future releases * name pointcuts with function names now partly supported: - '||','&&', '!', and within works with function names - the argument of call() and execution() can now be a complex expression, which results in a name pointcut that contains function names - within() supports function names * proceed: - it is now possible to use tjp->proceed() instead of tjp->action().trigger() * examples: - void removed in front of before, after, and around - thisJoinPoint and aspectOf renamed - updated proceed calls * new command line options: - --config can now be provide the config file for the ac++ parser. If you use --config it is not necessary to define PUMA_CONFIG. * Open issues: - it is not possible to weave aspects into code instanciated from templates (ac++ creates no templates instances) * stable release: 2003-07-01 release date of the stable 0.7 version - with sources & GPL Version 0.7pre2 (2003-03-12) * enhanced performance for larger input files * unnamed unions are now parsed w/o segmentation fault (Bug #21) * Solaris port is now operational (bug fix Bug #20) * MacOS X is now supported * more basic template stuff is working * new 'single translation unit transformation' mode: - ac++ can now manipulate the translation units, the header files, and generate the acgen-file in separate runs. - => simple integration of ac++ into Makefiles - new command line options (run ac++ without arguments to get a description) - examples: . ac++ -p . -c foo.cc -o foo.acc g++ -o foo.o -x C++ -c foo.acc => use these commands to compile foo.cc . ac++ -p . -g -o gen.acc g++ -o gen.o -x C++ -c gen.acc => use these commands to generate all link-once code. . ac++ -p . -d somepath/manipulated_headers -i => use this to generate manipulated header files (useful if your program is a library) - even in the new mode the -p option is still needed, because ac++ needs to know, which files belong to the project. External files are never manipulated. - full compatibility: the old 'whole program transformation' mode still works as usual. * -a option to specify the aspect header files explicity, e.g. . ac++ -p . -c a.cc -o a.acc -a aspect1.ah -a aspect2.ah => transforms a.cc -> a.acc and regards the listed aspect header files . use -a 0, if no aspect header files should be considered (if this option is combined with -a it has no impact) * Many code generation bugfixes, e.g.: - derived() pointcut function fixed - code generation for execution join points fixed - generation of empty initializer list for JoinPoint object * Significantly reduced the number segmentation faults in the parser :-) Version 0.7pre1 (2003-03-03) * Completely new parser . basic templates can be parsed correctly . STL parsing not yet possible, STL support is coming soon. * (slightly) changed commandline arguments . old: "-p dir-in dir-out" new: "-p dir-in -d dir-out" . new options to support single file operation of ac++(EXPERIMENTAL) ac++ -p -c -o * Changes to puma.config -A option format, old 0.6 puma.config do not work anymore. Use the supplied pumag++conf.pl (Win32 users, please adjust pumabc55.cfg to your needs). Version 0.6 (2002-07-29) * Changed JoinPoint-API . renamed toString to signature . renamed signature to type . added typedef JPType (result type of jptype()) . added typedef Result (result type of result(); void if there is no result) * Fixed code generation for advice on virtual methods * Fixed code generation for nested around advice . extended Action example to test/demonstrate this * Fixed handling of symbolic links to files within the project directory Version 0.6pre2 (2002-07-08) * First Win32 release (using cygwin cross compiler 2.95.3 for mingw target) * Fixed examples for Solaris platform * Added support for -e switch to specify extension(s) for C++ files * Added support for pointcut of type class as argument for call and execution * Some minor code generator changes * Many parser extensions to handle non standard header files (GNUC, BCC, VC) Version 0.6pre1 (2002-05-10) * Now compiles with gcc3.1 * Fixed many small bugs * Improved code generation (inline declarations, casts, type information, forward declarations, ...) * Added basic exception support in PUMA * Changed all examples to use stdio instead of iostream Version 0.5 (2002-04-05) * Added support for nested around advice * Added support for operator functions (as join points) * Added support for dynamic Action objects * Changed ThisJoinPoint-API: - type of source (that()) and target (target()) object now available via JoinPoint::That/::Target typedef - that() and target() now use actual pointer type if possible - changed toString(), args(), argtype(int), signature(), id(), resulttype(), jptype() into static member functions of JoinPoint - now accessible via thisJoinPoint-> (deprecated) or JoinPoint:: * Improved code generation - handling of aspect attribute access in advice - handling of user defined aspectOf functions - merged per advice ThisJoinPoint structs into single per join point struct - on demand generation of action objects and wrapper functions Version 0.4 (2002-03-05) * New language features: introduction of base classes; user defined aspectOf functions * Support for Actions, proceed() in around advice (thisjoinPoint->action().trigger()); (limited to one around advice per call or execution join point) * Improved code generation (ThisJoinPoint now as struct not class) -> smaller memory footprint * New examples: o Action: demonstrates around advice for execution and call join point with thisjoinPoint->action().trigger() o Cache: very simple Action cache o ID: illustrates usage of thisJoinPoint->id() o IconCache: implementation of an application specific cache Version 0.4-pre3 (2002-02-12) * Added Support for "within" pointcut function * Fixed some bugs in the code generator Version 0.4-pre2 (2002-02-06) * Added rudimentary support for templates in PUMA Version 0.4-pre (2002-01-29) * Minor changes to compile on Solaris Version 0.3-fix1 (2002-01-24) * Changed code generation for call join points * Fixed a little strange bug in PUMA that prevented a correct code generation in some special cases Version 0.3 (2002-01-17) * Added support for call join points (functions, methods, _no_ operators) * New methods for the thisJoinPoint pseudo object - void* that(): gives the pointer of the callers object (if known, otherwise 0) - void* target(): gives the pointer of the target object (if known, otherwise 0) - int jptype(): gives the numerical type of a join point - void* result(): gives pointer to memory holding the result of a call (or 0 if unknown) - char* resulttype(): gives mangled type of result * Changed thisJoinPoint->typeinfo(int) into ->argtype(int) * Added support for virtual pointcuts * Added support for wrapping functions with default arguments * Fixed generated code for around advices, wrapper code for static functions * Fixed bug in PUMA project managment (path handling) * Minor improvements to the PUMA parser * More C++ ABI v3 name mangling support Version 0.2 (2001-12-03) * New methods for the thisJoinPoint pseudo object - unsigned id(): gives a unique identifier of the join point - const char* signature(): gives the signature of a method join point (C++ ABI v3 name mangling) - const char* typeinfo(int): gives the mangled type of a method argument * Extended Trace example: uses the new thisJoinPoint methods for an universal trace aspect * Replaced last Flex scanner with Orange equivalent * Fixed some internal PUMA bugs * Removed some minor memory leaks from PUMA * Added basic C++ ABI v3 name mangling support to PUMA Version 0.1 (2001-11-06) * Added automatic dependency mechanism * Removed some serious memory leaks from PUMA * Fixed some internal PUMA bugs