This file lists the major changes and improvements made to AspectC++ and the PUMA framework. Version 0.9.pre1 (2004-07-07) * implemented a match expression parser that tolerates whitespace and checks the match expression syntax. The syntax and semantics of the new match expressions in not compatible in any case. Refer to the corresponding section in the Language Reference Manual for details. * described and implemented "construction" and "destruction" joinpoints, which may be used to define advice for object instantiations. The 'Instanced' example now uses this new feature. * changed handling of "forced includes". See -include option in the compiler manual. * the joinpoint IDs which can be obtained via the joinpoint-API are now unique not only in the translation unit but in the whole project if a project repository is used (-r option). * the -g -i -d and -o can now be used together, i.e. the name of the acgen.cc file can be selected even if headers are generated at the same time. * Changed the code generation pattern for cflow. This fixes the Visual C++ problem #185 and is a first step to make acgen.cc unneeded. * implemented an option --no_line that avoids the generation of #line directives by ac++. * improved handling of macros. The chance that ac++ is not able to weave because of macros was reduced. For example, if only a function name or function call argument is a macro, weaving will work now, while it failed in older versions. * fixed execution advice for conversion operators * important fixed parser bugs: elaborated type names made the parser jump into the wrong scope, fixed two serious problems in the overload resolution, member functions of nested classes were not parsed so far, fixed #include directives for absolute paths, fixed implicit conversion from 0 to pointer. * code improvements: all Puma classes are now encapsulated in a namespace. After some cleanup woven code now compiles in Visual Studio 2003. This means: It is possible to compile ac++ with VC++ 7, makefiles improved * pumag++conf.pl is now ready for g++ 3.4. * implemented some more GNU g++ extensions. * performance improvements: pointcut evaluation and parser (name lookup in namespaces) * updated manuals, avoid problem with black background with acroread 5 on Linux. * made a new example 'ObserverPattern'. Version 0.8.1 (2004-04-16) * fixed the bug that caused ac++ 0.8 being unable to transform the Puma code, which is needed to compile itself. * fixed the parser problems that caused errors when the QT header files were included (tested on Linux). * fixed match-signatures which contain array types * fixed code generation for the proceed code, which is generated for call advice for operators * avoid warning if ac++ generated code is compiled with g++ -Wall, because unintialized _fptr in action struct * improved mangling of match expressions in type check functions * fixed generation of aspect friend declarations in classes, if these are defined in a namespace; added Namespaces test program Version 0.8 (2004-03-18) * added support for passing definitions of macros with arguments in the command line and the parser configuration file * extended the pumag++conf.pl script to handle paths in the cygwin environment correctly * documented the --config option, which can be used to provide the name of parser configuration file * the parser does not require PUMA_CONFIG being defined anymore * fixed further template-related parser problems * fixed problems with generated code that did not compile under MS Visual Studio .NET 2002 Version 0.8pre2 (2004-03-09) * fixed several parser problems. g++ 3.3 STL headers can now be parsed! * added the --vc switch to enable Visual C++ parser extensions * added support for execution advice for constructors and destructors. Warning: this is experimental! * implemented the 'result' pointcut function * fixed broken call advice for pure virtual functions * fixed problem with strange end of line characters under Windows * added Windows resources, e.g. an icon * AspectC++ and Puma sources don't use strstream.h anymore * updated the documentation Version 0.8pre1 (2004-01-28) * improved the implementation of the cflow() pointcut function: There can now be an arbitrary number of cflows in every pointcut expression. They can be combined with the usual operators for and, or, and not. The cflow arguments can still have no context variables or runtime conditions. The generated code is exception-safe but should not be used in multithreaded environments. * examples/CFlow/CFlow.ah: made CFlow example a little bit more complex to show the feature * changed code generation for the advice activation code. All becomes part of a class now. For ordinary call advice the class becomes a local class and, thus, has the same access rights as the enclosing function * access control by the C++ compiler is no longer inhibited by replacing every "private" or "protected" by "public". The member protections now remain untouched by the weaver. All aspects are priviledged, they become friends of all other classes and aspects. This is not the final solution. * improved code generation for consts and typedefs as return types in functions with advice * strongly changed the implementation of dynamic type checks, now we can check for types which are unknown in a translation unit. * finished implementation of that and target functions and their combination to complex conditions * support for advice for calls during the initialization of globals and in baseclass initializer lists of constructors * changed code generation to support advice activation from forward joinpoints, i.e. joinpoints with code defined in include files that are included by the affecting aspect header. Include cycles are avoided/handled. * Changed code generation: advice and aspectof functions now remain members of the aspect class. If they require a type JoinPoint or an object tjp, they are transformed into template functions. * made the wrapped function of an execution join point always inline and const or volatile according to its type. * changed the code generation at execution join points - __exec_old.. is never virtual now. Furthermore changed the code that invokes the original function at execution join points: a qualified name is not used for method invocations anymore. The invocation of the original function at call join points is also changed: qualified names are only used if the method was virtual and the original call was qualified, too. => now the 'proceed()' operation really performs the original action. * added the --gnu-2.95 option, which is needed when g++ 2.9x header files are parsed. pumag++conf.pl automatically adds the option to the generated config file if it detects a g++ 2.x compiler. * a lot of bug fixes - with wrong signatures of functions defined in a namespace - reimplemented IncludeExpander, the old one didn't expand in some case which caused a wrong definition order. For example, if an aspect header included a header file for which it defines advice. - fixed several name mangling problems, e.g. name mangling ambiguity with CV qualifiers, destructor name mangling - fixed seg fault after error some messages - fixed problem with context variables in advice code, they (more than one) can now be used in arbitrary order - fixed problem that '= =' was generated for default argument declarations. - fixed problem of missing space when an anonymous argument without declarators has to be generated - fixed problem that in some cases %anon was generated. - fixed problem that advice code functions got identical names when the advice was defined in an abstract base aspect and more than one derived aspect affected the same join point * updated the manuals regarding changes in cflow, that, target, cflow example, versioning scheme, unimplemented features and some g++ back-end specifics; fixed font in manuals * further improved the compilation speed 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