Boost-Commit :

Date view	Thread view	Subject view	Author view

From: hartmut.kaiser_at_[hidden]
Date: 2008-07-29 17:37:10

Next message: eric_at_[hidden]: "[Boost-commit] svn:boost r47872 - trunk/tools/boostbook/xsl/doxygen"
Previous message: daniel_james_at_[hidden]: "[Boost-commit] svn:boost r47870 - in trunk/more/getting_started: . detail"

Author: hkaiser
Date: 2008-07-29 17:37:09 EDT (Tue, 29 Jul 2008)
New Revision: 47871
URL: http://svn.boost.org/trac/boost/changeset/47871

Log:
Wave: More documentation changes
Text files modified:
   branches/release/libs/wave/doc/class_reference_context.html | 1234 +++++++++++++++++++++++++--------------
   branches/release/libs/wave/doc/class_reference_ctxpolicy.html | 657 ++++++++++++++------
   branches/release/libs/wave/doc/preface.html | 130 +++
   3 files changed, 1342 insertions(+), 679 deletions(-)

Modified: branches/release/libs/wave/doc/class_reference_context.html
==============================================================================
--- branches/release/libs/wave/doc/class_reference_context.html (original)
+++ branches/release/libs/wave/doc/class_reference_context.html 2008-07-29 17:37:09 EDT (Tue, 29 Jul 2008)
@@ -1,515 +1,861 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
- <head>
- <title>The Context Object</title>
- <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
- <link rel="stylesheet" href="theme/style.css" type="text/css">
- </head>
- <body text="#000000" background="theme/bkd.gif">
-<table width="100%" border="0" cellspacing="2" background="theme/bkd2.gif">
- <tr>
- <td width="21"> <h1></h1></td>
- <td width="885"> The
- Context Object</td>
- <td width="96"></td>
- </tr>
+<head>
+ <title>The Context Object</title>
+
+
+ <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+
+ <link rel="stylesheet" href="theme/style.css" type="text/css">
+
+</head>
+
+
+ <body style="color: rgb(0, 0, 0); background-image: url(theme/bkd.gif);">
+
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+
+ <tbody>
+
+ <tr>
+
+ <td width="21">
+ <h1></h1>
+
+ </td>
+
+ <td width="885"> The Context Object</td>
+
+ <td width="96"></td>
+
+ </tr>
+
+ </tbody>
</table>
+
 
- <table border="0">
- <tr>
+
+<table border="0">
+
+ <tbody>
+
+ <tr>
+
 <td width="10"></td>
+
 <td width="30"></td>
- <td width="30"></td>
+
+ <td width="30"></td>
+
 <td width="30"></td>
+
 </tr>
- </table>
-<blockquote>
+
+ </tbody>
+</table>
+
+<blockquote>
 Introduction 
