Boost.Wave: A Standard compliant C++ preprocessor library

http://www.boost.org/

Copyright (c) 2001-2013 Hartmut Kaiser. Distributed under the Boost

Software License, Version 1.0. (See accompanying file

LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-------------------------------------------------------------------------------

TODO (known issues):

- Fix expansion of macros, which replacement-list terminates in a partial

macro expansion.

- Try to remove the second parameter from the pp_iterator<>::force_include

function.

- Fix the trigraph backslash problem in the re2c (C/C++ and IDL) scanners, if

there is the end of the (internal) buffer just in between a '??/' and a '\n'.

-------------------------------------------------------------------------------

CHANGELOG

Boost V1.74:

- Fixed TRAC #10733: Hooks not called for expanding specific predefined macros

- Fixed #58: C++11 long long literals must use consistent case

- Repaired two samples and added a new one for macro naming enforcement

- Implemented C++20 changes for variadic macros, including __VA_OPT__()

- Added C++17 feature __has_include()

Boost V1.73:

- Fixed TRAC #7822: waveidl sample does not use the IDL lexer

- Fixed TRAC #9874: Turning off 'include_next' support breaks include

- Fixed a typedef shadowing a class (MSVC warning 4458) - Conrad Poelman

- Updated waveidl to match recent changes in the RE2C lexer

- Samples now build cleanly

- Ensured samples and wave driver are covered by continuous integration

Boost V1.55:

- Fixed #8848: Wave driver improperly processes 0xFFFFui64 token

- Fixed #9098: Wave driver option --c++0x invalid

Boost V1.54:

- Fixed #8478: Make Boost.wave compatible with Clang's -Wimplicit-fallthrough

diagnostic.

Boost V1.53:

- Fixed a problem with context<>::add_macro_definition which sometimes

appended a superfluous T_EOF to the macro replacement list.

Boost V1.52.0:

- Added util::create_directories() wrapper to account for new behavior of

boost::filesystem::create_directories().

- Fixed an obscure problem when preprocessing directives wouldn't be recognized

if the previous line contained nothing but an empty macro invocation

(see new test case t_9_023.cpp)

- Added a new command line option --license=<file> to the Wave driver tool

which allows to pre-pend the content of a (license) file to every newly

created file. This option simplifies the implementation of partial

preprocessing as done on Phoenix, Fusion, etc.

- Changed the effect of the -N command line option to simply not expand

the macro by pretending it was not defined. Earlier the whole invocation

sequence was skipped, now we skip only the macro itself, which still expands

the arguments for the macro invocation.

- Fixed a couple of compilation warnings

Boost V1.51.0

- Fixed #7050: Invalid memory write bug in lexing_exception

- Fixed #7159: Text-lines are processed as if they were preprocessing directives

- Changed --c++0x command line option to --c++11.

Boost V1.50.0

- V2.3.2

- Fixed #6758: not all members are initialized by base_iteration_context

constructor.

- Fixed #6838: Adding include file with force_include makes Wave fail to emit

#line directive

- Added support for test of --forceinclude option to testwave executable,

added test case verifying #6838 is fixed.

- Fixed #6870: build wave driver failed

Boost V1.48.0

- V2.3.1

- Added the flag support_option_emit_contnewlines allowing to control whether

backslash newline sequences are emitted by the Wave library. The default is

as before: these tokens will be silently ignored (after the token positions

have been properly updated). Note: this option is supported by the SLex lexer

module only.

- Fixed #5887: flex_string.hpp needs to include <ios>

Boost V1.47.0

- V2.3.0

- After preprocessing the body of any #pragma wave option() the wave tool now

concatenates all adjacent string literals into a single string literal.

- Fixed whitespace handling, added a corresponding set of test cases

(t_9_020.cpp)

- Added a new preprocessing hook: locate_include_file allowing to customize the

way include files are located.

- Added new command line option --noexpand/-N to the Wave driver allowing to

suppress macro expansion for a given macro name (works for both, object like

and function like macros). This option has to be used very carefully as it

not only leaves the whole macro invocation untouched in the generated output

but also removes this macro from consideration for Wave itself. This can

cause unexpected results if the suppressed macro would influence #ifdef's

later on.

- Fixed Wave driver to retain all macros defined on the command line in

interactive mode.

- Fixed problem #5554: wave slex parser eof without eol skips the last line.

- Added the compile time configuartion option BOOST_WAVE_WCHAR_T_SIGNEDNESS,

which can be set to BOOST_WAVE_WCHAR_T_AUTOSELECT, BOOST_WAVE_WCHAR_T_FORCE_SIGNED,

or BOOST_WAVE_WCHAR_T_FORCE_UNSIGNED), it defaults to autoßselect.

- Fixed a problem in teh wave driver tool related to #pragma option(output).

If wave was invoked in rapid succession this erroneously appended to an

existing file instead of overwriting that file.

- Fixed #5569: slex CONTLINE token works only for LF line endings

Boost V1.46.0

- V2.2.0

- Added recognition of C++0x keywords to Re2C lexers.

- Added --c++0x command line option to Wave to enabling the recognition of

C++0x keywords, converting those to C++0x tokens.

- Adapted all of the library to play well with Boost.Filesystem V3 (which is

the default from now on).

- Added support for extended character and string literals, added test case

(which required to add C++0x support to the test application).

- Added proper predefined macros fro --c++0x mode. __cplusplus is currently

defined to 201101L, but this will change when the Standard is finalized.

- Fixed a problem with object like macros, which when being adjacent to a

parenthesis, caused the parenthesis to disappear when the macro expansion

was suppressed by the expanding_object_like_macro() hook function.

- Fixed a bug in pragma option(preserve), missing to set to preserve=1 if

after the previous value was preserve=2.

- Changed the --preserve option of the wave tool to interprete the integer

argument in a slightly different way:

0: no whitespace is preserved,

1: only begin of line whitespace is preserved,

2: only begin of line whitespace and comments are preserved,

3: all whitespace is preserved

The #pragma wave option(preserve) now supports these arguments:

[0|1|2|3|push|pop].

Boost V1.45.0

- V2.1.0

