Boost-Commit :

Date view	Thread view	Subject view	Author view

From: joel_at_[hidden]
Date: 2008-07-11 06:07:20

Author: djowel
Date: 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
New Revision: 47303
URL: http://svn.boost.org/trac/boost/changeset/47303

Log:
merge from release branch
Added:
   trunk/libs/spirit/doc/concepts_template.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/concepts_template.qbk
   trunk/libs/spirit/doc/html/images/alert.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/alert.png
   trunk/libs/spirit/doc/html/images/callouts/
      - copied from r47301, /branches/release/libs/spirit/doc/html/images/callouts/
   trunk/libs/spirit/doc/html/images/callouts/1.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/1.png
   trunk/libs/spirit/doc/html/images/callouts/10.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/10.png
   trunk/libs/spirit/doc/html/images/callouts/11.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/11.png
   trunk/libs/spirit/doc/html/images/callouts/12.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/12.png
   trunk/libs/spirit/doc/html/images/callouts/13.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/13.png
   trunk/libs/spirit/doc/html/images/callouts/14.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/14.png
   trunk/libs/spirit/doc/html/images/callouts/15.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/15.png
   trunk/libs/spirit/doc/html/images/callouts/2.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/2.png
   trunk/libs/spirit/doc/html/images/callouts/3.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/3.png
   trunk/libs/spirit/doc/html/images/callouts/4.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/4.png
   trunk/libs/spirit/doc/html/images/callouts/5.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/5.png
   trunk/libs/spirit/doc/html/images/callouts/6.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/6.png
   trunk/libs/spirit/doc/html/images/callouts/7.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/7.png
   trunk/libs/spirit/doc/html/images/callouts/8.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/8.png
   trunk/libs/spirit/doc/html/images/callouts/9.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/9.png
   trunk/libs/spirit/doc/html/images/callouts/Thumbs.db
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/callouts/Thumbs.db
   trunk/libs/spirit/doc/html/images/caution.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/caution.png
   trunk/libs/spirit/doc/html/images/flowofcontrol.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/flowofcontrol.png
   trunk/libs/spirit/doc/html/images/important.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/important.png
   trunk/libs/spirit/doc/html/images/note.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/note.png
   trunk/libs/spirit/doc/html/images/spiritkarmaflow.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/spiritkarmaflow.png
   trunk/libs/spirit/doc/html/images/spiritstructure.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/spiritstructure.png
   trunk/libs/spirit/doc/html/images/tip.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/tip.png
   trunk/libs/spirit/doc/html/images/tokenstructure.png
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/images/tokenstructure.png
   trunk/libs/spirit/doc/html/index.html
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/html/index.html
   trunk/libs/spirit/doc/qi_and_karma/actions.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/qi_and_karma/actions.qbk
   trunk/libs/spirit/doc/qi_and_karma/complex.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/qi_and_karma/complex.qbk
   trunk/libs/spirit/doc/qi_and_karma/num_list2.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/qi_and_karma/num_list2.qbk
   trunk/libs/spirit/doc/qi_and_karma/num_list3.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/qi_and_karma/num_list3.qbk
   trunk/libs/spirit/doc/qi_and_karma/num_list4.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/qi_and_karma/num_list4.qbk
   trunk/libs/spirit/doc/qi_and_karma/roman.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/qi_and_karma/roman.qbk
   trunk/libs/spirit/doc/qi_and_karma/sum_tutorial.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/qi_and_karma/sum_tutorial.qbk
   trunk/libs/spirit/doc/qi_and_karma/tutorial_intro.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/qi_and_karma/tutorial_intro.qbk
   trunk/libs/spirit/doc/qi_and_karma/warming_up.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/qi_and_karma/warming_up.qbk
   trunk/libs/spirit/doc/reference_template.qbk
      - copied unchanged from r47301, /branches/release/libs/spirit/doc/reference_template.qbk
   trunk/libs/spirit/example/qi/num_list1.cpp
      - copied unchanged from r47301, /branches/release/libs/spirit/example/qi/num_list1.cpp
   trunk/libs/spirit/example/qi/num_list4.cpp
      - copied unchanged from r47301, /branches/release/libs/spirit/example/qi/num_list4.cpp
   trunk/libs/spirit/phoenix/doc/html/phoenix/container.html
      - copied unchanged from r47301, /branches/release/libs/spirit/phoenix/doc/html/phoenix/container.html
   trunk/libs/spirit/test/karma/eol.cpp
      - copied unchanged from r47301, /branches/release/libs/spirit/test/karma/eol.cpp
Removed:
   trunk/libs/spirit/doc/qi_and_karma/tutorials.qbk
   trunk/libs/spirit/example/qi/num_list.cpp
   trunk/libs/spirit/phoenix/doc/html/boostbook.css
Properties modified:
   trunk/libs/spirit/classic/example/fundamental/position_iterator/position_iterator.err1 (props changed)
   trunk/libs/spirit/classic/example/fundamental/position_iterator/position_iterator.err2 (props changed)
   trunk/libs/spirit/classic/example/fundamental/position_iterator/position_iterator.err3 (props changed)
   trunk/libs/spirit/classic/example/fundamental/position_iterator/position_iterator.ok (props changed)
   trunk/libs/spirit/doc/html/ (props changed)
   trunk/libs/spirit/doc/html/images/ (props changed)
   trunk/libs/spirit/phoenix/doc/html/ (props changed)
Text files modified:
   trunk/libs/spirit/classic/doc/closures.html | 2
   trunk/libs/spirit/doc/Jamfile | 9
   trunk/libs/spirit/doc/qi_and_karma.qbk | 12
   trunk/libs/spirit/doc/rationale.qbk | 19
   trunk/libs/spirit/doc/spirit2.qbk | 28
   trunk/libs/spirit/doc/what_s_new.qbk | 42
   trunk/libs/spirit/example/qi/Jamfile | 3
   trunk/libs/spirit/example/qi/actions.cpp | 52 +
   trunk/libs/spirit/example/qi/complex_number.cpp | 2
   trunk/libs/spirit/example/qi/num_list2.cpp | 5
   trunk/libs/spirit/example/qi/num_list3.cpp | 6
   trunk/libs/spirit/example/qi/roman.cpp | 10
   trunk/libs/spirit/example/qi/sum.cpp | 8
   trunk/libs/spirit/phoenix/doc/Jamfile.v2 | 1
   trunk/libs/spirit/phoenix/doc/html/index.html | 168 +++-
   trunk/libs/spirit/phoenix/doc/html/phoenix/acknowledgement.html | 26
   trunk/libs/spirit/phoenix/doc/html/phoenix/actors.html | 39
   trunk/libs/spirit/phoenix/doc/html/phoenix/algorithm.html | 1140 +++++++++++++++++++++++++++++----------
   trunk/libs/spirit/phoenix/doc/html/phoenix/basics.html | 112 ++-
   trunk/libs/spirit/phoenix/doc/html/phoenix/composite.html | 515 +++++++++++------
   trunk/libs/spirit/phoenix/doc/html/phoenix/inside_phoenix.html | 507 +++++++++++------
   trunk/libs/spirit/phoenix/doc/html/phoenix/introduction.html | 26
   trunk/libs/spirit/phoenix/doc/html/phoenix/organization.html | 354 ++++++++---
   trunk/libs/spirit/phoenix/doc/html/phoenix/primitives.html | 130 ++-
   trunk/libs/spirit/phoenix/doc/html/phoenix/references.html | 26
   trunk/libs/spirit/phoenix/doc/html/phoenix/starter_kit.html | 209 +++---
   trunk/libs/spirit/phoenix/doc/html/phoenix/wrap_up.html | 50 +
   trunk/libs/spirit/phoenix/doc/users_manual.qbk | 1017 +++++++++++++++++-----------------
   28 files changed, 2844 insertions(+), 1674 deletions(-)

Modified: trunk/libs/spirit/classic/doc/closures.html
==============================================================================
--- trunk/libs/spirit/classic/doc/closures.html (original)
+++ trunk/libs/spirit/classic/doc/closures.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -61,7 +61,7 @@
 <td class="note_box"><img src="theme/alert.gif" width="16" height="16"> Closures
 and Phoenix 
 Spirit v1.8 closure support requires Phoenix.
- In the future, Spirit will fully support BLL.
+ In the future, Spirit will fully support BLL.
 Currently, work is underway to merge the features of both libraries.</td>
 </tr>
</table>

Modified: trunk/libs/spirit/doc/Jamfile
==============================================================================
--- trunk/libs/spirit/doc/Jamfile (original)
+++ trunk/libs/spirit/doc/Jamfile 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -19,9 +19,10 @@
 <xsl:param>boost.root=../../../..
 <xsl:param>boost.libraries=../../../libraries.htm
 <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
- <xsl:param>chunk.section.depth=5
- <xsl:param>chunk.first.sections=1
- <xsl:param>toc.section.depth=4
- <xsl:param>toc.max.depth=4
+ <xsl:param>chunk.section.depth=4
+ #<xsl:param>chunk.first.sections=1
+ <xsl:param>toc.section.depth=3
+ <xsl:param>toc.max.depth=3
 <xsl:param>generate.section.toc.level=4
+ <xsl:param>admon.graphics.path=images/
 ;

Modified: trunk/libs/spirit/doc/qi_and_karma.qbk
==============================================================================
--- trunk/libs/spirit/doc/qi_and_karma.qbk (original)
+++ trunk/libs/spirit/doc/qi_and_karma.qbk 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -8,7 +8,17 @@

[section Qi and Karma]

-[include qi_and_karma/tutorials.qbk]
+[section Tutorials]
+[include qi_and_karma/tutorial_intro.qbk]
+[include qi_and_karma/warming_up.qbk]
+[include qi_and_karma/actions.qbk]
+[include qi_and_karma/complex.qbk]
+[include qi_and_karma/sum_tutorial.qbk]
+[include qi_and_karma/num_list2.qbk]
+[include qi_and_karma/num_list3.qbk]
+[include qi_and_karma/num_list4.qbk]
+[include qi_and_karma/roman.qbk]
+[endsect]

[section Abstracts]
[include qi_and_karma/peg.qbk]

Deleted: trunk/libs/spirit/doc/qi_and_karma/tutorials.qbk
==============================================================================
--- trunk/libs/spirit/doc/qi_and_karma/tutorials.qbk 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
+++ (empty file)
@@ -1,10 +0,0 @@
-[/==============================================================================
- Copyright (C) 2001-2008 Joel de Guzman
- Copyright (C) 2001-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)
-===============================================================================/]
-
-[section Tutorials]
-[endsect]

Modified: trunk/libs/spirit/doc/rationale.qbk
==============================================================================
--- trunk/libs/spirit/doc/rationale.qbk (original)
+++ trunk/libs/spirit/doc/rationale.qbk 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -7,23 +7,4 @@
===============================================================================/]

[section Rationale]
-
-[heading Qi]
-
-
-[heading Karma]
-
-Why (almost) all __karma__ components expose a attribute type not equal to
-`unused` even if they are 'fully defined'?
-
-A component is 'fully defined' if it has a value to generate, even if no
-attribute is passed from the generator context nor is one assigned using a
-semantic action. For instance, all literal generators (char_('a'), int_(0),
-etc.) are fully defined.
-
-
-
-[heading Lex]
-
-
[endsect]

Modified: trunk/libs/spirit/doc/spirit2.qbk
==============================================================================
--- trunk/libs/spirit/doc/spirit2.qbk (original)
+++ trunk/libs/spirit/doc/spirit2.qbk 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -24,8 +24,8 @@
[/ Some links ]