- Header 'wave/context.hpp' synopsis 
- Public Typedefs 
- Template parameters 
- Member functions
- </blockquote>
+
+ <a href="class_reference_context.html#header_synopsis">Header
+'wave/context.hpp' synopsis</a> 
+
+ <a href="class_reference_context.html#public_typedefs">Public
+Typedefs</a> 
+
+ <a href="class_reference_context.html#template_parameters">Template
+parameters</a> 
+
+ <a href="class_reference_context.html#member_functions">Member
+functions</a>
+
+</blockquote>
+
<h2><a name="introduction"></a>Introduction</h2>
-The <tt>boost::wave::context<></tt> object is the main user visible object of
- the <tt>Wave</tt> library. It exists to generate the pair of iterators, which
- while dereferenced return the preprocessed tokens. Additionally it is used
- to control other aspects of the preprocessing, such as 
-<blockquote>
- <IMG id="IMG1" height="13" src="theme/bullet.gif" width="13"> include
- search paths, which define, where to search for files to be included with
- <tt>#include <...></tt> and <tt>#include "..."</tt> directives 
- <img src="theme/bullet.gif" width="13" height="13"> which
- macros to predefine and which of the predefined macros to undefine 
- <img src="theme/bullet.gif" width="13" height="13"> several
- other options as for instance to control, whether to enable several extensions
- to the C++ Standard (as for instance variadics and placemarkers) or not.
-</blockquote>
-<h2><a name="header_synopsis"></a>Header wave/cpp_context.hpp
- synopsis</h2>
-<pre>namespace boost {
-namespace wave {
-
- template <
- typename Iterator, typename LexIterator,
- typename InputPolicy, typename ContextPolicy
- >
- class context : public InputPolicy
- {
- public:
-
- typedef pp_iterator<context> iterator_type;
- typedef Token token_type;
- typedef typename token_type::position_type position_type;
- typedef std::list<token_type> token_sequence_type; 
- // constructor
- context(Iterator const &first_,
- Iterator const &last_,
- char const *fname = "<Unknown>",
- ContextPolicy const& ctx_policy = ContextPolicy())
-
- // iterator interface
- iterator_type begin() const;
- iterator_type end() const;
-
- // maintain include paths
- bool add_include_path(char const *path_);
- bool add_sysinclude_path(char const *path_);
- void set_sysinclude_delimiter();
-
- size_t get_iteration_depth() const;
-
- // maintain defined macros
- bool add_macro_definition(std::string macrostring,
- bool is_predefined = false);
- template <typename String>
- bool is_defined_macro(String const &name) const;
- bool remove_macro_definition(std::string const &name,
- bool even_predefined = false);
- void reset_macro_definitions();
- bool get_macro_definition(
- std::string const &name, bool &is_function_style, 
- bool &is_predefined, position_type &pos,
- std::vector<token_type> &parameters,
- token_sequence_type &definition) const;
- name_iterator macro_names_begin();
- name_iterator macro_names_end();
- const_name_iterator macro_names_begin() const;
- const_name_iterator macro_names_end() const;
-
- // other options
- void set_language(language_support enable);
- language_support get_language() const; 
- void set_max_include_nesting_depth(std::size_t new_depth); size_t get_max_include_nesting_depth() const; 
- // get the Wave version information 
- static std::string get_version();
- static std::string get_version_string();
- };
-
-} // namespace wave
-} // namespace boost</pre>
-<h2><a name="template_parameters"></a>Template parameters</h2>
-The <tt>boost::wave::context</tt> object has three template parameters to specify
- the concrete behaviour of its operation. The following table describes these
- with more detail.
-<table width="90%" border="0" align="center">
- <tr>
- <td colspan="2" class="table_title">Template parameters required for the
- <tt>boost::wave::context</tt> class </td>
- </tr>
- <tr>
- <td width="32%" class="table_cells"><code>Iterator</code></td>
- <td width="68%" class="table_cells">The type of the underlying iterator,
- through which the input stream is accessed. 
- This should be at least an <tt>forward_iterator</tt> type iterator.</td>
- </tr>
- <tr>
- <td class="table_cells"><code>LexIterator</code></td>
- <td class="table_cells">The type of the lexer type to be used by the <tt>Wave</tt>
- library to identify tokens in the input stream.</td>
- </tr>
- <tr>
- <td class="table_cells"><code>InputPolicy</code></td>
- <td class="table_cells">The type of the input policy class, which allows
- to customize the behaviour of the Wave library and the type of the iterators
- to use, when it comes to including and opening an included file.</td>
- </tr>
- <tr>
- <td class="table_cells"><code>ContextPolicy</code></td>
- <td class="table_cells">The type of the context policy class, which allows
- to customize different aspects of the behaviour of the preprocessing. The requirements of this policy and the available customization points provided by this policy are described here.</td>
- </tr>
+
+The <tt>boost::wave::context<></tt>
+object is the main user visible object of the <tt>Wave</tt>
+library. It exists to generate the pair of iterators, which while
+dereferenced return the preprocessed tokens. Additionally it is used to
+control other aspects of the preprocessing, such as 
+
+<blockquote>
+ <img id="IMG1" src="theme/bullet.gif" height="13" width="13"> include
+search paths, which define, where to search for files to be included
+with <tt>#include <...></tt> and <tt>#include "..."</tt>
+directives 
+
+ <img src="theme/bullet.gif" height="13" width="13"> which macros to
+predefine and which of the predefined macros to undefine 
+
+ <img src="theme/bullet.gif" height="13" width="13"> several other options as
+for instance to control, whether to enable several extensions to the
+C++ Standard (as for instance variadics and placemarkers) or not.
+
+</blockquote>
+
+<h2><a name="header_synopsis"></a>Header
+wave/cpp_context.hpp
+synopsis</h2>
+
+<pre>namespace boost { namespace wave { struct this_type {}; template < typename Iterator, typename LexIterator, typename InputPolicy, typename ContextPolicy, typename Derived = this_type > class context : public InputPolicy { typedef <unspecified> token_sequence_type; public: typedef pp_iterator<context> iterator_type; typedef Token token_
type; typedef typename token_type::position_type position_type; typedef std::list<token_type> token_sequence_type; // constructor context(Iterator const &first_, Iterator const &last_, char const *fname = "<Unknown>", ContextPolicy const& ctx_policy = ContextPolicy()) // iterator interface iterator_type begin() const; iterator_type begin(Iterator const &first, Iterator const &last) const; iterator_type end() const; // maintain include paths bool add_include_path(char const *path_); bool add_sysinclude_path(char const *path_); void set_sysinclude_delimiter(); size_t get_iteration_depth() const; // maintain defined m
acros template <typename String> bool add_macro_definition(String macrostring, bool is_predefined = false); template <typename String> bool add_macro_definition(StringT const &name, position_type const& pos, bool has_params, std::vector<token_type> &parameters, token_sequence_type &definition, bool is_predefined = false) template <typename String> bool is_defined_macro(String const &name) const; template <typename String> bool remove_macro_definition(String const &name, bool even_predefined = false); void reset_macro_definitions(); template <typename String> bool <a href="class_reference_context.html#get_macro_definition">
get_macro_definition</a>( String const &name, bool &is_function_style, bool &is_predefined, position_type &pos, std::vector<token_type> &parameters, token_sequence_type &definition) const; typedef <unspecified> macromap_type; typedef typename macromap_type::name_iterator name_iterator; typedef typename macromap_type::const_name_iterator const_name_iterator; name_iterator macro_names_begin(); name_iterator macro_names_end(); const_name_iterator <a href="class_reference_context.html#m
acro_names_iterators">macro_names_begin</a>() const; const_name_iterator macro_names_end() const; // other options void set_language(language_support enable); language_support get_language() const; void set_max_include_nesting_depth(std::size_t new_depth); size_t get_max_include_nesting_depth() const; // get the Wave version information static
std::string get_version(); static std::string get_version_string(); }; } // namespace wave } // namespace boost</pre>
+
+<h2><a name="template_parameters"></a>Template
+parameters</h2>
+
+The <tt>boost::wave::context</tt> object has
+three template parameters to specify the concrete behaviour of its
+operation. The following table describes these with more detail.
+
+<table align="center" border="0" width="90%">
+
+ <tbody>
+
+ <tr>
+
+ <td colspan="2" class="table_title">Template
+parameters required for the <tt>boost::wave::context</tt>
+class </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells" width="32%"><code>Iterator</code></td>
+
+ <td class="table_cells" width="68%">
+ The type of the underlying iterator, through which the
+input stream is accessed. 
+
+This should be at least an <tt>forward_iterator</tt> type
+iterator.
+
+ </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>LexIterator</code></td>
+
+ <td class="table_cells">
+ The type of the lexer type to be used by the <tt>Wave</tt>
+library to identify tokens in the input stream.
+
+ </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>InputPolicy</code></td>
+
+ <td class="table_cells">
+ The type of the input policy class, which allows to
+customize the behaviour of the Wave library and the type of the
+iterators to use, when it comes to including and opening an included
+file.
+
+ </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>ContextPolicy</code></td>
+
+ <td class="table_cells">
+ The type of the context policy class, which allows to
+customize different aspects of the behaviour of the preprocessing. The
+requirements of this policy and the available customization points
+provided by this policy are described here.  
+ 
+
+ </td>
+
+ </tr>
+
+ <tr class="table_cells">
+
+ <td class="table_cells"><code>Derived</code></td>
+
+ <td>
+ The type of the type being derived from the context type (if
+any). This template parameter is optional and defaults to 'this_type',
+which means that the context type will be used assuming no derived type exists. 
+
+ 
+ </td>
+
+ </tr>
+
+ </tbody>
</table>
-For further information about the lexer type to use, please refer to the <a href="class_reference_lexer.html">The
- Lexer Interface </a>.
-If the template parameter <tt>InputPolicy</tt> is omitted, the template <tt>boost::wave::iteration_context_policies::load_file_to_string</tt>
- is used. For further information about the input policy, please refer to the
- topic The Input Policy.
-If the template parameter ContextPolicy is omitted, the <tt>boost::wave::context_policies::eat_whitespace</tt>
- policy type is used, implementing certain basic preprocessing hooks needed for normal (default) execution. For further
- information about the context policy, please refer to the topic <a href="class_reference_ctxpolicy.html">The
- Context Policy</a>. 
-<h2><a name="public_typedefs"></a>Public Typedefs</h2>
-The <tt>boost::wave::context</tt> template defines the following public typedefs, which may be useful while using this class:
-<table width="90%" border="0" align="center">
- <tr>
- <td colspan="2" class="table_title">Public typedef's defined by the <tt>boost::wave::context</tt> class </td>
- </tr>
- <tr>
- <td class="table_cells"><code>iterator_type</code></td>
- <td class="table_cells">The <tt>Iterator</tt> template parameter provided, while the <tt>context</tt> class was instantiated. </td>
- </tr>
- <tr>
- <td class="table_cells"><code>lex_type</code></td>
- <td class="table_cells">The <tt>LexIterator</tt> template parameter provided, while the <tt>context</tt> class was instantiated. </td>
- </tr>
- <tr>
- <td width="32%" class="table_cells"><code>token_type</code></td>
- <td width="68%" class="table_cells">The token type, which is returned by the <tt>context</tt> generated iterators. This type is taken from the <tt>LexIterator</tt> template parameter provided, whicle the <tt>context</tt> class was instantiated.</td>
- </tr>
- <tr>
- <td class="table_cells"><code>input_policy_type</code></td>
- <td class="table_cells">The <tt>InputPolicy</tt> template parameter provided, while the <tt>context</tt> class was instantiated. </td>
- </tr>
- <tr>
- <td class="table_cells"><code>context_policy_type</code></td>
- <td class="table_cells">The <tt>ContextPolicy</tt> template parameter provided, while the <tt>context</tt> class was instantiated. </td>
- </tr>
- <tr>
- <td class="table_cells"><code>position_type</code></td>
- <td class="table_cells">The type of the position information contained in every returned token, which describes the point, at which the given token was recognised. </td>
- </tr>
+
+For further information about the lexer type to use, please
+refer to the <a href="class_reference_lexer.html">The
+Lexer Interface </a>.
+
+If the template parameter <tt>InputPolicy</tt> is
+omitted, the template <tt>boost::wave::iteration_context_policies::load_file_to_string</tt>
+is used. For further information about the input policy, please refer
+to the topic <a href="class_reference_inptpolcy.html">The
+Input Policy</a>.
+
+If the template parameter ContextPolicy is omitted, the <tt>boost::wave::context_policies::eat_whitespace</tt>
+policy type is used, implementing certain basic preprocessing hooks
+needed for normal (default) execution. For further information about
+the context policy, please refer to the topic The Context Policy.
+
+
+<h2><a name="public_typedefs"></a>Public
+Typedefs</h2>
+
+The <tt>boost::wave::context</tt> template
+defines the following public typedefs, which may be useful while using
+this class:
+
+<table align="center" border="0" width="90%">
+
+ <tbody>
+
+ <tr>
+
+ <td colspan="2" class="table_title">Public
+typedef's defined by the <tt>boost::wave::context</tt>
+class </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>iterator_type</code></td>
+
+ <td class="table_cells">
+ The <tt>Iterator</tt> template parameter
+provided, while the <tt>context</tt> class was
+instantiated. 
+
+ </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>lex_type</code></td>
+
+ <td class="table_cells">
+ The <tt>LexIterator</tt> template parameter
+provided, while the <tt>context</tt> class was
+instantiated. 
+
+ </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells" width="32%"><code>token_type</code></td>
+
+ <td class="table_cells" width="68%">
+ The token type, which is returned by the <tt>context</tt>
+generated iterators. This type is taken from the <tt>LexIterator</tt>
+template parameter provided, whicle the <tt>context</tt>
+class was instantiated.
+
+ </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>input_policy_type</code></td>
+
+ <td class="table_cells">
+ The <tt>InputPolicy</tt> template parameter
+provided, while the <tt>context</tt> class was
+instantiated. 
+
+ </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>context_policy_type</code></td>
+
+ <td class="table_cells">
+ The <tt>ContextPolicy</tt> template
+parameter provided, while the <tt>context</tt> class was
+instantiated. 
+
+ </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>position_type</code></td>
+
+ <td class="table_cells">
+ The type of the position information contained in every
+returned token, which describes the point, at which the given token was
+recognised. 
+
+ </td>
+
+ </tr>
+
+ </tbody>
</table>
-<h2><a name="member_functions"></a>Member functions</h2>
+
+<h2><a name="member_functions"></a>Member
+functions</h2>
+
<a name="constructor" id="constructor"></a>Constructor
-<pre> context(Iterator const &first,
- Iterator const &last, char const *filename,
- ContextPolicy const& ctx_policy);</pre>
- Constructs a context object on top of the input stream given by the pair
- of auxilliary iterators <tt>[first, last)</tt>. The iterators should
- be at least <tt>forward_iterator</tt> type iterators. The filename parameter
- is to be supplied for informational purposes only. This string is used for
- indicating the token positions inside the input stream, it is not validated
- against the file system. If the filename parameter is not given it defaults
- to "<Unknown>". If the ctx_policy
- parameter isn't supplied it defaults to a default constructed <tt>ContextPolicy</tt>
- object. 
- Additionally the macro symbol table is filled with the predefined macros
- and the current reference directory is set to the path of the given filename.
- If this filename does not reference valid file system item, the current reference
- directory is set to the current system directory. (The current reference directory
- is the file system path, which is used as the target directory during the
- processing of <tt>#include "..."</tt> directives).
- <h3>Iterator interface</h3>
-The pair of iterators returned by the <tt>context::begin</tt> and <tt>context::end</tt>
- functions is the main interface for accessing the preprocessed tokens from the
- preprocessor engine. While iterating over the given iterator range <tt>[begin, end)</tt>
- there are returned the preprocessed C++ tokens, which are generated on the fly
- from the underlying input stream. The returned iterators are conceptually of
- <tt>forward_iterator</tt> type.
+
+<pre> context(Iterator const &first, Iterator const &last, char const *filename, ContextPolicy const& ctx_policy);</pre>
+
+Constructs a context object on top of the input stream given
+by the pair of auxilliary iterators <tt>[first, last)</tt>.
+The iterators should be at least <tt>forward_iterator</tt>
+type iterators. The filename parameter is to be supplied for
+informational purposes only. This string is used for indicating the
+token positions inside the input stream, it is not validated against
+the file system. If the filename parameter is not given it defaults to "<Unknown>". If
+the ctx_policy parameter isn't supplied it defaults to a default
+constructed <tt>ContextPolicy</tt> object. 
+
+Additionally the macro symbol table is filled with the
+predefined macros and the current reference directory is set to the
+path of the given filename. If this filename does not reference valid
+file system item, the current reference directory is set to the current
+system directory. (The current reference directory is the file system
+path, which is used as the target directory during the processing of <tt>#include "..."</tt>
+directives).
+
+<h3>Iterator interface</h3>
+
+The pair of iterators returned by the <tt>context::begin</tt>
+and <tt>context::end</tt> functions is the main interface
+for accessing the preprocessed tokens from the preprocessor engine.
+While iterating over the given iterator range <tt>[begin, end)</tt>
+there are returned the preprocessed C++ tokens, which are generated on
+the fly from the underlying input stream. The returned iterators are
+conceptually of <tt>forward_iterator</tt> type.
+
<a name="iterator_interface_begin"></a>begin
-<pre> iterator_type begin();</pre>
+
+<pre> iterator_type begin(); iterator_type begin(Iterator const &first, Iterator const &last, );</pre>
+
<blockquote>
- Initializes and returns the starting iterator for the preprocessed token
- stream.
-
+ Initializes and returns the starting iterator for the
+preprocessed token stream. The iterator pair given by the parameters  <tt>[first, last)</tt>
+specifies the input sequence to preprocess. The first version of this
+function uses the iinput stream as specified by the constructor. 
+
</blockquote>
+
<a name="iterator_interface_end" id="iterator_interface_end"></a>end
+
<pre> iterator_type end() const;</pre>
-<blockquote>
- Initializes and returns the end of stream iterator to compare with for detecting
- the end of the preprocessed token stream.
+
+<blockquote>
+ Initializes and returns the end of stream iterator to
+compare with for detecting the end of the preprocessed token stream.
+
</blockquote>
+
<h3>Maintain include paths</h3>
-The <tt>Wave</tt> library maintains two separate search paths for include
- files. A search path for user include files and a search path for system include
- files. Any directories specified with the add_include_path()
- function before the function set_sysinclude_delimiter()
- is called are searched only for the case of <tt>#include "..."</tt>
- directives, they are not searched for <tt>#include <file></tt> directives.
- I.e. these directories are added to the user include search path. 
-If additional directories are specified with the add_include_path()
- function after a call to the function set_sysinclude_delimiter(),
- these directories are searched for all <tt>#include</tt> directives. I.e. these
- directories are added to the system include search path.
-In addition, a call to the function set_sysinclude_delimiter()
- inhibits the use of the current reference directory as the first search directory
- for <tt>#include "..."</tt> directives. Therefore, the current
- reference directory is searched only, if it is requested explicitly with a call
- to the function add_include_path(".").
-
-Callig both functions, the set_sysinclude_delimiter()
- and add_include_path(".") allows you
- to control precisely, which directories are searched before the current one
- and which are searched after.
-These functions are modelled after the command line behaviour implemented by
- the popular gcc compiler. 
+
+The <tt>Wave</tt> library maintains two separate
+search paths for include files. A search path for user include files
+and a search path for system include files. Any directories specified
+with the add_include_path()
+function before the function set_sysinclude_delimiter()
+is called are searched only for the case of <tt>#include "..."</tt>
+directives, they are not searched for <tt>#include <file></tt>
+directives. I.e. these directories are added to the user include search
+path. 
+
+If additional directories are specified with the add_include_path()
+function after a call to the function set_sysinclude_delimiter(),
+these directories are searched for all <tt>#include</tt>
+directives. I.e. these directories are added to the system include
+search path.
+
+In addition, a call to the function set_sysinclude_delimiter()
+inhibits the use of the current reference directory as the first search
+directory for <tt>#include "..."</tt> directives.
+Therefore, the current reference directory is searched only, if it is
+requested explicitly with a call to the function add_include_path("."). 
+
+Callig both functions, the set_sysinclude_delimiter()
+and add_include_path(".")
+allows you to control precisely, which directories are searched before
+the current one and which are searched after.
+
+These functions are modelled after the command line behaviour
+implemented by the popular gcc compiler. 
+

+
<a name="add_include_path"></a>add_include_path
-<pre> bool add_include_path(char const *path);
-</pre>
-<blockquote>
- Adds the given file system path to the user include search paths. After a
- call to the set_sysinclude_delimiter()
- this function adds the given file system path to the system include search
- paths. Note though, that the given path is validated against the file system.
- 
- If the given path string does not form a name of a valid file system directory
- item, the function returns <tt>false</tt>. If the given path was successfully
- added to the include search paths in question, the function returns <tt>true</tt>.
+
+<pre> bool add_include_path(char const *path); </pre>
+
+<blockquote>
+ Adds the given file system path to the user include search
+paths. After a call to the set_sysinclude_delimiter()
+this function adds the given file system path to the system include
+search paths. Note though, that the given path is validated against the
+file system. 
+
+ If the given path string does not form a name of a valid
+file system directory item, the function returns <tt>false</tt>.
+If the given path was successfully added to the include search paths in
+question, the function returns <tt>true</tt>.
+
</blockquote>
+
<a name="add_sysinclude_path"></a>add_sysinclude_path
+
<pre> bool add_sysinclude_path(char const *path);</pre>
-<blockquote>
- Adds the given file system path to the system include search paths. This
- function operates on the system include search path regardless of the mode
- of operation of the add_include_path(). Note
- though, that the given path is validated against the file system.
- If the given path string does not form a name of a valid file system directory
- item, the function returns <tt>false</tt>. If the given path was successfully
- added to the system include search paths, the function returns <tt>true</tt>.
+
+<blockquote>
+ Adds the given file system path to the system include search
+paths. This function operates on the system include search path
+regardless of the mode of operation of the add_include_path(). Note
+though, that the given path is validated against the file system.
+
+ If the given path string does not form a name of a valid
+file system directory item, the function returns <tt>false</tt>.
+If the given path was successfully added to the system include search
+paths, the function returns <tt>true</tt>.
+
</blockquote>
+
<a name="set_sysinclude_delimiter"></a>set_sysinclude_delimiter
-<pre> void set_sysinclude_delimiter();</pre>
-<blockquote>
- Switches the mode, how the add_include_path()
- function operates. By default the given file system path is added to the user
- include search paths. After calling this function a subsequent call to the
- add_include_path() adds the given file system
- path to the system include search paths. Additionally it inhibits the the
- use of the current reference directory as the first search directory for <tt>#include "..."</tt>
- directives.
+
+<pre> void set_sysinclude_delimiter();</pre>
+
+<blockquote>
+ Switches the mode, how the add_include_path()
+function operates. By default the given file system path is added to
+the user include search paths. After calling this function a subsequent
+call to the add_include_path()
+adds the given file system path to the system include search paths.
+Additionally it inhibits the the use of the current reference directory
+as the first search directory for <tt>#include "..."</tt>
+directives.
+
</blockquote>
+
<a name="get_iteration_depth"></a>get_iteration_depth
+
<pre> size_t get_iteration_depth() const;</pre>
-<blockquote>
- Returns the actual include iteration depth, i.e. the current number of include
- levels to be poped from the include iteration context, before the main (topmost)
- iteration context is reached.
+
+<blockquote>
+ Returns the actual include iteration depth, i.e. the current
+number of include levels to be poped from the include iteration
+context, before the main (topmost) iteration context is reached.
+
</blockquote>
+
<h3>Maintain defined macros</h3>
+
<a name="add_macro_definition"></a>add_macro_definition
-<pre> bool add_macro_definition(
- std::string macrostring,
- bool is_predefined);
-</pre>
-<blockquote>
- Adds a new macro definition to the macro symbol table. The parameter <tt>macrostring</tt>
- should contain the macro to define in the command line format, i.e. something
- like <tt>MACRO(x)=definition</tt>. The following table describes this format
- in more detail. The parameter <tt>is_predefined</tt> should be true while
- defining predefined macros, i.e. macros, which are not undefinable with an
- <tt>#undef</tt> directive from inside the preprocessed input stream. If this
- parameter is not given, it defaults to <tt>false</tt>.
- <table width="90%" border="0" align="center">
- <tr>
- <td colspan="2" class="table_title">Summary of possible formats for defining
- macros </td>
- </tr>
- <tr>
- <td width="32%" class="table_cells"><code>MACRO</code></td>
- <td width="68%" class="table_cells"><code>define <tt>MACRO</tt> as 1</code></td>
- </tr>
- <tr>
- <td class="table_cells"><code>MACRO=</code></td>
- <td class="table_cells"><code>define <tt>MACRO</tt> as nothing (empty)</code></td>
- </tr>
- <tr>
- <td class="table_cells"><code>MACRO=definition</code></td>
- <td class="table_cells"><code>define <tt>MACRO</tt> as <tt>definition</tt></code></td>
- </tr>
- <tr>
- <td width="32%" class="table_cells"><code>MACRO(x)</code></td>
- <td width="68%" class="table_cells"><code>define <tt>MACRO(x)</tt> as 1</code></td>
- </tr>
- <tr>
- <td class="table_cells"><code>MACRO(x)=</code></td>
- <td class="table_cells"><code>define <tt>MACRO(x)</tt> as nothing (empty)</code></td>
- </tr>
- <tr>
- <td class="table_cells"><code>MACRO(x)=definition</code></td>
- <td class="table_cells"><code>define <tt>MACRO(x)</tt> as <tt>definition</tt></code></td>
- </tr>
+
+<pre> bool add_macro_definition( std::string macrostring, bool is_predefined); </pre>
+
+<blockquote>
+ Adds a new macro definition to the macro symbol table. The
+parameter <tt>macrostring</tt> should contain the macro to
+define in the command line format, i.e. something like <tt>MACRO(x)=definition</tt>.
+The following table describes this format in more detail. The parameter
+ <tt>is_predefined</tt> should be true while defining
+predefined macros, i.e. macros, which are not undefinable with an <tt>#undef</tt>
+directive from inside the preprocessed input stream. If this parameter
+is not given, it defaults to <tt>false</tt>.
+
+ <table align="center" border="0" width="90%">
+
+ <tbody>
+
+ <tr>
+
+ <td colspan="2" class="table_title">Summary
+of possible formats for defining macros </td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells" width="32%"><code>MACRO</code></td>
+
+ <td class="table_cells" width="68%"><code>define
+ <tt>MACRO</tt> as 1</code></td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>MACRO=</code></td>
+
+ <td class="table_cells"><code>define <tt>MACRO</tt>
+as nothing (empty)</code></td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>MACRO=definition</code></td>
+
+ <td class="table_cells"><code>define <tt>MACRO</tt>
+as <tt>definition</tt></code></td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells" width="32%"><code>MACRO(x)</code></td>
+
+ <td class="table_cells" width="68%"><code>define
+ <tt>MACRO(x)</tt> as 1</code></td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>MACRO(x)=</code></td>
+
+ <td class="table_cells"><code>define <tt>MACRO(x)</tt>
+as nothing (empty)</code></td>
+
+ </tr>
+
+ <tr>
+
+ <td class="table_cells"><code>MACRO(x)=definition</code></td>
+
+ <td class="table_cells"><code>define <tt>MACRO(x)</tt>
+as <tt>definition</tt></code></td>
+
+ </tr>
+
+ </tbody>
 </table>
- The function returns <tt>false</tt>, if the macro to define already was defined
- and the new definition is equivalent to the existing one, it returns true,
- if the new macro was successfully added to the macro symbol table.
- If the given macro definition resembles a redefinition and the new macro
- is not identical to the already defined macro (in the sense defined by the
- C++ Standard), the function throws a corresponding <tt>preprocess_exception</tt>.
+
+ The function returns <tt>false</tt>, if the
+macro to define already was defined and the new definition is
+equivalent to the existing one, it returns true, if the new macro was
+successfully added to the macro symbol table.
+
+ If the given macro definition resembles a redefinition and
+the new macro is not identical to the already defined macro (in the
+sense defined by the C++ Standard), the function throws a corresponding
+ <tt>preprocess_exception</tt>.
+
</blockquote>
+
<a name="is_defined_macro"></a>is_defined_macro
-<pre> template <typename String>
- bool is_defined_macro(String const &name) const; </pre>
+
+<pre> template <typename String> bool is_defined_macro(String const &name) const; </pre>
+
<blockquote>
- Returns, if a macro with the given <tt>name</tt> is defined, i.e. if it is
- contained in the macro symbol table.
- </blockquote>
+ Returns, if a macro with the given <tt>name</tt>
+is defined, i.e. if it is contained in the macro symbol table.
+
+</blockquote>
+
<a name="get_macro_definition"></a>get_macro_definition
-<pre> bool get_macro_definition(
- std::string const &name, bool &is_function_style, 
- bool &is_predefined, position_type &pos,
- std::vector<token_type> &parameters,
- token_sequence_type &definition) const; </pre>
-<blockquote>
- Allows to retrieve all information known with regard to a macro definition. The parameter <tt>name</tt> specifies the name of the macro the information should be returned for. The parameters
- <tt>is_function_style</tt> and <tt>is_predefined</tt> return, whether the macro has been defined as a function style macro or as a predefined macro resp. The parameter <tt>pos</tt> will contain the position the macro was defined at. The parameter <tt>parameters</tt> will contain the names of the parameters the macro was defined with and the parameter <tt>definition</tt> will contain the token sequence for the definition (macro body).
- The function returns <tt>true</tt> is the macro was defined and the requested information has been successfully retrieved, <tt>false</tt> otherwise.
+
+<pre> template <typename String> bool get_macro_definition( String const &name, bool &is_function_style, bool &is_predefined, position_type &pos, std::vector<token_type> &parameters, token_sequence_type &definition) const; </pre>
+
+<blockquote>
+ Allows to retrieve all information known with regard to a
+macro definition. The parameter <tt>name</tt> specifies
+the name of the macro the information should be returned for. The
+parameters <tt>is_function_style</tt> and <tt>is_predefined</tt>
+return, whether the macro has been defined as a function style macro or
+as a predefined macro resp. The parameter <tt>pos</tt>
+will contain the position the macro was defined at. The parameter <tt>parameters</tt>
+will contain the names of the parameters the macro was defined with and
+the parameter <tt>definition</tt> will contain the token
+sequence for the definition (macro body).
+
+ The function returns <tt>true</tt> is the macro
+was defined and the requested information has been successfully
+retrieved, <tt>false</tt> otherwise.
+
</blockquote>
+
<a name="remove_macro_definition"></a>remove_macro_definition
-<pre> bool remove_macro_definition(
- std::string const &name,
- bool even_predefined); </pre>
-<blockquote>
- Removes the definition of the macro with the given <tt>name</tt> from the
- macro symbol table. This operation is equivalent to an <tt>#undef</tt> directive
- with this <tt>name</tt> executed from within the input stream. If the parameter
- <tt>even_predefined</tt> is <tt>true</tt>, then the macro is removed from
- the macro symbol table even, if it is defined as a predefined macro. 
- Note though, that the following macros are not undefinable in any
- case: <tt>__FILE__</tt>, <tt>__LINE__</tt>, <tt>__DATE__</tt>, <tt>__TIME__</tt>,
- <tt>__cplusplus</tt>, <tt>__STDC__</tt>. If the parameter <tt>even_predefined</tt>
- is not given, it defaults to <tt>false</tt>.
- The function returns <tt>false</tt>, if the macro to undefine was not defined
- and returns <tt>true</tt> otherwise.
- If the macro to remove may not be undefined (it is a predefined macro and
- the parameter <tt>even_predefined</tt> is set to <tt>false</tt> or it is one
- of the mentioned not undefinable macros above) the function throws a <tt>preprocess_exception</tt>.
+
+<pre> template <typename String> bool remove_macro_definition( String const &name, bool even_predefined); </pre>
+
+<blockquote>
+ Removes the definition of the macro with the given <tt>name</tt>
+from the macro symbol table. This operation is equivalent to an <tt>#undef</tt>
+directive with this <tt>name</tt> executed from within the
+input stream. If the parameter <tt>even_predefined</tt> is
+ <tt>true</tt>, then the macro is removed from the macro
+symbol table even, if it is defined as a predefined macro. 
+
+ Note though, that the following macros are not
+undefinable in any case: <tt>__FILE__</tt>, <tt>__LINE__</tt>,
+ <tt>__DATE__</tt>, <tt>__TIME__</tt>, <tt>__cplusplus</tt>,
+ <tt>__STDC__</tt>. If the parameter <tt>even_predefined</tt>
+is not given, it defaults to <tt>false</tt>.
+
+ The function returns <tt>false</tt>, if the
+macro to undefine was not defined and returns <tt>true</tt>
+otherwise.
+
+ If the macro to remove may not be undefined (it is a
+predefined macro and the parameter <tt>even_predefined</tt>
+is set to <tt>false</tt> or it is one of the mentioned not
+undefinable macros above) the function throws a <tt>preprocess_exception</tt>.
+
</blockquote>
+
<a name="reset_macro_definitions"></a>reset_macro_definitions
+
<pre> void reset_macro_definitions(); </pre>
+
<blockquote>
- Resets the macro symbol table to it's initial state, i.e. undefines all user defined macros and inserts the internal predefined macros as described here.
+ Resets the macro symbol table to it's initial state, i.e.
+undefines all user defined macros and inserts the internal predefined
+macros as described here.
+
</blockquote>
-<a name="macro_names_iterators"></a>macro_names_begin, macro_names_end 
-<pre> name_iterator macro_names_begin();
- name_iterator macro_names_end();
- const_name_iterator macro_names_begin() const;
- const_name_iterator macro_names_end() const;
-</pre>
+
+<a name="macro_names_iterators"></a>macro_names_begin,
+macro_names_end 
+
+<pre> name_iterator macro_names_begin(); name_iterator macro_names_end(); const_name_iterator macro_names_begin() const; const_name_iterator macro_names_end() const; </pre>
+
<blockquote>
- The <tt>macro_names_begin</tt> and <tt>macro_names_end</tt> functions return iterators allowing to iterate on the names of all defined macros.
+ The <tt>macro_names_begin</tt> and <tt>macro_names_end</tt>
+functions return iterators allowing to iterate on the names of all
+defined macros.
+
</blockquote>
-<h3><a name="get_version"></a>Get Version information</h3>
+
+<h3><a name="get_version"></a>Get Version
+information</h3>
+
get_version
-<pre> static std::string get_version(); </pre>
+
+<pre> static std::string get_version(); </pre>
+
<blockquote>
- Returns a string containing the current Wave version formatted as 0xvvrsbbbb
- (this is a string representation of the equivalent hexadecimal number), where
- 'vv' is the version number, 'r'
- the release number, 's' the subrelease number
- and 'bbbb' the build number. A possible return
- value looks like 0x00910454. The returned value
- is the same as is inserted in the preprocessed token stream, when the predefined
- macro <tt>__WAVE_VERSION__</tt> is expanded.
+ Returns a string containing the current Wave version
+formatted as 0xvvrsbbbb
+(this is a string representation of the equivalent hexadecimal number),
+where 'vv' is the
+version number, 'r'
+the release number, 's'
+the subrelease number and 'bbbb'
+the build number. A possible return value looks like 0x00910454. The returned value
+is the same as is inserted in the preprocessed token stream, when the
+predefined macro <tt>__WAVE_VERSION__</tt> is expanded.
+
</blockquote>
+
get_version_str
-<pre> static std::string get_version_str(); </pre>
-<blockquote>
- Returns a string containing the current Wave version formatted as "v.rr.ss.bbbb",
- where 'v' is the version number, 'rr'
- the release number, 'ss' the subrelease number
- and 'bbbb' the build number. A possible return
- value looks like "0.9.1.454". The returned
- value is the same as it will be inserted in the preprocessed token stream, when the
- predefined macro <tt>__WAVE_VERSION_STR__</tt> is expanded.
+
+<pre> static std::string get_version_str(); </pre>
+
+<blockquote>
+ Returns a string containing the current Wave version
+formatted as "v.rr.ss.bbbb",
+where 'v' is the
+version number, 'rr'
+the release number, 'ss'
+the subrelease number and 'bbbb'
+the build number. A possible return value looks like "0.9.1.454". The returned value
+is the same as it will be inserted in the preprocessed token stream,
+when the predefined macro <tt>__WAVE_VERSION_STR__</tt> is
+expanded.
+
</blockquote>
+
<h3>Control extended options</h3>
+
<a name="language_support"></a>set_language 
- get_language
-<pre> void set_language(language_support language,
- bool reset_macros = true);
- language_support get_language() const;</pre>
-<blockquote>
- This functions allows to specify the language mode, in which the <tt>Wave</tt>
- library should work. The possible language modes are defined by the enumerated
- type <tt>language_support</tt>:
- <pre> enum language_support {
- // support flags for C++98
- support_normal = 0x01,
- support_cpp = support_normal,
-
- // support flags for C99
- support_option_long_long = 0x02,
- support_option_variadics = 0x04,
- support_c99 = support_option_variadics |
- support_option_long_long |
- 0x08,
-
- // the mask for the main language settings
- support_option_mask = 0xFF00, 
- // additional fine tuning of the general behavior
- support_option_preserve_comments = 0x0100,
- support_option_no_character_validation = 0x0200,
- support_option_convert_trigraphs = 0x0400,
- support_option_single_line = 0x0800,
- support_option_prefer_pp_numbers = 0x1000,
- support_option_emit_line_directives = 0x2000,
- support_option_include_guard_detection = 0x4000,
- support_option_emit_pragma_directives = 0x8000
- };</pre>
- When used with <tt>support_option_variadics</tt> the support for variadics, placemarkers
- and the <tt>operator _Pragma()</tt> is enabled in normal C++ mode. When used with the <tt>support_option_long_long</tt> the support for long long suffixes is enabled in C++ mode. 
- The <tt>support_c99</tt> switches on the C99 language support, which enables variadics, placemarkers, the <tt>operator _Pragma</tt> and long long suffixes by default. Additionally it disables the C++ specific tokens such as <tt>'->*'</tt>, <tt>'.*'</tt>, <tt>'::'</tt> etc. 
- The <tt>support_option_...</tt> values are to be used in conjunction with the main language settings (<tt>support_normal</tt> and <tt>support_c99</tt>) . 
+
+get_language
+
+<pre> void set_language(language_support language, bool reset_macros = true); language_support get_language() const;</pre>
+
+<blockquote>
+ This functions allows to specify the language mode, in which
+the <tt>Wave</tt> library should work. The possible
+language modes are defined by the enumerated type <tt>language_support</tt>:
+
+ <pre> enum language_support { // support flags for C++98 support_normal = 0x01, support_cpp = support_normal, // support flags for C99 support_option_long_long = 0x02, support_option_variadics = 0x04, support_c99 = support_option_variadics | support_option_long_long | 0x08, // the mask for the main language settings support_option_mask = 0xFF80, // additional fine tuning of the general behavior support_option_insert_whitespace = 0x0080, support_option_preserve_comments = 0x0100, support_option_no_character_validation = 0x0200, support_option_convert_trigraphs = 0x0400, support_option_single_line = 0x0800, support_option_prefer_pp_numbers = 0x1000, support_option_emit_line_directiv
es = 0x2000, support_option_include_guard_detection = 0x4000, support_option_emit_pragma_directives = 0x8000 };</pre>
+
+ When used with <tt>support_option_variadics</tt>
+the support for variadics, placemarkers and the <tt>operator _Pragma()</tt>
+is enabled in normal C++ mode. When used with the <tt>support_option_long_long</tt>
+the support for long long suffixes is enabled in C++ mode. 
+
+ The <tt>support_c99</tt> switches on the C99
+language support, which enables variadics, placemarkers, the <tt>operator _Pragma</tt>
+and long long suffixes by default. Additionally it disables the C++
+specific tokens such as <tt>'->*'</tt>, <tt>'.*'</tt>,
+ <tt>'::'</tt> etc. 
+
+ The <tt>support_option_...</tt> values are to
+be used in conjunction with the main language settings (<tt>support_normal</tt>
+and <tt>support_c99</tt>) . 
+
 <ul>
- <li>If the <tt>support_option_preserve_comments</tt> flag is set, the <tt>Wave</tt> library preserves almost all comments in the source code. The only comments not preserved are those contained inside macro definitions. If this flag is not set all comments are replaced by a single space. </li>
- <li>If the <tt>support_option_no_character_validation</tt> flag is set , the <tt>Wave</tt> library does not validate universal character literals (given in the form of <tt>'u1234'</tt> or <tt>'U12345678'</tt>) to be in the allowed value range. This flag is merely used for internal purposes by the testing framework and will be rarely used by a user of the library.</li>
- <li>If the <tt>support_option_convert_trigraphs</tt> flag is set, the <tt>Wave</tt> library replaces all occurences of trigraph characters with their non-trigraph character sequence (i.e. <tt>'??='</tt> is replaced by <tt>'#'</tt> etc.) . By default no replacement is performed. </li>
- <li>If the <tt>support_option_single_line</tt> flag is set, the <tt>Wave</tt> library will now reprot an error if the last line of the processed input is not terminated by a new line. This flag is merely used for internal purposes by the testing framework and will be rarely used by a user of the library.</li>
- <li>If the <tt>support_option_prefer_pp_numbers</tt> flag is set, the <tt>Wave</tt> library is instructed to correctly identify pp-number's in the input stream. These get recognized into 'normal' number tokens before they get returned to the calling application. The flag is set by default and is used merely for internal purposes and will be rarely reset by a user of the library. </li>
- <li>If the support_option_emit_line_directives flag is set, the <tt>Wave</tt> library will emit #line directives in the generated token stream, if appropriate. This flag is set by default, to prevent the library from generating #line directives it must be reset explicitely. </li>
- <li>If the support_option_include_guard_detection flag is set, the <tt>Wave</tt> library will try to automatically identify include guards during the processing of a included file. Files which contained include guards are handled as if they contained a #pragma once, i.e. these files wonn#t be opened twice, even if specified in a second #include statement. </li>
+
+ <li>If the <tt>support_option_insert_whitespace</tt>
+flag is set, the <tt>Wave</tt> library  inserts
+additional whitespace between tokens where the concatenated string
+representation of the two tokens would form another valid C++ token.
+This is very importatnt to avoid mis-interpretations of the generated
+output if it is going to be processed by a C++ compiler afterwards.
+  </li>
+ <li>If the <tt>support_option_preserve_comments</tt>
+flag is set, the <tt>Wave</tt> library preserves almost
+all comments in the source code. The only comments not preserved are
+those contained inside macro definitions. If this flag is not set all
+comments are replaced by a single space. </li>
+
+ <li>If the <tt>support_option_no_character_validation</tt>
+flag is set , the <tt>Wave</tt> library does not validate
+universal character literals (given in the form of <tt>'u1234'</tt>
+or <tt>'U12345678'</tt>) to be in the allowed value range.
+This flag is merely used for internal purposes by the testing framework
+and will be rarely used by a user of the library.</li>
+
+ <li>If the <tt>support_option_convert_trigraphs</tt>
+flag is set, the <tt>Wave</tt> library replaces all
+occurences of trigraph characters with their non-trigraph character
+sequence (i.e. <tt>'??='</tt> is replaced by <tt>'#'</tt>
+etc.) . By default no replacement is performed. </li>
+
+ <li>If the <tt>support_option_single_line</tt>
+flag is set, the <tt>Wave</tt> library will now reprot an
+error if the last line of the processed input is not terminated by a
+new line. This flag is merely used for internal purposes by the testing
+framework and will be rarely used by a user of the library.</li>
+
+ <li>If the <tt>support_option_prefer_pp_numbers</tt>
+flag is set, the <tt>Wave</tt> library is instructed to
+correctly identify pp-number's in the input stream. These get
+recognized into 'normal' number tokens before they get returned to the
+calling application. The flag is set by default and is used merely for
+internal purposes and will be rarely reset by a user of the library. </li>
+
+ <li>If the support_option_emit_line_directives
+flag is set, the <tt>Wave</tt> library will emit #line directives in the
+generated token stream, if appropriate. This flag is set by default, to
+prevent the library from generating #line
+directives it must be reset explicitely. </li>
+
+ <li>If the support_option_include_guard_detection
+flag is set, the <tt>Wave</tt> library will try to
+automatically identify include guards during the processing of a
+included file. Files which contained include guards are handled as if
+they contained a #pragma once, i.e. these files wonn#t be opened twice,
+even if specified in a second #include
+statement. </li>
+
 </ul>
+
 <blockquote>
- During this process the library will recognize two forms of include guards:
- <pre> #ifndef INCLUDE_GUARD_MACRO
- #define INCLUDE_GUARD_MACRO
- ...
- #endif
-
- or
-
- #if !defined(INCLUDE_GUARD_MACRO)
- #define INCLUDE_GUARD_MACRO
- ...
- #endif</pre>
- Note, that the parenthesis in the second form are optional (i.e. <tt>!defined INCLUDE_GUARD_MACRO</tt> will work as well). The code allows for any whitespace, newline and single
- '#' tokens before the #if/#ifndef and after the final #endif for the include guard to be recognized.
- This flag is on by default, so if you do not want the library to automatically reconize include guards you will need to reset this explicitely. 
+ During this process the library will recognize two forms
+of include guards:
+
+ <pre> #ifndef INCLUDE_GUARD_MACRO #define INCLUDE_GUARD_MACRO ... #endif or #if !defined(INCLUDE_GUARD_MACRO) #define INCLUDE_GUARD_MACRO ... #endif</pre>
+
+ Note, that the parenthesis in the second form are
+optional (i.e. <tt>!defined INCLUDE_GUARD_MACRO</tt> will
+work as well). The code allows for any whitespace, newline and single
+'#' tokens before the #if/#ifndef and after the
+final #endif for
+the include guard to be recognized.
+
+ This flag is on by default, so if you do not want the
+library to automatically reconize include guards you will need to reset
+this explicitely. 
+
 </blockquote>
+
 <ul>
- <li>If the <tt>support_option_emit_pragma_directives</tt> flag is set, the <tt>Wave</tt> library will emit all unknown #pragma directives to the output. This suport option will be recognized only if the <tt>BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES</tt> is defined during compilation to a value not equal to zero (see here for more information). </li>
+
+ <li>If the <tt>support_option_emit_pragma_directives</tt>
+flag is set, the <tt>Wave</tt> library will emit all
+unknown #pragma
+directives to the output. This suport option will be recognized only if
+the <tt>BOOST_WAVE_EMIT_PRAGMA_DIRECTIVES</tt> is defined
+during compilation to a value not equal to zero (see here for more
+information). </li>
+
 </ul>
- If the parameter <tt>reset_macros</tt> is true the <tt>set_language</tt> function internally resets the list of defined macros, so please be careful not to call it after you have defined your own macros already. 
+
+ If the parameter <tt>reset_macros</tt>
+is true the <tt>set_language</tt> function internally
+resets the list of defined macros, so please be careful not to call it
+after you have defined your own macros already. 
+
</blockquote>
+
<a name="set_max_include_nesting_depth" id="set_max_include_nesting_depth"></a>set_max_include_nesting_depth 
- get_max_include_nesting_depth
-<pre> void set_max_include_nesting_depth(size_t new_depth);
- size_t get_max_include_nesting_depth() const;</pre>
-<blockquote>
- This functions allow to set or to get the maximal possible include file nesting
- depth supported by the <tt>Wave</tt> library. The initial value for this is
- determined by the preprocessing constant <tt>WAVE_MAX_INCLUDE_LEVEL_DEPTH</tt>
- (see here).
+
+get_max_include_nesting_depth
+
+<pre> void set_max_include_nesting_depth(size_t new_depth); size_t get_max_include_nesting_depth() const;</pre>
+
+<blockquote>
+ This functions allow to set or to get the maximal possible
+include file nesting depth supported by the <tt>Wave</tt>
+library. The initial value for this is determined by the preprocessing
+constant <tt>WAVE_MAX_INCLUDE_LEVEL_DEPTH</tt> (see here).
+
</blockquote>
+
<table border="0">
- <tr>
- <td width="10"></td>
- <td width="30"></td>
- <td width="30"></td>
- <td width="30"></td>
- </tr>
+
+ <tbody>
+
+ <tr>
+
+ <td width="10"></td>
+
+ <td width="30"></td>
+
+ <td width="30"></td>
+
+ <td width="30"></td>
+
+ </tr>
+
+ </tbody>
</table>
+
<hr size="1">
-Copyright © 2003-2008 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) 
+Copyright © 2003-2008
+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) 
+