- Token pasting is well formed only as long as the formed token(s) are

pp_tokens as defined by the C++0x Standard. Until now, Wave allowed for

non-pp_tokens to be formed in --variadics mode.

- Fixed a problem, which prevented reporting /##/ in a macro definition as

invalid token pasting.

- Fixed problem preventing the skipped_token hook to be called for 'inactive'

conditional preprocessing directive tokens. Improved overall consistency in

reporting skipped tokens to the hooks function when processing conditional

preprocessing directives. Added a new test case verifying the skipped_token

hook gets called reproducibly (t_2_020.cpp).

- Fixed a problem with the pp hooks 'expanding_object_like_macro' and

'expanding_function_like_macro', which when returning true were stopping all

preprocessing instead of just inhibiting the expansion of the macro.

- Fixed a duplicated call to the pp hook skipped_token for preprocessing

directives inside inactive conditional branches.

- Changing exception handling to fix clang++ regression errors.

- Replaced assert() with BOOST_ASSERT to pacify the Boost inspect tool.

Boost V1.44.0

- V2.0.6

- Added information about the file type to iteration context. This can be

either main_file, system_header, or user_header depending whether the handled

file is the main file to preprocess, a include file opened from `#include <>`,

or a include file opened from `#include ""`.

- Added support for new Boost visibility macros. Properly exported all

exceptions, etc.

Boost V1.43.0

- V2.0.5

- Fixed the wave driver application to strip leading and trailing whitespace

from macro names specified on the command line using -U.

- Fixed line number counting for lines containing nothing but whitespace

followed by a C++ comment if the next line is a pp directive.

- Fixed emitting of a #line directive after returned from an include file.

- A couple of fixes allowing to properly report the current line number in

#line directives for different whitespace preserve modes (see --preserve/-p).

- Added new preprocessing hook: emit_line_directive, allowing to customize the

format of the generated #line directive.

- Changed --line/-l command line option of the wave driver application to

accept 0, 1, and 2 as options. The option values 0 and 1 behave as before

(disable/enable the generation of #line directives), while the option value 2

will generate the #line directive using the relative filename (instead of the

absolute filename emitted from option 1). The default option is value 1.

- Added new example: emit_custom_line_directives, demonstrating the use of the

new preprocessing hook.

- Added new preprocessing hook: found_unknown_directive, which is being invoked

whenever an unknown preprocessor directive (i.e. '#' followed by some

identifier) is detected. It allows to interpret the directive and to provide

some replacement text.

- Added new example: custom_directives demonstrating the usage of the new

preprocessing hook.

- Fixed #4113: cpp_lexer does not handle qualified backslashes correctly.

- Fixed #3106: wave on VS2010 beta compiler generates error.

Boost V1.42.0

- V2.0.4

- Fixed Wave for latest changes in multi_pass iterator.

Boost V1.41.0

- V2.0.3

- Switched to Re2C V0.13.5

- Fixed --list_includes/-l command line option of the wave driver tool to

correctly indent the generated list of included files.

- Finally fixed all remaining examples. Everything seems to work fine now.

- Specifying a custom token type now works as expected. The new lexer interface

introduced in V2.0 broke this part.

- Removed old code related to pre Boost V1.31 (related to V1 of iterator

library).

- Added a new commandline option --macrocounts/-c to the Wave driver application

which lists all macro invocation counts to an optionally specified file

(default is cout).

- Fixed compilation problems caused by recent changes to the multi_pass iterator

from Spirit V2.1.

- Added the new preprocessing hooks detected_pragma_once() and

detected_include_guard() which are getting called whenever either a #pragma

once has been detected or if the include guard heuristics detected an

include guard for a particular include file.

- Added a new command line option to the wave driver tool: --listguards/-g

allowing to trace all include files which are either contain a #pragma once

or contain include guards.

- Started to elminate g++ struct aliasing warnings (more to fix, mostly in

flex_string).

Boost V1.40.0

- V2.0.2

- Fixed a long standing race condition inhibiting to use Wave in multi threaded

environments.