[def __spirit__ [@http://spirit.sourceforge.net Spirit]]
-[def __phoenix__ [@http://boost.org/libs/spirit/phoenix/index.html Phoenix]]
-[def __phoenix2__ [@http://spirit.sourceforge.net/dl_more/phoenix_v2/libs/spirit/phoenix/doc/html/index.html Phoenix2]]
+[def __phoenix__ [@../../phoenix/doc/html/index.html Phoenix]]
+[def __phoenix2__ [@../../phoenix/doc/html/index.html Phoenix2]]
[def __fusion__ [@http://spirit.sourceforge.net/dl_more/fusion_v2/libs/fusion/doc/html/index.html Fusion]]
[def __mpl__ [@http://www.boost.org/libs/mpl/index.html MPL]]
[def __boost_tuples__ [@http://www.boost.org/libs/tuple/index.html Boost.Tuples]]
@@ -51,6 +51,8 @@

[def __boost_variant__ [@http://www.boost.org/doc/html/variant.html `boost::variant<>`]]
[def __boost_iterator_range__ [@http://www.boost.org/libs/range/doc/utility_class.html#iter_range `boost::iterator_range<>`]]
+[def __boost_bind__ [@http://www.boost.org/libs/bind/index.html Boost.Bind]]
+[def __boost_lambda__ [@http://www.boost.org/libs/lambda/index.html Boost.Lambda]]

[def __classic__ /Spirit.Classic/]
@@ -97,22 +99,22 @@

[/ Some images ]

-[def __note__ [$../../../../doc/html/images/adm_note.png]]
-[def __tip__ [$../../../../doc/html/images/adm_tip.png]]
-[def __important__ [$../../../../doc/html/images/adm_important.png]]
-[def __caution__ [$../../../../doc/html/images/adm_caution.png]]
-[def __danger__ [$../../../../doc/html/images/adm_danger.png]]
+[def __note__ [$images/note.png]]
+[def __tip__ [$images/tip.png]]
+[def __important__ [$images/important.png]]
+[def __caution__ [$images/caution.png]]
+[def __danger__ [$images/alert.png]]

[/ some templates]

-[/ fig[ref title label]
- Image element with a title.
+[/ fig[ref title label]
+ Image element with a title.

- ref := Reference to the image file.
- title := The title to associate with this figure.
+ ref := Reference to the image file.
+ title := The title to associate with this figure.
 label := the id to use to be able to reference this picture
-]
+]
[template fig[ref title label]'''
 <figure id="'''[label]'''">
 <title>'''[title]'''</title>
@@ -125,7 +127,7 @@
 </textobject>
 </inlinemediaobject>
 </figure>
-''']
+''']

[/ Here we go ]

Modified: trunk/libs/spirit/doc/what_s_new.qbk
==============================================================================
--- trunk/libs/spirit/doc/what_s_new.qbk (original)
+++ trunk/libs/spirit/doc/what_s_new.qbk 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -10,36 +10,36 @@

[heading Spirit Classic]

-The Spirit V1.8.x code base has been integrated with Spirit V2. It is now called
-__classic__. Even if the directory structure has changed (the Spirit Classic
-headers are now moved to the '$BOOST_ROOT/boost/spirit/home/classic' directory),
-we created forwarding headers allowing to compile existing applications without
-any change. These forwarding headers are deprecated, though, which will result
-in corresponding warnings generated for each of the headers starting with Boost
-V1.38. The forwarding headers are expected to be removed in the future.
-
-The recommended way of using Spirit Classic now is to include header files from
-the directory '$BOOST_ROOT/boost/spirit/include'. All files of Spirit Classic
-in this directory have a 'classic_' prefixed to their name. For example the
-include
+The Spirit V1.8.x code base has been integrated with Spirit V2. It is now called
+__classic__. Even if the directory structure has changed (the Spirit Classic
+headers are now moved to the '''$BOOST_ROOT/boost/spirit/home/classic''' directory),
+we created forwarding headers allowing to compile existing applications without
+any change. These forwarding headers are deprecated, though, which will result
+in corresponding warnings generated for each of the headers starting with Boost
+V1.38. The forwarding headers are expected to be removed in the future.
+
+The recommended way of using Spirit Classic now is to include header files from
+the directory '''$BOOST_ROOT/boost/spirit/include'''. All files of Spirit Classic
+in this directory have a 'classic_' prefixed to their name. For example the
+include

#include <boost/spirit/core/core.hpp>

-now should be written as:
+now should be written as:

#include <boost/spirit/include/classic_core.hpp>

-To avoid namespace conflicts with the new Spirit V2 library we moved Spirit Classic
-into the namespace `boost::spirit::classic`. All references to the former
+To avoid namespace conflicts with the new Spirit V2 library we moved Spirit Classic
+into the namespace `boost::spirit::classic`. All references to the former
namespace `boost::spirit` need to be adjusted as soon as the header names are
-corrected as described above. As an alternative you can define the preprocessor
-constant `BOOST_SPIRIT_USE_OLD_NAMESPACE`, which will force the Spirit Classic
-code to be in the namespace `boost::spirit` as before. This is not recommended,
+corrected as described above. As an alternative you can define the preprocessor
+constant `BOOST_SPIRIT_USE_OLD_NAMESPACE`, which will force the Spirit Classic
+code to be in the namespace `boost::spirit` as before. This is not recommended,
though, as it may result in naming clashes.

-The change of the namespace will be automatically deactivated whenever the
-deprecated include files are being used. This ensures full backwards
-compatibility for existing applications.
+The change of the namespace will be automatically deactivated whenever the
+deprecated include files are being used. This ensures full backwards
+compatibility for existing applications.

[endsect]

Modified: trunk/libs/spirit/example/qi/Jamfile
==============================================================================
--- trunk/libs/spirit/example/qi/Jamfile (original)
+++ trunk/libs/spirit/example/qi/Jamfile 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -13,9 +13,10 @@
exe roman : roman.cpp ;
exe mini_xml1 : mini_xml1.cpp ;
exe mini_xml2 : mini_xml2.cpp ;
-exe num_list : num_list.cpp ;
+exe num_list1 : num_list1.cpp ;
exe num_list2 : num_list2.cpp ;
exe num_list3 : num_list3.cpp ;
+exe num_list4 : num_list4.cpp ;

exe calc1 : calc1.cpp ;
exe calc2 : calc2.cpp ;

Modified: trunk/libs/spirit/example/qi/actions.cpp
==============================================================================
--- trunk/libs/spirit/example/qi/actions.cpp (original)
+++ trunk/libs/spirit/example/qi/actions.cpp 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -15,16 +15,29 @@
// Presented are various ways to attach semantic actions
// * Using plain function pointer
// * Using simple function object
-// * Using boost.bind
+// * Using boost.bind with a plain function
+// * Using boost.bind with a member function
// * Using boost.lambda

using namespace boost::spirit;

+//[tutorial_semantic_action_functions
+// A plain function
void write(int const& i)
{
 std::cout << i << std::endl;
}

+// A member function
+struct writer
+{
+ void print(int const& i) const
+ {
+ std::cout << i << std::endl;
+ }
+};
+
+// A function object
struct write_action
{
 void operator()(int const& i, unused_type, unused_type) const
@@ -32,32 +45,51 @@
 std::cout <> int_[&write] >> '}');
+ char const *first = "{42}", *last = first + std::strlen(first);
+ //[tutorial_attach_actions1
+ qi::parse(first, last, '{' >> int_[&write] >> '}');
+ //]
 }

 { // example using simple function object

- char const *s1 = "{43}", *e1 = s1 + std::strlen(s1);
- qi::parse(s1, e1, '{' >> int_[write_action()] >> '}');
+ char const *first = "{43}", *last = first + std::strlen(first);
+ //[tutorial_attach_actions2
+ qi::parse(first, last, '{' >> int_[write_action()] >> '}');
+ //]
+ }
+
+ { // example using boost.bind with a plain function
+
+ char const *first = "{44}", *last = first + std::strlen(first);
+ //[tutorial_attach_actions3
+ qi::parse(first, last, '{' >> int_[boost::bind(&write, _1)] >> '}');
+ //]
 }

- { // example using boost.bind
+ { // example using boost.bind with a member function

- char const *s1 = "{44}", *e1 = s1 + std::strlen(s1);
- qi::parse(s1, e1, '{' >> int_[boost::bind(&write, _1)] >> '}');
+ char const *first = "{44}", *last = first + std::strlen(first);
+ //[tutorial_attach_actions4
+ writer w;
+ qi::parse(first, last, '{' >> int_[boost::bind(&writer::print, &w, _1)] >> '}');
+ //]
 }

 { // example using boost.lambda

 namespace lambda = boost::lambda;
- char const *s1 = "{45}", *e1 = s1 + std::strlen(s1);
- qi::parse(s1, e1, '{' >> int_[std::cout << lambda::_1 << '\n'] >> '}');
+ char const *first = "{45}", *last = first + std::strlen(first);
+ using lambda::_1;
+ //[tutorial_attach_actions5
+ qi::parse(first, last, '{' >> int_[std::cout << _1 << '\n'] >> '}');
+ //]
 }

 return 0;

Modified: trunk/libs/spirit/example/qi/complex_number.cpp
==============================================================================
--- trunk/libs/spirit/example/qi/complex_number.cpp (original)
+++ trunk/libs/spirit/example/qi/complex_number.cpp 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -31,6 +31,7 @@
///////////////////////////////////////////////////////////////////////////////
// Our complex number parser/compiler
///////////////////////////////////////////////////////////////////////////////
+//[tutorial_complex_number
template <typename Iterator>
bool parse_complex(Iterator first, Iterator last, std::complex<double>& c)
{
@@ -53,6 +54,7 @@
c = std::complex<double>(rN, iN);
return r;
}
+//]

////////////////////////////////////////////////////////////////////////////
// Main program

Deleted: trunk/libs/spirit/example/qi/num_list.cpp
==============================================================================
--- trunk/libs/spirit/example/qi/num_list.cpp 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
+++ (empty file)
@@ -1,100 +0,0 @@
-/*=============================================================================
- Copyright (c) 2002-2007 Joel de Guzman
-
- 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)
-=============================================================================*/
-///////////////////////////////////////////////////////////////////////////////
-//
-// This sample demontrates a parser for a comma separated list of numbers.
-// The numbers are inserted in a vector using phoenix.
-//
-// [ JDG May 10, 2002 ] spirit1
-// [ JDG March 24, 2007 ] spirit2
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include <boost/config/warning_disable.hpp>
-#include <boost/spirit/include/qi.hpp>
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_stl.hpp>
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-using namespace boost::phoenix;
-using namespace boost::spirit;
-using namespace boost::spirit::qi;
-using namespace boost::spirit::ascii;
-using namespace boost::spirit::arg_names;
-
-///////////////////////////////////////////////////////////////////////////////
-// Our number list compiler
-///////////////////////////////////////////////////////////////////////////////
-template <typename Iterator>
-bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
-{
- bool r = phrase_parse(first, last,
-
- // Begin grammar
- (
- double_[push_back(ref(v), _1)]
- >> *(',' >> double_[push_back(ref(v), _1)])
- )
- ,
- // End grammar
-
- space);
-
- if (first != last) // fail if we did not get a full match
- return false;
- return r;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// Main program
-////////////////////////////////////////////////////////////////////////////
-int
-main()
-{
- std::cout << "/////////////////////////////////////////////////////////\n\n";
- std::cout << "\t\tA comma separated list parser for Spirit...\n\n";
- std::cout << "/////////////////////////////////////////////////////////\n\n";
-
- std::cout << "Give me a comma separated list of numbers.\n";
- std::cout << "The numbers will be inserted in a vector of numbers\n";
- std::cout << "Type [q or Q] to quit\n\n";
-
- std::string str;
- while (getline(std::cin, str))
- {
- if (str.empty() || str[0] == 'q' || str[0] == 'Q')
- break;
-
- std::vector<double> v;
- if (parse_numbers(str.begin(), str.end(), v))
- {
- std::cout << "-------------------------\n";
- std::cout << "Parsing succeeded\n";
- std::cout << str << " Parses OK: " << std::endl;
-
- for (std::vector<double>::size_type i = 0; i < v.size(); ++i)
- std::cout << i << ": " << v[i] << std::endl;
-
- std::cout << "\n-------------------------\n";
- }
- else
- {
- std::cout << "-------------------------\n";
- std::cout << "Parsing failed\n";
- std::cout << "-------------------------\n";
- }
- }
-
- std::cout << "Bye... :-) \n\n";
- return 0;
-}
-
-

Modified: trunk/libs/spirit/example/qi/num_list2.cpp
==============================================================================
--- trunk/libs/spirit/example/qi/num_list2.cpp (original)
+++ trunk/libs/spirit/example/qi/num_list2.cpp 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -33,6 +33,7 @@
///////////////////////////////////////////////////////////////////////////////
// Our number list compiler
///////////////////////////////////////////////////////////////////////////////
+//[tutorial_numlist2
template <typename Iterator>
bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
{
@@ -40,7 +41,8 @@

 // Begin grammar
 (
- double_[push_back(ref(v), _1)] % ','
+ double_[push_back(ref(v), _1)]
+ >> *(',' >> double_[push_back(ref(v), _1)])
 )
 ,
 // End grammar
@@ -51,6 +53,7 @@
 return false;
 return r;
}
+//]

////////////////////////////////////////////////////////////////////////////
// Main program

Modified: trunk/libs/spirit/example/qi/num_list3.cpp
==============================================================================
--- trunk/libs/spirit/example/qi/num_list3.cpp (original)
+++ trunk/libs/spirit/example/qi/num_list3.cpp 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -33,6 +33,7 @@
///////////////////////////////////////////////////////////////////////////////
// Our number list compiler
///////////////////////////////////////////////////////////////////////////////
+//[tutorial_numlist3
template <typename Iterator>
bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
{
@@ -40,17 +41,18 @@

 // Begin grammar
 (
- double_ % ','
+ double_[push_back(ref(v), _1)] % ','
 )
 ,
 // End grammar

- v, space);
+ space);

 if (first != last) // fail if we did not get a full match
 return false;
 return r;
}
+//]

////////////////////////////////////////////////////////////////////////////
// Main program

Modified: trunk/libs/spirit/example/qi/roman.cpp
==============================================================================
--- trunk/libs/spirit/example/qi/roman.cpp (original)
+++ trunk/libs/spirit/example/qi/roman.cpp 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -29,9 +29,10 @@

///////////////////////////////////////////////////////////////////////////////
// Parse roman hundreds (100..900) numerals using the symbol table.
-// Notice that the data associated with each slot is passed
-// to attached semantic actions.
+// Notice that the data associated with each slot is the parser's attribute
+// (which is passed to attached semantic actions).
///////////////////////////////////////////////////////////////////////////////
+//[tutorial_roman_hundreds
struct hundreds_ : symbols<char, unsigned>
{
 hundreds_()
@@ -50,10 +51,12 @@
 }

} hundreds;
+//]

///////////////////////////////////////////////////////////////////////////////
// Parse roman tens (10..90) numerals using the symbol table.
///////////////////////////////////////////////////////////////////////////////
+//[tutorial_roman_tens
struct tens_ : symbols<char, unsigned>
{
 tens_()
@@ -72,10 +75,12 @@
 }

} tens;
+//]

///////////////////////////////////////////////////////////////////////////////
// Parse roman ones (1..9) numerals using the symbol table.
///////////////////////////////////////////////////////////////////////////////
+//[tutorial_roman_ones
struct ones_ : symbols<char, unsigned>
{
 ones_()
@@ -94,6 +99,7 @@
 }

} ones;
+//]

///////////////////////////////////////////////////////////////////////////////
// roman (numerals) grammar

Modified: trunk/libs/spirit/example/qi/sum.cpp
==============================================================================
--- trunk/libs/spirit/example/qi/sum.cpp (original)
+++ trunk/libs/spirit/example/qi/sum.cpp 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -14,22 +14,27 @@
///////////////////////////////////////////////////////////////////////////////

#include <boost/config/warning_disable.hpp>
+//[tutorial_adder_includes
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
-
#include <iostream>
#include <string>
+//]

+//[tutorial_adder_using
using namespace boost::phoenix;
using namespace boost::spirit;
using namespace boost::spirit::qi;
using namespace boost::spirit::ascii;
using namespace boost::spirit::arg_names;
+//]

///////////////////////////////////////////////////////////////////////////////
// Our adder
///////////////////////////////////////////////////////////////////////////////
+
+//[tutorial_adder
template <typename Iterator>
bool adder(Iterator first, Iterator last, double& n)
{
@@ -48,6 +53,7 @@
return false;
return r;
}
+//]

////////////////////////////////////////////////////////////////////////////
// Main program

Modified: trunk/libs/spirit/phoenix/doc/Jamfile.v2
==============================================================================
--- trunk/libs/spirit/phoenix/doc/Jamfile.v2 (original)
+++ trunk/libs/spirit/phoenix/doc/Jamfile.v2 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -16,5 +16,6 @@
 :
 <xsl:param>boost.root=../../../../..
 <xsl:param>boost.libraries=../../../../libraries.htm
+ <xsl:param>html.stylesheet=../../../../../doc/html/boostbook.css
 ;

Deleted: trunk/libs/spirit/phoenix/doc/html/boostbook.css
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/boostbook.css 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
+++ (empty file)
@@ -1,511 +0,0 @@
-/*=============================================================================
- Copyright (c) 2004 Joel de Guzman
- http://spirit.sourceforge.net/
-
- Use, modification and distribution is subject to 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)
-=============================================================================*/
-
-/*=============================================================================
- Body defaults
-=============================================================================*/
-
- body
- {
- margin: 1em;
- font-family: sans-serif;
- }
-
-/*=============================================================================
- Paragraphs
-=============================================================================*/
-
- p
- {
- text-align: left;
- font-size: 10pt;
- line-height: 1.15;
- }
-
-/*=============================================================================
- Program listings
-=============================================================================*/
-
- /* Code on paragraphs */
- p tt.computeroutput
- {
- font-size: 9pt;
- }
-
- pre.synopsis
- {
- font-size: 90%;
- margin: 1pc 4% 0pc 4%;
- padding: 0.5pc 0.5pc 0.5pc 0.5pc;
- }
-
- .programlisting,
- .screen
- {
- font-size: 9pt;
- display: block;
- margin: 1pc 4% 0pc 4%;
- padding: 0.5pc 0.5pc 0.5pc 0.5pc;
- }
-
- /* Program listings in tables don't get borders */
- td .programlisting,
- td .screen
- {
- margin: 0pc 0pc 0pc 0pc;
- padding: 0pc 0pc 0pc 0pc;
- }
-
-/*=============================================================================
- Headings
-=============================================================================*/
-
- h1, h2, h3, h4, h5, h6
- {
- text-align: left;
- margin: 1em 0em 0.5em 0em;
- font-weight: bold;
- }
-
- h1 { font: 140% }
- h2 { font: bold 140% }
- h3 { font: bold 130% }
- h4 { font: bold 120% }
- h5 { font: italic 110% }
- h6 { font: italic 100% }
-
- /* Top page titles */
- title,
- h1.title,
- h2.title
- h3.title,
- h4.title,
- h5.title,
- h6.title,
- .refentrytitle
- {
- font-weight: bold;
- margin-bottom: 1pc;
- }
-
- h1.title { font-size: 140% }
- h2.title { font-size: 140% }
- h3.title { font-size: 130% }
- h4.title { font-size: 120% }
- h5.title { font-size: 110% }
- h6.title { font-size: 100% }
-
- .section h1
- {
- margin: 0em 0em 0.5em 0em;
- font-size: 140%;
- }
-
- .section h2 { font-size: 140% }
- .section h3 { font-size: 130% }
- .section h4 { font-size: 120% }
- .section h5 { font-size: 110% }
- .section h6 { font-size: 100% }
-
- /* Code on titles */
- h1 tt.computeroutput { font-size: 140% }
- h2 tt.computeroutput { font-size: 140% }
- h3 tt.computeroutput { font-size: 130% }
- h4 tt.computeroutput { font-size: 120% }
- h5 tt.computeroutput { font-size: 110% }
- h6 tt.computeroutput { font-size: 100% }
-
-/*=============================================================================
- Author
-=============================================================================*/
-
- h3.author
- {
- font-size: 100%
- }
-
-/*=============================================================================
- Lists
-=============================================================================*/
-
- li
- {
- font-size: 10pt;
- line-height: 1.3;
- }
-
- /* Unordered lists */
- ul
- {
- text-align: left;
- }
-
- /* Ordered lists */
- ol
- {
- text-align: left;
- }
-
-/*=============================================================================
- Links
-=============================================================================*/
-
- a
- {
- text-decoration: none; /* no underline */
- }
-
- a:hover
- {
- text-decoration: underline;
- }
-
-/*=============================================================================
- Spirit style navigation
-=============================================================================*/
-
- .spirit-nav
- {
- text-align: right;
- }
-
- .spirit-nav a
- {
- color: white;
- padding-left: 0.5em;
- }
-
- .spirit-nav img
- {
- border-width: 0px;
- }
-
-/*=============================================================================
- Table of contents
-=============================================================================*/
-
- .toc
- {
- margin: 1pc 4% 0pc 4%;
- padding: 0.1pc 1pc 0.1pc 1pc;
- font-size: 80%;
- line-height: 1.15;
- }
-
- .boost-toc
- {
- float: right;
- padding: 0.5pc;
- }
-
-/*=============================================================================
- Tables
-=============================================================================*/
-
- .table-title,
- div.table p.title
- {
- margin-left: 4%;
- padding-right: 0.5em;
- padding-left: 0.5em;
- }
-
- .informaltable table,
- .table table
- {
- width: 92%;
- margin-left: 4%;
- margin-right: 4%;
- }
-
- div.informaltable table,
- div.table table
- {
- padding: 4px;
- }
-
- /* Table Cells */
- div.informaltable table tr td,
- div.table table tr td
- {
- padding: 0.5em;
- text-align: left;
- font-size: 9pt;
- }
-
- div.informaltable table tr th,
- div.table table tr th
- {
- padding: 0.5em 0.5em 0.5em 0.5em;
- border: 1pt solid white;
- font-size: 80%;
- }
-
-/*=============================================================================
- Blurbs
-=============================================================================*/
-
- div.note,
- div.tip,
- div.important,
- div.caution,
- div.warning,
- p.blurb
- {
- font-size: 9pt; /* A little bit smaller than the main text */
- line-height: 1.2;
- display: block;
- margin: 1pc 4% 0pc 4%;
- padding: 0.5pc 0.5pc 0.5pc 0.5pc;
- }
-
- p.blurb img
- {
- padding: 1pt;
- }
-
-/*=============================================================================
- Variable Lists
-=============================================================================*/
-
- /* Make the terms in definition lists bold */
- div.variablelist dl dt,
- span.term
- {
- font-weight: bold;
- font-size: 10pt;
- }
-
- div.variablelist table tbody tr td
- {
- text-align: left;
- vertical-align: top;
- padding: 0em 2em 0em 0em;
- font-size: 10pt;
- margin: 0em 0em 0.5em 0em;
- line-height: 1;
- }
-
- div.variablelist dl dt
- {
- margin-bottom: 0.2em;
- }
-
- div.variablelist dl dd
- {
- margin: 0em 0em 0.5em 2em;
- font-size: 10pt;
- }
-
- div.variablelist table tbody tr td p,
- div.variablelist dl dd p
- {
- margin: 0em 0em 0.5em 0em;
- line-height: 1;
- }
-
-/*=============================================================================
- Misc
-=============================================================================*/
-
- /* Title of books and articles in bibliographies */
- span.title
- {
- font-style: italic;
- }
-
- span.underline
- {
- text-decoration: underline;
- }
-
- span.strikethrough
- {
- text-decoration: line-through;
- }
-
- /* Copyright, Legal Notice */
- div div.legalnotice p
- {
- text-align: left
- }
-
-/*=============================================================================
- Colors
-=============================================================================*/
-
- @media screen
- {
- /* Links */
- a
- {
- color: #005a9c;
- }
-
- a:visited
- {
- color: #9c5a9c;
- }
-
- h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
- h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
- h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
- {
- text-decoration: none; /* no underline */
- color: #000000;
- }
-
- /* Syntax Highlighting */
- .keyword { color: #0000AA; }
- .identifier { color: #000000; }
- .special { color: #707070; }
- .preprocessor { color: #402080; }
- .char { color: teal; }
- .comment { color: #800000; }
- .string { color: teal; }
- .number { color: teal; }
- .white_bkd { background-color: #FFFFFF; }
- .dk_grey_bkd { background-color: #999999; }
-
- /* Copyright, Legal Notice */
- .copyright
- {
- color: #666666;
- font-size: small;
- }
-
- div div.legalnotice p
- {
- color: #666666;
- }
-
- /* Program listing */
- pre.synopsis
- {
- border: 1px solid #DCDCDC;
- }
-
- .programlisting,
- .screen
- {
- border: 1px solid #DCDCDC;
- }
-
- td .programlisting,
- td .screen
- {
- border: 0px solid #DCDCDC;
- }
-
- /* Blurbs */
- div.note,
- div.tip,
- div.important,
- div.caution,
- div.warning,
- p.blurb
- {
- border: 1px solid #DCDCDC;
- }
-
- /* Table of contents */
- .toc
- {
- border: 1px solid #DCDCDC;
- }
-
- /* Tables */
- div.informaltable table tr td,
- div.table table tr td
- {
- border: 1px solid #DCDCDC;
- }
-
- div.informaltable table tr th,
- div.table table tr th
- {
- background-color: #F0F0F0;
- border: 1px solid #DCDCDC;
- }
-
- /* Misc */
- span.highlight
- {
- color: #00A000;
- }
- }
-
- @media print
- {
- /* Links */
- a
- {
- color: black;
- }
-
- a:visited
- {
- color: black;
- }
-
- .spirit-nav
- {
- display: none;
- }
-
- /* Program listing */
- pre.synopsis
- {
- border: 1px solid gray;
- }
-
- .programlisting,
- .screen
- {
- border: 1px solid gray;
- }
-
- td .programlisting,
- td .screen
- {
- border: 0px solid #DCDCDC;
- }
-
- /* Table of contents */
- .toc
- {
- border: 1px solid gray;
- }
-
- .informaltable table,
- .table table
- {
- border: 1px solid gray;
- border-collapse: collapse;
- }
-
- /* Tables */
- div.informaltable table tr td,
- div.table table tr td
- {
- border: 1px solid gray;
- }
-
- div.informaltable table tr th,
- div.table table tr th
- {
- border: 1px solid gray;
- }
-
- /* Misc */
- span.highlight
- {
- font-weight: bold;
- }
- }

Modified: trunk/libs/spirit/phoenix/doc/html/index.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/index.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/index.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,22 +2,22 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Chapter 1. Phoenix 2.0</title>
-<link rel="stylesheet" href="boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="index.html" title="Chapter 1. Phoenix 2.0">
<link rel="next" href="phoenix/introduction.html" title="Introduction">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="phoenix/introduction.html"><img src="images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="phoenix/introduction.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a></div>
<div class="chapter" lang="en">
<div class="titlepage"><div>
<div><h2 class="title">
@@ -31,7 +31,7 @@
<div>Copyright © 2002-2005 Joel
 de Guzman, Dan Marsden</div>
<div><div class="legalnotice">
-<a name="id442840"></a>
+<a name="id385775"></a>
 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)
 
@@ -50,7 +50,8 @@
<dt>Composites</dt>
<dt>Lazy Operators</dt>
<dt>Lazy Statements</dt>
-<dt>Construct, New, Delete, Casts</dt>
+<dt><a href="phoenix/starter_kit.html#phoenix.starter_kit.construct__new__delete__casts">Construct,
+ New, Delete, Casts</a></dt>
<dt>Lazy Functions</dt>
<dt>More</dt>
</dl></dd>
@@ -80,7 +81,8 @@
<dd><dl>
<dt>Actors In Detail</dt>
<dt>Actor Example</dt>
-<dt>Composites In Detail</dt>
+<dt><a href="phoenix/inside_phoenix.html#phoenix.inside_phoenix.composites_in_detail">Composites
+ In Detail</a></dt>
<dt>Composing</dt>
<dt>Extending</dt>
</dl></dd>
@@ -91,25 +93,37 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.preface"></a>Preface</h2></div></div></div>
-<div class="blockquote"><blockquote class="blockquote">
- Functional programming is so called because a program consists
- entirely of functions. The main program itself is written as a function which
- receives the program's input as its argument and delivers the program's output
- as its result. Typically the main function is defined in terms of other functions,
- which in turn are defined in terms of still more functions until at the bottom
- level the functions are language primitives.
- </blockquote></div>
-<div class="blockquote"><blockquote class="blockquote">
- John Hughes-- Why Functional Programming
- Matters
- </blockquote></div>
+<a name="phoenix.preface"></a>Preface</h2></div></div></div>
+<div class="blockquote"><blockquote class="blockquote">
+
+ 
+
+ Functional programming is so called because a program consists
+ entirely of functions. The main program itself is written as a function
+ which receives the program's input as its argument and delivers the program's
+ output as its result. Typically the main function is defined in terms of
+ other functions, which in turn are defined in terms of still more functions
+ until at the bottom level the functions are language primitives.
+ 
+
+ 
+</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+
+ 
+
+ John Hughes-- Why Functional
+ Programming Matters
+ 
+
+ 
+</blockquote></div>

 <img src="images/lambda_cpp.png" alt="lambda_cpp">
 
<a name="phoenix.preface.description"></a><h2>
-<a name="id372685"></a>
- Description
+<a name="id387100"></a>
+ Description
 </h2>

 Phoenix enables Functional Programming (FP) in C++. The design and implementation
@@ -128,8 +142,8 @@
 The library is organized in highly independent modules and layers.
 
<a name="phoenix.preface.how_to_use_this_manual"></a><h2>
-<a name="id372541"></a>
- How to use this manual
+<a name="id385881"></a>
+ How to use this manual
 </h2>

 The Phoenix library is organized in logical modules. This documentation provides
@@ -150,41 +164,83 @@
 Some icons are used to mark certain topics indicative of their relevance. These
 icons precede some text to indicate:
 
-<div class="informaltable">
-<h4>
-<a name="id372571"></a>
- Icons
- </h4>
-<table class="table">
+<div class="table">
+<a name="id385416"></a>Table 1.1. Icons
+<table class="table" summary="Icons">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Icon</th>
-<th>Name</th>
-<th>Meaning</th>
+<th>
+ 
+ Icon
+ 
+ </th>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ Meaning
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td><img src="images/note.png" alt="note"></td>
-<td>Note</td>
-<td>Information provided
- is auxiliary but will give the reader a deeper insight into a specific
- topic. May be skipped.</td>
+<td>
+ 
+ <img src="images/note.png" alt="note">
+ 
+ </td>
+<td>
+ 
+ Note
+ 
+ </td>
+<td>
+ 
+ Information provided is auxiliary but will give the reader a deeper insight
+ into a specific topic. May be skipped.
+ 
+ </td>
</tr>
<tr>
-<td><img src="images/alert.png" alt="alert"></td>
-<td>Alert</td>
-<td>Information provided
- is of utmost importance.</td>
+<td>
+ 
+ <img src="images/alert.png" alt="alert">
+ 
+ </td>
+<td>
+ 
+ Alert
+ 
+ </td>
+<td>
+ 
+ Information provided is of utmost importance.
+ 
+ </td>
</tr>
<tr>
-<td><img src="images/tip.png" alt="tip"></td>
-<td>Tip</td>
-<td>A potentially useful
- and helpful piece of information.</td>
+<td>
+ 
+ <img src="images/tip.png" alt="tip">
+ 
+ </td>
+<td>
+ 
+ Tip
+ 
+ </td>
+<td>
+ 
+ A potentially useful and helpful piece of information.
+ 
+ </td>
</tr>
</tbody>
</table>
@@ -195,8 +251,8 @@
 Repository</a>.
 
<a name="phoenix.preface.support"></a><h2>
-<a name="id374497"></a>
- Support
+<a name="id385607"></a>
+ Support
 </h2>

 Please direct all questions to Spirit's mailing list. You can subscribe to
@@ -209,16 +265,16 @@
 The news group mirrors the mailing list. Here is a link to the archives: http://news.gmane.org/gmane.comp.parsers.spirit.general.
 
<a name="phoenix.preface._emphasis_role__bold___emphasis____to_my_dear_daughter__phoenix__emphasis___emphasis_"></a><h2>
-<a name="id374555"></a>
- ...To my dear daughter, Phoenix
+<a name="id385673"></a>
+ ...To my dear daughter, Phoenix
 </h2>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: June 09, 2006 at 13:58:55 GMT</td>
-<td align="right"></td>
+<td align="left">Last revised: July 02, 2008 at 05:20:39 GMT</td>
+<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>
-<div class="spirit-nav"><a accesskey="n" href="phoenix/introduction.html"><img src="images/next.png" alt="Next"></a></div>
+<div class="spirit-nav"><a accesskey="n" href="phoenix/introduction.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a></div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/acknowledgement.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/acknowledgement.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/acknowledgement.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Acknowledgement</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,21 +10,21 @@
<link rel="next" href="references.html" title="References">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="wrap_up.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="references.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="wrap_up.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="references.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.acknowledgement"></a>Acknowledgement</h2></div></div></div>
+<a name="phoenix.acknowledgement"></a>Acknowledgement</h2></div></div></div>
<div class="orderedlist"><ol type="1">
<li>
Hartmut Kaiser implemented the original lazy casts and constructors based
@@ -76,12 +76,16 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="wrap_up.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="references.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="wrap_up.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="references.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/actors.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/actors.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/actors.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Actors</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,30 +10,35 @@
<link rel="next" href="primitives.html" title="Primitives">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="organization.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="primitives.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="organization.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="primitives.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.actors"></a>Actors</h2></div></div></div>
+<a name="phoenix.actors"></a>Actors</h2></div></div></div>

 The <tt class="computeroutput">Actor</tt> is the main concept
 behind the library. Actors are function objects. An actor can accept 0 to
 <tt class="computeroutput">PHOENIX_LIMIT</tt> arguments.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> You can set <tt class="computeroutput">PHOENIX_LIMIT</tt>,
- the predefined maximum arity an actor can take. By default, <tt class="computeroutput">PHOENIX_LIMIT</tt> is set to 10.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ You can set <tt class="computeroutput">PHOENIX_LIMIT</tt>,
+ the predefined maximum arity an actor can take. By default, <tt class="computeroutput">PHOENIX_LIMIT</tt> is set to 10.
+ </td></tr>
</table></div>

 Phoenix supplies an <tt class="computeroutput">actor</tt> class
@@ -71,12 +76,16 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="organization.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="primitives.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="organization.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="primitives.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/algorithm.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/algorithm.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/algorithm.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Algorithm</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,21 +10,21 @@
<link rel="next" href="inside_phoenix.html" title="Inside Phoenix">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="container.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="inside_phoenix.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="container.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="inside_phoenix.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.algorithm"></a>Algorithm</h2></div></div></div>
+<a name="phoenix.algorithm"></a>Algorithm</h2></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/algorithm.hpp>
</pre>
@@ -55,7 +55,7 @@
<pre class="programlisting">
int array[] = {1, 2, 3};
int output[3];
-std::copy(array, array + 3, output); // We have to provide iterators
+std::copy(array, array + 3, output); // We have to provide iterators
 // to both the start and end of array
</pre>

@@ -64,7 +64,7 @@
<pre class="programlisting">
int array[] = {1, 2, 3};
int output[3];
-copy(arg1, arg2)(array, output); // Notice only 2 arguments, the end of
+copy(arg1, arg2)(array, output); // Notice only 2 arguments, the end of
 // array is established automatically
</pre>

@@ -76,320 +76,866 @@
 The following tables describe the different categories of algorithms, and their
 semantics.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> Arguments in brackets denote optional parameters.</td></tr></tbody>
-</table></div>
-<div class="informaltable">
-<h4>
-<a name="id471284"></a>
- Iteration Algorithms
- </h4>
-<table class="table">
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> Arguments in brackets denote optional parameters.
+ </div>
+<div class="table">
+<a name="id485812"></a>Table 1.7. Iteration Algorithms
+<table class="table" summary="Iteration Algorithms">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Function</th>
-<th>stl Semantics</th>
+<th>
+ 
+ Function
+ 
+ </th>
+<th>
+ 
+ stl Semantics
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td><tt class="computeroutput">for_each(r, c)</tt></td>
-<td><tt class="computeroutput">for_each(begin(r), end(r), f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">accumulate(r, o[, f])</tt></td>
-<td><tt class="computeroutput">accumulate(begin(r), end(r), o[, f])</tt></td>
+<td>
+ 
+ <tt class="computeroutput">for_each(r, c)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">for_each(begin(r), end(r), f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">accumulate(r, o[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">accumulate(begin(r), end(r), o[, f])</tt>
+ 
+ </td>
</tr>
</tbody>
</table>
</div>
-<div class="informaltable">
-<h4>
-<a name="id471564"></a>
- Querying Algorithms
- </h4>
-<table class="table">
+<div class="table">
+<a name="id486119"></a>Table 1.8. Querying Algorithms
+<table class="table" summary="Querying Algorithms">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Function</th>
-<th>stl Semantics</th>
+<th>
+ 
+ Function
+ 
+ </th>
+<th>
+ 
+ stl Semantics
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td><tt class="computeroutput">find(r, a)</tt></td>
-<td><tt class="computeroutput">find(begin(r), end(r), a)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">find_if(r, f)</tt></td>
-<td><tt class="computeroutput">find_if(begin(r), end(r), f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">find_end(r1, r2[, f])</tt></td>
-<td><tt class="computeroutput">find_end(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">find_first_of(r1, r2[, f])</tt></td>
-<td><tt class="computeroutput">find_first_of(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">adjacent_find(r[, f])</tt></td>
-<td><tt class="computeroutput">adjacent_find(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">count(r, a)</tt></td>
-<td><tt class="computeroutput">count(begin(r), end(r), a)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">count_if(r, f)</tt></td>
-<td><tt class="computeroutput">count_if(begin(r), end(r), f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">mismatch(r, i[, f])</tt></td>
-<td><tt class="computeroutput">mismatch(begin(r), end(r), i[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">equal(r, i[, f])</tt></td>
-<td><tt class="computeroutput">equal(begin(r), end(r), i[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">search(r1, r2[, f])</tt></td>
-<td><tt class="computeroutput">search(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">lower_bound(r, a[, f])</tt></td>
-<td><tt class="computeroutput">lower_bound(begin(r), end(r), a[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">upper_bound(r, a[, f])</tt></td>
-<td><tt class="computeroutput">upper_bound(begin(r), end(r), a[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">equal_range(r, a[, f])</tt></td>
-<td><tt class="computeroutput">equal_range(begin(r), end(r), a[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">binary_search(r, a[, f])</tt></td>
-<td><tt class="computeroutput">binary_search(begin(r), end(r), a[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">includes(r1, r2[, f])</tt></td>
-<td><tt class="computeroutput">includes(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">min_element(r[, f])</tt></td>
-<td><tt class="computeroutput">min_element(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">max_element(r[, f])</tt></td>
-<td><tt class="computeroutput">max_element(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">lexicographical_compare(r1, r2[, f])</tt></td>
-<td><tt class="computeroutput">lexicographical_compare(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
+<td>
+ 
+ <tt class="computeroutput">find(r, a)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">find(begin(r), end(r), a)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">find_if(r, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">find_if(begin(r), end(r), f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">find_end(r1, r2[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">find_end(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">find_first_of(r1, r2[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">find_first_of(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">adjacent_find(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">adjacent_find(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">count(r, a)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">count(begin(r), end(r), a)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">count_if(r, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">count_if(begin(r), end(r), f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">distance(r)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">distance(begin(r), end(r))</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">mismatch(r, i[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">mismatch(begin(r), end(r), i[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">equal(r, i[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">equal(begin(r), end(r), i[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">search(r1, r2[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">search(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">lower_bound(r, a[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">lower_bound(begin(r), end(r), a[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">upper_bound(r, a[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">upper_bound(begin(r), end(r), a[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">equal_range(r, a[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">equal_range(begin(r), end(r), a[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">binary_search(r, a[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">binary_search(begin(r), end(r), a[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">includes(r1, r2[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">includes(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">min_element(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">min_element(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">max_element(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">max_element(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">lexicographical_compare(r1, r2[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">lexicographical_compare(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
</tr>
</tbody>
</table>
</div>
-<div class="informaltable">
-<h4>
-<a name="id473941"></a>
- Transformation Algorithms
- </h4>
-<table class="table">
+<div class="table">
+<a name="id488843"></a>Table 1.9. Transformation Algorithms
+<table class="table" summary="Transformation Algorithms">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Function</th>
-<th>stl Semantics</th>
+<th>
+ 
+ Function
+ 
+ </th>
+<th>
+ 
+ stl Semantics
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td><tt class="computeroutput">copy(r, o)</tt></td>
-<td><tt class="computeroutput">copy(begin(r), end(r), o)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">copy_backward(r, o)</tt></td>
-<td><tt class="computeroutput">copy_backward(begin(r), end(r), o)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">transform(r, o, f)</tt></td>
-<td><tt class="computeroutput">transform(begin(r), end(r), o, f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">transform(r, i, o, f)</tt></td>
-<td><tt class="computeroutput">transform(begin(r), end(r), i, o, f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">replace(r, a, b)</tt></td>
-<td><tt class="computeroutput">replace(begin(r), end(r), a, b)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">replace_if(r, f, a)</tt></td>
-<td><tt class="computeroutput">replace(begin(r), end(r), f, a)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">replace_copy(r, o, a, b)</tt></td>
-<td><tt class="computeroutput">replace_copy(begin(r), end(r), o, a, b)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">replace_copy_if(r, o, f, a)</tt></td>
-<td><tt class="computeroutput">replace_copy_if(begin(r), end(r), o, f, a)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">fill(r, a)</tt></td>
-<td><tt class="computeroutput">fill(begin(r), end(r), a)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">fill_n(r, n, a)</tt></td>
-<td><tt class="computeroutput">fill_n(begin(r), n, a)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">generate(r, f)</tt></td>
-<td><tt class="computeroutput">generate(begin(r), end(r), f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">generate_n(r, n, f)</tt></td>
-<td><tt class="computeroutput">generate_n(begin(r), n, f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">remove(r, a)</tt></td>
-<td><tt class="computeroutput">remove(begin(r), end(r), a)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">remove_if(r, f)</tt></td>
-<td><tt class="computeroutput">remove_if(begin(r), end(r), f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">remove_copy(r, o, a)</tt></td>
-<td><tt class="computeroutput">remove_copy(begin(r), end(r), o, a)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">remove_copy_if(r, o, f)</tt></td>
-<td><tt class="computeroutput">remove_copy_if(begin(r), end(r), o, f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">unique(r[, f])</tt></td>
-<td><tt class="computeroutput">unique(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">unique_copy(r, o[, f])</tt></td>
-<td><tt class="computeroutput">unique_copy(begin(r), end(r), o[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">reverse(r)</tt></td>
-<td><tt class="computeroutput">reverse(begin(r), end(r))</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">reverse_copy(r, o)</tt></td>
-<td><tt class="computeroutput">reverse_copy(begin(r), end(r), o)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">rotate(r, m)</tt></td>
-<td><tt class="computeroutput">rotate(begin(r), m, end(r))</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">rotate_copy(r, m, o)</tt></td>
-<td><tt class="computeroutput">rotate_copy(begin(r), m, end(r), o)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">random_shuffle(r[, f])</tt></td>
-<td><tt class="computeroutput">random_shuffle(begin(r), end(r), f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">partition(r, f)</tt></td>
-<td><tt class="computeroutput">partition(begin(r), end(r), f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">stable_partition(r, f)</tt></td>
-<td><tt class="computeroutput">stable_partition(begin(r), end(r), f)</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">sort(r[, f])</tt></td>
-<td><tt class="computeroutput">sort(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">stable_sort(r[, f])</tt></td>
-<td><tt class="computeroutput">stable_sort(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">partial_sort(r, m[, f])</tt></td>
-<td><tt class="computeroutput">partial_sort(begin(r), m, end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">partial_sort_copy(r1, r2[, f])</tt></td>
-<td><tt class="computeroutput">partial_sort_copy(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">nth_element(r, n[, f])</tt></td>
-<td><tt class="computeroutput">nth_element(begin(r), n, end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">merge(r1, r2, o[, f])</tt></td>
-<td><tt class="computeroutput">merge(begin(r1), end(r1), begin(r2), end(r2), o[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">inplace_merge(r, m[, f])</tt></td>
-<td><tt class="computeroutput">inplace_merge(begin(r), m, end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">set_union(r1, r2, o[, f])</tt></td>
-<td><tt class="computeroutput">set_union(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">set_intersection(r1, r2, o[, f])</tt></td>
-<td><tt class="computeroutput">set_intersection(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">set_difference(r1, r2, o[, f])</tt></td>
-<td><tt class="computeroutput">set_difference(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">set_symmetric_difference(r1, r2, o[, f])</tt></td>
-<td><tt class="computeroutput">set_symmetric_difference(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">push_heap(r[, f])</tt></td>
-<td><tt class="computeroutput">push_heap(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">pop_heap(r[, f])</tt></td>
-<td><tt class="computeroutput">pop_heap(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">make_heap(r[, f])</tt></td>
-<td><tt class="computeroutput">make_heap(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">sort_heap(r[, f])</tt></td>
-<td><tt class="computeroutput">sort_heap(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">next_permutation(r[, f])</tt></td>
-<td><tt class="computeroutput">next_permutation(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">prev_permutation(r[, f])</tt></td>
-<td><tt class="computeroutput">prev_permutation(begin(r), end(r)[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">inner_product(r, o, a[, f1, f2])</tt></td>
-<td><tt class="computeroutput">inner_product(begin(r), end(r), o[, f1, f2])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">partial_sum(r, o[, f])</tt></td>
-<td><tt class="computeroutput">partial_sum(begin(r), end(r), o[, f])</tt></td>
-</tr>
-<tr>
-<td><tt class="computeroutput">adjacent_difference(r, o[, f])</tt></td>
-<td><tt class="computeroutput">adjacent_difference(begin(r), end(r), o[, f])</tt></td>
+<td>
+ 
+ <tt class="computeroutput">copy(r, o)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">copy(begin(r), end(r), o)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">copy_backward(r, o)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">copy_backward(begin(r), end(r), o)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">transform(r, o, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">transform(begin(r), end(r), o, f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">transform(r, i, o, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">transform(begin(r), end(r), i, o, f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">replace(r, a, b)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">replace(begin(r), end(r), a, b)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">replace_if(r, f, a)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">replace(begin(r), end(r), f, a)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">replace_copy(r, o, a, b)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">replace_copy(begin(r), end(r), o, a, b)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">replace_copy_if(r, o, f, a)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">replace_copy_if(begin(r), end(r), o, f, a)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">fill(r, a)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">fill(begin(r), end(r), a)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">fill_n(r, n, a)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">fill_n(begin(r), n, a)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">generate(r, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">generate(begin(r), end(r), f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">generate_n(r, n, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">generate_n(begin(r), n, f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">remove(r, a)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">remove(begin(r), end(r), a)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">remove_if(r, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">remove_if(begin(r), end(r), f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">remove_copy(r, o, a)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">remove_copy(begin(r), end(r), o, a)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">remove_copy_if(r, o, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">remove_copy_if(begin(r), end(r), o, f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">unique(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">unique(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">unique_copy(r, o[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">unique_copy(begin(r), end(r), o[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">reverse(r)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">reverse(begin(r), end(r))</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">reverse_copy(r, o)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">reverse_copy(begin(r), end(r), o)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">rotate(r, m)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">rotate(begin(r), m, end(r))</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">rotate_copy(r, m, o)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">rotate_copy(begin(r), m, end(r), o)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">random_shuffle(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">random_shuffle(begin(r), end(r), f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">partition(r, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">partition(begin(r), end(r), f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">stable_partition(r, f)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">stable_partition(begin(r), end(r), f)</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">sort(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">sort(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">stable_sort(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">stable_sort(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">partial_sort(r, m[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">partial_sort(begin(r), m, end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">partial_sort_copy(r1, r2[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">partial_sort_copy(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">nth_element(r, n[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">nth_element(begin(r), n, end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">merge(r1, r2, o[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">merge(begin(r1), end(r1), begin(r2), end(r2), o[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">inplace_merge(r, m[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">inplace_merge(begin(r), m, end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">set_union(r1, r2, o[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">set_union(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">set_intersection(r1, r2, o[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">set_intersection(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">set_difference(r1, r2, o[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">set_difference(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">set_symmetric_difference(r1, r2, o[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">set_symmetric_difference(begin(r1), end(r1), begin(r2), end(r2)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">push_heap(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">push_heap(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">pop_heap(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">pop_heap(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">make_heap(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">make_heap(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">sort_heap(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">sort_heap(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">next_permutation(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">next_permutation(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">prev_permutation(r[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">prev_permutation(begin(r), end(r)[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">inner_product(r, o, a[, f1, f2])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">inner_product(begin(r), end(r), o[, f1, f2])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">partial_sum(r, o[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">partial_sum(begin(r), end(r), o[, f])</tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">adjacent_difference(r, o[, f])</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">adjacent_difference(begin(r), end(r), o[, f])</tt>
+ 
+ </td>
</tr>
</tbody>
</table>
@@ -397,12 +943,16 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="container.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="inside_phoenix.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="container.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="inside_phoenix.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/basics.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/basics.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/basics.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Basics</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,36 +10,47 @@
<link rel="next" href="organization.html" title="Organization">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="starter_kit.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="organization.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="starter_kit.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="organization.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.basics"></a>Basics</h2></div></div></div>
+<a name="phoenix.basics"></a>Basics</h2></div></div></div>

 Almost everything is a function in the Phoenix library that can be evaluated
- as <tt class="computeroutput">f(a1, a2, ..., an)</tt>,
- where n is the function's arity, or number of arguments
- that the function expects. Operators are also functions. For example, <tt class="computeroutput">a + b</tt> is just a function with arity == 2 (or
- binary). <tt class="computeroutput">a + b</tt> is the same as <tt class="computeroutput">add(a, b)</tt>, <tt class="computeroutput">a + b + c</tt> is the same as <tt class="computeroutput">add(add(a, b), c)</tt>.
- 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> Amusingly, functions may even return functions.
- We shall see what this means in a short while.</td></tr></tbody>
+ as <tt class="computeroutput">f(a1, a2, ..., an)</tt>, where n is the function's
+ arity, or number of arguments that the function expects. Operators are also
+ functions. For example, <tt class="computeroutput">a + b</tt> is just
+ a function with arity == 2 (or binary). <tt class="computeroutput">a
+ + b</tt>
+ is the same as <tt class="computeroutput">add(a, b)</tt>, <tt class="computeroutput">a
+ + b + c</tt> is the
+ same as <tt class="computeroutput">add(add(a, b),
+ c)</tt>.
+ 
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ Amusingly, functions may even return functions. We shall see what this means
+ in a short while.
+ </td></tr>
</table></div>
<a name="phoenix.basics.partial_function_application"></a><h2>
-<a name="id446467"></a>
- Partial Function Application
+<a name="id459717"></a>
+ <a href="basics.html#phoenix.basics.partial_function_application">Partial Function
+ Application</a>
 </h2>

 Think of a function as a black box. You pass arguments and it returns something
@@ -51,9 +62,9 @@

 A fully evaluated function is one in which all the arguments are given. All
 functions in plain C++ are fully evaluated. When you call the <tt class="computeroutput">sin(x)</tt> function, you have to pass a number x. The
- function will return a result in return: the sin of x. When you call the <tt class="computeroutput">add(x, y)</tt> function, you have to pass two numbers x and
- y. The function will return the sum of the two numbers. The figure below is
- a fully evaluated <tt class="computeroutput">add</tt> function.
+ function will return a result in return: the sin of x. When you call the <tt class="computeroutput">add(x, y)</tt>
+ function, you have to pass two numbers x and y. The function will return the
+ sum of the two numbers. The figure below is a fully evaluated <tt class="computeroutput">add</tt> function.
 

 <img src="../images/adder.png" alt="adder">
@@ -89,8 +100,9 @@
 application.
 
<a name="phoenix.basics.stl_and_higher_order_functions"></a><h2>
-<a name="id446722"></a>
- STL and higher order functions
+<a name="id459987"></a>
+ <a href="basics.html#phoenix.basics.stl_and_higher_order_functions">STL and higher
+ order functions</a>
 </h2>

 So, what's all the fuss? What makes partial function application so useful?
@@ -101,22 +113,28 @@
find_if(c.begin(), c.end(), arg1 % 2 == 1)
</pre>

- The expression <tt class="computeroutput">arg1 % 2 == 1</tt> evaluates to a lambda function. <tt class="computeroutput">arg1</tt> is a placeholder for an argument to
+ The expression <tt class="computeroutput">arg1 %
+ 2 == 1</tt> evaluates to a lambda function. <tt class="computeroutput">arg1</tt> is a placeholder for an argument to
 be supplied later. Hence, since there's only one unsupplied argument, the lambda
 function has an arity 1. It just so happens that <tt class="computeroutput">find_if</tt>
 supplies the unsupplied argument as it loops from <tt class="computeroutput">c.begin()</tt>
 to <tt class="computeroutput">c.end()</tt>.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> Higher order functions are functions which can take
- other functions as arguments, and may also return functions as results.
- Higher order functions are functions that are treated like any other
- objects and can be used as arguments and return values from functions.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ Higher order functions are functions which can take other functions as arguments,
+ and may also return functions as results. Higher order functions are functions
+ that are treated like any other objects and can be used as arguments and
+ return values from functions.
+ </td></tr>
</table></div>
<a name="phoenix.basics.lazy_evaluation"></a><h2>
-<a name="id446996"></a>
- Lazy Evaluation
+<a name="id460243"></a>
+ Lazy Evaluation
 </h2>

 In Phoenix, to put it more accurately, function evaluation has two stages:
@@ -173,8 +191,9 @@
cout << (arg1 % 2 == 1)(y) << endl; // prints 0 or false
</pre>
<a name="phoenix.basics.forwarding_function_problem"></a><h2>
-<a name="id447608"></a>
- Forwarding Function Problem
+<a name="id460872"></a>
+ <a href="basics.html#phoenix.basics.forwarding_function_problem">Forwarding Function
+ Problem</a>
 </h2>

 Usually, we, as clients, write the call-back functions while libraries (such
@@ -204,8 +223,8 @@
 Function Problem</a>" but prohibits code like above.
 
<a name="phoenix.basics.polymorphic_functions"></a><h2>
-<a name="id447803"></a>
- Polymorphic Functions
+<a name="id461082"></a>
+ Polymorphic Functions
 </h2>

 Unless otherwise noted, Phoenix generated functions are fully polymorphic.
@@ -224,20 +243,25 @@
 reader might notice that this function call in fact takes in heterogeneous
 arguments where <tt class="computeroutput">arg1</tt> is of
 type <tt class="computeroutput">std::string</tt> and <tt class="computeroutput">arg2</tt>
- is of type <tt class="computeroutput">char const*</tt>. <tt class="computeroutput">add</tt>
- still works because the C++ standard library allows the expression <tt class="computeroutput">a + b</tt> where <tt class="computeroutput">a</tt>
- is a <tt class="computeroutput">std::string</tt> and <tt class="computeroutput">b</tt>
- is a <tt class="computeroutput">char const*</tt>.
+ is of type <tt class="computeroutput">char const*</tt>. <tt class="computeroutput">add</tt>
+ still works because the C++ standard library allows the expression <tt class="computeroutput">a + b</tt>
+ where <tt class="computeroutput">a</tt> is a <tt class="computeroutput">std::string</tt>
+ and <tt class="computeroutput">b</tt> is a <tt class="computeroutput">char
+ const*</tt>.
 
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="starter_kit.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="organization.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="starter_kit.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="organization.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/composite.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/composite.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/composite.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Composite</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,21 +10,21 @@
<link rel="next" href="container.html" title="Container">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="primitives.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="container.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="primitives.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="container.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.composite"></a>Composite</h2></div></div></div>
+<a name="phoenix.composite"></a>Composite</h2></div></div></div>
<div class="toc"><dl>
<dt>Function</dt>
<dt>Operator</dt>
@@ -44,11 +44,15 @@
 A composite is-a tuple of 0..N actors. N is the predefined maximum actors a
 composite can take.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> You can set <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt>,
- the predefined maximum actors a composite can take. By default, <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt> is set to
- <tt class="computeroutput">PHOENIX_LIMIT</tt> (See Actors).</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ You can set <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt>,
+ the predefined maximum actors a composite can take. By default, <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt> is set to <tt class="computeroutput">PHOENIX_LIMIT</tt> (See Actors).
+ </td></tr>
</table></div>

 As mentioned, each of the actors A0..AN can, in turn, be another composite,
@@ -57,7 +61,7 @@
 
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.composite.function"></a>Function</h3></div></div></div>
+<a name="phoenix.composite.function"></a>Function</h3></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/function/function.hpp>
</pre>
@@ -85,12 +89,11 @@
 arguments, and implements the function logic.
 </li>
<li>
- A nested metafunction <tt class="computeroutput">result<A1, ... AN></tt>
- that takes the types of the <tt class="computeroutput">N</tt>
- arguments to the function and returns the result type of the function.
- (There is a special case for function objects that accept no arguments.
- Such nullary functors are only required to define a typedef <tt class="computeroutput">result_type</tt> that reflects the return
- type of its <tt class="computeroutput">operator()</tt>).
+ A nested metafunction <tt class="computeroutput">result<A1, ... AN></tt> that takes the types of the <tt class="computeroutput">N</tt> arguments to the function and returns
+ the result type of the function. (There is a special case for function
+ objects that accept no arguments. Such nullary functors are only required
+ to define a typedef <tt class="computeroutput">result_type</tt>
+ that reflects the return type of its <tt class="computeroutput">operator()</tt>).
 </li>
</ul></div>

@@ -157,16 +160,15 @@
 case as <tt class="computeroutput">factorial_impl</tt> does
 not require any state).
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/alert.png" alt="alert"> Take care though when using function objects with
- state because they are often copied repeatedly, and state may change
- in one of the copies, rather than the original.</td></tr></tbody>
-</table></div>
+<div class="sidebar">
+ <img src="../images/alert.png" alt="alert"> Take care though when using function objects with state
+ because they are often copied repeatedly, and state may change in one of
+ the copies, rather than the original.
+ </div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.composite.operator"></a>Operator</h3></div></div></div>
+<a name="phoenix.composite.operator"></a>Operator</h3></div></div></div>

 This facility provides a mechanism for lazily evaluating operators. Syntactically,
 a lazy operator looks and feels like an ordinary C/C++ infix, prefix or postfix
@@ -187,14 +189,16 @@
find_if(c.begin(), c.end(), arg1 % 2 == 1)
</pre>

- Through operator overloading, the expression <tt class="computeroutput">arg1 % 2 == 1</tt> actually
+ Through operator overloading, the expression <tt class="computeroutput">arg1
+ % 2 == 1</tt> actually
 generates an actor. This actor object is passed on to STL's <tt class="computeroutput">find_if</tt> function. From the viewpoint of
 STL, the composite is simply a function object expecting a single argument
 of the containers value_type. For each element in <tt class="computeroutput">c</tt>,
 the element is passed on as an argument <tt class="computeroutput">arg1</tt>
 to the actor (function object). The actor checks if this is an odd value
- based on the expression <tt class="computeroutput">arg1 % 2 == 1</tt> where
- arg1 is replaced by the container's element.
+ based on the expression <tt class="computeroutput">arg1 % 2 ==
+ 1</tt> where arg1 is replaced by the container's
+ element.
 

 Like lazy functions (see function),
@@ -245,25 +249,26 @@
</pre>
<div class="orderedlist"><ol type="1">
<li>
- Following rule 1, <tt class="computeroutput">arg1 + 3</tt>
- is lazily evaluated since <tt class="computeroutput">arg1</tt>
- is an actor (see primitives).
+ Following rule 1, <tt class="computeroutput">arg1 + 3</tt> is lazily
+ evaluated since <tt class="computeroutput">arg1</tt> is
+ an actor (see primitives).
 </li>
<li>
- The result of this <tt class="computeroutput">arg1 + 3</tt>
- expression is an actor object, following rule 4.
+ The result of this <tt class="computeroutput">arg1 + 3</tt> expression
+ is an actor object, following rule 4.
 </li>
<li>
- Continuing, <tt class="computeroutput">arg1 + 3 + 6</tt>
- is again lazily evaluated. Rule 2.
+ Continuing, <tt class="computeroutput">arg1 +
+ 3 + 6</tt> is again lazily evaluated. Rule 2.
 </li>
<li>
- By rule 4 again, the result of <tt class="computeroutput">arg1 + 3 + 6</tt>
- is an actor object.
+ By rule 4 again, the result of <tt class="computeroutput">arg1
+ + 3 + 6</tt> is an
+ actor object.
 </li>
<li>
- As <tt class="computeroutput">arg1 + 3 + 6</tt> is an actor, <tt class="computeroutput">-(arg1 + 3 + 6)</tt> is lazily
- evaluated. Rule 2.
+ As <tt class="computeroutput">arg1 +
+ 3 + 6</tt> is an actor, <tt class="computeroutput">-(arg1 + 3 + 6)</tt> is lazily evaluated. Rule 2.
 </li>
</ol></div>

@@ -283,20 +288,21 @@
val(1) << 3; // Lazily evaluated
</pre>
<a name="phoenix.composite.operator.supported_operators"></a><h2>
-<a name="id455378"></a>
- Supported operators
+<a name="id469049"></a>
+ <a href="composite.html#phoenix.composite.operator.supported_operators">Supported
+ operators</a>
 </h2>
<a name="phoenix.composite.operator.unary_operators"></a><h3>
-<a name="id455393"></a>
- Unary operators
+<a name="id469075"></a>
+ Unary operators
 </h3>
<pre class="programlisting">
prefix: ~, !, -, +, ++, --, & (reference), * (dereference)
postfix: ++, --
</pre>
<a name="phoenix.composite.operator.binary_operators"></a><h3>
-<a name="id455528"></a>
- Binary operators
+<a name="id469223"></a>
+ Binary operators
 </h3>
<pre class="programlisting">
=, [], +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
@@ -305,21 +311,23 @@
&&, ||, ->*
</pre>
<a name="phoenix.composite.operator.ternary_operator"></a><h3>
-<a name="id455740"></a>
- Ternary operator
+<a name="id469446"></a>
+ Ternary operator
 </h3>
<pre class="programlisting">
if_else(c, a, b)
</pre>

 The ternary operator deserves special mention. Since C++ does not allow us
- to overload the conditional expression: <tt class="computeroutput">c ? a : b</tt>,
- the if_else pseudo function is provided for this purpose. The behavior is
- identical, albeit in a lazy manner.
+ to overload the conditional expression: <tt class="computeroutput">c
+ ? a : b</tt>, the
+ if_else pseudo function is provided for this purpose. The behavior is identical,
+ albeit in a lazy manner.
 
<a name="phoenix.composite.operator.member_pointer_operator"></a><h3>
-<a name="id455848"></a>
- Member pointer operator
+<a name="id469566"></a>
+ <a href="composite.html#phoenix.composite.operator.member_pointer_operator">Member
+ pointer operator</a>
 </h3>
<pre class="programlisting">
a->*member_object_pointer
@@ -360,77 +368,133 @@

(arg1->*&A::func)(arg2)(a, i); // returns a->func(i)
</pre>
-<div class="informaltable">
-<h4>
-<a name="id456264"></a>
- Include Files
- </h4>
-<table class="table">
+<div class="table">
+<a name="id469993"></a>Table 1.4. Include Files
+<table class="table" summary="Include Files">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Operators</th>
-<th>File</th>
+<th>
+ 
+ Operators
+ 
+ </th>
+<th>
+ 
+ File
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
<td>
-<tt class="computeroutput">-</tt>, <tt class="computeroutput">+</tt>, <tt class="computeroutput">++</tt>,
- <tt class="computeroutput">--</tt>, <tt class="computeroutput">+=</tt>,
- <tt class="computeroutput">-=</tt>, <tt class="computeroutput">*=</tt>,
- <tt class="computeroutput">/=</tt>, <tt class="computeroutput">%=</tt>,
- <tt class="computeroutput">*</tt>, <tt class="computeroutput">/</tt>,
- <tt class="computeroutput">%</tt>
-</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/operator/arithmetic.hpp></tt></td>
+ 
+ <tt class="computeroutput">-</tt>, <tt class="computeroutput">+</tt>,
+ <tt class="computeroutput">++</tt>, <tt class="computeroutput">--</tt>,
+ <tt class="computeroutput">+=</tt>, <tt class="computeroutput">-=</tt>,
+ <tt class="computeroutput">*=</tt>, <tt class="computeroutput">/=</tt>,
+ <tt class="computeroutput">%=</tt>, <tt class="computeroutput">*</tt>,
+ <tt class="computeroutput">/</tt>, <tt class="computeroutput">%</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/operator/arithmetic.hpp></tt>
+ 
+ </td>
</tr>
<tr>
<td>
-<tt class="computeroutput">&=</tt>, <tt class="computeroutput">|=</tt>, <tt class="computeroutput">^=</tt>,
+ 
+ <tt class="computeroutput">&=</tt>, <tt class="computeroutput">|=</tt>, <tt class="computeroutput">^=</tt>,
 <tt class="computeroutput"><<=</tt>, <tt class="computeroutput">>>=</tt>, <tt class="computeroutput">&</tt>,
 <tt class="computeroutput">|</tt>, <tt class="computeroutput">^</tt>,
 <tt class="computeroutput"><<</tt>, <tt class="computeroutput">>></tt>
-</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/operator/bitwise.hpp></tt></td>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/operator/bitwise.hpp></tt>
+ 
+ </td>
</tr>
<tr>
<td>
-<tt class="computeroutput">==</tt>, <tt class="computeroutput">!=</tt>, <tt class="computeroutput"><</tt>,
- <tt class="computeroutput"><=</tt>, <tt class="computeroutput">></tt>,
- <tt class="computeroutput">>=</tt>
-</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/operator/comparison.hpp></tt></td>
+ 
+ <tt class="computeroutput">==</tt>, <tt class="computeroutput">!=</tt>,
+ <tt class="computeroutput"><</tt>, <tt class="computeroutput"><=</tt>,
+ <tt class="computeroutput">></tt>, <tt class="computeroutput">>=</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/operator/comparison.hpp></tt>
+ 
+ </td>
</tr>
<tr>
<td>
-<tt class="computeroutput"><<</tt>, <tt class="computeroutput">>></tt>
-</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/operator/io.hpp></tt></td>
+ 
+ <tt class="computeroutput"><<</tt>, <tt class="computeroutput">>></tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/operator/io.hpp></tt>
+ 
+ </td>
</tr>
<tr>
<td>
-<tt class="computeroutput">!</tt>, &&,
- <tt class="computeroutput">||</tt>
-</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/operator/logical.hpp></tt></td>
+ 
+ <tt class="computeroutput">!</tt>, &&, <tt class="computeroutput">||</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/operator/logical.hpp></tt>
+ 
+ </td>
</tr>
<tr>
<td>
-<tt class="computeroutput">&x</tt>,
+ 
+ <tt class="computeroutput">&x</tt>,
 <tt class="computeroutput">*p</tt>,
 <tt class="computeroutput">=</tt>, <tt class="computeroutput">[]</tt>
-</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/operator/self.hpp></tt></td>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/operator/self.hpp></tt>
+ 
+ </td>
</tr>
<tr>
-<td><tt class="computeroutput">if_else(c, a, b)</tt></td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/operator/if_else.hpp></tt></td>
+<td>
+ 
+ <tt class="computeroutput">if_else(c, a, b)</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/operator/if_else.hpp></tt>
+ 
+ </td>
</tr>
<tr>
-<td><tt class="computeroutput">->*</tt></td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/operator/member.hpp></tt></td>
+<td>
+ 
+ <tt class="computeroutput">->*</tt>
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/operator/member.hpp></tt>
+ 
+ </td>
</tr>
</tbody>
</table>
@@ -438,16 +502,20 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.composite.statement"></a>Statement</h3></div></div></div>
+<a name="phoenix.composite.statement"></a>Statement</h3></div></div></div>
<div class="toc"><dl>
-<dt>Block Statement</dt>
+<dt><a href="composite.html#phoenix.composite.statement.block_statement">Block
+ Statement</a></dt>
<dt>if_ Statement</dt>
<dt>ifelse statement</dt>
-<dt>switch_ statement</dt>
-<dt>while_ Statement</dt>
+<dt><a href="composite.html#phoenix.composite.statement.switch__statement">switch_
+ statement</a></dt>
+<dt><a href="composite.html#phoenix.composite.statement.while__statement">while_
+ Statement</a></dt>
<dt>dowhile Statement</dt>
<dt>for_ Statement</dt>
-<dt>try_ catch_ Statement</dt>
+<dt><a href="composite.html#phoenix.composite.statement.try__catch__statement">try_
+ catch_ Statement</a></dt>
<dt>throw_</dt>
</dl></div>

@@ -480,19 +548,29 @@
 underscore. Second, the block uses square brackets instead of the familiar
 curly braces {}.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> C++ in C++? 
- In as much as Spirit
- attempts to mimic EBNF in C++, Phoenix attempts to mimic C++ in C++!!!
- </td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+
+ C++ in C++?
+ 
+
+ In as much as Spirit
+ attempts to mimic EBNF in C++, Phoenix attempts to mimic C++ in C++!!!
+ 
+</td></tr>
</table></div>

 Here are more examples with annotations. The code almost speaks for itself.
 
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.composite.statement.block_statement"></a>Block Statement</h4></div></div></div>
+<a name="phoenix.composite.statement.block_statement"></a><a href="composite.html#phoenix.composite.statement.block_statement" title="Block
+ Statement">Block
+ Statement</a></h4></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/statement/sequence.hpp>
</pre>
@@ -551,7 +629,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.composite.statement.if__statement"></a>if_ Statement</h4></div></div></div>
+<a name="phoenix.composite.statement.if__statement"></a>if_ Statement</h4></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/statement/if.hpp>
</pre>
@@ -568,7 +646,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.composite.statement.if_else__statement"></a>ifelse statement</h4></div></div></div>
+<a name="phoenix.composite.statement.if_else__statement"></a>ifelse statement</h4></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/statement/if.hpp>
</pre>
@@ -620,7 +698,9 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.composite.statement.switch__statement"></a>switch_ statement</h4></div></div></div>
+<a name="phoenix.composite.statement.switch__statement"></a><a href="composite.html#phoenix.composite.statement.switch__statement" title="switch_
+ statement">switch_
+ statement</a></h4></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/statement/switch.hpp>
</pre>
@@ -657,7 +737,9 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.composite.statement.while__statement"></a>while_ Statement</h4></div></div></div>
+<a name="phoenix.composite.statement.while__statement"></a><a href="composite.html#phoenix.composite.statement.while__statement" title="while_
+ Statement">while_
+ Statement</a></h4></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/statement/while.hpp>
</pre>
@@ -689,7 +771,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.composite.statement.do_while__statement"></a>dowhile Statement</h4></div></div></div>
+<a name="phoenix.composite.statement.do_while__statement"></a>dowhile Statement</h4></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/statement/do_while.hpp>
</pre>
@@ -726,7 +808,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.composite.statement.for__statement"></a>for_ Statement</h4></div></div></div>
+<a name="phoenix.composite.statement.for__statement"></a>for_ Statement</h4></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/statement/for.hpp>
</pre>
@@ -741,10 +823,9 @@
</pre>

 It is again very similar to the C++ for statement. Take note that the init_statement,
- conditional_expression and step_statement are separated by the comma instead
- of the semi-colon and each must be present (i.e. <tt class="computeroutput">for_(,,)</tt> is invalid). This is a case where the
- nothing actor can be
- useful.
+ conditional_expression and stepstatement are
+ separated by the comma instead of the semi-colon and each must be present
+ (i.e. `for(,,)` is invalid). This is a case where the nothing actor can be useful.
 

 Example: This code prints each element N times where N is the element's
@@ -768,15 +849,22 @@
 the viewpoint of <tt class="computeroutput">for_each</tt>,
 what was passed is just a functor, no more, no less.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> Unlike lazy functions and lazy operators, lazy
- statements always return void.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ Unlike lazy functions and lazy operators, lazy statements always return
+ void.
+ </td></tr>
</table></div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.composite.statement.try__catch__statement"></a>try_ catch_ Statement</h4></div></div></div>
+<a name="phoenix.composite.statement.try__catch__statement"></a><a href="composite.html#phoenix.composite.statement.try__catch__statement" title="try_
+ catch_ Statement">try_
+ catch_ Statement</a></h4></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/statement/try_catch.hpp>
</pre>
@@ -828,7 +916,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.composite.statement.throw_"></a>throw_</h4></div></div></div>
+<a name="phoenix.composite.statement.throw_"></a>throw_</h4></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/statement/throw.hpp>
</pre>
@@ -878,7 +966,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.composite.object"></a>Object</h3></div></div></div>
+<a name="phoenix.composite.object"></a>Object</h3></div></div></div>

 The Object module deals with object construction, destruction and conversion.
 The module provides "lazy" versions of C++'s
@@ -886,8 +974,8 @@
 <tt class="computeroutput">dynamic_cast</tt>, <tt class="computeroutput">const_cast</tt> and <tt class="computeroutput">reinterpret_cast</tt>.
 
<a name="phoenix.composite.object.construction"></a><h2>
-<a name="id461627"></a>
- Construction
+<a name="id475604"></a>
+ Construction
 </h2>

 Lazy constructors...
@@ -916,18 +1004,22 @@
 Constructs a <tt class="computeroutput">std::string</tt> from <tt class="computeroutput">arg1</tt>
 and <tt class="computeroutput">arg2</tt>.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> The maximum number of actual parameters is limited
- by the preprocessor constant PHOENIX_COMPOSITE_LIMIT. Note though,
- that this limit should not be greater than PHOENIX_LIMIT. By default,
- <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt>
- is set to <tt class="computeroutput">PHOENIX_LIMIT</tt>
- (See Actors).</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ The maximum number of actual parameters is limited by the preprocessor
+ constant PHOENIX_COMPOSITE_LIMIT. Note though, that this limit should not
+ be greater than PHOENIX_LIMIT. By default, <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt>
+ is set to <tt class="computeroutput">PHOENIX_LIMIT</tt>
+ (See Actors).
+ </td></tr>
</table></div>
<a name="phoenix.composite.object.new"></a><h2>
-<a name="id461989"></a>
- New
+<a name="id475958"></a>
+ New
 </h2>

 Lazy new...
@@ -956,15 +1048,19 @@
 Creates a <tt class="computeroutput">std::string</tt> from <tt class="computeroutput">arg1</tt>
 and <tt class="computeroutput">arg2</tt> on the heap.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> Again, the maximum number of actual parameters
- is limited by the preprocessor constant PHOENIX_COMPOSITE_LIMIT. See
- the note above.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ Again, the maximum number of actual parameters is limited by the preprocessor
+ constant PHOENIX_COMPOSITE_LIMIT. See the note above.
+ </td></tr>
</table></div>
<a name="phoenix.composite.object.delete"></a><h2>
-<a name="id462327"></a>
- Delete
+<a name="id476284"></a>
+ Delete
 </h2>

 Lazy delete...
@@ -988,8 +1084,8 @@
delete_<std::string>(arg1) // note the spelling of delete_ (with trailing underscore)
</pre>
<a name="phoenix.composite.object.casts"></a><h2>
-<a name="id462522"></a>
- Casts
+<a name="id476494"></a>
+ Casts
 </h2>

 Lazy casts...
@@ -1025,7 +1121,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.composite.scope"></a>Scope</h3></div></div></div>
+<a name="phoenix.composite.scope"></a>Scope</h3></div></div></div>

 Up until now, the most basic ingredient is missing: creation of and access
 to local variables in the stack. When recursion comes into play, you will
@@ -1045,8 +1141,8 @@
 This section deals with local variables and nested lambda scopes.
 
<a name="phoenix.composite.scope.local_variables"></a><h2>
-<a name="id463114"></a>
- Local Variables
+<a name="id477099"></a>
+ Local Variables
 </h2>
<pre class="programlisting">
#include <boost/spirit/phoenix/scope/local_variable.hpp>
@@ -1067,20 +1163,21 @@
actor<local_variable<size_key> > size;
</pre>
<a name="phoenix.composite.scope.predefined_local_variables"></a><h2>
-<a name="id463348"></a>
- Predefined Local Variables
+<a name="id477350"></a>
+ <a href="composite.html#phoenix.composite.scope.predefined_local_variables">Predefined
+ Local Variables</a>
 </h2>

- There are a few predefined instances of <tt class="computeroutput">actor<local_variable<Key> ></tt>
+ There are a few predefined instances of <tt class="computeroutput">actor<local_variable<Key> ></tt>
 named <tt class="computeroutput">_a</tt>..<tt class="computeroutput">_z</tt>
- that you can already use. To make use of them, simply use the <tt class="computeroutput">namespace boost::phoenix::local_names</tt>:
+ that you can already use. To make use of them, simply use the <tt class="computeroutput">namespace boost::phoenix::local_names</tt>:
 
<pre class="programlisting">
using namespace boost::phoenix::local_names;
</pre>
<a name="phoenix.composite.scope.let"></a><h2>
-<a name="id463515"></a>
- let
+<a name="id477537"></a>
+ let
 </h2>
<pre class="programlisting">
#include <boost/spirit/phoenix/scope/let.hpp>
@@ -1102,12 +1199,17 @@
<pre class="programlisting">
local-id = lambda-expression
</pre>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> You can set <tt class="computeroutput">PHOENIX_LOCAL_LIMIT</tt>,
- the predefined maximum local variable declarations in a let expression.
- By default, <tt class="computeroutput">PHOENIX_LOCAL_LIMIT</tt>
- is set to <tt class="computeroutput">PHOENIX_LIMIT</tt>.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ You can set <tt class="computeroutput">PHOENIX_LOCAL_LIMIT</tt>,
+ the predefined maximum local variable declarations in a let expression.
+ By default, <tt class="computeroutput">PHOENIX_LOCAL_LIMIT</tt>
+ is set to <tt class="computeroutput">PHOENIX_LIMIT</tt>.
+ </td></tr>
</table></div>

 Example:
@@ -1119,8 +1221,9 @@
]
</pre>
<a name="phoenix.composite.scope.reference_preservation"></a><h2>
-<a name="id463919"></a>
- Reference Preservation
+<a name="id477932"></a>
+ <a href="composite.html#phoenix.composite.scope.reference_preservation">Reference
+ Preservation</a>
 </h2>

 The type of the local variable assumes the type of the lambda- expression.
@@ -1173,8 +1276,8 @@
 and <tt class="computeroutput">ref</tt>s are L-values. <tt class="computeroutput">val</tt>s are R-values.
 
<a name="phoenix.composite.scope.visibility"></a><h2>
-<a name="id464447"></a>
- Visibility
+<a name="id478484"></a>
+ Visibility
 </h2>

 The scope and lifetimes of the local variables is limited within the let-body.
@@ -1226,8 +1329,8 @@
]
</pre>
<a name="phoenix.composite.scope.lambda"></a><h2>
-<a name="id464895"></a>
- lambda
+<a name="id478949"></a>
+ lambda
 </h2>
<pre class="programlisting">
#include <boost/spirit/phoenix/scope/lambda.hpp>
@@ -1321,12 +1424,16 @@
 information from outer <tt class="computeroutput">lambda</tt>
 scopes through the local variables.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> This is a crucial difference between <tt class="computeroutput">let</tt> and <tt class="computeroutput">lambda</tt>:
- <tt class="computeroutput">let</tt> does not introduce
- new arguments; <tt class="computeroutput">lambda</tt>
- does.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ This is a crucial difference between <tt class="computeroutput">let</tt>
+ and <tt class="computeroutput">lambda</tt>: <tt class="computeroutput">let</tt> does not introduce new arguments;
+ <tt class="computeroutput">lambda</tt> does.
+ </td></tr>
</table></div>

 Another example: Using our lazy <tt class="computeroutput">for_each</tt>,
@@ -1355,7 +1462,7 @@
 
<div class="orderedlist"><ol type="1">
<li>
- a 2-dimensional container (e.g. <tt class="computeroutput">vector<vector<int> ></tt>)
+ a 2-dimensional container (e.g. <tt class="computeroutput">vector<vector<int> ></tt>)
 </li>
<li>
 a container element (e.g. <tt class="computeroutput">int</tt>)
@@ -1368,7 +1475,7 @@
 Solution:
 
<pre class="programlisting">
-for_each(arg1,
+for_each(arg1,
 lambda(_a = arg2)
 [
 push_back(arg1, _a)
@@ -1387,7 +1494,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.composite.bind"></a>Bind</h3></div></div></div>
+<a name="phoenix.composite.bind"></a>Bind</h3></div></div></div>

 Binding is the act of tying together a function to some
 arguments for deferred (lazy) evaluation. Named <a href="composite.html#phoenix.composite.function" title="Function">Lazy
@@ -1397,13 +1504,17 @@
 to a lambda expression, <tt class="computeroutput">bind</tt>
 is your friend.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> Take note that binders are monomorphic. Rather
- than binding functions, the preferred way is to write true generic
- and polymorphic lazy-functions.
- However, since most of the time we are dealing with adaptation of exisiting
- code, binders get the job done faster.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ Take note that binders are monomorphic. Rather than binding functions,
+ the preferred way is to write true generic and polymorphic lazy-functions.
+ However, since most of the time we are dealing with adaptation of exisiting
+ code, binders get the job done faster.
+ </td></tr>
</table></div>

 There is a set of overloaded <tt class="computeroutput">bind</tt>
@@ -1411,8 +1522,8 @@
 function generates a suitable binder object, a composite.
 
<a name="phoenix.composite.bind.binding_functions"></a><h2>
-<a name="id466754"></a>
- Binding Functions
+<a name="id480812"></a>
+ Binding Functions
 </h2>
<pre class="programlisting">
#include <boost/spirit/phoenix/bind/bind_function.hpp>
@@ -1421,9 +1532,9 @@
 Example, given a function <tt class="computeroutput">foo</tt>:
 
<pre class="programlisting">
-void foo(int n)
-{
- std::cout << n << std::endl;
+void foo(int n)
+{
+ std::cout << n << std::endl;
}
</pre>

@@ -1447,8 +1558,9 @@
 will print out "4".
 
<a name="phoenix.composite.bind.binding_member_functions"></a><h2>
-<a name="id467129"></a>
- Binding Member Functions
+<a name="id481207"></a>
+ <a href="composite.html#phoenix.composite.bind.binding_member_functions">Binding Member
+ Functions</a>
 </h2>
<pre class="programlisting">
#include <boost/spirit/phoenix/bind/bind_member_function.hpp>
@@ -1459,9 +1571,9 @@
 given:
 
<pre class="programlisting">
-struct xyz
-{
- void foo(int) const;
+struct xyz
+{
+ void foo(int) const;
};
</pre>

@@ -1483,8 +1595,9 @@
bind(&xyz::foo, obj, 100) // obj.foo(100)
</pre>
<a name="phoenix.composite.bind.binding_member_variables"></a><h2>
-<a name="id467594"></a>
- Binding Member Variables
+<a name="id481689"></a>
+ <a href="composite.html#phoenix.composite.bind.binding_member_variables">Binding Member
+ Variables</a>
 </h2>
<pre class="programlisting">
#include <boost/spirit/phoenix/bind/bind_member_variable.hpp>
@@ -1497,9 +1610,9 @@
 and returning a reference to the bound member variable. For instance, given:
 
<pre class="programlisting">
-struct xyz
-{
- int v;
+struct xyz
+{
+ int v;
};
</pre>

@@ -1515,20 +1628,24 @@
 
<pre class="programlisting">
xyz obj;
-bind(&xyz::v, arg1) // arg1.v
-bind(&xyz::v, obj) // obj.v
+bind(&xyz::v, arg1) // arg1.v
+bind(&xyz::v, obj) // obj.v
bind(&xyz::v, arg1)(obj) = 4 // obj.v = 4
</pre>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="primitives.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="container.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="primitives.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="container.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/inside_phoenix.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/inside_phoenix.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/inside_phoenix.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Inside Phoenix</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,25 +10,26 @@
<link rel="next" href="wrap_up.html" title="Wrap Up">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="algorithm.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="wrap_up.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="algorithm.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="wrap_up.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.inside_phoenix"></a>Inside Phoenix</h2></div></div></div>
+<a name="phoenix.inside_phoenix"></a>Inside Phoenix</h2></div></div></div>
<div class="toc"><dl>
<dt>Actors In Detail</dt>
<dt>Actor Example</dt>
-<dt>Composites In Detail</dt>
+<dt><a href="inside_phoenix.html#phoenix.inside_phoenix.composites_in_detail">Composites
+ In Detail</a></dt>
<dt>Composing</dt>
<dt>Extending</dt>
</dl></div>
@@ -40,24 +41,31 @@
 
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.inside_phoenix.actors_in_detail"></a>Actors In Detail</h3></div></div></div>
+<a name="phoenix.inside_phoenix.actors_in_detail"></a>Actors In Detail</h3></div></div></div>
<a name="phoenix.inside_phoenix.actors_in_detail.actor_concept"></a><h3>
-<a name="id479686"></a>
- Actor Concept
+<a name="id495225"></a>
+ <a href="inside_phoenix.html#phoenix.inside_phoenix.actors_in_detail.actor_concept">Actor
+ Concept</a>
 </h3>

 The main concept is the <tt class="computeroutput">Actor</tt>.
 Actors are function objects (that can accept 0 to N arguments (where N is
 a predefined maximum).
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> You can set <tt class="computeroutput">PHOENIX_LIMIT</tt>,
- the predefined maximum arity an actor can take. By default, <tt class="computeroutput">PHOENIX_LIMIT</tt> is set to 10.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ You can set <tt class="computeroutput">PHOENIX_LIMIT</tt>,
+ the predefined maximum arity an actor can take. By default, <tt class="computeroutput">PHOENIX_LIMIT</tt> is set to 10.
+ </td></tr>
</table></div>
<a name="phoenix.inside_phoenix.actors_in_detail.actor_template_class"></a><h3>
-<a name="id479780"></a>
- actor template class
+<a name="id495302"></a>
+ <a href="inside_phoenix.html#phoenix.inside_phoenix.actors_in_detail.actor_template_class">actor
+ template class</a>
 </h3>

 The <tt class="computeroutput">actor</tt> template class
@@ -77,7 +85,7 @@

 template <typename T0, typename T1>
 actor(T0 const& _0, T1 const& _1);
-
+
 // more constructors

 typename apply_actor<eval_type, basic_environment<> >::type
@@ -94,50 +102,93 @@
 // function call operators
};
</pre>
-<div class="informaltable">
-<h4>
-<a name="id480555"></a>
- Actor Concept Requirements
- </h4>
-<table class="table">
+<div class="table">
+<a name="id496086"></a>Table 1.10. Actor Concept Requirements
+<table class="table" summary="Actor Concept Requirements">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Expression</th>
-<th>Result/Semantics</th>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Result/Semantics
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td><tt class="computeroutput">T::eval_type</tt></td>
-<td>The actor's
- Eval type</td>
-</tr>
-<tr>
-<td><tt class="computeroutput">T()</tt></td>
-<td>Default
- Constructor</td>
-</tr>
-<tr>
-<td><tt class="computeroutput">T(base)</tt></td>
-<td>Constructor
- from Eval</td>
-</tr>
-<tr>
-<td><tt class="computeroutput">T(arg0, arg1, ..., argN)</tt></td>
-<td>Pass through constructors</td>
-</tr>
-<tr>
-<td><tt class="computeroutput">x(arg0, arg1, ..., argN)</tt></td>
-<td>Function call operators</td>
+<td>
+ 
+ <tt class="computeroutput">T::eval_type</tt>
+ 
+ </td>
+<td>
+ 
+ The actor's Eval type
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">T()</tt>
+ 
+ </td>
+<td>
+ 
+ Default Constructor
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">T(base)</tt>
+ 
+ </td>
+<td>
+ 
+ Constructor from Eval
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">T(arg0, arg1, ..., argN)</tt>
+ 
+ </td>
+<td>
+ 
+ Pass through constructors
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">x(arg0, arg1, ..., argN)</tt>
+ 
+ </td>
+<td>
+ 
+ Function call operators
+ 
+ </td>
</tr>
</tbody>
</table>
</div>
<a name="phoenix.inside_phoenix.actors_in_detail.eval_concept"></a><h3>
-<a name="id480807"></a>
- Eval Concept
+<a name="id496398"></a>
+ <a href="inside_phoenix.html#phoenix.inside_phoenix.actors_in_detail.eval_concept">Eval
+ Concept</a>
 </h3>

 The <tt class="computeroutput">actor</tt> template class
@@ -148,37 +199,56 @@
 make it easy to write models of the concept. We shall see an example in the
 <a href="inside_phoenix.html#phoenix.inside_phoenix.actor_example" title="Actor Example">next section</a>.
 
-<div class="informaltable">
-<h4>
-<a name="id480890"></a>
- Eval Concept Requirements
- </h4>
-<table class="table">
+<div class="table">
+<a name="id496494"></a>Table 1.11. Eval Concept Requirements
+<table class="table" summary="Eval Concept Requirements">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Expression</th>
-<th>Result/Semantics</th>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Result/Semantics
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td><tt class="computeroutput">return x.eval(env)</tt></td>
-<td>Evaluates the function
- (see Environment below)</td>
-</tr>
-<tr>
-<td><tt class="computeroutput">T::result<Env>::type</tt></td>
-<td>The return type
- of eval (see Environment below)</td>
+<td>
+ 
+ <tt class="computeroutput">return x.eval(env)</tt>
+ 
+ </td>
+<td>
+ 
+ Evaluates the function (see Environment below)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">T::result<Env>::type</tt>
+ 
+ </td>
+<td>
+ 
+ The return type of eval (see Environment below)
+ 
+ </td>
</tr>
</tbody>
</table>
</div>
<a name="phoenix.inside_phoenix.actors_in_detail.constructors"></a><h3>
-<a name="id481035"></a>
- Constructors
+<a name="id496665"></a>
+ Constructors
 </h3>

 In addition to a default constructor and an constructor from a Eval object,
@@ -186,44 +256,60 @@
 <tt class="computeroutput">PHOENIX_LIMIT</tt>). These constructors
 simply forward the arguments to the <tt class="computeroutput">base</tt>.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> Parametric Base Class
- Pattern Notice that actor derives from its
- template argument Eval. This is the inverse of the curiously recurring
- template pattern (CRTP). With the CRTP, a class, T, has a Derived template
- parameter that is assumed to be its subclass. The "parametric
- base class pattern" (PBCP), on the other hand, inverses the inheritance
- and makes a class, T, the derived class. Both CRTP and PBCP techniques
- have its pros and cons, which is outside the scope of this document.
- CRTP should really be renamed "parametric subclass pattern (PSCP),
- but again, that's another story. </td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+
+ Parametric Base Class Pattern
+ 
+
+ Notice that actor derives from its template argument Eval. This is the
+ inverse of the curiously recurring template pattern (CRTP). With the CRTP,
+ a class, T, has a Derived template parameter that is assumed to be its
+ subclass. The "parametric base class pattern" (PBCP), on the
+ other hand, inverses the inheritance and makes a class, T, the derived
+ class. Both CRTP and PBCP techniques have its pros and cons, which is outside
+ the scope of this document. CRTP should really be renamed "parametric
+ subclass pattern (PSCP), but again, that's another story.
+ 
+</td></tr>
</table></div>
<a name="phoenix.inside_phoenix.actors_in_detail.function_call_operators"></a><h3>
-<a name="id481142"></a>
- Function Call Operators
+<a name="id496762"></a>
+ <a href="inside_phoenix.html#phoenix.inside_phoenix.actors_in_detail.function_call_operators">Function
+ Call Operators</a>
 </h3>

 There are N function call operators for 0 to N arguments (N == <tt class="computeroutput">PHOENIX_LIMIT</tt>). The actor class accepts
 the arguments and forwards the arguments to the actor's base <tt class="computeroutput">Eval</tt> for evaluation.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> Forwarding Function
- Problem The function call operators cannot
- accept non-const temporaries and literal constants. There is a known
- issue with current C++ called the "<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_top">Forwarding
- Function Problem</a>". The problem is that given an arbitrary
- function <tt class="computeroutput">F</tt>, using current
- C++ language rules, one cannot create a forwarding function <tt class="computeroutput">FF</tt> that transparently assumes the
- arguments of <tt class="computeroutput">F</tt>. Disallowing
- non-const rvalues arguments partially solves the problem but prohibits
- code such as <tt class="computeroutput">f(1, 2, 3);</tt>.
- </td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+
+ Forwarding Function Problem
+ 
+
+ The function call operators cannot accept non-const temporaries and literal
+ constants. There is a known issue with current C++ called the "<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_top">Forwarding
+ Function Problem</a>". The problem is that given an arbitrary
+ function <tt class="computeroutput">F</tt>, using current
+ C++ language rules, one cannot create a forwarding function <tt class="computeroutput">FF</tt> that transparently assumes the arguments
+ of <tt class="computeroutput">F</tt>. Disallowing non-const
+ rvalues arguments partially solves the problem but prohibits code such
+ as <tt class="computeroutput">f(1, 2, 3);</tt>.
+ 
+</td></tr>
</table></div>
<a name="phoenix.inside_phoenix.actors_in_detail.environment"></a><h3>
-<a name="id481329"></a>
- Environment
+<a name="id496934"></a>
+ Environment
 </h3>

 On an actor function call, before calling the actor's <tt class="computeroutput">Eval::eval</tt>
@@ -232,35 +318,61 @@
 <tt class="computeroutput">basic_environment</tt> template
 class is a model of.
 
-<div class="informaltable">
-<h4>
-<a name="id481397"></a>
- Environment Concept Requirements
- </h4>
-<table class="table">
+<div class="table">
+<a name="id497013"></a>Table 1.12. Environment Concept Requirements
+<table class="table" summary="Environment Concept Requirements">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Expression</th>
-<th>Result/Semantics</th>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Result/Semantics
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td><tt class="computeroutput">x.args()</tt></td>
-<td>The
- arguments in a tie (a tuple of references)</td>
-</tr>
-<tr>
-<td><tt class="computeroutput">T::args_type</tt></td>
-<td>The arguments'
- types in an MPL sequence</td>
-</tr>
-<tr>
-<td><tt class="computeroutput">T::tie_type</tt></td>
-<td>The tie (tuple
- of references) type</td>
+<td>
+ 
+ <tt class="computeroutput">x.args()</tt>
+ 
+ </td>
+<td>
+ 
+ The arguments in a tie (a tuple of references)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">T::args_type</tt>
+ 
+ </td>
+<td>
+ 
+ The arguments' types in an MPL sequence
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">T::tie_type</tt>
+ 
+ </td>
+<td>
+ 
+ The tie (tuple of references) type
+ 
+ </td>
</tr>
</tbody>
</table>
@@ -276,8 +388,8 @@
 such as local variables, etc.
 
<a name="phoenix.inside_phoenix.actors_in_detail.apply_actor"></a><h3>
-<a name="id481574"></a>
- apply_actor
+<a name="id497228"></a>
+ apply_actor
 </h3>

 <tt class="computeroutput">apply_actor</tt> is a standard
@@ -320,8 +432,8 @@
}
</pre>
<a name="phoenix.inside_phoenix.actors_in_detail.actor_result"></a><h3>
-<a name="id482224"></a>
- actor_result
+<a name="id497910"></a>
+ actor_result
 </h3>

 For reasons of symmetry to the family of <tt class="computeroutput">actor::operator()</tt> there is a special metafunction usable
@@ -340,7 +452,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.inside_phoenix.actor_example"></a>Actor Example</h3></div></div></div>
+<a name="phoenix.inside_phoenix.actor_example"></a>Actor Example</h3></div></div></div>

 Let us see a very simple prototypical example of an actor. This is not a
 toy example. This is actually part of the library. Remember the reference?.
@@ -401,7 +513,9 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.inside_phoenix.composites_in_detail"></a>Composites In Detail</h3></div></div></div>
+<a name="phoenix.inside_phoenix.composites_in_detail"></a><a href="inside_phoenix.html#phoenix.inside_phoenix.composites_in_detail" title="Composites
+ In Detail">Composites
+ In Detail</a></h3></div></div></div>

 We stated before that composites are actors that are composed of zero or
 more actors (see Composite). This
@@ -415,25 +529,36 @@
 <a href="inside_phoenix.html#phoenix.inside_phoenix.actors_in_detail.eval_concept"><tt class="computeroutput">Eval</tt></a> instances and an eval policy.
 The individual Eval instances are stored in a tuple.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> In a sense, the original definition of "composite",
- more or less, will do just fine because Eval instances never exist
- alone and are always wrapped in an <tt class="computeroutput">actor</tt>
- template class which inherits from it anyway. The resulting actor IS-AN
- Eval.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ In a sense, the original definition of "composite", more or less,
+ will do just fine because Eval instances never exist alone
+ and are always wrapped in an <tt class="computeroutput">actor</tt>
+ template class which inherits from it anyway. The resulting actor IS-AN
+ Eval.
+ </td></tr>
</table></div>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> You can set <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt>,
- the predefined maximum <tt class="computeroutput">Eval</tt>s
- (actors) a composite can take. By default, <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt>
- is set to <tt class="computeroutput">PHOENIX_LIMIT</tt>
- (See Actors).</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ You can set <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt>,
+ the predefined maximum <tt class="computeroutput">Eval</tt>s
+ (actors) a composite can take. By default, <tt class="computeroutput">PHOENIX_COMPOSITE_LIMIT</tt>
+ is set to <tt class="computeroutput">PHOENIX_LIMIT</tt>
+ (See Actors).
+ </td></tr>
</table></div>
<a name="phoenix.inside_phoenix.composites_in_detail.composite_template_class"></a><h2>
-<a name="id483520"></a>
- composite template class
+<a name="id499206"></a>
+ <a href="inside_phoenix.html#phoenix.inside_phoenix.composites_in_detail.composite_template_class">composite
+ template class</a>
 </h2>
<pre class="programlisting">
template <typename EvalPolicy, typename EvalTuple>
@@ -456,7 +581,7 @@

 template <typename U0, typename U1>
 composite(U0 const& _0, U1 const& _1);
-
+
 // more constructors

 template <typename Env>
@@ -465,8 +590,8 @@
};
</pre>
<a name="phoenix.inside_phoenix.composites_in_detail.evaltuple"></a><h2>
-<a name="id484112"></a>
- EvalTuple
+<a name="id499812"></a>
+ EvalTuple
 </h2>

 <tt class="computeroutput">EvalTuple</tt>, holds all the
@@ -477,8 +602,8 @@
 base class.
 
<a name="phoenix.inside_phoenix.composites_in_detail.evalpolicy"></a><h2>
-<a name="id484203"></a>
- EvalPolicy
+<a name="id499923"></a>
+ EvalPolicy
 </h2>

 The composite's <tt class="computeroutput">eval</tt> member
@@ -491,29 +616,54 @@

 <img src="../images/funnel_out.png" alt="funnel_out">
 
-<div class="informaltable">
-<h4>
-<a name="id484285"></a>
- EvalPolicy Requirements
- </h4>
-<table class="table">
+<div class="table">
+<a name="id500013"></a>Table 1.13. EvalPolicy Requirements
+<table class="table" summary="EvalPolicy Requirements">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Expression</th>
-<th>Result/Semantics</th>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Result/Semantics
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td><tt class="computeroutput">x.eval<RT>(env, eval0, eval1, ..., evalN)</tt></td>
-<td>Evaluate the composite</td>
-</tr>
-<tr>
-<td><tt class="computeroutput">T::result<Env, Eval0, Eval1, Eval2, ..., EvalN>::type</tt></td>
-<td>The
- return type of eval</td>
+<td>
+ 
+ <tt class="computeroutput">x.eval<RT>(env, eval0,
+ eval1,
+ ..., evalN)</tt>
+ 
+ </td>
+<td>
+ 
+ Evaluate the composite
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <tt class="computeroutput">T::result<Env, Eval0,
+ Eval1,
+ Eval2,
+ ..., EvalN>::type</tt>
+ 
+ </td>
+<td>
+ 
+ The return type of eval
+ 
+ </td>
</tr>
</tbody>
</table>
@@ -532,21 +682,22 @@
eval(Env const& env) const
{
 typedef typename result<Env>::type return_type;
- return EvalPolicy::template
+ return EvalPolicy::template
 eval<return_type>(
 env
 , get<0>(*this) // gets the 0th element from EvalTuple
- , get<1>(*this)); // gets the 1st element from EvalTuple
+ , get<1>(*this)); // gets the 1st element from EvalTuple
}
</pre>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.inside_phoenix.composing"></a>Composing</h3></div></div></div>
+<a name="phoenix.inside_phoenix.composing"></a>Composing</h3></div></div></div>
<div class="toc"><dl>
<dt>compose</dt>
<dt>as_composite</dt>
-<dt>Composite Example</dt>
+<dt><a href="inside_phoenix.html#phoenix.inside_phoenix.composing.composite_example">Composite
+ Example</a></dt>
</dl></div>

 Composites are never instantiated directly. Front end expression templates
@@ -560,12 +711,13 @@
 easier. We have a set of overloaded <tt class="computeroutput">compose</tt>
 functions and an <tt class="computeroutput">as_composite</tt>
 metafunction. Together, these helpers make composing a breeze. We'll provide
- an <a href="inside_phoenix.html#phoenix.inside_phoenix.composing.composite_example" title="Composite Example">example
+ an <a href="inside_phoenix.html#phoenix.inside_phoenix.composing.composite_example" title="Composite
+ Example">example
 of a composite</a> later to see why.
 
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.inside_phoenix.composing.compose"></a>compose</h4></div></div></div>
+<a name="phoenix.inside_phoenix.composing.compose"></a>compose</h4></div></div></div>
<pre class="programlisting">
compose<EvalPolicy>(arg0, arg1, arg2, ..., argN);
</pre>
@@ -581,12 +733,12 @@
</pre>

 converts the argument <tt class="computeroutput">3</tt> to
- an <tt class="computeroutput">actor<value<int> >(3)</tt>.
+ an <tt class="computeroutput">actor<value<int> >(3)</tt>.
 
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.inside_phoenix.composing.as_composite"></a>as_composite</h4></div></div></div>
+<a name="phoenix.inside_phoenix.composing.as_composite"></a>as_composite</h4></div></div></div>
<pre class="programlisting">
as_composite<EvalPolicy, Arg0, Arg1, Arg2, ..., ArgN>::type
</pre>
@@ -607,10 +759,13 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
-<a name="phoenix.inside_phoenix.composing.composite_example"></a>Composite Example</h4></div></div></div>
+<a name="phoenix.inside_phoenix.composing.composite_example"></a><a href="inside_phoenix.html#phoenix.inside_phoenix.composing.composite_example" title="Composite
+ Example">Composite
+ Example</a></h4></div></div></div>

 Now, let's examine an example. Again, this is not a toy example. This is
- actually part of the library. Remember the while_ lazy statement? Putting
+ actually part of the library. Remember the <a href="composite.html#phoenix.composite.statement.while__statement" title="while_
+ Statement"><tt class="computeroutput">while_</tt></a> lazy statement? Putting
 together everything we've learned so far, we will present it here in its
 entirety (verbatim):
 
@@ -719,7 +874,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.inside_phoenix.extending"></a>Extending</h3></div></div></div>
+<a name="phoenix.inside_phoenix.extending"></a>Extending</h3></div></div></div>

 We've shown how it is very easy to extend phoenix by writing new primitives
 and composites. The modular design of Phoenix makes it extremely extensible.
@@ -739,12 +894,16 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="algorithm.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="wrap_up.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="algorithm.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="wrap_up.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/introduction.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/introduction.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/introduction.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Introduction</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,21 +10,21 @@
<link rel="next" href="starter_kit.html" title="Starter Kit">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="starter_kit.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="starter_kit.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.introduction"></a>Introduction</h2></div></div></div>
+<a name="phoenix.introduction"></a>Introduction</h2></div></div></div>

<img src="../images/banner.png" alt="banner">

@@ -55,12 +55,16 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="starter_kit.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="../index.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="starter_kit.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/organization.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/organization.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/organization.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Organization</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,21 +10,21 @@
<link rel="next" href="actors.html" title="Actors">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="basics.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="actors.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="basics.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="actors.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.organization"></a>Organization</h2></div></div></div>
+<a name="phoenix.organization"></a>Organization</h2></div></div></div>

 Care and attention to detail was given, painstakingly, to the design and implementation
 of Phoenix.
@@ -47,8 +47,8 @@
 files. There are no object files to link against.
 
<a name="phoenix.organization.core"></a><h2>
-<a name="id448254"></a>
- Core
+<a name="id461572"></a>
+ Core
 </h2>

 The lowest two layers comprise the core.
@@ -75,58 +75,126 @@
 Composites are composed of zero or more actors. Each actor in a composite can
 again be another composite.
 
-<div class="informaltable">
-<h4>
-<a name="id448312"></a>
- Modules
- </h4>
-<table class="table">
+<div class="table">
+<a name="id461636"></a>Table 1.2. Modules
+<table class="table" summary="Modules">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Module</th>
-<th>Description</th>
+<th>
+ 
+ Module
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td>Function</td>
-<td>Lazy functions support (e.g. <tt class="computeroutput">add</tt>)</td>
-</tr>
-<tr>
-<td>Operator</td>
-<td>Lazy operators support (e.g. <tt class="computeroutput">+</tt>)</td>
-</tr>
-<tr>
-<td>Statement</td>
-<td>Lazy statments (e.g. <tt class="computeroutput">if_</tt>,
- <tt class="computeroutput">while_</tt>)</td>
-</tr>
-<tr>
-<td>Object</td>
-<td>Lazy casts (e.g. <tt class="computeroutput">static_cast_</tt>),
+<td>
+ 
+ Function
+ 
+ </td>
+<td>
+ 
+ Lazy functions support (e.g. <tt class="computeroutput">add</tt>)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Operator
+ 
+ </td>
+<td>
+ 
+ Lazy operators support (e.g. <tt class="computeroutput">+</tt>)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Statement
+ 
+ </td>
+<td>
+ 
+ Lazy statments (e.g. <tt class="computeroutput">if_</tt>,
+ <tt class="computeroutput">while_</tt>)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Object
+ 
+ </td>
+<td>
+ 
+ Lazy casts (e.g. <tt class="computeroutput">static_cast_</tt>),
 object creation destruction (e.g. <tt class="computeroutput">new_</tt>,
- <tt class="computeroutput">delete_</tt>)</td>
-</tr>
-<tr>
-<td>Scope</td>
-<td>Support for scopes, local variables and lambda-lambda</td>
-</tr>
-<tr>
-<td>Bind</td>
-<td>Lazy functions from free functions, member
- functions or member variables.</td>
-</tr>
-<tr>
-<td>Container</td>
-<td>Set of predefined "lazy" functions
- that work on STL containers and sequences (e.g. <tt class="computeroutput">push_back</tt>).</td>
-</tr>
-<tr>
-<td>Algorithm</td>
-<td>Set of predefined "lazy" versions
- of the STL algorithms (e.g. <tt class="computeroutput">find_if</tt>).</td>
+ <tt class="computeroutput">delete_</tt>)
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Scope
+ 
+ </td>
+<td>
+ 
+ Support for scopes, local variables and lambda-lambda
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Bind
+ 
+ </td>
+<td>
+ 
+ Lazy functions from free functions, member functions or member variables.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Container
+ 
+ </td>
+<td>
+ 
+ Set of predefined "lazy" functions that work on STL containers
+ and sequences (e.g. <tt class="computeroutput">push_back</tt>).
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Algorithm
+ 
+ </td>
+<td>
+ 
+ Set of predefined "lazy" versions of the STL algorithms (e.g.
+ <tt class="computeroutput">find_if</tt>).
+ 
+ </td>
</tr>
</tbody>
</table>
@@ -135,74 +203,154 @@
 Each module is defined in a header file with the same name. For example, the
 core module is defined in <tt class="computeroutput"><boost/spirit/phoenix/core.hpp></tt>.
 
-<div class="informaltable">
-<h4>
-<a name="id448597"></a>
- Includes
- </h4>
-<table class="table">
+<div class="table">
+<a name="id462002"></a>Table 1.3. Includes
+<table class="table" summary="Includes">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
-<th>Module</th>
-<th>File</th>
+<th>
+ 
+ Module
+ 
+ </th>
+<th>
+ 
+ File
+ 
+ </th>
</tr></thead>
<tbody>
<tr>
-<td>Core</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/core.hpp></tt></td>
-</tr>
-<tr>
-<td>Function</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/function.hpp></tt></td>
-</tr>
-<tr>
-<td>Operator</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/operator.hpp></tt></td>
-</tr>
-<tr>
-<td>Statement</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/statement.hpp></tt></td>
-</tr>
-<tr>
-<td>Object</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/object.hpp></tt></td>
-</tr>
-<tr>
-<td>Scope</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/scope.hpp></tt></td>
-</tr>
-<tr>
-<td>Bind</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/bind.hpp></tt></td>
-</tr>
-<tr>
-<td>Container</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/container.hpp></tt></td>
-</tr>
-<tr>
-<td>Algorithm</td>
-<td><tt class="computeroutput">#include <boost/spirit/phoenix/algorithm.hpp></tt></td>
+<td>
+ 
+ Core
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/core.hpp></tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Function
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/function.hpp></tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Operator
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/operator.hpp></tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Statement
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/statement.hpp></tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Object
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/object.hpp></tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Scope
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/scope.hpp></tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Bind
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/bind.hpp></tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Container
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/container.hpp></tt>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Algorithm
+ 
+ </td>
+<td>
+ 
+ <tt class="computeroutput">#include <boost/spirit/phoenix/algorithm.hpp></tt>
+ 
+ </td>
</tr>
</tbody>
</table>
</div>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> Finer grained include files are available per feature;
- see the succeeding sections.</td></tr></tbody>
-</table></div>
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> Finer grained include files are available per feature;
+ see the succeeding sections.
+ </div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="basics.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="actors.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="basics.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="actors.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/primitives.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/primitives.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/primitives.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Primitives</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,21 +10,21 @@
<link rel="next" href="composite.html" title="Composite">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="actors.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="composite.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="actors.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="composite.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.primitives"></a>Primitives</h2></div></div></div>
+<a name="phoenix.primitives"></a>Primitives</h2></div></div></div>
<div class="toc"><dl>
<dt>Arguments</dt>
<dt>Values</dt>
@@ -40,7 +40,7 @@
 
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.primitives.arguments"></a>Arguments</h3></div></div></div>
+<a name="phoenix.primitives.arguments"></a>Arguments</h3></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/core/argument.hpp>
</pre>
@@ -55,11 +55,13 @@
 an imaginary data-bin where a function argument will be placed.
 
<a name="phoenix.primitives.arguments.predefined_arguments"></a><h2>
-<a name="id450010"></a>
- Predefined Arguments
+<a name="id463514"></a>
+ <a href="primitives.html#phoenix.primitives.arguments.predefined_arguments">Predefined
+ Arguments</a>
 </h2>

- There are a few predefined instances of <tt class="computeroutput">actor<argument<N> ></tt> named <tt class="computeroutput">arg1</tt>..<tt class="computeroutput">argN</tt>, and its BLL
+ There are a few predefined instances of <tt class="computeroutput">actor<argument<N>
+ ></tt> named <tt class="computeroutput">arg1</tt>..<tt class="computeroutput">argN</tt>, and its BLL
 counterpart <tt class="computeroutput">_1</tt>..<tt class="computeroutput">_N</tt>. (where N is a predefined maximum).
 

@@ -71,7 +73,8 @@
actor<argument<2> > const arg3 = argument<2>();
</pre>

- and its BLL <tt class="computeroutput">_1</tt>..<tt class="computeroutput">_N</tt>
+ and its BLL
+ <tt class="computeroutput">_1</tt>..<tt class="computeroutput">_N</tt>
 style counterparts:
 
<pre class="programlisting">
@@ -79,14 +82,22 @@
actor<argument<1> > const _2 = argument<1>();
actor<argument<2> > const _3 = argument<2>();
</pre>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> You can set <tt class="computeroutput">PHOENIX_ARG_LIMIT</tt>,
- the predefined maximum placeholder index. By default, <tt class="computeroutput">PHOENIX_ARG_LIMIT</tt> is set to <tt class="computeroutput">PHOENIX_LIMIT</tt> (See Actors).</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ You can set <tt class="computeroutput">PHOENIX_ARG_LIMIT</tt>,
+ the predefined maximum placeholder index. By default, <tt class="computeroutput">PHOENIX_ARG_LIMIT</tt>
+ is set to <tt class="computeroutput">PHOENIX_LIMIT</tt>
+ (See Actors).
+ </td></tr>
</table></div>
<a name="phoenix.primitives.arguments.user_defined_arguments"></a><h2>
-<a name="id450741"></a>
- User Defined Arguments
+<a name="id464241"></a>
+ <a href="primitives.html#phoenix.primitives.arguments.user_defined_arguments">User
+ Defined Arguments</a>
 </h2>

 When appropriate, you can define your own <tt class="computeroutput">argument<N></tt>
@@ -109,8 +120,9 @@
add(arg1, 6)
</pre>
<a name="phoenix.primitives.arguments.evaluating_an_argument"></a><h2>
-<a name="id450940"></a>
- Evaluating an Argument
+<a name="id464459"></a>
+ <a href="primitives.html#phoenix.primitives.arguments.evaluating_an_argument">Evaluating
+ an Argument</a>
 </h2>

 An argument, when evaluated, selects the Nth argument from the those passed
@@ -137,8 +149,8 @@
Hello World
</pre>
<a name="phoenix.primitives.arguments.extra_arguments"></a><h2>
-<a name="id451295"></a>
- Extra Arguments
+<a name="id464831"></a>
+ Extra Arguments
 </h2>

 In C and C++, a function can have extra arguments that are not at all used
@@ -172,17 +184,22 @@
 takes in the first argument (<tt class="computeroutput">arg1</tt>)
 and the fifth argument (<tt class="computeroutput">arg5</tt>).
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> There are a few reasons why enforcing strict arity
- is not desireable. A case in point is the callback function. Typical
- callback functions provide more information than is actually needed.
- Lambda functions are often used as callbacks.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ There are a few reasons why enforcing strict arity is not desireable. A
+ case in point is the callback function. Typical callback functions provide
+ more information than is actually needed. Lambda functions are often used
+ as callbacks.
+ </td></tr>
</table></div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.primitives.values"></a>Values</h3></div></div></div>
+<a name="phoenix.primitives.values"></a>Values</h3></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/core/value.hpp>
</pre>
@@ -190,7 +207,7 @@
 Whenever we see a constant in a partially applied function, an
 
<pre class="programlisting">
-actor<value<T> >
+actor<value<T> >
</pre>

 (where T is the type of the constant) is automatically created for us. For
@@ -201,22 +218,23 @@
</pre>

 Passing a second argument, <tt class="computeroutput">6</tt>,
- an <tt class="computeroutput">actor<value<int> ></tt> is implicitly created behind the scenes.
- This is also equivalent to:
+ an <tt class="computeroutput">actor<value<int> ></tt>
+ is implicitly created behind the scenes. This is also equivalent to:
 
<pre class="programlisting">
add(arg1, val(6))
</pre>

 <tt class="computeroutput">val(x)</tt> generates
- an <tt class="computeroutput">actor<value<T> ></tt> where <tt class="computeroutput">T</tt>
+ an <tt class="computeroutput">actor<value<T> ></tt> where <tt class="computeroutput">T</tt>
 is the type of <tt class="computeroutput">x</tt>. In most
 cases, there's no need to explicitly use <tt class="computeroutput">val</tt>,
 but, as we'll see later on, there are situations where this is unavoidable.
 
<a name="phoenix.primitives.values.evaluating_a_value"></a><h2>
-<a name="id452041"></a>
- Evaluating a Value
+<a name="id465592"></a>
+ <a href="primitives.html#phoenix.primitives.values.evaluating_a_value">Evaluating a
+ Value</a>
 </h2>

 Like arguments, values are also actors. As such, values can be evaluated.
@@ -231,7 +249,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.primitives.references"></a>References</h3></div></div></div>
+<a name="phoenix.primitives.references"></a>References</h3></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/core/reference.hpp>
</pre>
@@ -260,19 +278,24 @@
actor<reference<T> >
</pre>

- This is similar to <tt class="computeroutput">actor<value<T> ></tt> above but instead holds a reference to
- a variable.
+ This is similar to <tt class="computeroutput">actor<value<T>
+ ></tt> above but instead holds a reference
+ to a variable.
 

- We normally don't instantiate <tt class="computeroutput">actor<reference<T> ></tt> objects directly. Instead we use <tt class="computeroutput">ref</tt>. For example (where <tt class="computeroutput">i</tt>
- is an <tt class="computeroutput">int</tt> variable):
+ We normally don't instantiate <tt class="computeroutput">actor<reference<T>
+ ></tt> objects directly. Instead we
+ use <tt class="computeroutput">ref</tt>. For example (where
+ <tt class="computeroutput">i</tt> is an <tt class="computeroutput">int</tt>
+ variable):
 
<pre class="programlisting">
add_assign(ref(i), 2)
</pre>
<a name="phoenix.primitives.references.evaluating_a_reference"></a><h2>
-<a name="id452625"></a>
- Evaluating a Reference
+<a name="id466212"></a>
+ <a href="primitives.html#phoenix.primitives.references.evaluating_a_reference">Evaluating
+ a Reference</a>
 </h2>

 References are actors. Hence, references can be evaluated. Such invocation
@@ -289,21 +312,22 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.primitives.constant_references"></a>Constant References</h3></div></div></div>
+<a name="phoenix.primitives.constant_references"></a>Constant References</h3></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/core/reference.hpp>
</pre>

 Another free function <tt class="computeroutput">cref(cv)</tt>
 may also be used. <tt class="computeroutput">cref(cv)</tt> creates
- an <tt class="computeroutput">actor<reference<T const&> ></tt>
- object. This is similar to <tt class="computeroutput">actor<value<T> ></tt> but when the data to be passed as argument
- to a function is heavy and expensive to copy by value, the <tt class="computeroutput">cref(cv)</tt> offers a lighter alternative.
+ an <tt class="computeroutput">actor<reference<T const&> ></tt>
+ object. This is similar to <tt class="computeroutput">actor<value<T>
+ ></tt> but when the data to be passed
+ as argument to a function is heavy and expensive to copy by value, the <tt class="computeroutput">cref(cv)</tt> offers a lighter alternative.
 
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.primitives.nothing"></a>Nothing</h3></div></div></div>
+<a name="phoenix.primitives.nothing"></a>Nothing</h3></div></div></div>
<pre class="programlisting">
#include <boost/spirit/phoenix/core/nothing.hpp>
</pre>
@@ -318,12 +342,16 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="actors.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="composite.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="actors.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="composite.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/references.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/references.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/references.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,28 +2,28 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>References</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="prev" href="acknowledgement.html" title="Acknowledgement">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="acknowledgement.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a>
+<a accesskey="p" href="acknowledgement.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.references"></a>References</h2></div></div></div>
+<a name="phoenix.references"></a>References</h2></div></div></div>
<div class="orderedlist"><ol type="1">
<li>
Why Functional Programming Matters, John Hughes, 1989. Available online at
@@ -75,12 +75,16 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="acknowledgement.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a>
+<a accesskey="p" href="acknowledgement.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/starter_kit.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/starter_kit.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/starter_kit.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Starter Kit</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,21 +10,21 @@
<link rel="next" href="basics.html" title="Basics">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="introduction.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="basics.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="introduction.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="basics.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.starter_kit"></a>Starter Kit</h2></div></div></div>
+<a name="phoenix.starter_kit"></a>Starter Kit</h2></div></div></div>
<div class="toc"><dl>
<dt>Values</dt>
<dt>References</dt>
@@ -32,7 +32,8 @@
<dt>Composites</dt>
<dt>Lazy Operators</dt>
<dt>Lazy Statements</dt>
-<dt>Construct, New, Delete, Casts</dt>
+<dt><a href="starter_kit.html#phoenix.starter_kit.construct__new__delete__casts">Construct,
+ New, Delete, Casts</a></dt>
<dt>Lazy Functions</dt>
<dt>More</dt>
</dl></div>
@@ -58,23 +59,27 @@
 into high gear quickly.
 
<a name="phoenix.starter_kit.functors_everywhere"></a><h2>
-<a name="id373131"></a>
- Functors everywhere
+<a name="id386325"></a>
+ Functors everywhere
 </h2>

 Phoenix is built on function objects (functors). The functor is the main building
 block. We compose functors to build more complex functors... to build more
 complex functors... and so on. Almost everything is a functor.
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> Functors are so ubiquitous in Phoenix that, in the
- manual, the words "functor" and "function"
- are used interchangeably.</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ Functors are so ubiquitous in Phoenix that, in the manual, the words "functor"
+ and "function" are used interchangeably.
+ </td></tr>
</table></div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.starter_kit.values"></a>Values</h3></div></div></div>
+<a name="phoenix.starter_kit.values"></a>Values</h3></div></div></div>

 Values are functions! Examples:
 
@@ -85,12 +90,12 @@

 The first evaluates to a nullary function (a function taking no arguments)
 that returns an <tt class="computeroutput">int</tt>, <tt class="computeroutput">3</tt>. The second evaluates to a nullary function
- that returns a <tt class="computeroutput">char const(&)[13]</tt>, <tt class="computeroutput">"Hello,
+ that returns a <tt class="computeroutput">char const(&)[13]</tt>, <tt class="computeroutput">"Hello,
 World"</tt>.
 
<a name="phoenix.starter_kit.values.lazy_evaluation"></a><h2>
-<a name="id373334"></a>
- Lazy Evaluation
+<a name="id386515"></a>
+ Lazy Evaluation
 </h2>

 Confused? <tt class="computeroutput">val(3)</tt> is a unary
@@ -106,11 +111,9 @@

 (See values.cpp)
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> Learn more about values here.
-</td></tr></tbody>
-</table></div>
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> Learn more about values here.
+ </div>

 The second function call (the one with no arguments) calls the nullary function
 which then returns <tt class="computeroutput">3</tt>. The need
@@ -121,8 +124,8 @@
 anything and defers the evaluation for later.
 
<a name="phoenix.starter_kit.values.callbacks"></a><h2>
-<a name="id372414"></a>
- Callbacks
+<a name="id456078"></a>
+ Callbacks
 </h2>

 It may not be immediately apparent how lazy evaluation can be useful by just
@@ -151,7 +154,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.starter_kit.references"></a>References</h3></div></div></div>
+<a name="phoenix.starter_kit.references"></a>References</h3></div></div></div>

 References are functions. They hold a reference to a value stored somehere.
 For example, given:
@@ -172,20 +175,19 @@

 Like <tt class="computeroutput">val</tt>, the expressions
 above evaluates to a nullary function; the first one returning an <tt class="computeroutput">int&</tt>,
- and the second one returning a <tt class="computeroutput">char const*&</tt>.
+ and the second one returning a <tt class="computeroutput">char
+ const*&</tt>.
 

 (See references.cpp)
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> Learn more about references here.
-</td></tr></tbody>
-</table></div>
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> Learn more about references here.
+ </div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.starter_kit.arguments"></a>Arguments</h3></div></div></div>
+<a name="phoenix.starter_kit.arguments"></a>Arguments</h3></div></div></div>

 Arguments are also functions? You bet!
 
@@ -214,15 +216,13 @@

 (See arguments.cpp)
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> Learn more about arguments here.
-</td></tr></tbody>
-</table></div>
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> Learn more about arguments here.
+ </div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.starter_kit.composites"></a>Composites</h3></div></div></div>
+<a name="phoenix.starter_kit.composites"></a>Composites</h3></div></div></div>

 What we have seen so far, are what are called primitives.
 You can think of primitives (such as values, references and arguments) as
@@ -236,7 +236,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.starter_kit.lazy_operators"></a>Lazy Operators</h3></div></div></div>
+<a name="phoenix.starter_kit.lazy_operators"></a>Lazy Operators</h3></div></div></div>

 You can use the usual set of operators to form composites. Examples:
 
@@ -247,15 +247,17 @@
ref(x) = arg1[arg2] // assuming arg1 is indexable and arg2 is a valid index
</pre>

- Note the expression: <tt class="computeroutput">3 * arg3</tt>.
- This expression is actually a short-hand equivalent to: <tt class="computeroutput">val(3) * arg3</tt>.
+ Note the expression: <tt class="computeroutput">3 *
+ arg3</tt>. This expression is actually
+ a short-hand equivalent to: <tt class="computeroutput">val(3)
+ * arg3</tt>.
 In most cases, like above, you can get away with it. But in some cases, you
 will have to explicitly wrap your values in <tt class="computeroutput">val</tt>.
 Rules of thumb:
 
<div class="itemizedlist"><ul type="disc">
<li>
- In a binary expression (e.g. <tt class="computeroutput">3 * arg3</tt>),
+ In a binary expression (e.g. <tt class="computeroutput">3 * arg3</tt>),
 at least one of the operands must be a phoenix primitive or composite.
 </li>
<li>
@@ -279,14 +281,13 @@
x[ref(i)] // illegal (x is not a phoenix primitive or composite)
ref(x[ref(i)]) // illegal (x is not a phoenix primitive or composite)
</pre>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> Learn more about operators here.
-</td></tr></tbody>
-</table></div>
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> Learn more about operators here.
+ </div>
<a name="phoenix.starter_kit.lazy_operators.first_practical_example"></a><h2>
-<a name="id444445"></a>
- First Practical Example
+<a name="id457730"></a>
+ <a href="starter_kit.html#phoenix.starter_kit.lazy_operators.first_practical_example">First
+ Practical Example</a>
 </h2>

 We've covered enough ground to present a real world example. We want to find
@@ -318,25 +319,26 @@
find_if(c.begin(), c.end(), arg1 % 2 == 1)
</pre>

- The expression <tt class="computeroutput">arg1 % 2 == 1</tt> automagically
- creates a functor with the expected behavior. In FP, this unnamed function
- is called a lambda function. Unlike the function pointer version, which is
- monomorphic (expects and works only with a fixed type int argument), the
- Phoenix version is fully polymorphic and works with any container (of ints,
- of longs, of bignum, etc.) as long as its elements can handle the <tt class="computeroutput">arg1 % 2 == 1</tt> expression.
+ The expression <tt class="computeroutput">arg1 %
+ 2 == 1</tt> automagically creates a functor with the
+ expected behavior. In FP, this unnamed function is called a lambda function.
+ Unlike the function pointer version, which is monomorphic (expects and works
+ only with a fixed type int argument), the Phoenix version is fully polymorphic
+ and works with any container (of ints, of longs, of bignum, etc.) as long
+ as its elements can handle the <tt class="computeroutput">arg1
+ % 2 == 1</tt> expression.
 

 (See find_if.cpp)
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> ...That's it, we're done.
- Well if you wish to know a little bit more, read on...</td></tr></tbody>
-</table></div>
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> ...That's it, we're done.
+ Well if you wish to know a little bit more, read on...
+ </div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.starter_kit.lazy_statements"></a>Lazy Statements</h3></div></div></div>
+<a name="phoenix.starter_kit.lazy_statements"></a>Lazy Statements</h3></div></div></div>

 Lazy statements? Sure. There are lazy versions of the C++ statements we all
 know and love. For example:
@@ -360,15 +362,15 @@

 (See if.cpp)
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> Learn more about statements here.
-</td></tr></tbody>
-</table></div>
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> Learn more about statements here.
+ </div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.starter_kit.construct__new__delete__casts"></a>Construct, New, Delete, Casts</h3></div></div></div>
+<a name="phoenix.starter_kit.construct__new__delete__casts"></a><a href="starter_kit.html#phoenix.starter_kit.construct__new__delete__casts" title="Construct,
+ New, Delete, Casts">Construct,
+ New, Delete, Casts</a></h3></div></div></div>

 You'll probably want to work with objects. There are lazy versions of constructor
 calls, <tt class="computeroutput">new</tt>, <tt class="computeroutput">delete</tt>
@@ -380,22 +382,23 @@
delete_(arg1) // deletes arg1 (assumed to be a pointer)
static_cast_<int*>(arg1) // static_cast's arg1 to an int*
</pre>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/note.png" alt="note"> Take note that, by convention, names that conflict
- with C++ reserved words are appended with a single trailing underscore
- <tt class="computeroutput">'_'</tt>
-</td></tr></tbody>
-</table></div>
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> Learn more about this here.
-</td></tr></tbody>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td colspan="2" align="left" valign="top">
+ Take note that, by convention, names that conflict with C++ reserved words
+ are appended with a single trailing underscore <tt class="computeroutput">'_'</tt>
+ </td></tr>
</table></div>
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> Learn more about this here.
+ </div>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.starter_kit.lazy_functions"></a>Lazy Functions</h3></div></div></div>
+<a name="phoenix.starter_kit.lazy_functions"></a>Lazy Functions</h3></div></div></div>

 As you write more lambda functions, you'll notice certain patterns that you
 wish to refactor as reusable functions. When you reach that point, you'll
@@ -412,23 +415,24 @@
struct is_odd_impl
{
 template <typename Arg>
- struct result
- {
- typedef bool type;
+ struct result
+ {
+ typedef bool type;
 };

 template <typename Arg>
 bool operator()(Arg arg1) const
- {
- return arg1 % 2 == 1;
+ {
+ return arg1 % 2 == 1;
 }
};

function<is_odd_impl> is_odd;
</pre>
<a name="phoenix.starter_kit.lazy_functions.things_to_note_"></a><h2>
-<a name="id445824"></a>
- Things to note:
+<a name="id459077"></a>
+ <a href="starter_kit.html#phoenix.starter_kit.lazy_functions.things_to_note_">Things
+ to note:</a>
 </h2>
<div class="itemizedlist"><ul type="disc">
<li>
@@ -461,8 +465,9 @@
 (See function.cpp)
 
<a name="phoenix.starter_kit.lazy_functions.predefined_lazy_functions"></a><h2>
-<a name="id446061"></a>
- Predefined Lazy Functions
+<a name="id459332"></a>
+ <a href="starter_kit.html#phoenix.starter_kit.lazy_functions.predefined_lazy_functions">Predefined
+ Lazy Functions</a>
 </h2>

 The library is chock full of STL savvy, predefined lazy functions covering
@@ -473,7 +478,7 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h3 class="title">
-<a name="phoenix.starter_kit.more"></a>More</h3></div></div></div>
+<a name="phoenix.starter_kit.more"></a>More</h3></div></div></div>

 As mentioned earlier, this chapter is not a thorough discourse of the library.
 It is meant only to cover enough ground to get you into high gear as quickly
@@ -482,22 +487,24 @@
 things (e.g. Bind vs. Lazy
 Functions).
 
-<div class="informaltable"><table class="table">
-<colgroup><col></colgroup>
-<tbody><tr><td class="blurb"> <img src="../images/tip.png" alt="tip"> ...If you still wish to
- learn more, the read on...
-</td></tr></tbody>
-</table></div>
+<div class="sidebar">
+ <img src="../images/tip.png" alt="tip"> ...If you still wish to learn
+ more, the read on...
+ </div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="introduction.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="basics.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="introduction.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="basics.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/html/phoenix/wrap_up.html
==============================================================================
--- trunk/libs/spirit/phoenix/doc/html/phoenix/wrap_up.html (original)
+++ trunk/libs/spirit/phoenix/doc/html/phoenix/wrap_up.html 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -2,7 +2,7 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Wrap Up</title>
-<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
@@ -10,21 +10,21 @@
<link rel="next" href="acknowledgement.html" title="Acknowledgement">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%">
+<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center">Home</td>
+<td align="center">Home</td>
<td align="center">Libraries</td>
-<td align="center">People</td>
-<td align="center">FAQ</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
<td align="center">More</td>
-</table>
+</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="inside_phoenix.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgement.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="inside_phoenix.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgement.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="phoenix.wrap_up"></a>Wrap Up</h2></div></div></div>
+<a name="phoenix.wrap_up"></a>Wrap Up</h2></div></div></div>

 Sooner or later more FP techniques become standard practice as people find
 the true value of this programming discipline outside the academe and into
@@ -37,15 +37,21 @@

 Let me quote Doug Gregor of Boost.org. About functional style programming libraries:
 
-<div class="blockquote"><blockquote class="blockquote">
- They're gaining acceptance, but are somewhat stunted by the ubiquitousness
- of broken compilers. The C++ community is moving deeper into the so-called
- "STL- style" programming paradigm, which brings many aspects of
- functional programming into the fold. Look at, for instance, the Spirit parser
- to see how such function objects can be used to build Yacc-like grammars
- with semantic actions that can build abstract syntax trees on the fly. This
- type of functional composition is gaining momentum.
- </blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+
+ 
+
+ They're gaining acceptance, but are somewhat stunted by the ubiquitousness
+ of broken compilers. The C++ community is moving deeper into the so-called
+ "STL- style" programming paradigm, which brings many aspects
+ of functional programming into the fold. Look at, for instance, the Spirit
+ parser to see how such function objects can be used to build Yacc-like
+ grammars with semantic actions that can build abstract syntax trees on
+ the fly. This type of functional composition is gaining momentum.
+ 
+
+ 
+</blockquote></div>

 Indeed. Phoenix is another attempt to introduce more FP techniques into the
 mainstream. Not only is it a tool that will make life easier for the programmer.
@@ -61,12 +67,16 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right">Copyright © 2002-2005 Joel
- de Guzman, Dan Marsden</td>
+<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
+ de Guzman, Dan Marsden
+ 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)
+ 
+</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="inside_phoenix.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgement.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="inside_phoenix.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgement.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Modified: trunk/libs/spirit/phoenix/doc/users_manual.qbk
==============================================================================
--- trunk/libs/spirit/phoenix/doc/users_manual.qbk (original)
+++ trunk/libs/spirit/phoenix/doc/users_manual.qbk 2008-07-11 06:07:15 EDT (Fri, 11 Jul 2008)
@@ -38,11 +38,11 @@

[section Preface]

-[:['Functional programming is so called because a program consists entirely of
-functions. The main program itself is written as a function which receives the
-program's input as its argument and delivers the program's output as its result.
-Typically the main function is defined in terms of other functions, which in
-turn are defined in terms of still more functions until at the bottom level the
+[:['Functional programming is so called because a program consists entirely of
+functions. The main program itself is written as a function which receives the
+program's input as its argument and delivers the program's output as its result.
+Typically the main function is defined in terms of other functions, which in
+turn are defined in terms of still more functions until at the bottom level the
functions are language primitives.]]

[:*John Hughes*-- /Why Functional Programming Matters/]
@@ -59,9 +59,9 @@
version, will probably be the last release of the library. Phoenix v2 will be
the basis of the Phoenix and __bll__ merger.

-Phoenix is a header only library. It is extremely modular by design. One can
-extract and use only a small subset of the full library, literally tearing the
-library into small pieces, without fear that the pieces won't work anymore. The
+Phoenix is a header only library. It is extremely modular by design. One can
+extract and use only a small subset of the full library, literally tearing the
+library into small pieces, without fear that the pieces won't work anymore. The
library is organized in highly independent modules and layers.

[h2 How to use this manual]
@@ -117,14 +117,14 @@
evaluation in C++. The focus is more on usefulness and practicality than purity,
elegance and strict adherence to FP principles.

-FP is a programming discipline that is not at all tied to a specific language.
-FP as a programming discipline can, in fact, be applied to many programming
-languages. In the realm of C++ for instance, we are seeing more FP techniques
-being applied. C++ is sufficiently rich to support at least some of the most
-important facets of FP. C++ is a multiparadigm programming language. It is not
-only procedural. It is not only object oriented. Beneath the core of the
-standard C++ library, a closer look into STL gives us a glimpse of FP already in
-place. It is obvious that the authors of STL know and practice FP. In the near
+FP is a programming discipline that is not at all tied to a specific language.
+FP as a programming discipline can, in fact, be applied to many programming
+languages. In the realm of C++ for instance, we are seeing more FP techniques
+being applied. C++ is sufficiently rich to support at least some of the most
+important facets of FP. C++ is a multiparadigm programming language. It is not
+only procedural. It is not only object oriented. Beneath the core of the
+standard C++ library, a closer look into STL gives us a glimpse of FP already in
+place. It is obvious that the authors of STL know and practice FP. In the near
future, we shall surely see more FP trickle down into the mainstream.

The truth is, most of the FP techniques can coexist quite well with the standard
@@ -136,30 +136,30 @@

[section Starter Kit]

-Most "quick starts" only get you a few blocks from where you are. From there,
-you are on your own. Yet, typically, you'd want to get to the next city. This
-starter kit shall be as minimal as possible, yet packed as much power as
+Most "quick starts" only get you a few blocks from where you are. From there,
+you are on your own. Yet, typically, you'd want to get to the next city. This
+starter kit shall be as minimal as possible, yet packed as much power as
possible.

-So you are busy and always on the go. You do not wish to spend a lot of time
-studying the library. You wish to be spared the details for later when you need
-it. For now, all you need to do is to get up to speed as quickly as possible and
+So you are busy and always on the go. You do not wish to spend a lot of time
+studying the library. You wish to be spared the details for later when you need
+it. For now, all you need to do is to get up to speed as quickly as possible and
start using the library. If this is the case, this is the right place to start.

-This chapter is by no means a thorough discourse of the library. For more
-information on Phoenix, please take some time to read the rest of the User's
-Guide. Yet, if you just want to use the library quickly, now, this chapter will
-probably suffice. Rather than taking you to the details of the library, we shall
-try to provide you with annotated exemplars instead. Hopefully, this will get
+This chapter is by no means a thorough discourse of the library. For more
+information on Phoenix, please take some time to read the rest of the User's
+Guide. Yet, if you just want to use the library quickly, now, this chapter will
+probably suffice. Rather than taking you to the details of the library, we shall
+try to provide you with annotated exemplars instead. Hopefully, this will get
you into high gear quickly.

[h2 Functors everywhere]

-Phoenix is built on function objects (functors). The functor is the main
-building block. We compose functors to build more complex functors... to build
-more complex functors... and so on. Almost everything is a functor.
+Phoenix is built on function objects (functors). The functor is the main
+building block. We compose functors to build more complex functors... to build
+more complex functors... and so on. Almost everything is a functor.

-[blurb __note__ Functors are so ubiquitous in Phoenix that, in the manual, the
+[note Functors are so ubiquitous in Phoenix that, in the manual, the
words /"functor"/ and /"function"/ are used interchangeably.]

[section Values]
@@ -169,15 +169,15 @@
 val(3)
 val("Hello, World")

-The first evaluates to a nullary function (a function taking no arguments) that
-returns an `int`, `3`. The second evaluates to a nullary function that returns
-a `char const(&)[13]`, `"Hello, World"`.
+The first evaluates to a nullary function (a function taking no arguments) that
+returns an `int`, `3`. The second evaluates to a nullary function that returns
+a `char const(&)[13]`, `"Hello, World"`.

[h2 Lazy Evaluation]

-Confused? `val(3)` is a unary function, you say? Yes it is. However, read
-carefully: /"evaluates to a nullary function"/. `val(3)` evaluates to (returns) a
-nullary function. Aha! `val(3)` returns a function! So, since `val(3)` returns a
+Confused? `val(3)` is a unary function, you say? Yes it is. However, read
+carefully: /"evaluates to a nullary function"/. `val(3)` evaluates to (returns) a
+nullary function. Aha! `val(3)` returns a function! So, since `val(3)` returns a
function, you can invoke it. Example:

 cout << val(3)() << endl;
@@ -186,19 +186,19 @@

[blurb __tip__ Learn more about values [link phoenix.primitives.values here.]]

-The second function call (the one with no arguments) calls the nullary function
-which then returns `3`. The need for a second function call is the reason why
-the function is said to be [*/Lazily Evaluated/]. The first call doesn't do
-anything. You need a second call to finally evaluate the thing. The first call
-lazily evaluates the function; i.e. doesn't do anything and defers the evaluation
+The second function call (the one with no arguments) calls the nullary function
+which then returns `3`. The need for a second function call is the reason why
+the function is said to be [*/Lazily Evaluated/]. The first call doesn't do
+anything. You need a second call to finally evaluate the thing. The first call
+lazily evaluates the function; i.e. doesn't do anything and defers the evaluation
for later.

[h2 Callbacks]

-It may not be immediately apparent how lazy evaluation can be useful by just
-looking at the example above. Putting the first and second function call in a
-single line is really not very useful. However, thinking of `val(3)` as a
-callback function (and in most cases they are actually used that way), will make
+It may not be immediately apparent how lazy evaluation can be useful by just
+looking at the example above. Putting the first and second function call in a
+single line is really not very useful. However, thinking of `val(3)` as a
+callback function (and in most cases they are actually used that way), will make
it clear. Example:

 template <typename F>
@@ -206,7 +206,7 @@
 {
 cout << f() << endl;
 }
-
+
 int
 main()
 {
@@ -230,8 +230,8 @@

 ref(i)
 ref(s)
-
-Like `val`, the expressions above evaluates to a nullary function; the first one
+
+Like `val`, the expressions above evaluates to a nullary function; the first one
returning an `int&`, and the second one returning a `char const*&`.

(See [@../../example/users_manual/references.cpp references.cpp])
@@ -243,10 +243,10 @@

Arguments are also functions? You bet!

-Until now, we have been dealing with expressions returning a nullary function.
-Arguments, on the other hand, evaluate to an N-ary function. An argument
-represents the Nth argument. There are a few predefined arguments arg1,
-arg2, arg3, arg4 and so on (and it's __bll__ counterparts: _1, _2, _3, _4 and so
+Until now, we have been dealing with expressions returning a nullary function.
+Arguments, on the other hand, evaluate to an N-ary function. An argument
+represents the Nth argument. There are a few predefined arguments arg1,
+arg2, arg3, arg4 and so on (and it's __bll__ counterparts: _1, _2, _3, _4 and so
on). Examples:

 arg1 // one-or-more argument function that returns its first argument
@@ -267,11 +267,11 @@
[endsect]
[section Composites]

-What we have seen so far, are what are called *primitives*. You can think of
+What we have seen so far, are what are called *primitives*. You can think of
primitives (such as values, references and arguments) as atoms.

-Things start to get interesting when we start /composing/ primitives to form
-*composites*. The composites can, in turn, be composed to form even more complex
+Things start to get interesting when we start /composing/ primitives to form
+*composites*. The composites can, in turn, be composed to form even more complex
composites.

[endsect]
@@ -284,25 +284,25 @@
 arg1 = arg2 + (3 * arg3)
 ref(x) = arg1[arg2] // assuming arg1 is indexable and arg2 is a valid index

-Note the expression: `3 * arg3`. This expression is actually a short-hand
-equivalent to: `val(3) * arg3`. In most cases, like above, you can get away with
-it. But in some cases, you will have to explicitly wrap your values in `val`.
-Rules of thumb:
+Note the expression: `3 * arg3`. This expression is actually a short-hand
+equivalent to: `val(3) * arg3`. In most cases, like above, you can get away with
+it. But in some cases, you will have to explicitly wrap your values in `val`.
+Rules of thumb:

-* In a binary expression (e.g. `3 * arg3`), at least one of the operands must be
+* In a binary expression (e.g. `3 * arg3`), at least one of the operands must be
 a phoenix primitive or composite.
-* In a unary expression (e.g. `arg1++`), the single operand must be a phoenix
+* In a unary expression (e.g. `arg1++`), the single operand must be a phoenix
 primitive or composite.
-
-If these basic rules are not followed, the result is either in error, or is
+
+If these basic rules are not followed, the result is either in error, or is
immediately evaluated. Some examples:

 ref(x) = 123 // lazy
 x = 123 // immediate
-
+
 ref(x)[0] // lazy
 x[0] // immediate
-
+
 ref(x)[ref(i)] // lazy
 ref(x)[i] // lazy (equivalent to ref(x)[val(i)])
 x[ref(i)] // illegal (x is not a phoenix primitive or composite)
@@ -312,9 +312,9 @@

[h2 First Practical Example]

-We've covered enough ground to present a real world example. We want to find the
-first odd number in an STL container. Normally we use a functor (function
-object) or a function pointer and pass that in to STL's `find_if` generic
+We've covered enough ground to present a real world example. We want to find the
+first odd number in an STL container. Normally we use a functor (function
+object) or a function pointer and pass that in to STL's `find_if` generic
function:

Write a function:
@@ -333,28 +333,28 @@

 find_if(c.begin(), c.end(), arg1 % 2 == 1)

-The expression `arg1 % 2 == 1` automagically creates a functor with the expected
-behavior. In FP, this unnamed function is called a lambda function. Unlike the
-function pointer version, which is monomorphic (expects and works only with a
-fixed type int argument), the Phoenix version is fully polymorphic and works
-with any container (of ints, of longs, of bignum, etc.) as long as its elements
+The expression `arg1 % 2 == 1` automagically creates a functor with the expected
+behavior. In FP, this unnamed function is called a lambda function. Unlike the
+function pointer version, which is monomorphic (expects and works only with a
+fixed type int argument), the Phoenix version is fully polymorphic and works
+with any container (of ints, of longs, of bignum, etc.) as long as its elements
can handle the `arg1 % 2 == 1` expression.

(See [@../../example/users_manual/find_if.cpp find_if.cpp])

-[blurb __tip__ ...[*That's it, we're done]. Well if you wish to know a little bit
+[blurb __tip__ ...[*That's it, we're done]. Well if you wish to know a little bit
more, read on...]

[endsect]
[section Lazy Statements]

-Lazy statements? Sure. There are lazy versions of the C++ statements we all know
+Lazy statements? Sure. There are lazy versions of the C++ statements we all know
and love. For example:

 if_(arg1 > 5)
 cout << arg1

-Say, for example, we wish to print all the elements that are greater than 5
+Say, for example, we wish to print all the elements that are greater than 5
(separated by a comma) in a vector. Here's how we write it:

 for_each(v.begin(), v.end(),
@@ -371,7 +371,7 @@
[endsect]
[section Construct, New, Delete, Casts]

-You'll probably want to work with objects. There are lazy versions of
+You'll probably want to work with objects. There are lazy versions of
constructor calls, `new`, `delete` and the suite of C++ casts. Examples:

 construct<std::string>(arg1, arg2) // constructs a std::string from arg1, arg2
@@ -379,7 +379,7 @@
 delete_(arg1) // deletes arg1 (assumed to be a pointer)
 static_cast_<int*>(arg1) // static_cast's arg1 to an int*

-[blurb __note__ Take note that, by convention, names that conflict with C++
+[note Take note that, by convention, names that conflict with C++
reserved words are appended with a single trailing underscore `'_'`]

[blurb __tip__ Learn more about this [link phoenix.composite.object here.]]
@@ -387,43 +387,43 @@
[endsect]
[section Lazy Functions]

-As you write more lambda functions, you'll notice certain patterns that you wish
-to refactor as reusable functions. When you reach that point, you'll wish that
-ordinary functions can co-exist with phoenix functions. Unfortunately, the
+As you write more lambda functions, you'll notice certain patterns that you wish
+to refactor as reusable functions. When you reach that point, you'll wish that
+ordinary functions can co-exist with phoenix functions. Unfortunately, the
/immediate/ nature of plain C++ functions make them incompatible.

-Lazy functions are your friends. The library provides a facility to make lazy
-functions. The code below is a rewrite of the `is_odd` function using the
+Lazy functions are your friends. The library provides a facility to make lazy
+functions. The code below is a rewrite of the `is_odd` function using the
facility:

 struct is_odd_impl
 {
 template <typename Arg>
- struct result
- {
- typedef bool type;
+ struct result
+ {
+ typedef bool type;
 };
-
+
 template <typename Arg>
 bool operator()(Arg arg1) const
- {
- return arg1 % 2 == 1;
+ {
+ return arg1 % 2 == 1;
 }
 };
-
+
 function<is_odd_impl> is_odd;

[h2 Things to note:]

-* `result` is a nested metafunction that reflects the return type of the
+* `result` is a nested metafunction that reflects the return type of the
 function (in this case, bool). This makes the function fully polymorphic:
 It can work with arbitrary `Arg` types.
-* There are as many Args in the `result` metafunction as in the actual
+* There are as many Args in the `result` metafunction as in the actual
 `operator()`.
* `is_odd_impl` implements the function.
* `is_odd`, an instance of `function<is_odd_impl>`, is the lazy function.

-Now, `is_odd` is a truly lazy function that we can use in conjunction with the
+Now, `is_odd` is a truly lazy function that we can use in conjunction with the
rest of phoenix. Example:

 find_if(c.begin(), c.end(), is_odd(arg1));
@@ -432,19 +432,19 @@

[h2 Predefined Lazy Functions]

-The library is chock full of STL savvy, predefined lazy functions covering the
-whole of the STL containers, iterators and algorithms. For example, there are lazy
-versions of container related operations such as assign, at, back, begin,
-pop_back, pop_front, push_back, push_front, etc. (See [link phoenix.container
+The library is chock full of STL savvy, predefined lazy functions covering the
+whole of the STL containers, iterators and algorithms. For example, there are lazy
+versions of container related operations such as assign, at, back, begin,
+pop_back, pop_front, push_back, push_front, etc. (See [link phoenix.container
Container]).

[endsect]
[section More]

-As mentioned earlier, this chapter is not a thorough discourse of the library.
-It is meant only to cover enough ground to get you into high gear as quickly as
-possible. Some advanced stuff is not discussed here (e.g. [link phoenix.composite.scope
-Scopes]); nor are features that provide alternative (short-hand) ways to do the
+As mentioned earlier, this chapter is not a thorough discourse of the library.
+It is meant only to cover enough ground to get you into high gear as quickly as
+possible. Some advanced stuff is not discussed here (e.g. [link phoenix.composite.scope
+Scopes]); nor are features that provide alternative (short-hand) ways to do the
same things (e.g. [link phoenix.composite.bind Bind] vs. Lazy Functions).

[blurb __tip__ ...*If you still wish to learn more, the read on...*]
@@ -457,38 +457,38 @@
[def __constant_n__ /n/]
[def __argument_n__ a/n/]

-Almost everything is a function in the Phoenix library that can be evaluated as
-`f(a1, a2, ..., __argument_n__)`, where __constant_n__ is the function's arity, or number of arguments that the
-function expects. Operators are also functions. For example, `a + b` is just a
-function with arity == 2 (or binary). `a + b` is the same as `add(a, b)`, `a + b
+Almost everything is a function in the Phoenix library that can be evaluated as
+`f(a1, a2, ..., __argument_n__)`, where __constant_n__ is the function's arity, or number of arguments that the
+function expects. Operators are also functions. For example, `a + b` is just a
+function with arity == 2 (or binary). `a + b` is the same as `add(a, b)`, `a + b
+ c` is the same as `add(add(a, b), c)`.

-[blurb __note__ Amusingly, functions may even return functions. We shall see
+[note Amusingly, functions may even return functions. We shall see
what this means in a short while.]

[h2 Partial Function Application]

-Think of a function as a black box. You pass arguments and it returns something
+Think of a function as a black box. You pass arguments and it returns something
back. The figure below depicts the typical scenario.

[$images/fbox.png]

-A fully evaluated function is one in which all the arguments are given. All
-functions in plain C++ are fully evaluated. When you call the `sin(x)` function,
-you have to pass a number x. The function will return a result in return: the
-sin of x. When you call the `add(x, y)` function, you have to pass two numbers x
-and y. The function will return the sum of the two numbers. The figure below is
+A fully evaluated function is one in which all the arguments are given. All
+functions in plain C++ are fully evaluated. When you call the `sin(x)` function,
+you have to pass a number x. The function will return a result in return: the
+sin of x. When you call the `add(x, y)` function, you have to pass two numbers x
+and y. The function will return the sum of the two numbers. The figure below is
a fully evaluated `add` function.

[$images/adder.png]

-A partially applied function, on the other hand, is one in which not all the
-arguments are supplied. If we are able to partially apply the function `add`
-above, we may pass only the first argument. In doing so, the function does not
-have all the required information it needs to perform its task to compute and
-return a result. What it returns instead is another function, a lambda function
---another black box. Unlike the original `add` function which has an arity of 2,
-the resulting lambda function has an arity of 1. Why? because we already
+A partially applied function, on the other hand, is one in which not all the
+arguments are supplied. If we are able to partially apply the function `add`
+above, we may pass only the first argument. In doing so, the function does not
+have all the required information it needs to perform its task to compute and
+return a result. What it returns instead is another function, a lambda function
+--another black box. Unlike the original `add` function which has an arity of 2,
+the resulting lambda function has an arity of 1. Why? because we already
supplied part of the input: `2`

[$images/add2.png]
@@ -500,14 +500,14 @@

[$images/add2_call.png]

-Obviously, partially applying the `add` function, as we see above, cannot be
-done directly in C++ where we are expected to supply all the arguments that a
-function expects. That's where the Phoenix library comes in. The library
+Obviously, partially applying the `add` function, as we see above, cannot be
+done directly in C++ where we are expected to supply all the arguments that a
+function expects. That's where the Phoenix library comes in. The library
provides the facilities to do partial function application.

[h2 STL and higher order functions]

-So, what's all the fuss? What makes partial function application so useful?
+So, what's all the fuss? What makes partial function application so useful?
Recall our original example in the [link phoenix.starter_kit previous section]:

 find_if(c.begin(), c.end(), arg1 % 2 == 1)
@@ -517,7 +517,7 @@
lambda function has an arity 1. It just so happens that `find_if` supplies the
unsupplied argument as it loops from `c.begin()` to `c.end()`.

-[blurb __note__ Higher order functions are functions which can take other
+[note Higher order functions are functions which can take other
functions as arguments, and may also return functions as results. Higher order
functions are functions that are treated like any other objects and can be used as
arguments and return values from functions.]
@@ -529,11 +529,11 @@
# Partial application
# Final evaluation

-The first stage is handled by a set of generator functions. These are your front
-ends (in the client's perspective). These generators create (through partial
-function application), higher order functions that can be passed on just like
-any other function pointer or function object. The second stage, the actual
-function call, can be invoked or executed anytime in the future, or not at all;
+The first stage is handled by a set of generator functions. These are your front
+ends (in the client's perspective). These generators create (through partial
+function application), higher order functions that can be passed on just like
+any other function pointer or function object. The second stage, the actual
+function call, can be invoked or executed anytime in the future, or not at all;
hence /"lazy"/.

If we look more closely, the first step involves partial function application:
@@ -554,8 +554,8 @@
 return first;
 }

-Again, typically, we, as clients, see only the first step. However, in this
-document and in the examples and tests provided, don't be surprised to see the
+Again, typically, we, as clients, see only the first step. However, in this
+document and in the examples and tests provided, don't be surprised to see the
first and second steps juxtaposed in order to illustrate the complete semantics
of Phoenix expressions. Examples:

@@ -568,23 +568,23 @@

[h2 Forwarding Function Problem]

-Usually, we, as clients, write the call-back functions while libraries (such as
-STL) provide the callee (e.g. `find_if`). In case the role is reversed, e.g.
-if you have to write an STL algorithm that takes in a predicate, or develop a
-GUI library that accepts event handlers, you have to be aware of a little known
-problem in C++ called the "__forwarding__".
+Usually, we, as clients, write the call-back functions while libraries (such as
+STL) provide the callee (e.g. `find_if`). In case the role is reversed, e.g.
+if you have to write an STL algorithm that takes in a predicate, or develop a
+GUI library that accepts event handlers, you have to be aware of a little known
+problem in C++ called the "__forwarding__".

Look again at the code above:

 (arg1 % 2 == 1)(x)

-Notice that, in the second-stage (the final evaluation), we used a variable `x`.
-Be aware that the second stage cannot accept non-const temporaries and literal
+Notice that, in the second-stage (the final evaluation), we used a variable `x`.
+Be aware that the second stage cannot accept non-const temporaries and literal
constants. Hence, this will fail:

 (arg1 % 2 == 1)(123) // Error!

-Disallowing non-const rvalues partially solves the "__forwarding__" but
+Disallowing non-const rvalues partially solves the "__forwarding__" but
prohibits code like above.

[h2 Polymorphic Functions]
@@ -597,10 +597,10 @@
 char const* w = " World";
 std::string r = add(arg1, arg2)(h, w);

-evaluates to `std::string("Hello World")`. The observant reader might notice
-that this function call in fact takes in heterogeneous arguments where `arg1` is
-of type `std::string` and `arg2` is of type `char const*`. `add` still works
-because the C++ standard library allows the expression `a + b` where `a` is a
+evaluates to `std::string("Hello World")`. The observant reader might notice
+that this function call in fact takes in heterogeneous arguments where `arg1` is
+of type `std::string` and `arg2` is of type `char const*`. `add` still works
+because the C++ standard library allows the expression `a + b` where `a` is a
`std::string` and `b` is a `char const*`.

[endsect]
@@ -608,27 +608,27 @@
[section Organization]

Care and attention to detail was given, painstakingly, to the design and
-implementation of Phoenix.
+implementation of Phoenix.

The library is organized in four layers:

[$images/organization.png]

-The modules are orthogonal, with no cyclic dependencies.
+The modules are orthogonal, with no cyclic dependencies.
Lower layers do not depend on higher layers. Modules in a layer do not depend on other modules in the same layer.
This means, for example, that Bind can be completely discarded if it is
not required; or one could perhaps take out Operator and Statement and just use Function,
which may be desireable in a pure FP application.

-The library has grown from the original Phoenix but still comprises only
-header files. There are no object files to link against.
+The library has grown from the original Phoenix but still comprises only
+header files. There are no object files to link against.

[h2 Core]

The lowest two layers comprise the core.

-The `Actor` is the main concept behind the library. Lazy functions are
-abstracted as actors. There are only 2
+The `Actor` is the main concept behind the library. Lazy functions are
+abstracted as actors. There are only 2
kinds of actors:

# Primitives
@@ -646,7 +646,7 @@
 [[Function] [Lazy functions support (e.g. `add`)]]
 [[Operator] [Lazy operators support (e.g. `+`)]]
 [[Statement] [Lazy statments (e.g. `if_`, `while_`)]]
- [[Object] [Lazy casts (e.g. `static_cast_`),
+ [[Object] [Lazy casts (e.g. `static_cast_`),
 object creation destruction (e.g.
 `new_`, `delete_`)]]
 [[Scope] [Support for scopes, local variables and lambda-lambda]]
@@ -673,17 +673,17 @@
 [[Algorithm] [`#include <boost/spirit/phoenix/algorithm.hpp>`]]
]

-[blurb __tip__ Finer grained include files are available per feature; see the
+[blurb __tip__ Finer grained include files are available per feature; see the
succeeding sections.]

[endsect]

[section Actors]

-The `Actor` is the main concept behind the library. Actors are function objects.
+The `Actor` is the main concept behind the library. Actors are function objects.
An actor can accept 0 to `PHOENIX_LIMIT` arguments.

-[blurb __note__ You can set `PHOENIX_LIMIT`, the predefined maximum arity an
+[note You can set `PHOENIX_LIMIT`, the predefined maximum arity an
actor can take. By default, `PHOENIX_LIMIT` is set to 10.]

Phoenix supplies an `actor` class template whose specializations
@@ -707,10 +707,10 @@
 //...
 };

-The actor class accepts the arguments through a set of function call operators
-for 0 to `PHOENIX_LIMIT` arities (Don't worry about the details, for now. Note, for example,
-that we skimp over the details regarding `return_type`). The arguments
-are then forwarded to the actor's `Eval` for evaluation.
+The actor class accepts the arguments through a set of function call operators
+for 0 to `PHOENIX_LIMIT` arities (Don't worry about the details, for now. Note, for example,
+that we skimp over the details regarding `return_type`). The arguments
+are then forwarded to the actor's `Eval` for evaluation.

[endsect]

@@ -729,13 +729,13 @@

 actor<argument<N> >

-to represent the Nth function argument. The argument placeholder acts as an
+to represent the Nth function argument. The argument placeholder acts as an
imaginary data-bin where a function argument will be placed.

[h2 Predefined Arguments]

-There are a few predefined instances of `actor<argument<N> >` named
-`arg1`..`argN`, and its __bll__ counterpart `_1`..`_N`. (where N is a predefined
+There are a few predefined instances of `actor<argument<N> >` named
+`arg1`..`argN`, and its __bll__ counterpart `_1`..`_N`. (where N is a predefined
maximum).

Here are some sample preset definitions of `arg1`..`argN`
@@ -750,7 +750,7 @@
 actor<argument<1> > const _2 = argument<1>();
 actor<argument<2> > const _3 = argument<2>();

-[blurb __note__ You can set `PHOENIX_ARG_LIMIT`, the predefined maximum
+[note You can set `PHOENIX_ARG_LIMIT`, the predefined maximum
placeholder index. By default, `PHOENIX_ARG_LIMIT` is set to `PHOENIX_LIMIT`
(See [link phoenix.actors Actors]).]

@@ -799,9 +799,9 @@

 add(arg1, arg2)

-We know now that partially applying this function results to a function that
-expects 2 arguments. However, the library is a bit more lenient and allows the
-caller to supply more arguments than is actually required. Thus, `add` actually
+We know now that partially applying this function results to a function that
+expects 2 arguments. However, the library is a bit more lenient and allows the
+caller to supply more arguments than is actually required. Thus, `add` actually
allows 2 /or more/ arguments. For instance, with:

 add(arg1, arg2)(x, y, z)
@@ -814,7 +814,7 @@
Here, arguments b, c, and d are ignored. The function `add` takes in the first
argument (`arg1`) and the fifth argument (`arg5`).

-[blurb __note__ There are a few reasons why enforcing strict arity is not
+[note There are a few reasons why enforcing strict arity is not
desireable. A case in point is the callback function. Typical callback functions
provide more information than is actually needed. Lambda functions are often
used as callbacks.]
@@ -827,25 +827,25 @@

Whenever we see a constant in a partially applied function, an

- actor<value<T> >
+ actor<value<T> >

-(where T is the type of the constant) is automatically created for
+(where T is the type of the constant) is automatically created for
us. For instance:

 add(arg1, 6)

-Passing a second argument, `6`, an `actor<value<int> >` is implicitly created
+Passing a second argument, `6`, an `actor<value<int> >` is implicitly created
behind the scenes. This is also equivalent to:

 add(arg1, val(6))

-`val(x)` generates an `actor<value<T> >` where `T` is the type of `x`. In most
+`val(x)` generates an `actor<value<T> >` where `T` is the type of `x`. In most
cases, there's no need to explicitly use `val`, but, as we'll see later on,
there are situations where this is unavoidable.

[h2 Evaluating a Value]

-Like arguments, values are also actors. As such, values can be evaluated.
+Like arguments, values are also actors. As such, values can be evaluated.
Invoking a value gives the value's identity. Example:

 cout << val(3)() << val("Hello World")();
@@ -858,8 +858,8 @@

 #include <boost/spirit/phoenix/core/reference.hpp>

-Values are immutable constants. Attempting to modify a value will result in a
-compile time error. When we want the function to modify the parameter, we use a
+Values are immutable constants. Attempting to modify a value will result in a
+compile time error. When we want the function to modify the parameter, we use a
reference instead. For instance, imagine a lazy function `add_assign`:

 void add_assign(T& x, T y) { x += y; } // pseudo code
@@ -869,24 +869,24 @@

 add_assign(1, 2) // error first argument is immutable

-In C++, we can pass in a reference to a variable as the first argument in our
-example above. Yet, by default, the library forces arguments passed to partially
-applied functions functions to be immutable values (see [link phoenix.primitives.values
+In C++, we can pass in a reference to a variable as the first argument in our
+example above. Yet, by default, the library forces arguments passed to partially
+applied functions functions to be immutable values (see [link phoenix.primitives.values
Values]). To achieve our intent, we use:

 actor<reference<T> >
-
-This is similar to `actor<value<T> >` above but instead holds a reference to a
+
+This is similar to `actor<value<T> >` above but instead holds a reference to a
variable.

-We normally don't instantiate `actor<reference<T> >` objects directly. Instead we
+We normally don't instantiate `actor<reference<T> >` objects directly. Instead we
use `ref`. For example (where `i` is an `int` variable):

 add_assign(ref(i), 2)

[h2 Evaluating a Reference]

-References are actors. Hence, references can be evaluated. Such invocation gives
+References are actors. Hence, references can be evaluated. Such invocation gives
the references's identity. Example:

 int i = 3;
@@ -900,9 +900,9 @@

 #include <boost/spirit/phoenix/core/reference.hpp>

-Another free function `cref(cv)` may also be used. `cref(cv)` creates an
-`actor<reference<T const&> >` object. This is similar to `actor<value<T> >` but
-when the data to be passed as argument to a function is heavy and expensive to
+Another free function `cref(cv)` may also be used. `cref(cv)` creates an
+`actor<reference<T const&> >` object. This is similar to `actor<value<T> >` but
+when the data to be passed as argument to a function is heavy and expensive to
copy by value, the `cref(cv)` offers a lighter alternative.

[endsect]
@@ -910,9 +910,9 @@

 #include <boost/spirit/phoenix/core/nothing.hpp>

-Finally, the `actor<null_actor>` does nothing; (a "bum", if you will :-).
-There's a sole `actor<null_actor>` instance named "nothing". This actor is
-actually useful in situations where we don't want to do anything. (See
+Finally, the `actor<null_actor>` does nothing; (a "bum", if you will :-).
+There's a sole `actor<null_actor>` instance named "nothing". This actor is
+actually useful in situations where we don't want to do anything. (See
[link phoenix.composite.statement.for__statement for_ Statement] for example).

[endsect]
@@ -921,23 +921,23 @@

[section Composite]

-Actors may be combined in a multitude of ways to form composites. Composites are
-actors that are composed of zero or more actors. Composition is hierarchical. An
-element of the composite can be a primitive or again another composite. The
-flexibility to arbitrarily compose hierarchical structures allows us to form
-intricate constructions that model complex functions, statements and
+Actors may be combined in a multitude of ways to form composites. Composites are
+actors that are composed of zero or more actors. Composition is hierarchical. An
+element of the composite can be a primitive or again another composite. The
+flexibility to arbitrarily compose hierarchical structures allows us to form
+intricate constructions that model complex functions, statements and
expressions.

-A composite is-a tuple of 0..N actors. N is the predefined maximum actors a
+A composite is-a tuple of 0..N actors. N is the predefined maximum actors a
composite can take.

-[blurb __note__ You can set `PHOENIX_COMPOSITE_LIMIT`, the predefined maximum
+[note You can set `PHOENIX_COMPOSITE_LIMIT`, the predefined maximum
actors a composite can take. By default, `PHOENIX_COMPOSITE_LIMIT` is set to
`PHOENIX_LIMIT` (See [link phoenix.actors Actors]).]

-As mentioned, each of the actors A0..AN can, in turn, be another composite,
-since a composite is itself an actor. This makes the composite a recursive
-structure. The actual evaluation is handled by a composite specific eval policy.
+As mentioned, each of the actors A0..AN can, in turn, be another composite,
+since a composite is itself an actor. This makes the composite a recursive
+structure. The actual evaluation is handled by a composite specific eval policy.

[section Function]

@@ -948,18 +948,18 @@
The function call looks familiar and feels the same as ordinary C++ functions.
However, unlike ordinary functions, the actual function execution is deferred.

-Unlike ordinary function pointers or functor objects that need to be explicitly bound through the bind function (see [link phoenix.composite.bind Bind]),
+Unlike ordinary function pointers or functor objects that need to be explicitly bound through the bind function (see [link phoenix.composite.bind Bind]),
the argument types of these functions are automatically lazily bound.

-In order to create a lazy function, we need to implement a model of the
+In order to create a lazy function, we need to implement a model of the
FunctionEval concept. For a function that takes `N` arguments, a model of FunctionEval must
provide:

* An `operator()` that implements that takes `N` arguments, and implements
the function logic.
* A nested metafunction `result<A1, ... AN>` that takes the types of the `N` arguments to
-the function and returns the result type of the function. (There is a special case for function
-objects that accept no arguments. Such nullary functors are only required to define a typedef
+the function and returns the result type of the function. (There is a special case for function
+objects that accept no arguments. Such nullary functors are only required to define a typedef
`result_type` that reflects the return type of its `operator()`).

For example, the following type implements the FunctionEval concept, in order to provide a
@@ -982,7 +982,7 @@

(See [@../../example/users_manual/factorial.cpp factorial.cpp])

-Having implemented the `factorial_impl` type, we can declare and instantiate a lazy
+Having implemented the `factorial_impl` type, we can declare and instantiate a lazy
`factorial` function this way:

 function<factorial_impl> factorial;
@@ -1006,8 +1006,8 @@

 function<factorial_impl> factorial(ftor);

-where ftor is an instance of factorial_impl (this is not necessary in this case
-as `factorial_impl` does not require any state).
+where ftor is an instance of factorial_impl (this is not necessary in this case
+as `factorial_impl` does not require any state).

[blurb __alert__ Take care though when using function objects with state because they are
often copied repeatedly, and state may change in one of the copies, rather than the
@@ -1027,7 +1027,7 @@
 1 / -arg1
 arg1 < 150

-We have seen the lazy operators in action (see [link phoenix.starter_kit
+We have seen the lazy operators in action (see [link phoenix.starter_kit
Quick Start]). Let's go back and examine them a little bit further:

 find_if(c.begin(), c.end(), arg1 % 2 == 1)
@@ -1057,8 +1057,8 @@

Operator expressions are lazily evaluated following four simple rules:

-# A binary operator, except `->*` will be lazily evaluated when
- /at least/ one of its operands is an actor object
+# A binary operator, except `->*` will be lazily evaluated when
+ /at least/ one of its operands is an actor object
 (see [link phoenix.actors actors]).
# Unary operators are lazily evaluted if their argument is an actor object.
# Operator `->*` is lazily evaluted if the left hand argument is an actor object.
@@ -1084,7 +1084,7 @@
Note that at least one operand of any operator must be a valid actor
for lazy evaluation to take effect. To force lazy evaluation of an
ordinary expression, we can use `ref(x)`, `val(x)` or `cref(x)` to
-transform an operand into a valid actor object (see [link phoenix.primitives primitives].
+transform an operand into a valid actor object (see [link phoenix.primitives primitives].
For example:

 1 << 3; // Immediately evaluated
@@ -1108,8 +1108,8 @@

 if_else(c, a, b)

-The ternary operator deserves special mention. Since C++ does not allow us to
-overload the conditional expression: `c ? a : b`, the if_else pseudo function is
+The ternary operator deserves special mention. Since C++ does not allow us to
+overload the conditional expression: `c ? a : b`, the if_else pseudo function is
provided for this purpose. The behavior is identical, albeit in a lazy manner.

[h3 Member pointer operator]
@@ -1148,13 +1148,13 @@

[table Include Files
 [[Operators] [File]]
- [[`-`, `+`, `++`, `--`, `+=`,
- `-=`, `*=`, `/=`, `%=`,
+ [[`-`, `+`, `++`, `--`, `+=`,
+ `-=`, `*=`, `/=`, `%=`,
 `*`, `/`, `%`] [`#include <boost/spirit/phoenix/operator/arithmetic.hpp>`]]
- [[`&=`, `|=`, `^=`, `<<=`,
- `>>=`, `&`, `|`, `^`, `<<`,
+ [[`&=`, `|=`, `^=`, `<<=`,
+ `>>=`, `&`, `|`, `^`, `<<`,
 `>>`] [`#include <boost/spirit/phoenix/operator/bitwise.hpp>`]]
- [[`==`, `!=`, `<`,
+ [[`==`, `!=`, `<`,
 `<=`, `>`, `>=`] [`#include <boost/spirit/phoenix/operator/comparison.hpp>`]]
 [[`<<`, `>>`] [`#include <boost/spirit/phoenix/operator/io.hpp>`]]
 [[`!`, &&, `||`] [`#include <boost/spirit/phoenix/operator/logical.hpp>`]]
@@ -1169,11 +1169,11 @@

[*/Lazy statements.../]

-The primitives and composite building blocks presented so far are sufficiently
+The primitives and composite building blocks presented so far are sufficiently
powerful to construct quite elaborate structures. We have presented lazy-
functions and lazy-operators. How about lazy-statements? First, an appetizer:

-Print all odd-numbered contents of an STL container using `std::for_each`
+Print all odd-numbered contents of an STL container using `std::for_each`
([@../../example/users_manual/all_odds.cpp all_odds.cpp]):

 for_each(c.begin(), c.end(),
@@ -1185,13 +1185,14 @@

Huh? Is that valid C++? Read on...

-Yes, it is valid C++. The sample code above is as close as you can get to the
-syntax of C++. This stylized C++ syntax differs from actual C++ code. First, the
-`if` has a trailing underscore. Second, the block uses square brackets instead
+Yes, it is valid C++. The sample code above is as close as you can get to the
+syntax of C++. This stylized C++ syntax differs from actual C++ code. First, the
+`if` has a trailing underscore. Second, the block uses square brackets instead
of the familiar curly braces {}.

-[blurb __note__ *C++ in C++?*\n\n
- In as much as __spirit__ attempts to mimic EBNF in C++,
+[note *C++ in C++?*
+
+ In as much as __spirit__ attempts to mimic EBNF in C++,
 Phoenix attempts to mimic C++ in C++!!!
]

@@ -1208,17 +1209,17 @@
 ....
 statement

-Basically, these are comma separated statements. Take note that unlike the C/C++
-semicolon, the comma is a separator put *in-between* statements. This is like
-Pascal's semicolon separator, rather than C/C++'s semicolon terminator. For
+Basically, these are comma separated statements. Take note that unlike the C/C++
+semicolon, the comma is a separator put *in-between* statements. This is like
+Pascal's semicolon separator, rather than C/C++'s semicolon terminator. For
example:

 statement,
 statement,
 statement, // ERROR!

-Is an error. The last statement should not have a comma. Block statements can be
-grouped using the parentheses. Again, the last statement in a group should not
+Is an error. The last statement should not have a comma. Block statements can be
+grouped using the parentheses. Again, the last statement in a group should not
have a trailing comma.

 statement,
@@ -1274,7 +1275,7 @@

Take note that `else` has a leading dot and a trailing underscore: `.else_`

-Example: This code prints out all the elements and appends `" > 5"`, `" == 5"`
+Example: This code prints out all the elements and appends `" > 5"`, `" == 5"`
or `" < 5"` depending on the element's actual value:

 for_each(c.begin(), c.end(),
@@ -1338,7 +1339,7 @@
 sequenced_statements
 ]

-Example: This code decrements each element until it reaches zero and prints out
+Example: This code decrements each element until it reaches zero and prints out
the number at each step. A newline terminates the printout of each value.

 for_each(c.begin(), c.end(),
@@ -1364,10 +1365,10 @@
 ]
 .while_(conditional_expression)

-Again, take note that `while` has a leading dot and a trailing underscore:
+Again, take note that `while` has a leading dot and a trailing underscore:
`.while_`

-Example: This code is almost the same as the previous example above with a
+Example: This code is almost the same as the previous example above with a
slight twist in logic.

 for_each(c.begin(), c.end(),
@@ -1393,13 +1394,13 @@
 sequenced_statements
 ]

-It is again very similar to the C++ for statement. Take note that the
-init_statement, conditional_expression and step_statement are separated by the
-comma instead of the semi-colon and each must be present (i.e. `for_(,,)` is
-invalid). This is a case where the [link phoenix.primitives.nothing nothing]
+It is again very similar to the C++ for statement. Take note that the
+init_statement, conditional_expression and step_statement are separated by the
+comma instead of the semi-colon and each must be present (i.e. `for_(,,)` is
+invalid). This is a case where the [link phoenix.primitives.nothing nothing]
actor can be useful.

-Example: This code prints each element N times where N is the element's value. A
+Example: This code prints each element N times where N is the element's value. A
newline terminates the printout of each value.

 int iii;
@@ -1413,11 +1414,11 @@
 )
 );

-As before, all these are lazily evaluated. The result of such statements are in
-fact composites that are passed on to STL's for_each function. In the viewpoint
+As before, all these are lazily evaluated. The result of such statements are in
+fact composites that are passed on to STL's for_each function. In the viewpoint
of `for_each`, what was passed is just a functor, no more, no less.

-[blurb __note__ Unlike lazy functions and lazy operators, lazy statements always
+[note Unlike lazy functions and lazy operators, lazy statements always
return void.]

[endsect]
@@ -1441,7 +1442,7 @@
 sequenced_statement
 ]

-Note the usual underscore after try and catch, and the extra parentheses required
+Note the usual underscore after try and catch, and the extra parentheses required
after the catch.

Example: The following code calls the (lazy) function `f` for each element, and
@@ -1508,8 +1509,8 @@

[section Object]

-The Object module deals with object construction, destruction and conversion.
-The module provides /"lazy"/ versions of C++'s object constructor, `new`,
+The Object module deals with object construction, destruction and conversion.
+The module provides /"lazy"/ versions of C++'s object constructor, `new`,
`delete`, `static_cast`, `dynamic_cast`, `const_cast` and `reinterpret_cast`.

[h2 Construction]
@@ -1522,8 +1523,8 @@

 construct<T>(ctor_arg1, ctor_arg2, ..., ctor_argN);

-where the given parameters are the parameters to the contructor of the object of
-type T (This implies, that type T is expected to have a constructor with a
+where the given parameters are the parameters to the contructor of the object of
+type T (This implies, that type T is expected to have a constructor with a
corresponding set of parameter types.).

Example:
@@ -1532,9 +1533,9 @@

Constructs a `std::string` from `arg1` and `arg2`.

-[blurb __note__ The maximum number of actual parameters is limited by the
-preprocessor constant PHOENIX_COMPOSITE_LIMIT. Note though, that this limit
-should not be greater than PHOENIX_LIMIT. By default, `PHOENIX_COMPOSITE_LIMIT`
+[note The maximum number of actual parameters is limited by the
+preprocessor constant PHOENIX_COMPOSITE_LIMIT. Note though, that this limit
+should not be greater than PHOENIX_LIMIT. By default, `PHOENIX_COMPOSITE_LIMIT`
is set to `PHOENIX_LIMIT` (See [link phoenix.actors Actors]).]

[h2 New]
@@ -1547,8 +1548,8 @@

 new_<T>(ctor_arg1, ctor_arg2, ..., ctor_argN);

-where the given parameters are the parameters to the contructor of the object of
-type T (This implies, that type T is expected to have a constructor with a
+where the given parameters are the parameters to the contructor of the object of
+type T (This implies, that type T is expected to have a constructor with a
corresponding set of parameter types.).

Example:
@@ -1557,7 +1558,7 @@

Creates a `std::string` from `arg1` and `arg2` on the heap.

-[blurb __note__ Again, the maximum number of actual parameters is limited by the
+[note Again, the maximum number of actual parameters is limited by the
preprocessor constant PHOENIX_COMPOSITE_LIMIT. See the note above.]

[h2 Delete]
@@ -1585,8 +1586,8 @@
 #include <boost/spirit/phoenix/object/const_cast.hpp>
 #include <boost/spirit/phoenix/object/reinterpret_cast.hpp>

-The set of lazy C++ cast template functions provide a way of lazily casting an
-object of a certain type to another type. The syntax resembles the well known
+The set of lazy C++ cast template functions provide a way of lazily casting an
+object of a certain type to another type. The syntax resembles the well known
C++ casts. Take note however that the lazy versions have a trailing underscore.

 static_cast_<T>(lambda_expression)
@@ -1604,17 +1605,17 @@

[section Scope]

-Up until now, the most basic ingredient is missing: creation of and access to
-local variables in the stack. When recursion comes into play, you will soon
-realize the need to have true local variables. It may seem that we do not need
-this at all since an unnamed lambda function cannot call itself anyway; at least
-not directly. With some sort of arrangement, situations will arise where a
-lambda function becomes recursive. A typical situation occurs when we store a
-lambda function in a [@http://www.boost.org/libs/function Boost.Function],
+Up until now, the most basic ingredient is missing: creation of and access to
+local variables in the stack. When recursion comes into play, you will soon
+realize the need to have true local variables. It may seem that we do not need
+this at all since an unnamed lambda function cannot call itself anyway; at least
+not directly. With some sort of arrangement, situations will arise where a
+lambda function becomes recursive. A typical situation occurs when we store a
+lambda function in a [@http://www.boost.org/libs/function Boost.Function],
essentially naming the unnamed lambda.

-There will also be situations where a lambda function gets passed as an argument
-to another function. This is a more common situation. In this case, the lambda
+There will also be situations where a lambda function gets passed as an argument
+to another function. This is a more common situation. In this case, the lambda
function assumes a new scope; new arguments and possibly new local variables.

This section deals with local variables and nested lambda scopes.
@@ -1627,8 +1628,8 @@

 actor<local_variable<Key> >

-to represent a local variable. The local variable acts as an imaginary data-bin
-where a local, stack based data will be placed. `Key` is an arbitrary type that
+to represent a local variable. The local variable acts as an imaginary data-bin
+where a local, stack based data will be placed. `Key` is an arbitrary type that
is used to identify the local variable. Example:

 struct size_key;
@@ -1636,8 +1637,8 @@

[h2 Predefined Local Variables]

-There are a few predefined instances of `actor<local_variable<Key> >`
-named `_a`..`_z` that you can already use. To make use of them, simply use the
+There are a few predefined instances of `actor<local_variable<Key> >`
+named `_a`..`_z` that you can already use. To make use of them, simply use the
`namespace boost::phoenix::local_names`:

 using namespace boost::phoenix::local_names;
@@ -1653,13 +1654,13 @@
 let-body
 ]

-`let` allows 1..N local variable declarations (where N ==
+`let` allows 1..N local variable declarations (where N ==
`PHOENIX_LOCAL_LIMIT`). Each declaration follows the form:

 local-id = lambda-expression

-[blurb __note__ You can set `PHOENIX_LOCAL_LIMIT`, the predefined maximum local
-variable declarations in a let expression. By default, `PHOENIX_LOCAL_LIMIT` is
+[note You can set `PHOENIX_LOCAL_LIMIT`, the predefined maximum local
+variable declarations in a let expression. By default, `PHOENIX_LOCAL_LIMIT` is
set to `PHOENIX_LIMIT`.]

Example:
@@ -1671,18 +1672,18 @@

[h2 Reference Preservation]

-The type of the local variable assumes the type of the lambda- expression. Type
+The type of the local variable assumes the type of the lambda- expression. Type
deduction is reference preserving. For example:

 let(_a = arg1, _b = 456)

-`_a` assumes the type of `arg1`: a reference to an argument, while `_b` has type
-`int`.
+`_a` assumes the type of `arg1`: a reference to an argument, while `_b` has type
+`int`.

Consider this:

 int i = 1;
-
+
 let(_a = arg1)
 [
 cout << --_a << ' '
@@ -1691,12 +1692,12 @@

 cout << i << endl;

-the output of above is : 0 0
+the output of above is : 0 0

While with this:

 int i = 1;
-
+
 let(_a = val(arg1))
 [
 cout << --_a << ' '
@@ -1705,16 +1706,16 @@

 cout << i << endl;

-the output is : 0 1
+the output is : 0 1

-Reference preservation is necessary because we need to have L-value access to
-outer lambda-scopes (especially the arguments). `arg`s and `ref`s are L-values.
+Reference preservation is necessary because we need to have L-value access to
+outer lambda-scopes (especially the arguments). `arg`s and `ref`s are L-values.
`val`s are R-values.

[h2 Visibility]

-The scope and lifetimes of the local variables is limited within the let-body.
-`let` blocks can be nested. A local variable may hide an outer local variable.
+The scope and lifetimes of the local variables is limited within the let-body.
+`let` blocks can be nested. A local variable may hide an outer local variable.
For example:

 let(_x = 1, _y = ", World")
@@ -1727,8 +1728,8 @@
 ]
 ]

-The RHS (right hand side lambda-expression) of each local-declaration cannot
-refer to any LHS local-id. At this point, the local-ids are not in scope yet;
+The RHS (right hand side lambda-expression) of each local-declaration cannot
+refer to any LHS local-id. At this point, the local-ids are not in scope yet;
they will only be in scope in the let-body. The code below is in error:

 let(
@@ -1760,8 +1761,8 @@

 #include <boost/spirit/phoenix/scope/lambda.hpp>

-A lot of times, you'd want to write a lazy function that accepts one or more
-functions (higher order functions). STL algorithms come to mind, for example.
+A lot of times, you'd want to write a lazy function that accepts one or more
+functions (higher order functions). STL algorithms come to mind, for example.
Consider a lazy version of `stl::for_each`:

 struct for_each_impl
@@ -1781,11 +1782,11 @@

 function<for_each_impl> const for_each = for_each_impl();

-Notice that the function accepts another function, `f` as an argument. The scope
-of this function, `f`, is limited within the `operator()`. When `f` is called
-inside `std::for_each`, it exists in a new scope, along with new arguments and,
-possibly, local variables. This new scope is not at all related to the outer
-scopes beyond the `operator()`.
+Notice that the function accepts another function, `f` as an argument. The scope
+of this function, `f`, is limited within the `operator()`. When `f` is called
+inside `std::for_each`, it exists in a new scope, along with new arguments and,
+possibly, local variables. This new scope is not at all related to the outer
+scopes beyond the `operator()`.

Simple syntax:

@@ -1794,7 +1795,7 @@
 lambda-body
 ]

-Like `let`, local variables may be declared, allowing 1..N local variable
+Like `let`, local variables may be declared, allowing 1..N local variable
declarations (where N == `PHOENIX_LOCAL_LIMIT`):

 lambda(local-declarations)
@@ -1802,9 +1803,9 @@
 lambda-body
 ]

-The same restrictions apply with regard to scope and visibility. The RHS
-(right hand side lambda-expression) of each local-declaration cannot refer
-to any LHS local-id. The local-ids are not in scope yet; they will be in
+The same restrictions apply with regard to scope and visibility. The RHS
+(right hand side lambda-expression) of each local-declaration cannot refer
+to any LHS local-id. The local-ids are not in scope yet; they will be in
scope only in the lambda-body:

 lambda(
@@ -1818,18 +1819,18 @@

 for_each(arg1, lambda[cout << arg1])

-As far as the arguments are concerned (arg1..argN), the scope in which the
-lambda-body exists is totally new. The left `arg1` refers to the argument passed
-to `for_each` (a container). The right `arg1` refers to the argument passed by
-`std::for_each` when we finally get to call `operator()` in our `for_each_impl`
+As far as the arguments are concerned (arg1..argN), the scope in which the
+lambda-body exists is totally new. The left `arg1` refers to the argument passed
+to `for_each` (a container). The right `arg1` refers to the argument passed by
+`std::for_each` when we finally get to call `operator()` in our `for_each_impl`
above (a container element).

-Yet, we may wish to get information from outer scopes. While we do not have
-access to arguments in outer scopes, what we still have is access to local
-variables from outer scopes. We may only be able to pass argument related
-information from outer `lambda` scopes through the local variables.
+Yet, we may wish to get information from outer scopes. While we do not have
+access to arguments in outer scopes, what we still have is access to local
+variables from outer scopes. We may only be able to pass argument related
+information from outer `lambda` scopes through the local variables.

-[blurb __note__ This is a crucial difference between `let` and `lambda`: `let`
+[note This is a crucial difference between `let` and `lambda`: `let`
does not introduce new arguments; `lambda` does.]

Another example: Using our lazy `for_each`, and a lazy `push_back`:
@@ -1860,16 +1861,16 @@

Solution:

- for_each(arg1,
+ for_each(arg1,
 lambda(_a = arg2)
 [
 push_back(arg1, _a)
 ]
 )

-Since we do not have access to the arguments of the outer scopes beyond the
-lambda-body, we introduce a local variable `_a` that captures the second outer
-argument: `arg2`. Hence: _a = arg2. This local variable is visible inside the
+Since we do not have access to the arguments of the outer scopes beyond the
+lambda-body, we introduce a local variable `_a` that captures the second outer
+argument: `arg2`. Hence: _a = arg2. This local variable is visible inside the
lambda scope.

(See [@../../example/users_manual/lambda.cpp lambda.cpp])
@@ -1878,20 +1879,20 @@

[section Bind]

-['Binding] is the act of tying together a function to some arguments for
-deferred (lazy) evaluation. Named [link phoenix.composite.function Lazy functions]
-require a bit of typing. Unlike (unnamed) lambda expressions, we need to write a
-functor somewhere offline, detached from the call site. If you wish to transform a
-plain function, member function or member variable to a lambda expression, `bind`
-is your friend.
-
-[blurb __note__ Take note that binders are monomorphic. Rather than binding
-functions, the preferred way is to write true generic and polymorphic [link
-phoenix.composite.function lazy-functions]. However, since most of the time we
+['Binding] is the act of tying together a function to some arguments for
+deferred (lazy) evaluation. Named [link phoenix.composite.function Lazy functions]
+require a bit of typing. Unlike (unnamed) lambda expressions, we need to write a
+functor somewhere offline, detached from the call site. If you wish to transform a
+plain function, member function or member variable to a lambda expression, `bind`
+is your friend.
+
+[note Take note that binders are monomorphic. Rather than binding
+functions, the preferred way is to write true generic and polymorphic [link
+phoenix.composite.function lazy-functions]. However, since most of the time we
are dealing with adaptation of exisiting code, binders get the job done faster.]

-There is a set of overloaded `bind` template functions. Each `bind(x)`
-function generates a suitable binder object, a [link phoenix.composite
+There is a set of overloaded `bind` template functions. Each `bind(x)`
+function generates a suitable binder object, a [link phoenix.composite
composite].

[h2 Binding Functions]
@@ -1900,17 +1901,17 @@

Example, given a function `foo`:

- void foo(int n)
- {
- std::cout << n << std::endl;
+ void foo(int n)
+ {
+ std::cout << n << std::endl;
 }

Here's how the function `foo` may be bound:

 bind(&foo, arg1)

-This is now a full-fledged [link phoenix.composite composite] that can finally
-be evaluated by another function call invocation. A second function call will
+This is now a full-fledged [link phoenix.composite composite] that can finally
+be evaluated by another function call invocation. A second function call will
invoke the actual `foo` function. Example:

 int i = 4;
@@ -1922,20 +1923,20 @@

 #include <boost/spirit/phoenix/bind/bind_member_function.hpp>

-Binding member functions can be done similarly. A bound member function takes in
+Binding member functions can be done similarly. A bound member function takes in
a pointer or reference to an object as the first argument. For instance, given:

- struct xyz
- {
- void foo(int) const;
+ struct xyz
+ {
+ void foo(int) const;
 };

`xyz`'s `foo` member function can be bound as:

 bind(&xyz::foo, obj, arg1) // obj is an xyz object

-Take note that a lazy-member functions expects the first argument to be a
-pointer or reference to an object. Both the object (reference or pointer) and
+Take note that a lazy-member functions expects the first argument to be a
+pointer or reference to an object. Both the object (reference or pointer) and
the arguments can be lazily bound. Examples:

 xyz obj;
@@ -1947,29 +1948,29 @@

 #include <boost/spirit/phoenix/bind/bind_member_variable.hpp>

-Member variables can also be bound much like member functions. Member variables
-are not functions. Yet, like the [link phoenix.primitives.references `ref(x)`] that
-acts like a nullary function returning a reference to the data, member variables,
-when bound, act like a unary function, taking in a pointer or reference to an
-object as its argument and returning a reference to the bound member variable.
+Member variables can also be bound much like member functions. Member variables
+are not functions. Yet, like the [link phoenix.primitives.references `ref(x)`] that
+acts like a nullary function returning a reference to the data, member variables,
+when bound, act like a unary function, taking in a pointer or reference to an
+object as its argument and returning a reference to the bound member variable.
For instance, given:

- struct xyz
- {
- int v;
+ struct xyz
+ {
+ int v;
 };

`xyz::v` can be bound as:

 bind(&xyz::v, obj) // obj is an xyz object

-As noted, just like the bound member function, a bound member variable also
-expects the first (and only) argument to be a pointer or reference to an object.
+As noted, just like the bound member function, a bound member variable also
+expects the first (and only) argument to be a pointer or reference to an object.
The object (reference or pointer) can be lazily bound. Examples:

 xyz obj;
- bind(&xyz::v, arg1) // arg1.v
- bind(&xyz::v, obj) // obj.v
+ bind(&xyz::v, arg1) // arg1.v
+ bind(&xyz::v, obj) // obj.v
 bind(&xyz::v, arg1)(obj) = 4 // obj.v = 4

[endsect]
@@ -1979,13 +1980,13 @@

 #include <boost/spirit/phoenix/container.hpp>

-The container module predefines a set of lazy functions that work on STL
-containers. These functions provide a mechanism for the lazy evaluation of the
-public member functions of the STL containers. The lazy functions are thin
-wrappers that simply forward to their respective counterparts in the STL
-library.
+The container module predefines a set of lazy functions that work on STL
+containers. These functions provide a mechanism for the lazy evaluation of the
+public member functions of the STL containers. The lazy functions are thin
+wrappers that simply forward to their respective counterparts in the STL
+library.

-Lazy functions are provided for all of the member functions of the following
+Lazy functions are provided for all of the member functions of the following
containers:

* deque
@@ -1994,8 +1995,8 @@
* multimap
* vector

-Indeed, should your class have member functions with the same names and
-signatures as those listed below, then it will automatically be supported. To
+Indeed, should your class have member functions with the same names and
+signatures as those listed below, then it will automatically be supported. To
summarize, lazy functions are provided for member functions:

* assign
@@ -2024,8 +2025,8 @@
* splice
* value_comp

-The lazy functions' names are the same as the corresponding member function. The
-difference is that the lazy functions are free functions and therefore does not
+The lazy functions' names are the same as the corresponding member function. The
+difference is that the lazy functions are free functions and therefore does not
use the member "dot" syntax.

[table Sample usage
@@ -2035,11 +2036,11 @@
 [[`my_vector1.swap(my_vector2)`] [`swap(arg1, arg2)`]]
]

-Notice that member functions with names that clash with stl algorithms are
+Notice that member functions with names that clash with stl algorithms are
absent. This will be provided in Phoenix's algorithm module.

-No support is provided here for lazy versions of `operator+=`, `operator[]` etc.
-Such operators are not specific to STL containers and lazy versions can
+No support is provided here for lazy versions of `operator+=`, `operator[]` etc.
+Such operators are not specific to STL containers and lazy versions can
therefore be found in [link phoenix.composite.operator operators].

The following table describes the container functions and their semantics.
@@ -2082,7 +2083,7 @@

 #include <boost/spirit/phoenix/algorithm.hpp>

-The algorithm module provides wrappers for the standard algorithms in the
+The algorithm module provides wrappers for the standard algorithms in the
`<algorithm>` and `<numeric>` headers.

The algorithms are divided into the categories iteration, transformation and querying,
@@ -2093,26 +2094,26 @@
 #include <boost/spirit/phoenix/stl/algorithm/transformation.hpp>
 #include <boost/spirit/phoenix/stl/algorithm/querying.hpp>

-The functions of the algorithm module take ranges as arguments where
-appropriate. This is different to the standard
-library, but easy enough to pick up. Ranges are described in detail in the
+The functions of the algorithm module take ranges as arguments where
+appropriate. This is different to the standard
+library, but easy enough to pick up. Ranges are described in detail in the
__boost_range__ library.

For example, using the standard copy algorithm to copy between 2 arrays:

 int array[] = {1, 2, 3};
 int output[3];
- std::copy(array, array + 3, output); // We have to provide iterators
+ std::copy(array, array + 3, output); // We have to provide iterators
 // to both the start and end of array

The analogous code using the phoenix algorithm module is:

 int array[] = {1, 2, 3};
 int output[3];
- copy(arg1, arg2)(array, output); // Notice only 2 arguments, the end of
+ copy(arg1, arg2)(array, output); // Notice only 2 arguments, the end of
 // array is established automatically

-The __boost_range__ library provides support for standard containers, strings and
+The __boost_range__ library provides support for standard containers, strings and
arrays, and can be extended to support additional types.

The following tables describe the different categories of algorithms, and their
@@ -2208,25 +2209,25 @@
[def __eval_tuple__ [link phoenix.inside_phoenix.composites_in_detail.evaltuple `EvalTuple`]]
[def __environment__ [link phoenix.inside_phoenix.actors_in_detail.environment `Environment`]]

-This chapter explains in more detail how the library operates. The information
-henceforth should not be necessary to those who are interested in just using the
-library. However, a microscopic view might prove to be beneficial to moderate
+This chapter explains in more detail how the library operates. The information
+henceforth should not be necessary to those who are interested in just using the
+library. However, a microscopic view might prove to be beneficial to moderate
to advanced programmers who wish to extend the library.

[section Actors In Detail]

[h3 Actor Concept]

-The main concept is the `Actor`. Actors are function objects (that can accept 0
+The main concept is the `Actor`. Actors are function objects (that can accept 0
to N arguments (where N is a predefined maximum).

-[blurb __note__ You can set `PHOENIX_LIMIT`, the predefined maximum arity an
+[note You can set `PHOENIX_LIMIT`, the predefined maximum arity an
actor can take. By default, `PHOENIX_LIMIT` is set to 10.]

[h3 actor template class]

The `actor` template class models the `Actor` concept:
-
+
 template <typename Eval>
 struct actor : Eval
 {
@@ -2240,7 +2241,7 @@

 template <typename T0, typename T1>
 actor(T0 const& _0, T1 const& _1);
-
+
 // more constructors

 typename apply_actor<eval_type, basic_environment<> >::type
@@ -2268,10 +2269,10 @@

[h3 Eval Concept]

-The `actor` template class has a single template parameter, `Eval`, from which
-it derives from. While the `Actor` concept represents a function, the `Eval`
-concept represents the function body. The requirements for `Eval` are
-intentionally kept simple, to make it easy to write models of the concept. We
+The `actor` template class has a single template parameter, `Eval`, from which
+it derives from. While the `Actor` concept represents a function, the `Eval`
+concept represents the function body. The requirements for `Eval` are
+intentionally kept simple, to make it easy to write models of the concept. We
shall see an example in the [link phoenix.inside_phoenix.actor_example next section].

[table Eval Concept Requirements
@@ -2282,44 +2283,46 @@

[h3 Constructors]

-In addition to a default constructor and an constructor from a Eval object,
-there are templated (pass through) constructors for 1 to N arguments (N ==
+In addition to a default constructor and an constructor from a Eval object,
+there are templated (pass through) constructors for 1 to N arguments (N ==
`PHOENIX_LIMIT`). These constructors simply forward the arguments to the `base`.

-[blurb __note__ *Parametric Base Class Pattern*\n\n
- Notice that actor derives from its template argument Eval. This is the
- inverse of the curiously recurring template pattern (CRTP). With the CRTP, a
- class, T, has a Derived template parameter that is assumed to be its
- subclass. The "parametric base class pattern" (PBCP), on the other hand,
- inverses the inheritance and makes a class, T, the derived class. Both CRTP
- and PBCP techniques have its pros and cons, which is outside the scope of
- this document. CRTP should really be renamed "parametric subclass pattern
+[note *Parametric Base Class Pattern*
+
+ Notice that actor derives from its template argument Eval. This is the
+ inverse of the curiously recurring template pattern (CRTP). With the CRTP, a
+ class, T, has a Derived template parameter that is assumed to be its
+ subclass. The "parametric base class pattern" (PBCP), on the other hand,
+ inverses the inheritance and makes a class, T, the derived class. Both CRTP
+ and PBCP techniques have its pros and cons, which is outside the scope of
+ this document. CRTP should really be renamed "parametric subclass pattern
 (PSCP), but again, that's another story.
]

[h3 Function Call Operators]

-There are N function call operators for 0 to N arguments (N == `PHOENIX_LIMIT`).
-The actor class accepts the arguments and forwards the arguments to the actor's
-base `Eval` for evaluation.
+There are N function call operators for 0 to N arguments (N == `PHOENIX_LIMIT`).
+The actor class accepts the arguments and forwards the arguments to the actor's
+base `Eval` for evaluation.

[def [$http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm]

-[blurb __note__ *Forwarding Function Problem*\n\n
- The function call operators cannot accept non-const temporaries and literal
- constants. There is a known issue with current C++ called the
- "__forwarding__". The problem is that given an arbitrary function `F`, using
- current C++ language rules, one cannot create a forwarding function `FF`
- that transparently assumes the arguments of `F`. Disallowing non-const
- rvalues arguments partially solves the problem but prohibits code such as
+[note *Forwarding Function Problem*
+
+ The function call operators cannot accept non-const temporaries and literal
+ constants. There is a known issue with current C++ called the
+ "__forwarding__". The problem is that given an arbitrary function `F`, using
+ current C++ language rules, one cannot create a forwarding function `FF`
+ that transparently assumes the arguments of `F`. Disallowing non-const
+ rvalues arguments partially solves the problem but prohibits code such as
 `f(1, 2, 3);`.
]

[h3 Environment]

-On an actor function call, before calling the actor's `Eval::eval` for
-evaluation, the actor creates an ['*environment*]. Basically, the environment
-packages the arguments in a tuple. The `Environment` is a concept, of which, the
+On an actor function call, before calling the actor's `Eval::eval` for
+evaluation, the actor creates an ['*environment*]. Basically, the environment
+packages the arguments in a tuple. The `Environment` is a concept, of which, the
`basic_environment` template class is a model of.

[table Environment Concept Requirements
@@ -2333,12 +2336,12 @@

[$images/funnel_in.png]

-Other parts of the library (e.g. the scope module) extends the `Environment`
+Other parts of the library (e.g. the scope module) extends the `Environment`
concept to hold other information such as local variables, etc.

[h3 apply_actor]

-`apply_actor` is a standard MPL style metafunction that simply calls the
+`apply_actor` is a standard MPL style metafunction that simply calls the
Action's `result` nested metafunction:

 template <typename Action, typename Env>
@@ -2347,18 +2350,18 @@
 typedef typename Action::template result<Env>::type type;
 };

-After evaluating the arguments and doing some computation, the `eval` member
-function returns something back to the client. To do this, the forwarding
-function (the actor's `operator()`) needs to know the return type of the eval
-member function that it is calling. For this purpose, models of `Eval` are
+After evaluating the arguments and doing some computation, the `eval` member
+function returns something back to the client. To do this, the forwarding
+function (the actor's `operator()`) needs to know the return type of the eval
+member function that it is calling. For this purpose, models of `Eval` are
required to provide a nested template class:

 template <typename Env>
 struct result;

-This nested class provides the result type information returned by the `Eval`'s
-`eval` member function. The nested template class `result` should have a typedef
-`type` that reflects the return type of its member function `eval`.
+This nested class provides the result type information returned by the `Eval`'s
+`eval` member function. The nested template class `result` should have a typedef
+`type` that reflects the return type of its member function `eval`.

For reference, here's a typical `actor::operator()` that accepts two arguments:

@@ -2371,9 +2374,9 @@

[h3 actor_result]

-For reasons of symmetry to the family of `actor::operator()` there is a special
-metafunction usable for actor result type calculation named `actor_result`. This
-metafunction allows us to directly to specify the types of the parameters to be
+For reasons of symmetry to the family of `actor::operator()` there is a special
+metafunction usable for actor result type calculation named `actor_result`. This
+metafunction allows us to directly to specify the types of the parameters to be
passed to the `actor::operator()` function. Here's a typical `actor_result` that
accepts two arguments:

@@ -2387,8 +2390,8 @@
[endsect]
[section Actor Example]

-Let us see a very simple prototypical example of an actor. This is not a toy
-example. This is actually part of the library. Remember the [link
+Let us see a very simple prototypical example of an actor. This is not a toy
+example. This is actually part of the library. Remember the [link
phoenix.primitives.references `reference`]?.

First, we have a model of the `Eval` concept: the `reference`:
@@ -2414,8 +2417,8 @@
 T& ref;
 };

-Models of `Eval` are never created directly and its instances never exist alone.
-We have to wrap it inside the `actor` template class to be useful. The `ref`
+Models of `Eval` are never created directly and its instances never exist alone.
+We have to wrap it inside the `actor` template class to be useful. The `ref`
template function does this for us:

 template <typename T>
@@ -2425,34 +2428,34 @@
 return reference<T>(v);
 }

-The `reference` template class conforms to the __eval__ concept. It has a nested
-`result` metafunction that reflects the return type of its `eval` member
-function, which peforms the actual function. `reference<T>` stores a reference to
-a `T`. Its `eval` member function simply returns the reference. It does not make
-use of the environment `Env`.
+The `reference` template class conforms to the __eval__ concept. It has a nested
+`result` metafunction that reflects the return type of its `eval` member
+function, which peforms the actual function. `reference<T>` stores a reference to
+a `T`. Its `eval` member function simply returns the reference. It does not make
+use of the environment `Env`.

/Pretty simple.../
-
+
[endsect]
[section Composites In Detail]

-We stated before that composites are actors that are composed of zero or more
-actors (see [link phoenix.composite Composite]). This is not quite accurate. The
-definition was sufficient at that point where we opted to keep things simple and
+We stated before that composites are actors that are composed of zero or more
+actors (see [link phoenix.composite Composite]). This is not quite accurate. The
+definition was sufficient at that point where we opted to keep things simple and
not bury the reader with details which she might not need anyway.

-Actually, a composite is a model of the __eval__ concept (more on this later).
-At the same time, it is also composed of 0..N (where N is a predefined maximum)
-__eval__ instances and an eval policy. The individual __eval__ instances are
+Actually, a composite is a model of the __eval__ concept (more on this later).
+At the same time, it is also composed of 0..N (where N is a predefined maximum)
+__eval__ instances and an eval policy. The individual __eval__ instances are
stored in a tuple.

-[blurb __note__ In a sense, the original definition of "composite", more or
-less, will do just fine because __eval__ instances never exist alone and are
-always wrapped in an `actor` template class which inherits from it anyway. The
+[note In a sense, the original definition of "composite", more or
+less, will do just fine because __eval__ instances never exist alone and are
+always wrapped in an `actor` template class which inherits from it anyway. The
resulting actor IS-AN __eval__.]

-[blurb __note__ You can set `PHOENIX_COMPOSITE_LIMIT`, the predefined maximum
-`Eval`s (actors) a composite can take. By default, `PHOENIX_COMPOSITE_LIMIT` is
+[note You can set `PHOENIX_COMPOSITE_LIMIT`, the predefined maximum
+`Eval`s (actors) a composite can take. By default, `PHOENIX_COMPOSITE_LIMIT` is
set to `PHOENIX_LIMIT` (See [link phoenix.actors Actors]).]

[h2 composite template class]
@@ -2477,7 +2480,7 @@

 template <typename U0, typename U1>
 composite(U0 const& _0, U1 const& _1);
-
+
 // more constructors

 template <typename Env>
@@ -2487,17 +2490,17 @@

[h2 EvalTuple]

-`EvalTuple`, holds all the __eval__ instances. The `composite` template class
-inherits from it. In addition to a default constructor and a constructor from an
-`EvalTuple` object, there are templated (pass through) constructors for 1 to N
-arguments (again, where N == `PHOENIX_COMPOSITE_LIMIT`). These constructors
+`EvalTuple`, holds all the __eval__ instances. The `composite` template class
+inherits from it. In addition to a default constructor and a constructor from an
+`EvalTuple` object, there are templated (pass through) constructors for 1 to N
+arguments (again, where N == `PHOENIX_COMPOSITE_LIMIT`). These constructors
simply forward the arguments to the `EvalTuple` base class.

[h2 EvalPolicy]

-The composite's `eval` member function calls its `EvalPolicy`'s `eval` member
-function (a static member function) passing in the [link
-phoenix.inside_phoenix.actors_in_detail.environment environment] and each of
+The composite's `eval` member function calls its `EvalPolicy`'s `eval` member
+function (a static member function) passing in the [link
+phoenix.inside_phoenix.actors_in_detail.environment environment] and each of
its actors, in parallel. The following diagram illustrates what's happening:

[$images/funnel_out.png]
@@ -2508,9 +2511,9 @@
 [ [`T::result<Env, Eval0, Eval1, Eval2, ..., EvalN>::type`] [The return type of eval] ]
]

-The `EvalPolicy` is expected to have a nested template class `result` which has a
-typedef `type` that reflects the return type of its member function `eval`.
-Here's a typical example of the composite's eval member function for a 2-actor
+The `EvalPolicy` is expected to have a nested template class `result` which has a
+typedef `type` that reflects the return type of its member function `eval`.
+Here's a typical example of the composite's eval member function for a 2-actor
composite:

 template <typename Env>
@@ -2518,49 +2521,49 @@
 eval(Env const& env) const
 {
 typedef typename result<Env>::type return_type;
- return EvalPolicy::template
+ return EvalPolicy::template
 eval<return_type>(
 env
 , get<0>(*this) // gets the 0th element from EvalTuple
- , get<1>(*this)); // gets the 1st element from EvalTuple
+ , get<1>(*this)); // gets the 1st element from EvalTuple
 }

[endsect]
[section Composing]

-Composites are never instantiated directly. Front end expression templates are
-used to generate the composites. Using expression templates, we implement a DSEL
-(Domain Specific Embedded Language) that mimicks native C++. You've seen this
-DSEL in action in the preceding sections. It is most evident in the
+Composites are never instantiated directly. Front end expression templates are
+used to generate the composites. Using expression templates, we implement a DSEL
+(Domain Specific Embedded Language) that mimicks native C++. You've seen this
+DSEL in action in the preceding sections. It is most evident in the
[link phoenix.composite.statement Statement] section.

-There are some facilities in the library to make composition of composites
-easier. We have a set of overloaded `compose` functions and an `as_composite`
-metafunction. Together, these helpers make composing a breeze. We'll provide an
-[link phoenix.inside_phoenix.composing.composite_example example of a
+There are some facilities in the library to make composition of composites
+easier. We have a set of overloaded `compose` functions and an `as_composite`
+metafunction. Together, these helpers make composing a breeze. We'll provide an
+[link phoenix.inside_phoenix.composing.composite_example example of a
composite] later to see why.

[section compose]

 compose<EvalPolicy>(arg0, arg1, arg2, ..., argN);

-Given an __eval_policy__ and some arguments `arg0`...argN, returns a proper
-`composite`. The arguments may or may not be phoenix actors (primitives of
-composites). If not, the arguments are converted to actors appropriately. For
+Given an __eval_policy__ and some arguments `arg0`...argN, returns a proper
+`composite`. The arguments may or may not be phoenix actors (primitives of
+composites). If not, the arguments are converted to actors appropriately. For
example:

 compose<X>(3)

converts the argument `3` to an `actor<value<int> >(3)`.
-
+
[endsect]

[section as_composite]

 as_composite<EvalPolicy, Arg0, Arg1, Arg2, ..., ArgN>::type

-This is the metafunction counterpart of `compose`. Given an __eval_policy__ and
-some argument types `Arg0`...ArgN, returns a proper `composite` type. For
+This is the metafunction counterpart of `compose`. Given an __eval_policy__ and
+some argument types `Arg0`...ArgN, returns a proper `composite` type. For
example:

 as_composite<X, int>::type
@@ -2571,9 +2574,9 @@

[section Composite Example]

-Now, let's examine an example. Again, this is not a toy example. This is actually
-part of the library. Remember the [link phoenix.composite.statement.while__statement
-`while_`] lazy statement? Putting together everything we've learned so far, we
+Now, let's examine an example. Again, this is not a toy example. This is actually
+part of the library. Remember the [link phoenix.composite.statement.while__statement
+`while_`] lazy statement? Putting together everything we've learned so far, we
will present it here in its entirety (verbatim):

 struct while_eval
@@ -2615,17 +2618,17 @@
 {
 return while_gen<Cond>(cond);
 }
-
-`while_eval` is an example of an __eval_policy__. `while_gen` and `while_` are
-the expression template front ends. Let's break this apart to understand what's
+
+`while_eval` is an example of an __eval_policy__. `while_gen` and `while_` are
+the expression template front ends. Let's break this apart to understand what's
happening. Let's start at the bottom. It's easier that way.

When you write:

 while_(cond)

-we generate an instance of `while_gen<Cond>`, where `Cond` is the type of
-`cond`. `cond` can be an arbitrarily complex actor expression. The `while_gen`
+we generate an instance of `while_gen<Cond>`, where `Cond` is the type of
+`cond`. `cond` can be an arbitrarily complex actor expression. The `while_gen`
template class has an `operator[]` accepting another expression. If we write:

 while_(cond)
@@ -2637,8 +2640,8 @@

 as_composite<while_eval, Cond, Do>::type

-where `Cond` is the type of `cond` and `Do` is the type of `do_`. Notice how we
-are using phoenix's [link phoenix.inside_phoenix.composing composition] (`compose`
+where `Cond` is the type of `cond` and `Do` is the type of `do_`. Notice how we
+are using phoenix's [link phoenix.inside_phoenix.composing composition] (`compose`
and `as_composite`) mechanisms here

 template <typename Do>
@@ -2653,8 +2656,8 @@
 while (cond.eval(env))
 do_.eval(env);

-`cond` and `do_`, at this point, are instances of __eval__. `cond` and `do_` are
-the __eval__ elements held by the composite's __eval_tuple__. `env` is the
+`cond` and `do_`, at this point, are instances of __eval__. `cond` and `do_` are
+the __eval__ elements held by the composite's __eval_tuple__. `env` is the
__environment__.

[endsect]
@@ -2663,16 +2666,16 @@

[section Extending]

-We've shown how it is very easy to extend phoenix by writing new primitives and
-composites. The modular design of Phoenix makes it extremely extensible. We have
-seen that layer upon layer, the whole library is built on a solid foundation.
-There are only a few simple well designed concepts that are laid out like
-bricks. Overall, the library is designed to be extended. Everything above the
-core layer can in fact be considered just as extensions to the library. This
+We've shown how it is very easy to extend phoenix by writing new primitives and
+composites. The modular design of Phoenix makes it extremely extensible. We have
+seen that layer upon layer, the whole library is built on a solid foundation.
+There are only a few simple well designed concepts that are laid out like
+bricks. Overall, the library is designed to be extended. Everything above the
+core layer can in fact be considered just as extensions to the library. This
modular design was inherited from the __spirit__ inline parser library.

-Extension is non-intrusive. And, whenever a component or module is extended, the
-new extension automatically becomes a first class citizen and is automatically
+Extension is non-intrusive. And, whenever a component or module is extended, the
+new extension automatically becomes a first class citizen and is automatically
recognized by all modules and components in the library.

[endsect]
@@ -2681,31 +2684,31 @@

[section Wrap Up]

-Sooner or later more FP techniques become standard practice as people find the
-true value of this programming discipline outside the academe and into the
-mainstream. In as much as structured programming of the 70s and object oriented
-programming in the 80s and generic programming in the 90s shaped our thoughts
-towards a more robust sense of software engineering, FP will certainly be a
-paradigm that will catapult us towards more powerful software design and
+Sooner or later more FP techniques become standard practice as people find the
+true value of this programming discipline outside the academe and into the
+mainstream. In as much as structured programming of the 70s and object oriented
+programming in the 80s and generic programming in the 90s shaped our thoughts
+towards a more robust sense of software engineering, FP will certainly be a
+paradigm that will catapult us towards more powerful software design and
engineering onward into the new millenium.

-Let me quote Doug Gregor of Boost.org. About functional style programming
+Let me quote Doug Gregor of Boost.org. About functional style programming
libraries:

-[:['They're gaining acceptance, but are somewhat stunted by the ubiquitousness
+[:['They're gaining acceptance, but are somewhat stunted by the ubiquitousness
of broken compilers. The C++ community is moving deeper into the so-called "STL-
-style" programming paradigm, which brings many aspects of functional programming
-into the fold. Look at, for instance, the Spirit parser to see how such function
-objects can be used to build Yacc-like grammars with semantic actions that can
-build abstract syntax trees on the fly. This type of functional composition is
+style" programming paradigm, which brings many aspects of functional programming
+into the fold. Look at, for instance, the Spirit parser to see how such function
+objects can be used to build Yacc-like grammars with semantic actions that can
+build abstract syntax trees on the fly. This type of functional composition is
gaining momentum.]]

-Indeed. Phoenix is another attempt to introduce more FP techniques into the
-mainstream. Not only is it a tool that will make life easier for the programmer.
-In its own right, the actual design of the library itself is a model of true C++
-FP in action. The library is designed and structured in a strict but clear and
-well mannered FP sense. By all means, use the library as a tool. But for those
-who want to learn more about FP in C++, don't stop there, I invite you to take a
+Indeed. Phoenix is another attempt to introduce more FP techniques into the
+mainstream. Not only is it a tool that will make life easier for the programmer.
+In its own right, the actual design of the library itself is a model of true C++
+FP in action. The library is designed and structured in a strict but clear and
+well mannered FP sense. By all means, use the library as a tool. But for those
+who want to learn more about FP in C++, don't stop there, I invite you to take a
closer look at the design of the library itself.

So there you have it. Have fun! See you in the FP world.
@@ -2714,8 +2717,8 @@

[section Acknowledgement]

-# Hartmut Kaiser implemented the original lazy casts and constructors based on
- his original work on Spirit SE "semantic expressions" (the precursor to
+# Hartmut Kaiser implemented the original lazy casts and constructors based on
+ his original work on Spirit SE "semantic expressions" (the precursor to
 Phoenix).
# Angus Leeming implemented the container functions on Phoenix-1 which I then
 ported to Phoenix-2.
@@ -2728,7 +2731,7 @@
# Dan Marsden, did almost all the work in bringing Phoenix-2 out the door.
# Eric Niebler did a 2.0 pre-release review and wrote some range related code
 that Phoenix stole and used in the algorithms.
-# Thorsten Ottosen; Eric's range_ex code began life as "container_algo" in the
+# Thorsten Ottosen; Eric's range_ex code began life as "container_algo" in the
 old boost sandbox, by Thorsten in 2002-2003.
# Jeremy Siek, even prior to Thorsten, in 2001, started the "container_algo".
# Vladimir Prus wrote the mutating algorithms code from the Boost Wiki.
@@ -2742,27 +2745,27 @@
 Available online at [@http://www.math.chalmers.se/~rjmh/Papers/whyfp.html].
# Boost.Lambda library, Jaakko Jarvi, 1999-2004 Jaakko Jarvi, Gary Powell.
 Available online at [@http://www.boost.org/libs/lambda/].
-# Functional Programming in C++ using the FC++ Library: a short article
- introducing FC++, Brian McNamara and Yannis Smaragdakis, August 2003. Available
+# Functional Programming in C++ using the FC++ Library: a short article
+ introducing FC++, Brian McNamara and Yannis Smaragdakis, August 2003. Available
 online at [@http://www.cc.gatech.edu/~yannis/fc++/].
-# Side-effects and partial function application in C++, Jaakko Jarvi and Gary
- Powell, 2001. Available online at
+# Side-effects and partial function application in C++, Jaakko Jarvi and Gary
+ Powell, 2001. Available online at
 [@http://osl.iu.edu/~jajarvi/publications/papers/mpool01.pdf].
-# Spirit Version 1.8.1, Joel de Guzman, Nov 2004. Available online at
+# Spirit Version 1.8.1, Joel de Guzman, Nov 2004. Available online at
 [@http://www.boost.org/libs/spirit/].
-# The Boost MPL Library, Aleksey Gurtovoy and David Abrahams, 2002-2004.
+# The Boost MPL Library, Aleksey Gurtovoy and David Abrahams, 2002-2004.
 Available online at [@http://www.boost.org/libs/mpl/].
-# Generic Programming Redesign of Patterns, Proceedings of the 5th European
- Conference on Pattern Languages of Programs, (EuroPLoP'2000) Irsee, Germany,
- July 2000. Available online at
+# Generic Programming Redesign of Patterns, Proceedings of the 5th European
+ Conference on Pattern Languages of Programs, (EuroPLoP'2000) Irsee, Germany,
+ July 2000. Available online at
 [@http://www.coldewey.com/europlop2000/papers/geraud%2Bduret.zip].
-# A Gentle Introduction to Haskell, Paul Hudak, John Peterson and Joseph Fasel,
+# A Gentle Introduction to Haskell, Paul Hudak, John Peterson and Joseph Fasel,
 1999. Available online at [@http://www.haskell.org/tutorial/].
-# Large scale software design, John Lackos, ISBN 0201633620, Addison-Wesley, July
+# Large scale software design, John Lackos, ISBN 0201633620, Addison-Wesley, July
 1996.
-# Design Patterns, Elements of Reusable Object-Oriented Software, Erich Gamma,
+# Design Patterns, Elements of Reusable Object-Oriented Software, Erich Gamma,
 Richard Helm, Ralph Jhonson, and John Vlissides, Addison-Wesley, 1995.
-# The Forwarding Problem: Arguments Peter Dimov, Howard E. Hinnant, Dave
+# The Forwarding Problem: Arguments Peter Dimov, Howard E. Hinnant, Dave
 Abrahams, September 09, 2002. Available online: __forwarding__.

[endsect]

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