-Last updated:
- Sunday, December 2, 2007 19:12
- 
+Last
+updated: Sunday, December
+2, 2007 19:12 

+
 
+
</body>
</html>

Modified: branches/release/libs/wave/doc/class_reference_ctxpolicy.html
==============================================================================
--- branches/release/libs/wave/doc/class_reference_ctxpolicy.html (original)
+++ branches/release/libs/wave/doc/class_reference_ctxpolicy.html 2008-07-29 17:37:09 EDT (Tue, 29 Jul 2008)
@@ -1,441 +1,684 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
-<title>The Context Policy</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link href="theme/style.css" rel="stylesheet" type="text/css">
+
+
+ <title>The Context Policy</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+
+ <link href="theme/style.css" rel="stylesheet" type="text/css">
</head>

+
<body>
-<table width="100%" border="0" cellspacing="2" background="theme/bkd2.gif">
- <tr>
- <td width="21"> <h1></h1></td>
+
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+
+ <tbody>
+ <tr>
+
+ <td width="21">
+ <h1></h1>
+ </td>
+
 <td width="885"> The
 Context Policy (new, current interface) </td>
- <td width="96"></td>
+
+ <td width="96"></td>
+
 </tr>
+
+ </tbody>
</table>
+
 
+
<table border="0">
- <tr>
+
+ <tbody>
+ <tr>
+
 <td width="10"></td>