- Incorporated the changes from latest version of the flex_string class (#2946).

- Fixed another race condition triggering problems using Wave in multi-threaded

environments.

Boost V1.39.0

- V2.0.1

- Fixed Wave to compile with BOOST_FILESYSTEM_NO_DEPRECATED defined (i.e. the

library doesn't use the deprecated filesystem interface anymore).

Boost V1.37.0

- Updated examples to reflect the recent changes in the used multi_pass

iterator.

- Fixed documentation links still pointing to the old Boost CVS (thanks to

Jürgen Hunold for providing the patch).

Boost V1.36.0

- Wave Version 2.0 is a new major release introducing some breaking API changes,

preventing it to be used with Boost versions earlier than V1.36.0. The API

and hook interface have been streamlined for more consistency. See the

documentation for more details.

- Added an additional template parameter to the context object, allowing to

specify any possibly derived type. This change propagates to the preprocessing

hooks, which now get passed the most derived context type as its first

argument allowing to access protected members in the original context type.

This fixes ticket #1752.

- Fixed a problem during parsing of #pragma wave directive, where the value

sequence contained a closing parenthesis. This caused a premature end of the

pragma value parsing.

- Fixed handling of support_option_single_line, which was ignored under certain

circumstances.

- Fixed ticket #1766: Wrong evaluation of conditional preprocessor directives

with predefined macros __FILE__, __LINE__ and __INCLUDE_LEVEL__. This bug

triggered an error in constructs like #ifndef __FILE__. Thanks to Daniel

Wadehn for reporting and supplying a patch. Added corresponding regression

test: t_2_018.cpp.

- Fixed a bug which reported a valid macro redefinition as invalid if the macro

replacement text referred to a second or higher parameter of this macro.

- Fixed a problem in the wave tool to allow two errors to occur while

preprocessing two consecutive tokens.

- Adjusted Spirit header includes to point to conform to the new directory

structure, removed support for Spirit versions earlier than V1.7.

- Started to migrate to new multi_pass iterators from Spirit V2.0.

Boost V1.35.0

- Wave Version 1.3

- Changed the return value of the 'evaluated_conditional_expression()' pp hook

to 'bool' allowing to force Wave to re-evaluate the current conditional

expression. This was suggested by Felipe Magno de Almeida.

- Added a wave::context object as first parameter to all pp hook functions.

This is an interface compatibility breaking change. The new pp-hooks can be

disabled by defining the BOOST_WAVE_USE_DEPRECIATED_PREPROCESSING_HOOKS

compile time constant to something not equal to zero. By default this

constant will be defined to zero for Boost V1.35.0 and newer, switching to

the new interface by default.

- Added optional support for the import keyword (needed for the C++ module

proposal). The identifier import will be recognized as a keyword, if

the compile time constant BOOST_WAVE_SUPPORT_IMPORT_KEYWORD is defined to

something not equal zero.

- Added new preprocessing hook functions: found_error_directive() and

found_warning_directive() to be called when #error/#warning directives are

encountered. This was suggested by Andreas Sæbjørnsen.

- Added a new sample to Wave: hannibal, a partial C++ parser implementation

initially written by Danny Havenith (http://havenith-verlinden.nl/hannibal/)

who agreed to add this here. Thanks!

- Added new preprocessing hook function: found_line_directive() to be called

when a #line directive is encountered. This was suggested by Andreas

Sæbjørnsen.

- Improved command line handling for the wave applet.

- Incorporated latest bug fixes for the Hannibal sample provided by Danny

Havenith.

- Added loading of a wave.cfg file from anywhere up the filesystem hierarchy

starting from the main input file for the wave driver applet up to the

root of the file system.

- Added support_option_emit_pragma_directive to allow to control at runtime,

whether unknown #pragma directives should be emitted or not. To maintain

compatibility with earlier versions this option is by default on if the

compile time constant BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES was defined to

be not equal to zero and it is off otherwise.

- Enabled XML serialization support.

- Added the throw_exception preprocessing hook, which gets called for every

occurring error (whenever an exception would have been thrown). The default

of this new hook function is to throw the corresponding exception, which

reproduces the old behavior.

- Implemented a new preprocessing hook: generated_token(), which get's called

whenever a token is about to be returned form the library. This function may

be used to alter the token before it gets returned to the calling

application.

- Added a new sample 'real_positions' demonstrating the new generated_token()

preprocessing hook and showing how to use Wave with a new token type without

using a new lexer type.

- Factored out the pure lex_input_interface to simplify writing different lexer

types for Wave.

- Added the token_statistics sample showing how to use Xpressive to build a

lexer for Wave.

- Changed the list_includes sample to use a lexer which is based on the lexertl

library written by Ben Hanson (http://www.benhanson.net/lexertl.html).

- Added a new support_option: insert_whitespace, allowing to switch off

whitespace insertion which is normally (by default) in place to disambiugate

C++ tokens, which would otherwise form different tokens in the output.

- Added a new commandline option to the Wave applet: --disambiguate, allowing

to control whitespace insertion. The default value for this option is

--disambiguate=1, resembling the previous behaviour. Specifying the option

--disambiguate=0 allows to suppress whitespace insertion alltogether.

- Added pragma option values push and pop to the line, preserve and output

options allowing to store and restore the current option. The syntax is:

#pragma wave options(<option>: push) and

#pragma wave options(<option>: pop)

where <option> may be line, preserve or output. Thanks to Eric Niebler for

suggesting this feature.

- Added the possibility to use static pre-compiled DFA tables for the lexertl

based lexer.

- Incorporated the changes from Andrei's latest version of the flex_string

class.

- Added the is_macro_defined(name) function to the context object as described

in the documentation. This function is usable with any string type compatible

with std::string.

- Changed behavior of the --force_include functionality, which now looks for

the file to be (force-)included in the current directory first.

- Switched to Re2C V0.11.2

- Added const specifiers to some of the context member functions.

- Fixed a problem in the SLex C++ lexer (cpp_tokens example).

- Fixed a runtime problem in the Re2C generated lexers when fed with

empty input files (thanks to Leo Davis for reporting and providing a patch).

- Added the is_eoi() function to token classes, returning true if the token

has been initialized to be the end of input token (T_EOI) (thanks to Ovanes

Markarian for suggesting this).

- Added missing #includes <cstring>, <cstdlib>, and <new> to flex_string.hpp.

- Added missing #include <climits> to cpp_chlit_grammar.hpp.

- Changed found_include_directive hook function to return a bool indicating,

whether the file should be included (true) or skipped (false). Thanks to

Felipe Magno de Almeida for suggesting this feature.

- Added code to the wave driver applet ignoring a #import directive (the whole

directive is passed through to the output) whenever the pp constant

BOOST_WAVE_SUPPORT_MS_EXTENSIONS is defined to something not equal to zero.

- Fixed the wave driver applet to correctly continue after a error or warning.

- Added a macro introspection facility allowing to iterate on all defined macro

names.

- Added a new commandline option --macronames/-m to the Wave driver application

which lists all defined macros and their definitions to an optionally

specified file (default is cout).

- Fixed configuration to take into account thread related build settings.

- Added the BOOST_WAVE_SUPPORT_LONGLONG_INTEGER_LITERALS pp constant allowing

to recognize large integer literals (larger in size than long/unsigned long)

even if these do not have a 'll' suffix. This pp constant is effective only,

if the target platform supports long long integers (BOOST_HAS_LONG_LONG is

defined).

- The following preprocessing hooks now return a boolean value, which when

returning 'true' cause the Wave library to skip the execution of the related

preprocessing action:

. found_directive: allows to skip the whole directive it is called for

. expanding_object_like_macro: allows to skip expansion of the given object

like macro, the macro symbol is copied to the output

. expanding_function_like_macro: allows to skip the expansion of the given

function like macro, the whole macro invocation (including all

macro invocation parameters) are copied to the output without any

further processing.

- Changed the interpretation of the return value of the found_include_directive

preprocessing hook: a return value of 'false' now processes the file

to be included normally and a return value of 'true' now skips the processing

of the include file directive (the file doesn't get included).

This change was necessary to make the return values of the preprocessing

hooks consistent. Now return 'false' generally means: normal execution and

return 'true' generally means: skip execution of the corresponding

preprocessor action.

- Fixed compilation problems on gcc, fixed ambiguity with boost code (detail

namespace was ambigious).

- Fixed predefined macro support to be thread safe.

- Added missing file to real_positions example. Thanks to Ludovic Aubert for

spotting the problem.

- Unterminated C++/C comment diagnostics are now a warning and not an error

anymore.

- Applied patch provided by Jens Seidel making sure every header compiles on

its own.

- Updates to the documentation.

- Fixed a problem in flex_string::compare() (#include_next was non-functional).

- Fixed a bug in the pp hook expanding_function_like_macro(), where the seqend

parameter was set to the first token after the closing parenthesis instead of

pointing at it.

- Added the BOOST_WAVE_SUPPORT_THREADING allowing to explicitly control

whether the Wave library is built with threading support enabled. If not

defined the build settings will be picked up from the Boost build environment

(BOOST_HAS_THREADS).

- Fixed a whitespace insertion glitch, where whitespace got inserted

unconditionally between two operators even if one of these was a comma.

- Fixed #line directive after a macro invocation containing newlines to

correctly reference the line number.

- Positions of macros defined on the command line now get properly reported as

"<command line>":1:...

- Added testing of the preprocessor hooks.

Boost V1.34.0

- Wave Version 1.2.4

- Added the possibility to explicitly enable/disable the generation of #line

directives. Added a corresponding commandline argument to the Wave driver

tool (--line/-L) which takes either 0 or 1 as its parameter.

- Added support for #pragma wave option(command: value) directives, which

supports the following commands:

. #pragma wave option(line: [0|1])

Enable/disable generation of #line directives

. #pragma wave option(preserve: [0|1|2])

Control whitespace preservation

. #pragma wave option(output: ["filename" | null | default])

Redirect output to the given file (or no output, if 'null' is specified,

or output to the file as given on the command line, if 'default' is

specified).

The filename is resolved relative to the directory of the processed

file.

These new #pragma directives are implemented in the Wave driver tool only.

It is possible to combine several options in one #pragma directive, i.e.

#pragma wave option(line: 0, preserve: 2).

- Changed the signature of the may_skip_whitespace() preprocessing hook to

additionally take the preprocessing context as its first parameter.

- Added the possibility to the Wave tool to disable initial output by

specifying a '-' as the output file. This is useful for syntax checks only or

in conjunction with the #pragma wave option(output: ...) to restrict the

generated output.

- Improved error reporting in the Wave tool on bad output file stream state.

- Switched to Re2C V0.10.0

- Fixed some of the VC7.1 /W4 warnings.

- The Wave tool now creates the directory hierarchy of output files as needed.

- Applied some optimization, which causes skipping of the parsing for almost

all preprocessor directives when the if block status is false. This gains

upto 10-20% in speed for average applications.

- Added error diagnostic for #elif without matching #if, which was missing

under certain circumstances.

- Avoided the evaluation of #elif expressions if one of the previous #if/#elif

blocks of the same level was true. This gains upto another 5% of speed for

average applications.

- The MS specific integer suffix 'i64' is now correctly supported by the Re2C

and SLex lexer components (only when BOOST_WAVE_SUPPORT_MS_EXTENSIONS is

defined during compilation).

- Changed the Wave tool to print the column number of an error/warning along

with the line number. The new format is: 'filename:line:column: error text'.

- It is now possible to recover from the unbalanced #if/#endif statement

warning in a proper way.

- The Wave library now automaticaly recognizes include guards in headers files

and uses this information to avoid opening these header files more than once.

This speeds up things by upto 10-20% depending on the concrete include files.

- Fixed the failing test t_6_023.cpp. Error reporting for illformed #else

directives was broken (because of some recent changes).

- Fixed the failing test t_5_007.cpp. This was caused by the automatic include

guard detection, which prevented the second inclusion of the specified

include file the test was relying on.

- Added the possibility to switch off the automatic include guard detection.

- Added a new command line option to the Wave tool: --noguard/-G, which

disables the automatic include guard detection.

- Now a header with include guards will be included correctly for a second time

after its include guard symbol gets undefined.

- Added the generating platform to Wave's full version string.

- Made the Wave tool fully interactive when started with input from stdin and

and output to stdout. In this mode the Wave tool preprocesses the input

line by line and not only after receiving the full input as normally.

- Added serialization support for the wave::context object, which stores

all information about defined macros and all #pragma once header information.

- Added the command line option --state (-s) to the Wave tool, which tries to

load the serialized information from the file given as the argument to

--state and save the state information at the end to the same file.

This option is available in interactive mode only.

- Added possibility to verify the compatibility of the configuration used

during compilation of the Wave library with the config info used for the

application. Added a corresponding test to the Wave tool.

- Added a new predefined macro __WAVE_CONFIG__ which expands to an integer

literal containg the configuration information the library was compiled

with.

- Added proper versioning support to the serialization of state.

- Fixed the macro tracing information to contain the column numbers of the macro

definitions as well (the format used is the same as for error messages).

- Fixed a memory leak in the flex_string copy on write code (thanks to Tobias

Schwinger for reporting this bug).

- Fixed a memory corruption bug in the Re2C scanner buffer management code

(thanks to Andreas Sæbjørnsen for spotting the bug).

- Fixed a major performance bottleneck in the lex_token class. This speeds up

Wave for upto another 20-40% depending on the amount of macro expansions to

perform.

- Added the BOOST_SPIRIT_USE_BOOST_ALLOCATOR_FOR_TREES and the

BOOST_SPIRIT_USE_LIST_FOR_TREES Spirit configration constants to the

wave_config.hpp to allow to fine tune the generated Spirit tree code. VC7.1

gives best results when both are defined.

- Fixed a memory corruption bug triggered by a possible dangling reference.

- Fixed Wave tools startup crash when compiled with VC8.

- Added the name of the generating compiler (BOOST_COMPILER) to the full

Wave version info.

- Fixed all Jamfile.v2 to correctly disable RTTI for VC7.1.

- Added #pragma message("...") to be optionally supported by the Wave library.

This may be enabled by defining the BOOST_WAVE_SUPPORT_PRAGMA_MESSAGE pp

constant to some value different from zero.

- Fixed a couple of typos in the file cpp.cpp preventing it to compile on

gcc 4.1.0 (thanks to Richard Guenther for reporting these).

- Richard Guenther fixed another buffer overrun problem in the Re2C scanner.

- Fixed Jamfile.v2 files for all sample applications.

- Fixed a bug which lead to reporting of an illegal preprocessing directive

inside not-evaluated conditional blocks under certain circumstances (thanks

to Tobias Schwinger for reporting).

- Fixed '#define true ...', '#define false ...' and other constructs, i.e. the

usage of the boolean keywords as identifiers during the preprocessing. Added

a corresponding test case (t_9_017.cpp). Thanks to Andreas Sæbjørnsen for

reporting.

- Corrected the Jamfile[.v2] of the waveidl sample to refer to correct file

names (thanks to Juergen Hunold for submitting a patch).

- Fixed a bug which prevented the main iterator from returning a T_EOF token

at the overall end of the input.

- Fixed a problem, where non-evaluated #elif directives never got passed to the

skippen_token() pp hook (thanks to Andreas Sæbjørnsen for reporting).

- Fixed a problem in the get_tokenname() function.

- Added a missing #define BOOST_WAVE_SOURCE 1 to the wave_config_constant.cpp

file.

- Fixed exception specifications to catch all exceptions by const&.

- Fixed predefined macros to appear to be defined at a position referring to

a file named "<built-in>". Thanks to Andreas Sæbjørnsen for reporting.

- Fixed the Re2C lexer not to segfault on empty files anymore.

- Stripped leading and trailing whitespace for all lines in a config file (Wave

driver tool).

- Fixed RTTI build issue for VC7.1/bjam --v2 (thanks to Rene Rivera for

submitting a patch for the Wave Jamfile.v2).

- Fixed certain problems reported by the Boost inspection tool.

- Fixed a couple of SunPro5.8 warnings.

- Fixed a bug resulting in a crash if a macro was redefined with a shorter

expansion list as it was defined initially. Added a corresponding test case.

- Fixed a bug causing an infinite loop when there was a missing endif in the

main preprocessed file.

- Improved error recovery for illegal preprocessing directive errors.

- Improved error handling and error recovery for conditional expressions

(#if/#elif expressions).

- Wave now passes 160 out of 161 tests from the MCPP V2.6.1 validation

testsuite!

- Added new warning for invalid #line number and filename arguments

- Improved error diagnostics for invalid #line directives containing arbitrary

tokens after at the end of the line.

- Improved error handling wrt the misuse of the __VA_ARG__ token in macro

definitions.

- The warning, that a file is not terminated by a newline is now issued for all

files, not only for the main file (as previous).

- Added a couple of new test cases to verify various diagnostics.

- Fixed wave applet not to report missing #endif's when in interactive mode.

- Cleaned up the Re2C lexer code.

- Fixed a bug, where a empty line followed by an arbitrary token and followed

by a preprocessing directive interpreted the preprcessing directive as if it

were the first non-whitespace token on the line. This error occurred only

if the #line directive generation was suppressed. Thanks to Joan Grant for

reporting this problem.

- Fixed a problem in the Wave applet which prevented the correct recognition of

Windows file paths in a configuration file, if this path was enclosed in

quotes.

- Extended the copyright notice to include the year 2007.

- Fixed a problem in preserve=1 mode, when a C style comment triggered the

generation of a #line directive.

- Worked around a linker issue for the True64/CXX compiler, complaining about

multiple defined symbols when using the flex_string class.

- Added missing documentation for the context::get_macro_definition function.

Sat Feb 18 2005

- Version 1.2.3

- Added a missing throw() specification to the function

cpp_exception::get_related_name().

- Fix Boost bug ([ boost-Bugs-1395857 ] wave redefines BSIZE).

- Added missing calls to the skipped_token() preprocessing hook which wasn't

called for pp directives inside disabled #if blocks.

- Made the context<> type noncopyable.

- Introduced the --extended/-x command line option to the wave driver

executable, which enables the #pragma wave system() directive. This directive

is now disabled by default because it may cause a potential security threat.

- Changed the what() function of the macro_handling_exception class, which now

correctly returns the name of the exception type itself.

- Added a diagnostic message to the wave driver executable, which is issued

whenever a #pragma wave system() directive is found, but the -x (--extended)

command line argument was not given.

- Fixed long integer suffix to be allowed to be mixed case (1Ll or 2lL).

- Fixed the BOOST_PP_CAT(1e, -1) pp-token bug. Wave now correctly recognizes

pp-number tokens, which are converted to C++ tokens right before they are

returned from the library.

- Moved the implementation of the token_id query functions (get_token_name(),

get_token_value()) to a separate source file.

- Fixed a bug, which prevented to prefer pp-numbers in files preprocessed as

a result of #include directives.

- Fixed a bug, which prevented to open #include'd files specified by an

absolute path.

- Fixed a problem in the expression parser value type.

- Fixed a dynaload compilation problem with VC7.1 of the re2c lexer tests.

Sat Dec 24 13:33:53 CST 2005

- Version 1.2.2

- Added three new preprocessing hooks: 'found_directive', 'skipped_token' and

'evaluated_conditional_expression' (thanks to Andreas Sæbjørnsen for the

suggestions).

- Removed hook forwarding functions in the context_type.

- Added missing include_next case branches for get_directivename() function.

- Added new sample: advanced_hooks.

- Fixed a possible buffer overflow in the cpplexer and cpp exception classes.

- Made the cpp_grammar thread safe.

- Removed the need for the get_directivename() function. Fixed typos in the

predefined token table.

- Removed assertions from get_token_name() and get_token_value() and replaced

these with more meaningful code.

- Added the BOOST_WAVE_USE_STRICT_LEXER configuration constant which allows to

decide, whether the '$' character will be recognized as a part of identifiers

or not (the default is BOOST_WAVE_USE_STRICT_LEXER == 0, i.e. '$' will be

recognized as part of identifiers).

- Added the possibility to testwave to extract a tagged comment based on a

preprocessor constant (testwave V0.4.0).

- Made the predefined_macros_grammar thread safe.

- Added dll support for the generated Wave libraries.

- Added the const_iterator based exlicit instantiations for the Re2C lexer to

the built Wave library and dll.

- Added the whitespace handling policy to the context object. This actually is

no separate policy, it's a new preprocessing hook allowing to decide, whether

a concrete token has to be skipped.

- Changed the --preserve option of the wave tool to take a single integer

argument (0: no whitespace is preserved, 1: only comments are preserved,

2: all whitespace is preserved)

- Edited the command line option descriptions of the wave driver.

- Fixed broken tags in documentation (magically inserted by DreamWeaver).

- Merged the new whitespace_handling policy with the existing preprocessing

hooks. The name of the new preprocessing hook ist may_skip_whitespace().

- Fixed compatibility issues for CW9.4 in the Wave test aplication.

- Added get_errorcode() member to the wave exception classes allowing to

get back the reason for the exception.

- Added boost::wave::is_recoverable(cpp_exception const&) alowing to decide,

whether it is possible to continue after a cpp_exception has been thrown.

This is a temporary hack to overcome the current limitation of the library

not allowing to do generic error recovery. It allows to recover from 75% of

the generated errors types.

- The --timer command line option for the Wave driver now prints the elapsed

time correctly even if a preprcessing error occurred.

- Fixed an error recovery problem which skipped one token after continuing in

case this was a pp directive.

- Added the --autooutput (-E) option to the Wave driver applet which redirects

the generated output to a file named after the input file changing the file

extension to '.i'.

- Changed all throw's to boost::throw_exception.

- Added the possibility to configure the command keyword for the wave specific

#pragma directives. It is now possible to define a string literal via

BOOST_WAVE_PRAGMA_COMMAND, which will be recognized and all corresponding

#pragmas are dispatched to the interpret_pragma() preprocessing hook.

The default value for BOOST_WAVE_PRAGMA_COMMAND is "wave", just to ensure

complete backward compatibility.

- Added missing #pragma warning(pop) directives.

- Fixed a bug wrt error propagation in the expression parser.

- Fixed an assertion fired when cpp_token is used to process the quick_start

sample.

- Fixed a (Windows specific) bug which triggered a boost::file_system exception

under certain conditions.

- Switched to Re2C V0.9.11

- Fixed a problem with the new '-E' (--autooutput) option.

- Added better error reporting for duplicate macro definitions to the Wave

tool. Added the macro_handling_exception type containing the corresponding

macro name via the new (virtual) get_related_name() function.

- Added the get_severity() function to the exceptions thrown by the Wave

library.

- Extended the copyright notice to include the year 2006.

Mon Dec 5 22:05:22 CST 2005

Boost V1.33.1

- Version 1.2.1

- Fixed bug reported as Sourceforge bug 1274584.

- Switched to Re2C V0.9.9.

- Fixed a bug where the 'parameters' and 'definition' parameters to the

defined_macro callback of the preprocessing hooks were always empty (thanks

to Stefan Seefeld for reporting).

- Fixed missing namespace specifiers in token definition macros (thanks to

Jozsef Mihalicza for reporting).

- Enabled --preserved and --long_long modes by default for the cpp_tokens

sample.

- Newline tokens reported a wrong line number (offset by one) when using the

Re2C generated lexer (thanks to Jozsef Mihalicza for pointing this out).

- Changed file positions to carry 'unsigned int' line and column numbers.

- Fixed tokens of a generated #line directive to carry the correct column

numbers.

- Tokens now contain the correct filename, line and column numbers even if

a #line directive was encountered.

- Fixed wrong line numbering in reference comments of the tests t_5_002.cpp and

t_5_035.cpp.

- Made sure, that preprocessor expression errors get ignored for 'passive'

#elif branches.

- Fixed an issue reported by the gcc debug stl.

- Added the <vc-7_1-stlport><*><rtti>off directive to all of the V1 Jamfiles.

Wed Aug 17 20:21:00 CST 2005

Boost V1.33.0

Version 1.2

- Fixed name clash wrt T_DIVIDE on FreeBSD.

- Fixed documentation of the different language_support flags.

- The support for long long suffixes is no longer bound to the variadics mode,

it has to be enabled by the new long_long mode (default in C99).

- Fixed compilation if BOOST_WAVE_DUMP_PARSE_TREE is defined.

- Fixed lexer error message wrt long_long mode.

- Stefan Seefeld fixed a bug in the lexer, where include_next was assumed for

included files containg a "include_" in their name.

- Fixed some trigraph token id's in the lexers.

- Added column information to the re2c generated lexer.

- Added tests for the different lexers.

- Fixed the found_include_directive preprocessing hook to carry the information

about #include_next directives as well.

- Separated the different lexer tests.

- Fixed a bug in the whitespace eater.

- Fixed a bug where Wave emitted the found C++ comments in --preserve mode even

if these were found inside of disabled #if/#endif blocks.

- Removed the function local static grammars to avoid possible raise conditions

and to make CW8.3 happy.

- Unified lexer interface, adjusted namespaces.

- Added lexer testcases to the regression tests.

- Fixed test cases to scale to 64 bit platforms.

- Disabled the MS specific extensions in the lexer tests in a platform related

way.

- Added special handling of the eof tokens inside the lexer iterator classes

for Comeau.

- Applied a workaround proposed by David Abrahams to make the slex lexer work

on the CodeWarrior platforms.

Sun May 8 17:22:59 WEDT 2005

Version 1.1.17

- Added ill_formed_character_literal and ill_formed_integer_literal errors.

- Improved error handling and diagnostics for integer overflow in #if/#elif

expressions.

- Fixed a bug in the testwave application which prevented the correct

recognition of expected errors under certain circumstances.

- Fixed a portability problem (for gcc 3.3.x) in the testwave application.

- Enforced that #if/#endif are balanced file wise.

- Changed the command line arguments for the Wave testrun to use absolute

directories.

- Changed the test application to return a value != zero if one of the given

config files were not found.

- Fixed a command line parsing problem caused by a change in the parameter

handling inside in the program_options library.

- Switched to the most recent version of re2c (V0.9.7.dev).

- Fixed a como compilation error and several como --a warnings.

- The T_EOF token doesn't carry the value of the previous token anymore.

- Added operator==() to the token classes to fix the ambiguity error reported

by the True64 compiler.

- Improved the error message, when empty arguments are used in pure C++ mode.

- Added character literal out of range testing and an additional corresponding

error message.

- Fixed parsing of long character literals (such as '\x1234').

- Fixed almost all problems diagnosed by the Boost inspection report.

- Several fixes to make the True64 compiler happy.

- Added the long long suffix handling to the C99 mode (LL/ll).

- Fixed a bug in the slex regex specifications.

Thu Apr 7 10:07:45 WEDT 2005

Version 1.1.16

- Fixed a bug in the white space eating component, which prevented a C++

comment to be suppressed if it followed after another whitespace.

- Fixed the inconsistencies between the documentation and the behaviour wrt the

different include search paths. See the Wave driver docs for details of how

the '-I', '-I-', and '-S' options work.

- Allowed to specify more than one config file ('@' syntax) on the command line

of the wave driver executable.

- Changed copyrights in all files to reflect the acceptance of Wave into Boost.

- Unknown preprocessing directives were not recognised as such anymore.

- If comments shouldn't be preserved all C++ comments are replaced by newline

tokens (instead of beeing igored completely).

- Fixed a bug in the white space eater component.

- Fixed a bug which reported wrong line numbers for error encountered during

retokenisation (concatination).

- Fixed a bug in the unescaping code.

- Fixed a compilation error of the testwave executable (added a missing

namespace specifier).

- Added a missing header to make cpp.re.cpp compile on CW.

- The predefined macro __BASE_FILE__ now returns a properly escaped file name

string.

- Fixed the function boost::wave::util::impl::unescape_lit().

- Added the Wave unit test framework. For now it contains about 60 unit tests

executed by a special test driver (testwave).

- Added the '$F' replacement string to the testwave application. This allows

to handle file paths sensitive comparison of the expected and real results.

- Fixed a minor problem in the whitespace eating component.

- Added optional trigraph conversion.

- Changed all size_t, time_t etc. to std::size_t, std::time_t etc (for CW).

- If the comments should not be preserved every C comment containing at minimum

one newline is now converted to a newline token.

- Added the lexed_tokens sample.

- Fixed warnings and errors reported by the CodeWarrior compiler.

- Added the '$V' replacement string to the testwave application. It expands to

the current BOOST_LIB_VERSION.

- Diagnosed the attempt to redefine the alternative operators as and, or etc.

- Improved error handling.

- Disabled the flex_string class for VC7, enabled to fallback to std::string

for this compiler.

- Renamed files to comply with the Boost rules.

- Added the first part of the MCPP validation suite to the Wave unit tests.

- Added even more missing "using namespace std;" statements for functions from

the C runtime library. The Wave test suite now contains more than 100 unit

tests.

- Added the $P/$P(basename) replacement string to the testwave application

which expands to the full path of the current file ($P) or to the current

directory/basename ($P(basename)).

- Fixed a bunch of portability problmes revealed by the regression tests on

different platforms. Thanks to Stefan Slapeda for his support to make it work

on the cw-9_4 toolset (win32).

Tue Mar 22 14:52:45 WEST 2005

Version 1.1.15

- Fixed a bug where the complete set of C99 predefined macros were pre-defined

when in C++ mode and variadics were enabled.

- When in variadics or C99 mode the __BASE_FILE__ predefined macro expanded to

<Unknown>.

- Added the --listincludes option to the Wave driver executable which allows to

log the file names of the include files opened.

- Fixed a gcc warning in token_cache.hpp (unused variable end).

- Changed the logic behind #include_next. It now starts searching with the

next directory after the directory the current file (the file containing the

#include_next directive) is located in.

- Changed the signature of the undefined_macro preprocessing hook to take the

token itself and not the macro name only. This is important to pass the full

context information about the position of the #undef directive to the

user provided hook (thanks to Stefan Seefeld for pointing that out).

- Fixed several broken links in the Context Policy topic.

- Fixed a bug in the handling of the #include_next directive inside of

non-evaluated #if blocks.

- Fixed a bug in the #include_next handling code (thanks to Stefan Seefeld).

- Changed the signature of the opened_include_file() preprocessing hook which

now receives not only the absolute file name of the openend include file but

additionally gets passed the (possibly) relative path of the openend include

file. This concrete format of the relative path depends on the format of the

include search directory given to the library.

- Added a new preprocessing hook 'found_include_directive()' which gets called

for every #include directive (even for those where the file to include

doesn't exist) and which gets passed the (expanded) token sequence found

after the #include directive token.

- The file names passed to the preprocessing hooks are now normalised.

- Changed the opened_include_file() preprocessing hook to receive the correct

relative path even if the included file was found in the current directory.

- Fixed a bug which reported 'defined(or)' as invalid (similarly all the other

alternative bit operation token types).

- Fixed a bug which prevented to define variadic macros from the command line.

- Added a 'preserve comments' mode to preserve the comments in the input stream

not inserted into macro definitions.

- Added a new --preserve (-p) command line switch to the wave driver

application to allow comments to be preserved in the generated output stream.

Mon Feb 21 09:30:04 WEST 2005

Version 1.1.14 (Fixes in response to the Boost review)

Wave was accepted into Boost!

With special thanks to Tom Brinkman, who volunteered to be the review manager.

With thanks to David Abrahams, Beman Dewes, Reece Dunn, Larry Evans,

Doug Gregor, Joel de Guzman, Baptiste Lepilleur, Andy Little, Paul Mensonides,

Dan Nuffer, Andreas Pokorny, Vladimir Prus, Gennadiy Rozental, Michiel Salters,

Jonathan Turkanis, Chris Uzdavinis, Pavel Vozenilek, Michael Walter for bug

reports, fixes and hints.

- Added support for the MS extensions #region and #endregion, which simply get

ignored by Wave. The support for these is enabled only, when the pp constant

BOOST_WAVE_SUPPORT_MS_EXTENSIONS is defined. Otherwise these get flagged as

an illegal preprocessor directive (as before).

- Fixed a problem, where the replacement text for a #pragma directive got lost

if this directive was on the last line of a processed (include-)file.

- Changed the default value for BOOST_WAVE_SUPPORT_MS_EXTENSIONS for non-

Windows systems to zero.

- Updated outdated external links in the documentation.

- Fixed certain grammatical and stylistic quirks in the documentation.

- Fixed a problem in libs/wave/build/Jamfile.v2 (as reported by Larry Evans).

Fixed the Jamfile.v2 in the samples directories accordingly.

- Added the '<toolset>vc-7_1:<rtti>off' to all Jamfile.v2 files to adjust for

the internal buffer overflow bug in the VC7.1 compiler (reported by Joel de

Guzman).

- Changed the '<toolset>vc-7_1:<rtti>off' to '<toolset>vc-7.1:<rtti>off' as

required by the Boost.Build.v2 library (suggested by Vladimir Prus).

- Finally fixed the Jamfile.v2 file (after a suggestion from Reece Dunn)

- Fixed the column number reported for tokens for Slex lexer based

configurations (reported by Baptiste Lepilleur).

- Added the __BASE_FILE__ predefined macro, which contains a string literal

of the main file name to preprocess (the one the context<> template was

created with). (suggested by Pavel Vozenilek)

- Used the boost::reverse_iterator instead of the std::reverse_iterator

for the flex_string class to allow compilation of Wave with VC7.0

(as suggested by Reece Dunn).

- Fixed a problem in the include_path template, which throwed a

boost::filesystem exception whenever a character was used in a file name

to include, which is marked as illegal by the default name checker of the

boost::filesystem::path.

Version 1.1.13 (Boost review candidate 2, bug fixed version)

- Fixed a problem, where the context<> template referenced temporary iterator

objects from the underlying stream (thanks to Michiel Salters for reporting

this).

- Fixed a bug in the re2c lexer, which allowed to dereference the end iterator

of the underlying input stream (thanks to Doug Gregor for pointing this out).

- Fixed several assertions fired by the iterator checking code of the VC8 stl.

Version 1.1.12 (Boost review candidate)

- A rough performance analysis showed, that 30% of the time is spent parsing

the input for pp directives (cpp_grammar), 35% of the time is spent inside

the flex_string code, mainly in the copy constructor and assignment

operator, 15% of the time is spent inside the list and vector member

functions, 10% is spent for memory allocation but only 1% of the time is

spent in the re2c lexer.

- Identified a performance problem, where the token_cache was instantiated

for every created lexer object, but needed to be initialised only once.

- Added #include <wave_version.hpp> to wave_config.hpp

- Fixed problems reported by the gcc 3.4.1 compiler.

- Adjusted Jamfiles for the new toolset names introduced in Boost V1.32.

Version 1.1.11

- Updated copyrights.

- Fixed some bugs introduced by the latest refactoring.

- Tried to fix the expansion of macros, which replacement-list terminates in a

partial macro expansion. No success so far.

Version 1.1.10

- Refactored some of the macro map (macro namespace) code (added comments,

splitted into separate files),

- Fixed some typename errors in cpp_macromap.hpp (thanks to Vladimir Prus).

- Fixed the BoostBuild V2 Jamfiles (thanks to Vladimir Prus).

Version 1.1.9

- Moved all of the #pragma wave option(value) operators out of the wavelib into

the wave driver program. Removed enable_trace() and trace_flags() policy

functions. Renamed trace_policy into context_policy.

- Added the defined_macro() and undefined_macro() preprocessing hooks to allow

easily to build macro cross referencers and such.

Version 1.1.8

- Replaced the usage of the string::erase() and string::insert() functions,

which were the only non-const string member functions used.

- Token pasting is now well defined in variadics mode (was in C++0x mode only).

- Changed the timing code in the wave driver to include the parsing of

files included by the --forceinclude command line switch.

- Performance measurements (very informal) [sec], the files are some of the

preprocessor specific test cases from Paul Mensonides chaos_pp library.

std::string flex_string const_string const_string

12 Byte 28 Byte

arithmetic.cpp 2.543 1.742 0.951 1.001

array.cpp 2.453 1.762 0.951 1.011

comparison.cpp 0.560 0.340 0.270 0.280

control.cpp 0.590 0.340 0.290 0.300

debug.cpp 0.370 0.310 0.190 0.190

detection.cpp 0.050 0.060 0.030 0.030

extended.cpp 0.370 0.260 0.190 0.190

facilities.cpp 0.610 0.340 0.290 0.300

iteration.cpp 1.081 0.550 0.410 0.450

list.cpp 1.742 1.141 0.811 0.851

logical.cpp 0.070 0.200 0.040 0.040

punctuation.cpp 0.030 0.080 0.020 0.020

repetition.cpp 1.392 0.851 0.650 0.690

selection.cpp 0.440 0.270 0.210 0.220

slot.cpp 0.680 0.350 0.240 0.270

tuple.cpp 0.420 0.240 0.190 0.210

Wed Aug 25 13:23:27 WEDT 2004

Version 1.1.7

- Branched for Boost Release.

- Removed several features from the code base:

. removed C++0x support

. removed TST support

- Fixed the program_option validator syntax, which has changed since the last

update.

- Removed misleading configuration options from the cpp_config.hpp file,

because the application will have to use the same config options as were used

during the compilation of the library.

- Changed the naming convention of typedef'd types in the library. Removed the

_t suffix, wherever possible.

- Updated the documentation to reflect the removal of the C++0x features.

- Changed the licensing scheme to:

// Copyright 2004 Joe Coder. Distributed under the Boost

// Software License, Version 1.0. (See accompanying file

// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

Mon May 24 10:02:47 WEDT 2004

Version 1.1.6

- Fixed a incompatibility with the new program_options version.

Version 1.1.5

Version 1.0.6

- Fixed a bug, which reported an #include statement as ill formed, if it was

followed by an empty C comment only. This was an error in the cpp.re regular

expression for C comments. Additionally, since this change simplified the

Re2C generated lexer a lot it was possible to remove the compiler workaround