+
 <td width="30"></td>
- <td width="30"></td>
+
+ <td width="30"></td>
+
 <td width="30"></td>
+
 </tr>
+
+ </tbody>
</table>
+
<blockquote>
+
 Introduction 
+
 <a href="class_reference_ctxpolicy.html#header_synopsis">Header 'wave/preprocessing_hooks.hpp'
 synopsis</a> 
+
 <a href="class_reference_ctxpolicy.html#member_functions">Member functions</a>
+
</blockquote>
+
<h2><a name="introduction"></a>Introduction</h2>
-Please note that the following description relates to the new preprocessing hooks interface used by default starting with the Boost V1.35.0 release. If you are interested in the older interface please look here. 
+
+Please note that the following description relates to the new
+preprocessing hooks interface used by default starting with the Boost
+V1.35.0 release. If you are interested in the older interface please
+look here. 
+
The context policy is used to provide callback hooks, which are called from inside the library into the user code, whenever
+
<ul>
+
 <li>a preprocessor directive has been recognized, </li>
+
 <li>a token is about to be returned from the preprocessor, </li>
+
 <li>a macro get's defined or undefined, </li>
+
 <li>a macro has been expanded or rescanned,</li>
+
 <li>an include file has been opened or closed, </li>
+
 <li>a conditional expression was evaluated,</li>
+
 <li>a token has to be skipped because it is contained in a non-evaluated conditional block, </li>
+
 <li> a pragma of the form <tt>'wave option[(value)]'</tt> has been recognized. </li>
+
</ul>
+
This policy type is used as a template parameter to the boost::wave::context<>
 object, where the default policy provides empty hook functions only.
+
<h2><a name="header_synopsis"></a>Header wave/preprocessing_hooks.hpp
 synopsis</h2>
-<pre>
-namespace boost {
-namespace wave {
-namespace context_policies {
-
- struct default_preprocessing_hooks {

- // general hook functions
- template <typename ContextT, typename TokenT>
- bool found_directive(ContextT const &ctx,
- TokenT const &directive); 
- // test, whether a given token may be skipped template <typename ContextT>
- bool may_skip_whitespace (ContextT const& ctx,
- TokenT &token, bool &skipped_newline); 
- // Conditional compilation
- template <typename ContextT, typename ContainerT> bool evaluated_conditional_expression(
- ContextT const &ctx, ContainerT const& expression, bool expression_value); 
- template <typename ContextT, typename TokenT>
- void skipped_token(ContextT const &ctx,
- TokenT const& token); 
- // macro expansion tracing
+<pre>namespace boost { namespace wave { namespace context_policies { struct default_preprocessing_hooks { // general hook functions
+ template <typename ContextT, typename TokenT> bool found_directive(ContextT const &ctx, TokenT const &directive); template <typename ContextT, typename ExceptionT> void throw_exception(ContextT const &ctx, ExceptionT const& e); // test, whether a given token may be skipped template <typename ContextT> bool <a href="c
lass_reference_ctxpolicy.html#may_skip_whitespace">may_skip_whitespace</a> (ContextT const& ctx, TokenT &token, bool &skipped_newline); 
+ // Conditional compilation
+ template < typename ContextT, typename TokenT, typename ContainerT > bool evaluated_conditional_expression( ContextT const &ctx, TokenT const& directive, ContainerT const& expression, bool expression_value); 
+ template <typename ContextT, typename TokenT> void skipped_token(ContextT const &ctx, TokenT const& token); template <typename ContextT, typename TokenT> TokenT const& generated_token(ContextT const &ctx, TokenT const& token); // macro expansion tracing
 template <
- typename ContextT, typename TokenT, typename ContainerT,
- typename IteratorT
- >
- bool expanding_function_like_macro(
- ContextT const &ctx, TokenT const &macrodef,
- std::vector<TokenT> const &formal_args,
- ContainerT const &definition, TokenT const &macrocall,
- std::vector<ContainerT> const &arguments,
- IteratorT const &seqstart, Iterator const &seqend);
-
- template <typename ContextT, typename TokenT, typename ContainerT>
- bool expanding_object_like_macro(
- ContextT const &ctx, TokenT const &macro,
- ContainerT const &definition, TokenT const &macrocall);
-
- template <typename ContextT, typename ContainerT>
- void expanded_macro(ContextT const &ctx,
- ContainerT const &result);
-
- template <typename ContextT, typename ContainerT>
- void rescanned_macro(ContextT const &ctx,
- ContainerT const &result);
-
- // include file tracing functions
- template <typename ContextT>
- bool found_include_directive(ContextT const &ctx,
- std::string const &filename, bool include_next);
-
- template <typename ContextT>
- void opened_include_file(ContextT const &ctx,
- std::string const &relname, std::string const& absname,
- std::size_t include_depth, bool is_system_include);
-
- template <typename ContextT>
- void returning_from_include_file(ContextT const &ctx);
-
- // interpretation of #pragma's of the form 
+ typename ContextT, typename TokenT, typename ContainerT, typename IteratorT > bool expanding_function_like_macro( ContextT const &ctx, TokenT const &macrodef, std::vector<TokenT> const &formal_args, ContainerT const &definition, TokenT const &macrocall, std::vector<ContainerT> const &arguments, IteratorT const &seqstart, Iterator const &seqend); 
 template <typename ContextT, typename TokenT, typename ContainerT> bool expanding_object_like_macro( ContextT const &ctx, TokenT const &macro, ContainerT const &definition, TokenT const &macrocall); template <typename ContextT, typename ContainerT> void expanded_macro(ContextT const &ctx, ContainerT const &result); 
 template <typename ContextT, typename ContainerT> void rescanned_macro(ContextT const &ctx, ContainerT const &result); // include file tracing functions
+ template <typename ContextT> bool found_include_directive(ContextT const &ctx, std::string const &filename, bool include_next); template <typename ContextT> void opened_include_file(ContextT const &ctx, std::string const &relname, std::string const& absname, bool is_system_include); template <typename ContextT> void returning_from_include_file(ContextT const &ctx); // interpretation of #pragma's of the form 
 // 'wave option[(value)]'
- template <typename ContextT, typename ContainerT>
- bool interpret_pragma(ContextT const &ctx, ContainerT &pending,
- typename ContextT::token_type const &option,
- ContainerT const &values,
- typename ContextT::token_type const &pragma_token);
-
- // macro definition hooks
- template <
- typename ContextT, typename TokenT, 
- typename ParametersT, typename DefinitionT
- >
- void defined_macro(ContextT const &ctx, TokenT const &name, 
- bool is_functionlike, ParametersT const &parameters,
- DefinitionT const &definition, bool is_predefined);
-
- template <typename ContextT, typename TokenT>
- void undefined_macro(ContextT const &ctx,
- TokenT const &name);
-
- // #error and #warning directive hooks
- template <typename ContextT, typename ContainerT>
- bool found_warning_directive(ContextT const &ctx,
- ContainerT const &message);
-
- template <typename ContextT, typename ContainerT>
- bool found_error_directive(ContextT const &ctx,
- ContainerT const &message);
-
- // #line directive hook
- template <typename ContextT, typename ContainerT>
- void found_line_directive(ContextT const &ctx,
- ContainerT const &arguments, unsigned int line,
- std::string const& filename);
- };
+ template <typename ContextT, typename ContainerT> bool interpret_pragma(ContextT const &ctx, ContainerT &pending, typename ContextT::token_type const &option, ContainerT const &values, typename ContextT::token_type const &pragma_token); // macro definition hooks
+ template < typename ContextT, typename TokenT, 
+ typename ParametersT, typename DefinitionT > void defined_macro(ContextT const &ctx, TokenT const &name, 
+ bool is_functionlike, ParametersT const &parameters, DefinitionT const &definition, bool is_predefined); template <typename ContextT, typename TokenT> void undefined_macro(ContextT const &ctx, TokenT const &name); // #error and #warning directive hooks
+ template <typename ContextT, typename ContainerT> bool found_warning_directive(ContextT const &ctx, ContainerT const &message); template <typename ContextT, typename ContainerT> bool found_error_directive(ContextT const &ctx, ContainerT const &message); // #line directive hook
+ template <typename ContextT, typename ContainerT> void found_line_directive(ContextT const &ctx, ContainerT const &arguments, unsigned int line, std::string const& filename); }; }}} // namespace boost::wave::context_policies</pre>

-}}} // namespace boost::wave::context_policies</pre>
<h2><a name="member_functions"></a>Member functions</h2>
+
<h3>General hook functions </h3>
+
<a name="found_directive"></a>found_directive
-<pre> template <typename ContextT, typename TokenT>
- bool found_directive(ContextT const& ctx, TokenT const &directive);
-</pre>
+
+<pre> template <typename ContextT, typename TokenT> bool found_directive(ContextT const& ctx, TokenT const &directive); </pre>
+
<blockquote>
+
 The function <tt>found_directive</tt> is called, whenever the preprocessor has detected one of the preprocessing directives (#define, #undef, #if, #idef, #ifndef, #elif, #endif, #error, #include, #pragma or #warning) .
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
 The parameter <tt>directive</tt> refers to the token containing the detected preprocessing directive. 
- If the return value is <tt>true</tt>, the directive will be skipped altogether, i.e. no preprocessing is done. The overall directive is replaced by a single newline character. If the return value is <tt>false</tt>, the directive is processed in the normal manner. 
+
+
+ If the return value is <tt>true</tt>, the directive will be
+skipped altogether, i.e. no preprocessing is done. The overall
+directive is replaced by a single newline character. If the return
+value is <tt>false</tt>, the directive is processed in the normal manner. 
+
</blockquote>
+
+<a name="throw_exception"></a>throw_exception
+
+<pre> template <typename ContextT, typename ExceptionT> void throw_exception(ContextT const &ctx, ExceptionT const& e);</pre>
+
+<blockquote>
+
+ he function <tt>throw_exception</tt> is called, whenever a preprocessing exception occurs .
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.  
+
+
+ The parameter <tt>e</tt> is the exception object containing detailed error information. 
+
+
+</blockquote>
+
<a name="may_skip_whitespace" id="may_skip"></a>may_skipwhitespace
-<pre> template <typename ContextT, typename TokenT>
- bool may_skip_whitespace(ContextT const& ctx, TokenT &token,
- bool& skipped_newline);
-</pre>
+
+<pre> template <typename ContextT, typename TokenT> bool may_skip_whitespace(ContextT const& ctx, TokenT &token, bool& skipped_newline); </pre>
+
<blockquote>
+
 The function <tt>may_skipwhitespace</tt> will be called by the library, whenever a token is about to be returned to the calling application. 
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Wave V1.2.4 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Wave V1.2.4 release. 
+
+
 The <tt>token</tt> parameter holds a reference to the current token. The policy is free to change this token if needed.
- The <tt>skipped_newline</tt> parameter holds a reference to a boolean value which should be set to true by the policy function whenever a newline is going to be skipped. 
+
+
+ The <tt>skipped_newline</tt> parameter holds a reference to a
+boolean value which should be set to true by the policy function
+whenever a newline is going to be skipped. 
+
+
 If the return value is <tt>true</tt>, the given token is skipped and the preprocessing continues to the next token. If the return value is <tt>false</tt>, the given token is returned to the calling application. Caution has to be used, because by returning true the policy function is able to force skipping even significant tokens not only whitespace. 
+
</blockquote>
+
<h3>Conditional compilation hook functions </h3>
+
<a name="evaluated_conditional_expression"></a>evaluated_conditional_expression
-<pre> template <typename ContextT, typename ContainerT> bool evaluated_conditional_expression(ContextT const& ctx,
- ContainerT const& expression, bool expression_value);
-</pre>
+
+<pre> template <typename ContextT, typename TokenT, typename ContainerT> bool evaluated_conditional_expression(ContextT const& ctx, TokenT const& directive, ContainerT const& expression, bool expression_value); </pre>
+
<blockquote>
- The function <tt>evaluated_conditional_expression</tt> is called, whenever the preprocessor has encountered a #if, #elif, #ifdef or #ifndef directive. This hook gets passed the non-expanded conditional expression (as it was given in the analysed source file) and the result of the evaluation of this expression in the current preprocessing context.
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+ The function <tt>evaluated_conditional_expression</tt> is called, whenever the preprocessor has encountered a #if, #elif, #ifdef or #ifndef
+directive. This hook gets passed the non-expanded conditional
+expression (as it was given in the analysed source file) and the result
+of the evaluation of this expression in the current preprocessing
+context.
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>token</tt> parameter holds a reference to the evaluated directive token. 
+
+
 The parameter <tt>expression</tt> holds the non-expanded token sequence
 comprising the evaluated expression.
+
+
 The parameter <tt>expression_value</tt> contains the result of the evaluation of
 the expression in the current preprocessing context. 
- The return value defines, whether the given expression has to be evaluated again, allowing to decide which of the conditional branches should be expanded. You need to return 'true' from this hook function to force the expression to be re-evaluated. Note, this was changed from a 'void' for the Boost V1.35.0 release. 
+
+
+ The return value defines, whether the given expression has to be
+evaluated again, allowing to decide which of the conditional branches
+should be expanded. You need to return 'true' from this hook function to force the expression to be re-evaluated. Note, this was changed from a 'void' for the Boost V1.35.0 release. 
+
 
+
</blockquote>
+
<a name="skipped_token"></a>skipped_token
-<pre> template <typename ContextT, typename TokenT>
- void skipped_token(ContextT const& ctx, TokenT const& token);
-</pre>
+
+<pre> template <typename ContextT, typename TokenT> void skipped_token(ContextT const& ctx, TokenT const& token); </pre>
+
<blockquote>
+
 The function <tt>skipped_token</tt> is called, whenever a token is about to be skipped due to a false preprocessor condition (code fragments to be
 skipped inside the not evaluated conditional #if/#else/#endif branches).
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
 The parameter <tt>token</tt> refers to the token to be skipped.
+
+</blockquote>
+
+<a name="generated_token"></a>generated_token
+
+<pre> template <typename ContextT, typename TokenT> TokenT const& generated_token(ContextT const& ctx, TokenT const& token); </pre>
+
+<blockquote>
+
+ The function <tt>generated_token</tt> is called, whenever a token is about to be returned from the library.
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The parameter <tt>token</tt> refers to the token about to be
+returned from the library. This function may alter the token, but in
+this case it must be implemented with a non-const reference for the
+token parameter, allowing to modify the token in place.
+ The default behavior is to return the passed token reference unchanged to the caller.
+
</blockquote>
+
<h3>Macro expansion tracking functions</h3>
+
<a name="expanding_function_like_macro"></a>expanding_function_like_macro
-<pre> template <typename ContextT, typename TokenT, typename ContainerT>
- bool expanding_function_like_macro(
- ContextT const& ctx, TokenT const &macrodef,
- std::vector<TokenT> const &formal_args,
- ContainerT const &definition, TokenT const &macrocall,
- std::vector<ContainerT> const &arguments,
- IteratorT const &seqstart, Iterator const &seqend);</pre>
+
+<pre> template <typename ContextT, typename TokenT, typename ContainerT> bool expanding_function_like_macro( ContextT const& ctx, TokenT const &macrodef, std::vector<TokenT> const &formal_args, ContainerT const &definition, TokenT const &macrocall, std::vector<ContainerT> const &arguments, IteratorT const &seqstart, Iterator const &seqend);</pre>
+
<blockquote>
+
 The function <tt>expanding_function_like_macro</tt> is called, whenever a
 function-like macro is to be expanded, i.e. before the actual expansion
 starts.
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
 The <tt>macroname</tt> parameter marks the position where the macro to expand
 is defined. It contains the token which identifies the macro name used inside
 the corresponding macro definition.
+
+
 The <tt>formal_args</tt> parameter holds the formal arguments used during
 the definition of the macro. 
+
+
 The <tt>definition</tt> parameter holds the macro definition for the macro
 to trace. This is a standard STL container which holds the token sequence
 identified during the macro definition as the macro replacement list.
+
+
 The <tt>macrocall</tt> parameter marks the position where this macro is invoked.
 It contains the token, which identifies the macro call inside the preprocessed
 input stream. 
+
+
 The <tt>arguments</tt> parameter holds the macro arguments used during the
 invocation of the macro. This is a vector of standard STL containers which
 contain the token sequences identified at the position of the macro call as
 the arguments to be used during the macro expansion. 
+
+
 The parameters <tt>seqstart</tt> and <tt>seqend</tt> point into the input token
 stream allowing to access the whole token sequence comprising the macro
 invocation (starting with the opening parenthesis and ending after the
 closing one).
- If the return value is <tt>true</tt>, the macro is not expanded, i.e. the overall macro invocation sequence, including the parameters are copied to the output without further processing . If the return value is <tt>false</tt>, the macro is expanded as expected. 
+
+
+ If the return value is <tt>true</tt>, the macro is not expanded,
+i.e. the overall macro invocation sequence, including the parameters
+are copied to the output without further processing . If the return
+value is <tt>false</tt>, the macro is expanded as expected. 
+
 
+
</blockquote>
+
<a name="expanding_object_like_macro"></a>expanding_object_like_macro
-<pre> template <typename ContextT, typename TokenT, typename ContainerT>
- bool expanding_object_like_macro(
- ContextT const& ctx, TokenT const &macro,
- ContainerT const &definition, TokenT const &macrocall);
-</pre>
+
+<pre> template <typename ContextT, typename TokenT, typename ContainerT> bool expanding_object_like_macro( ContextT const& ctx, TokenT const &macro, ContainerT const &definition, TokenT const &macrocall); </pre>
+
<blockquote>
+
 The function <tt>expanding_object_like_macro</tt> is called, whenever a object-like
 macro is to be expanded, i.e. before the actual expansion starts.
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
 The <tt>macroname</tt> parameter marks the position where the macro to expand
 is defined. It contains the token which identifies the macro name used inside
 the corresponding macro definition.
+
+
 The <tt>definition</tt> parameter holds the macro definition for the macro
 to trace. This is a standard STL container which holds the token sequence
 identified during the macro definition as the macro replacement list.
+
+
 The <tt>macrocall</tt> parameter marks the position where this macro is invoked.
 It contains the token which identifies the macro call inside the preprocessed
 input stream. 
+
+
 If the return value is <tt>true</tt>, the macro is not expanded, i.e. the macro symbol is copied to the output without further processing. If the return value is <tt>false</tt>, the macro is expanded as expected. 
-
+
+ 
+
</blockquote>
+
<a name="expanded_macro"></a>expanded_macro
-<pre> template <typename ContextT, typename ContainerT>
- void expanded_macro(ContextT const& ctx, ContainerT const &result);
-</pre>
+
+<pre> template <typename ContextT, typename ContainerT> void expanded_macro(ContextT const& ctx, ContainerT const &result); </pre>
+
<blockquote>
+
 The function <tt>expanded_macro</tt> is called whenever the expansion of
 a macro is finished, the replacement list is completely scanned and the identified
 macros herein are replaced by its corresponding expansion results, but before
 the rescanning process starts.
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
 The parameter <tt>result</tt> contains the the result of the macro expansion
 so far. This is a standard STL container containing the generated token sequence.
+
</blockquote>
+
<a name="rescanned_macro"></a>rescanned_macro
-<pre> template <typename ContextT, typename ContainerT>
- void rescanned_macro(ContextT const& ctx, ContainerT const &result);
-</pre>
+
+<pre> template <typename ContextT, typename ContainerT> void rescanned_macro(ContextT const& ctx, ContainerT const &result); </pre>
+
<blockquote>
+
 The function <tt>rescanned_macro</tt> is called whenever the rescanning
 of a macro is finished, i.e. the macro expansion is complete.
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
 The parameter <tt>result</tt> contains the the result of the whole macro
 expansion. This is a standard STL container containing the generated token
 sequence.
+
</blockquote>
+
<h3>Include file tracing functions</h3>
+
<a name="opened_include_file" id="found_include_directive"></a>found_include_directive
-<pre> template <typename ContextT>
- bool found_include_directive(ContextT const& ctx,
- std::string const &filename, bool include_next);
-</pre>
+
+<pre> template <typename ContextT> bool found_include_directive(ContextT const& ctx, std::string const &filename, bool include_next); </pre>
+
<blockquote>
+
 The function <tt>found_include_directive</tt> is called whenever whenever a #include directive was located..
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
 The parameter <tt>filename</tt> contains the (expanded) file name found after
- the #include directive. This has the format <tt><file></tt>, <tt>"file"</tt> or <tt>file</tt>.
- The formats <tt><file></tt> or <tt>"file"</tt> are used for #include directives found
+ the #include directive. This has the format <tt><file></tt>, <tt>"file"</tt> or <tt>file</tt>.
+ The formats <tt><file></tt> or <tt>"file"</tt> are used for #include directives found
 in the preprocessed token stream, the format <tt>file</tt> is used for files
 specified through the --force_include command line argument.
+
+
 The parameter <tt>include_next</tt> is set to true if the found directive was
 a #include_next directive and the <tt>BOOST_WAVE_SUPPORT_INCLUDE_NEXT</tt> preprocessing constant was defined to something != 0.
- If the return value is <tt>true</tt>, the include directive is not executed, i.e. the file to include is not loaded nor processed. The overall directive is replaced by a single newline character. If the return value is <tt>false</tt>, the directive is executed in a normal manner. 
+
+
+ If the return value is <tt>true</tt>, the include directive is not
+executed, i.e. the file to include is not loaded nor processed. The
+overall directive is replaced by a single newline character. If the
+return value is <tt>false</tt>, the directive is executed in a normal manner. 
+
 
+
</blockquote>
+
<a name="opened_include_file" id="opened_include_file"></a>opened_include_file
-<pre> template <typename ContextT>
- void opened_include_file(ContextT const& ctx,
- std::string const &rel_filename, std::string const &abs_filename,
- std::size_t include_depth, bool is_system_include);
-</pre>
+
+<pre> template <typename ContextT> void opened_include_file(ContextT const& ctx, std::string const &rel_filename, std::string const &abs_filename, bool is_system_include); </pre>
+
<blockquote>
+
 The function <tt>opened_include_file</tt> is called whenever a file referred
 by an #include directive was successfully located and opened.
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
- The parameter <tt>rel_filename</tt> contains the (normalised) probably relative file system path of the opened file. The concrete format of this file name depends on the format of the include search path given to the library beforehand.
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The parameter <tt>rel_filename</tt> contains the (normalised)
+probably relative file system path of the opened file. The concrete
+format of this file name depends on the format of the include search
+path given to the library beforehand.
+
+
 The parameter <tt>abs_filename</tt> contains the (normalised) full file system path of the
 opened file.
- The <tt>include_depth</tt> parameter contains the current include file depth.
- 
 The <tt>is_system_include</tt> parameter denotes, if the given file was found
 as a result of a <tt>#include <...></tt> directive.
+
</blockquote>
+
<a name="returning_from_include_file" id="returning_from_include_file"></a>returning_from_include_file
-<pre> template <typename ContextT>
- void returning_from_include_file(ContextT const& ctx);
-</pre>
+
+<pre> template <typename ContextT> void returning_from_include_file(ContextT const& ctx); </pre>
+
<blockquote>
+
 The function <tt>returning_from_include_file</tt> is called whenever an
 included file is about to be closed after it's processing is complete.
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
</blockquote>
+
<h3>Interpretation of #pragma's</h3>
+
<a name="interpret_pragma"></a>interpret_pragma
-<pre> template <typename ContextT, typename ContextT, typename ContainerT>
- bool interpret_pragma(ContextT const &ctx, ContainerT &pending,
- typename ContextT::token_type const &option,
- ContainerT const &values,
- typename ContextT::token_type const &pragma_token);
-</pre>
+
+<pre> template <typename ContextT, typename ContextT, typename ContainerT> bool interpret_pragma(ContextT const &ctx, ContainerT &pending, typename ContextT::token_type const &option, ContainerT const &values, typename ContextT::token_type const &pragma_token); </pre>
+
<blockquote>
+
 The function <tt>interpret_pragma</tt> is called whenever an unrecognized
- <tt>#pragma wave ...</tt> or operator <tt>_Pragma("wave ...")</tt>
+ <tt>#pragma wave ...</tt> or operator <tt>_Pragma("wave ...")</tt>
 is found in the input stream.
+
+
 The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. 
+
+
 The <tt>pending</tt> parameter may be used to push tokens back into the input
 stream which are to be used as the replacement text for the whole <tt>#pragma wave()</tt>
 directive. If this sequence is left empty, no replacement takes place, i.e.
 the interpreted directive is removed from the generated token stream.
+
+
 The <tt>option</tt> parameter contains the name of the interpreted pragma.
+
+
 The <tt>values</tt> parameter holds the value of the parameter provided to
 the pragma operator.
+
+
 The <tt>pragma_token</tt> parameter contains the actual #pragma token which
 may be used for extraction of the location information for some error output.
+
+
 If the return value is 'false', the whole #pragma directive is interpreted
 as unknown and a corresponding error message is issued. A return value of
 'true' signs a successful interpretation of the given #pragma. 
+
 
+
</blockquote>
+
<h3>Macro definition </h3>
+
<a name="defined_macro" id="defined_macro"></a>defined_macro
-<pre> template <
- typename ContextT, typename TokenT, typename ParametersT, 
- typename DefinitionT
- >
- void defined_macro(ContextT const& ctx,
- TokenT const &name, bool is_functionlike,
- ParametersT const &parameters, DefinitionT const &definition,
- bool is_predefined);
-</pre>
-<blockquote> The function <tt>defined_macro</tt> is called whenever a macro was defined successfully.
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+<pre> template < typename ContextT, typename TokenT, typename ParametersT, 
+ typename DefinitionT > void defined_macro(ContextT const& ctx, TokenT const &name, bool is_functionlike, ParametersT const &parameters, DefinitionT const &definition, bool is_predefined); </pre>
+
+<blockquote>
+ The function <tt>defined_macro</tt> is called whenever a macro was defined successfully.
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
 The parameter <tt>name</tt> is a reference to the token holding the macro name.
+
+
 The parameter <tt>is_functionlike</tt> is set to true whenever the newly
 defined macro is defined as a function like macro.
+
+
 The parameter <tt>parameters</tt> holds the parameter tokens for the macro
 definition. If the macro has no parameters or if it is a object like
 macro, then this container is empty.
+
+
 The parameter <tt>definition</tt> contains the token sequence given as the
 replacement sequence (definition part) of the newly defined macro.
+
+
 The parameter <tt>is_predefined</tt> is set to true for all macros predefined
 during the initialisation pahase of the library. 
+
 
+
</blockquote>
+
<a name="undefined_macro" id="undefined_macro"></a>undefined_macro
-<pre> template <typename ContextT, typename TokenT>
- void undefined_macro(ContextT const& ctx, TokenT const &name);
-</pre>
+
+<pre> template <typename ContextT, typename TokenT> void undefined_macro(ContextT const& ctx, TokenT const &name); </pre>
+
<blockquote>
+
 The function <tt>undefined_macro</tt> is called whenever a macro definition
 was removed successfully.
- The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. Note, this parameter was added for the Boost V1.35.0 release. 
+
+
+ The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt>
+used during instantiation of the preprocessing iterators by the user.
+Note, this parameter was added for the Boost V1.35.0 release. 
+
+
 The parameter <tt>name</tt> holds the token of the macro which definition was removed. 
+
 
+
</blockquote>
+
<a name="found_warning_directive" id="found_warning_directive"></a>found_warning_drective
-<pre> template <typename ContextT, typename ContainerT>
- bool found_warning_directive(ContextT const& ctx,
- ContainerT const &message);
-</pre>
+
+<pre> template <typename ContextT, typename ContainerT> bool found_warning_directive(ContextT const& ctx, ContainerT const &message); </pre>
+
<blockquote>
- The function <tt>found_warning_directive </tt> is called whenever a #warning directive has been encountered. Note, this function was added for the Boost V1.35.0 release. This function will be called only if the <tt>BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE</tt> compile time constant was defined to something not equal to zero (see the Compile Time Configuration for more information). 
+
+ The function <tt>found_warning_directive </tt> is called whenever a #warning directive
+has been encountered. Note, this function was added for the Boost
+V1.35.0 release. This function will be called only if the <tt>BOOST_WAVE_SUPPORT_WARNING_DIRECTIVE</tt> compile time constant was defined to something not equal to zero (see the Compile Time Configuration for more information). 
+
+
 The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. 
+
+
 The parameter <tt>message</tt> references the argument token sequence of the encountered #warning directive.
+
+
 If the return value is <tt>false</tt>, the library throws a preprocessor
 exception of the type <code>warning_directive</code> (normal execution continues), if the return value is <tt>true</tt> the execution continues as if no #warning directive has been found and the overall directive is replaced by a single newline. 
+
</blockquote>
+
<a name="found_error_directive" id="found_error_directive"></a>found_error_drective
-<pre> template <typename ContextT, typename ContainerT>
- bool found_error_directive(ContextT const& ctx,
- ContainerT const &message);
-</pre>
+
+<pre> template <typename ContextT, typename ContainerT> bool found_error_directive(ContextT const& ctx, ContainerT const &message); </pre>
+
<blockquote>
+
 The function <tt>found_error_directive </tt> is called whenever a #error directive has been encountered. Note, this function was added for the Boost V1.35.0 release. 
+
+
 The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. 
+
+
 The parameter <tt>message</tt> references the argument token sequence of the encountered #error directive.
+
+
 If the return value is <tt>false</tt>, the library throws a preprocessor
 exception of the type <code>error_directive</code> (normal execution continues), if the return value is <tt>true</tt> the execution continues as if no #error directive has been found and the overall directive is replaced by a single newline. 
+
</blockquote>
+
<a name="found_line_directive" id="found_line_directive"></a>found_line_drective
-<pre> template <typename ContextT, typename ContainerT>
- void found_line_drective(ContextT const& ctx,
- ContainerT const &arguments, unsigned int line,
- std::string const& filename);
-</pre>
+
+<pre> template <typename ContextT, typename ContainerT> void found_line_drective(ContextT const& ctx, ContainerT const &arguments, unsigned int line, std::string const& filename); </pre>
+
<blockquote>
+
 The function <tt>found_line_directive </tt> is called whenever a #line directive has been encountered. Note, this function was added for the Boost V1.35.0 release. 
+
+
 The <tt>ctx</tt> parameter provides a reference to the <tt>context_type</tt> used during instantiation of the preprocessing iterators by the user. 
+
+
 The parameter <tt>arguments</tt> references the argument token sequence of the encountered #line directive.
+
+
 The parameter <tt>line</tt> contains the recognized line number from the #line directive.
+
+
 The parameter <tt>filename</tt> references the recognized file name from the #line directive (if there was one given). 
+
 
+
</blockquote>
+
<table border="0">
- <tr>
+
+ <tbody>
+ <tr>
+
 <td width="10"></td>
+
 <td width="30"></td>
- <td width="30"></td>
+
+ <td width="30"></td>
+
 <td width="30"></td>
+
 </tr>
+
+ </tbody>
</table>
+
<hr size="1">
Copyright © 2003-2008 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) 
+
+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) 
+
Last updated:
 Sunday, December 2, 2007 19:12

+
</body>
</html>

Modified: branches/release/libs/wave/doc/preface.html
==============================================================================
--- branches/release/libs/wave/doc/preface.html (original)
+++ branches/release/libs/wave/doc/preface.html 2008-07-29 17:37:09 EDT (Tue, 29 Jul 2008)
@@ -1,28 +1,55 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
-<title>Preface</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link href="theme/style.css" rel="stylesheet" type="text/css">
+
+
+ <title>Preface</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+
+ <link href="theme/style.css" rel="stylesheet" type="text/css">
</head>

-<body text="#000000" background="theme/bkd.gif">
-<table width="100%" border="0" cellspacing="2" background="theme/bkd2.gif">
- <tr>
- <td width="21"> <h1></h1></td>
+
+<body background="theme/bkd.gif" text="#000000">
+
+<table background="theme/bkd2.gif" border="0" cellspacing="2" width="100%">
+
+ <tbody>
+ <tr>
+
+ <td width="21">
+ <h1></h1>
+ </td>
+
 <td width="885"> Preface</td>
- <td width="96"></td>
+
+ <td width="96"></td>
+
 </tr>
+
+ </tbody>
</table>
+
 
+
<table border="0">
- <tr>
+
+ <tbody>
+ <tr>
+
 <td width="10"></td>
+
 <td width="30"></td>
- <td width="30"><img src="theme/l_arr_disabled.gif" width="20" height="19" border="0"></td>
+
+ <td width="30"><img src="theme/l_arr_disabled.gif" border="0" height="19" width="20"></td>
+
 <td width="30"></td>
+
 </tr>
+
+ </tbody>
</table>
+
During the last time many new features have been developed as additions to the <tt>Spirit</tt>
 <a href="references.html#spirit">[4]</a> parser construction framework and we
 felt more and more, that it would be very helpful, to have a 'real world' example,
@@ -31,6 +58,7 @@
 interest of developers to have a modern, open source C++ preprocessor library
 to play with.  So we had the idea to implement a C++ preprocessor to fit
 this needs - <tt>Wave</tt> was born.
+
The <tt>Wave</tt> C++ preprocessor library uses the <a href="http://www.boost.org/">
 </a> <tt>Spirit[4]</tt> parser construction
 library to implement a C++ lexer with ISO/ANSI Standards conformant preprocessing
@@ -38,22 +66,30 @@
 token from the input stream. This preprocessed token is generated on the fly
 while iterating over the preprocessor iterator sequence (in the terminology
 of the STL these iterators are forward iterators). 
+
 The C++ preprocessor is a macro processor that under normal
 circumstances is used automatically by your C++ compiler to transform your program
 before actual compilation. It is called a macro processor because it allows
 to define macros, which are brief abbreviations for longer constructs. The
 C++ preprocessor provides four separate facilities that you can use as you see
 fit: 
+
<blockquote>
- <img src="theme/bullet.gif" width="13" height="13" id="IMG1"> Inclusion
+
+ <img src="theme/bullet.gif" id="IMG1" height="13" width="13"> Inclusion
 of header files 
- <img src="theme/bullet.gif" width="13" height="13" id="IMG1"> Macro
+
+ <img src="theme/bullet.gif" id="IMG1" height="13" width="13"> Macro
 expansion 
- <img src="theme/bullet.gif" width="13" height="13" id="IMG1"> Conditional
+
+ <img src="theme/bullet.gif" id="IMG1" height="13" width="13"> Conditional
 compilation 
- <img src="theme/bullet.gif" width="13" height="13" id="IMG1"> Line
+
+ <img src="theme/bullet.gif" id="IMG1" height="13" width="13"> Line
 control
+
</blockquote>
+
These features are greatly underestimated today, even more, the preprocessor
 has been frowned on for so long that its usage just hasn't been effectively
 pushed until the Boost preprocessor library [7]
@@ -61,49 +97,87 @@
 generative metaprogramming combined with template metaprogramming in C++ is
 by far one of the most powerful compile-time reflection/metaprogramming facilities
 that any language has ever supported.
-The C++ Standard [2] was adopted back in 1998, but there is still no (known to me) commercial C++ compiler, which has a bugfree implementation of the rather simple preprocessor requirements mandated therein. This may be a result of the mentioned underestimation or even banning of the preprocessor from good programming style during the last few years or may stem from the somewhat awkward standardese dialect of English used to describe it. Two open source projects are exceptions of this: gcc and Clang (a subproject of LLVM), both providing preprocessors with very good standards conformance. 
+
+The C++ Standard [2]
+was adopted back in 1998, but there is still no (known to me)
+commercial C++ compiler, which has a bugfree implementation of the
+rather simple preprocessor requirements mandated therein. This may be a
+result of the mentioned underestimation or even banning of the
+preprocessor from good programming style during the last few years or
+may stem from the somewhat awkward standardese dialect of English used
+to describe it. Two open source projects are exceptions of this: gcc
+and Clang (a subproject of LLVM), both providing preprocessors with
+very good standards conformance. 
+
So the main goals for the <tt>Wave</tt> project are:
+
<blockquote>
- <img src="theme/bullet.gif" width="13" height="13" id="IMG1"> full
+
+ <img src="theme/bullet.gif" id="IMG1" height="13" width="13"> full
 conformance with the C++ standard (ISO/IEC 14882:1998) [1]
 and with the C99 standard (INCITS/ISO/IEC 9899:1999) [2] 
- <img src="theme/bullet.gif" width="13" height="13"> usage of <tt>Spirit[4]</tt>
+
+ <img src="theme/bullet.gif" height="13" width="13"> usage of <tt>Spirit[4]</tt>
 for the parsing parts of the game (certainly :-) 
- <img src="theme/bullet.gif" width="13" height="13"> maximal usage
+
+ <img src="theme/bullet.gif" height="13" width="13"> maximal usage
 of STL and/or <tt>Boost</tt> libraries (for compactness and maintainability) 
- <img src="theme/bullet.gif" width="13" height="13"> straightforward
+
+ <img src="theme/bullet.gif" height="13" width="13"> straightforward
 extendability for the implementation of additional features 
- <img src="theme/bullet.gif" width="13" height="13"> building a
+
+ <img src="theme/bullet.gif" height="13" width="13"> building a
 flexible library for different C++ lexing and preprocessing needs
+
</blockquote>
-At the first steps it is not planned to make a very high performance or very
- small C++ preprocessor. If you are looking for these objectives you probably
- have to look at other places. Although our C++ preprocessor iterator works as expected and is usable as a reference implementation, for instance
- for testing of other preprocessor oriented libraries as the Boost Preprocessor
- library [7] et.al. Nevertheless recent work has lead to surprising performance enhancements (if compared
+
+At the first steps it is not planned to make a very high performance
+or very small C++ preprocessor. If you are looking for these objectives
+you probably have to look at other places. Although our C++
+preprocessor iterator works as expected and is usable as a reference
+implementation, for instance for testing of other preprocessor oriented
+libraries as the Boost Preprocessor library [7] et.al. Nevertheless recent work has lead to surprising performance enhancements (if compared
 with earlier versions). Wave is still somewhat slower as for instance EDG
 based preprocessors (Intel, Comeau) on simple input files, however, as
 complexity increases, time dilates expontentially on EDG. Preprocessing time
 dilates linearly under Wave, which causes it to easily outperform EDG based
preprocessors when complexity increases.
+
As tests showed, the <tt>Wave</tt> library is very conformant to the C++ Standard,
 such that it compiles several strict conformant macro definitions, which are
not even compilable with EDG based preprocessors (i.e. Comeau or Intel). 
+
<table border="0">
- <tr>
+
+ <tbody>
+ <tr>
+
 <td width="10"></td>
+
 <td width="30"></td>
- <td width="30"><img src="theme/l_arr_disabled.gif" width="20" height="19" border="0"></td>
+
+ <td width="30"><img src="theme/l_arr_disabled.gif" border="0" height="19" width="20"></td>
+
 <td width="30"></td>
+
 </tr>
+
+ </tbody>
</table>
+
<hr size="1">
Copyright © 2003-2008 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) 
+
+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) 
+

Last updated:
 Sunday, December 2, 2007 19:03

+
</body>
</html>

Next message: eric_at_[hidden]: "[Boost-commit] svn:boost r47872 - trunk/tools/boostbook/xsl/doxygen"
Previous message: daniel_james_at_[hidden]: "[Boost-commit] svn:boost r47870 - in trunk/more/getting_started: . detail"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk