Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

344 files changed, 41226 insertions, 0 deletions

diff --git a/src/boost/libs/spirit/example/Jamfile b/src/boost/libs/spirit/example/Jamfile
new file mode 100644
index 00000000..4aa2c3dd
--- /dev/null
+++ b/src/boost/libs/spirit/example/Jamfile
@@ -0,0 +1,20 @@
+#==============================================================================
+#   Copyright (c) 2010 Gevorg Voskanyan
+#   Copyright (c) 2001-2010 Joel de Guzman
+#   Copyright (c) 2001-2010 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)
+#==============================================================================
+
+# build all examples
+
+local examples = [ glob-tree [jJ]amfile [jJ]amfile.v2 ] ;
+
+for local ex in $(examples) {
+   local dir = $(ex:P) ;
+   if $(dir) != "" && $(dir) != "." {
+      build-project $(dir) ;
+   }
+}
+
diff --git a/src/boost/libs/spirit/example/karma/Jamfile b/src/boost/libs/spirit/example/karma/Jamfile
new file mode 100644
index 00000000..a93cbb7a
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/Jamfile
@@ -0,0 +1,38 @@
+#==============================================================================
+#   Copyright (c) 2001-2009 Hartmut Kaiser
+#   Copyright (c) 2001-2009 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)
+#==============================================================================
+project spirit-karma-example 
+    : requirements 
+        <c++-template-depth>300
+    :
+    :
+    ;
+
+exe actions_example : actions.cpp ;
+exe auto_facilities : auto_facilities.cpp ;
+exe basic_facilities : basic_facilities.cpp /boost//date_time ;
+exe karma_calc2_ast_dump : calc2_ast_dump.cpp ;
+exe karma_calc2_ast_rpn : calc2_ast_rpn.cpp ;
+exe karma_calc2_ast_vm : calc2_ast_vm.cpp ;
+exe classify_char : classify_char.cpp ;
+exe karma_complex_number : complex_number.cpp ;
+exe karma_complex_number_easier : complex_number_easier.cpp ;
+exe karma_complex_number_adapt : complex_number_adapt.cpp ;
+exe karma_num_list1 : num_list1.cpp ;
+exe karma_num_list2 : num_list2.cpp ;
+exe karma_num_list3 : num_list3.cpp ;
+exe karma_num_matrix : num_matrix.cpp ;
+exe key_value_sequence : key_value_sequence.cpp ;
+exe mini_xml_karma : mini_xml_karma.cpp ;
+exe printf_style_double_format : printf_style_double_format.cpp ;
+exe quick_start1 : quick_start1.cpp ;
+exe karma_reference : reference.cpp ;
+exe karma_reorder_struct : reorder_struct.cpp ;
+exe karma_escaped_string : escaped_string.cpp ;
+exe simple_columns_directive : simple_columns_directive.cpp ;
+exe quoted_strings : quoted_strings.cpp ;
+
diff --git a/src/boost/libs/spirit/example/karma/actions.cpp b/src/boost/libs/spirit/example/karma/actions.cpp
new file mode 100644
index 00000000..d5b5efe2
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/actions.cpp
@@ -0,0 +1,131 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Hartmut Kaiser
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/bind.hpp>
+
+#include <iostream>
+#include <sstream>
+
+// Presented are various ways to attach semantic actions
+//  * Using plain function pointer
+//  * Using simple function object
+//  * Using boost.bind
+//  * Using boost.lambda
+
+using boost::spirit::unused_type;
+
+//[karma_tutorial_semantic_action_functions
+namespace client
+{
+    namespace karma = boost::spirit::karma;
+
+    // A plain function
+    void read_function(int& i)
+    {
+        i = 42;
+    }
+
+    // A member function
+    struct reader
+    {
+        void print(int& i) const
+        {
+            i = 42;
+        }
+    };
+
+    // A function object
+    struct read_action
+    {
+        void operator()(int& i, unused_type, unused_type) const
+        {
+            i = 42;
+        }
+    };
+}
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    using boost::spirit::karma::int_;
+    using boost::spirit::karma::generate;
+    using client::read_function;
+    using client::reader;
+    using client::read_action;
+
+    { // example using plain functions
+        using namespace boost::spirit;
+
+        std::string generated;
+        std::back_insert_iterator<std::string> outiter(generated);
+
+        //[karma_tutorial_attach_actions1
+        generate(outiter, '{' << int_[&read_function] << '}');
+        //]
+
+        std::cout << "Simple function: " << generated << std::endl;
+    }
+
+    { // example using simple function object
+        using namespace boost::spirit;
+
+        std::string generated;
+        std::back_insert_iterator<std::string> outiter(generated);
+
+        //[karma_tutorial_attach_actions2
+        generate(outiter, '{' << int_[read_action()] << '}');
+        //]
+
+        std::cout << "Simple function object: " << generated << std::endl;
+    }
+
+    { // example using plain function with boost.bind
+        std::string generated;
+        std::back_insert_iterator<std::string> outiter(generated);
+
+        //[karma_tutorial_attach_actions3
+        generate(outiter, '{' << int_[boost::bind(&read_function, _1)] << '}');
+        //]
+
+        std::cout << "Simple function with Boost.Bind: " << generated << std::endl;
+    }
+
+    { // example using member function with boost.bind
+        std::string generated;
+        std::back_insert_iterator<std::string> outiter(generated);
+
+        //[karma_tutorial_attach_actions4
+        reader r;
+        generate(outiter, '{' << int_[boost::bind(&reader::print, &r, _1)] << '}');
+        //]
+
+        std::cout << "Member function: " << generated << std::endl;
+    }
+
+    { // example using boost.lambda
+        namespace lambda = boost::lambda;
+        using namespace boost::spirit;
+
+        std::string generated;
+        std::back_insert_iterator<std::string> outiter(generated);
+
+        //[karma_tutorial_attach_actions5
+        std::stringstream strm("42");
+        generate(outiter, '{' << int_[strm >> lambda::_1] << '}');
+        //]
+
+        std::cout << "Boost.Lambda: " << generated << std::endl;
+    }
+
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/auto_facilities.cpp b/src/boost/libs/spirit/example/karma/auto_facilities.cpp
new file mode 100644
index 00000000..b094f40a
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/auto_facilities.cpp
@@ -0,0 +1,244 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The main purpose of this example is to show the uniform and easy way of
+//  output formatting for different container types. 
+//
+//  The 'auto_' primitive used below is very similar to the 'stream' primitive
+//  demonstrated in the example 'basic_facilities.cpp' as it allows to generate
+//  output from a multitude of data types. The main difference is that it is
+//  mapped to the correct Karma generator instead of using any available 
+//  operator<<() for the contained data type. Additionally this means, that
+//  the format descriptions used below will be usable for any contained type as
+//  long as this type has a defined mapping to a Karma generator.
+
+//  use a larger value for the alignment field width (default is 10)
+#define BOOST_KARMA_DEFAULT_FIELD_LENGTH 25
+
+#include <boost/config/warning_disable.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include <algorithm>
+#include <cstdlib> 
+
+#include <boost/range.hpp>
+#include <boost/array.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+#include <boost/fusion/include/array.hpp>
+
+#include <boost/spirit/include/karma.hpp>
+
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace traits
+{
+    // We add a specialization for the create_generator customization point
+    // defining a custom output format for the value type of the std::map used
+    // below (std::pair<int const, std::string>). Generally, any specialization 
+    // for create_generator is expected to return the proto expression to be 
+    // used to generate output for the type the customization point has been 
+    // specialized for.
+    //
+    // We need to utilize proto::deep_copy as the expression contains a literal 
+    // (the ':') which normally gets embedded in the proto expression by 
+    // reference only. The deep copy converts the proto tree to hold this by 
+    // value. The deep copy operation can be left out for simpler proto 
+    // expressions (not containing references to temporaries). Alternatively
+    // you could use the proto::make_expr() facility to build the required
+    // proto expression.
+    template <>
+    struct create_generator<std::pair<int const, std::string> >
+    {
+        typedef proto::result_of::deep_copy<
+            BOOST_TYPEOF(int_ << ':' << string)
+        >::type type;
+
+        static type call()
+        {
+            return proto::deep_copy(int_ << ':' << string);
+        }
+    };
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+// Output the given containers in list format
+// Note: the format description does not depend on the type of the sequence
+//       nor does it depend on the type of the elements contained in the 
+//       sequence
+///////////////////////////////////////////////////////////////////////////////
+template <typename Container>
+void output_container(std::ostream& os, Container const& c)
+{
+    // output the container as a sequence without separators
+    os << 
+        karma::format(
+            auto_,                                // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format(
+            *auto_,                               // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a space separated sequence
+    os << 
+        karma::format_delimited(
+            auto_,                                // format description
+            space,                                // delimiter
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format_delimited(
+            *auto_,                               // format description
+            space,                                // delimiter
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format_delimited(
+            '[' << *auto_ << ']',                 // format description
+            space,                                // delimiter
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a comma separated list
+    os << 
+        karma::format(
+            auto_ % ", ",                         // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format(
+            '[' << (auto_ % ", ") << ']',         // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format(
+            '[' << -(auto_ % ", ") << ']',        // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format(
+            '[' << (+auto_ | "empty") << ']',     // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a comma separated list of items enclosed in '()'
+    os << 
+        karma::format(
+            ('(' << auto_ << ')') % ", ",         // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format(
+            '[' << (  
+                ('(' << auto_ << ')') % ", "
+             )  << ']',                           // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a HTML list
+    os << 
+        karma::format_delimited(
+            "<ol>" << 
+                *verbatim["<li>" << auto_ << "</li>"]
+            << "</ol>",                           // format description
+            '\n',                                 // delimiter
+            c                                     // data
+        ) << std::endl;
+
+    // output the container as right aligned column
+    os << 
+        karma::format_delimited(
+           *verbatim[
+                "|" << right_align[auto_] << "|"
+            ],                                    // format description
+            '\n',                                 // delimiter
+            c                                     // data
+        ) << std::endl;
+
+    os << std::endl;
+}
+
+int main()
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // C-style array
+    int i[4] = { 3, 6, 9, 12 };
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "int i[]" << std::endl;
+    output_container(std::cout, boost::make_iterator_range(i, i+4));
+
+    ///////////////////////////////////////////////////////////////////////////
+    // vector
+    std::vector<int> v (5);
+    std::generate(v.begin(), v.end(), std::rand); // randomly fill the vector
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "std::vector<int>" << std::endl;
+    output_container(std::cout, v);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // list
+    std::list<char> l;
+    l.push_back('A');
+    l.push_back('B');
+    l.push_back('C');
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "std::list<char>" << std::endl;
+    output_container(std::cout, l);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // strings
+    std::string str("Hello world!");
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "std::string" << std::endl;
+    output_container(std::cout, str);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // boost::array
+    boost::array<long, 5> arr;
+    std::generate(arr.begin(), arr.end(), std::rand); // randomly fill the array
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "boost::array<long, 5>" << std::endl;
+    output_container(std::cout, arr);
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  map of int --> string mappings
+    std::map<int, std::string> mappings;
+    mappings.insert(std::make_pair(0, "zero"));
+    mappings.insert(std::make_pair(1, "one"));
+    mappings.insert(std::make_pair(2, "two"));
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "std::map<int, std::string>" << std::endl;
+    output_container(std::cout, mappings);
+
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/basic_facilities.cpp b/src/boost/libs/spirit/example/karma/basic_facilities.cpp
new file mode 100644
index 00000000..63514032
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/basic_facilities.cpp
@@ -0,0 +1,229 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The main purpose of this example is to show the uniform and easy way of
+//  output formatting for different container types. 
+//
+//  Since the 'stream' primitive used below uses the streaming operator defined 
+//  for the container value_type, you must make sure to have a corresponding
+//  operator<<() available for this contained data type. OTOH this means, that
+//  the format descriptions used below will be usable for any contained type as
+//  long as this type has an associated streaming operator defined.
+
+//  use a larger value for the alignment field width (default is 10)
+#define BOOST_KARMA_DEFAULT_FIELD_LENGTH 25
+
+#include <boost/config/warning_disable.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include <algorithm>
+#include <cstdlib> 
+
+#include <boost/range.hpp>
+#include <boost/array.hpp>
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// This streaming operator is needed to generate the output from the map below
+// Yes, it's heresy, but this operator has to live in namespace std to be 
+// picked up by the compiler.
+namespace std {
+    inline std::ostream& 
+    operator<<(std::ostream& os, std::pair<int const, std::string> v)
+    {
+        os << v.first << ": " << v.second;
+        return os;
+    }
+}
+
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/karma_format.hpp>
+
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+
+///////////////////////////////////////////////////////////////////////////////
+// Output the given containers in list format
+// Note: the format description does not depend on the type of the sequence
+//       nor does it depend on the type of the elements contained in the 
+//       sequence
+///////////////////////////////////////////////////////////////////////////////
+template <typename Container>
+void output_container(std::ostream& os, Container const& c)
+{
+    // output the container as a space separated sequence
+    os << 
+        karma::format(
+            *stream,                              // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a space separated sequence
+    os << 
+        karma::format_delimited(
+            *stream,                              // format description
+            space,                                // delimiter
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format_delimited(
+            '[' << *stream << ']',                // format description
+            space,                                // delimiter
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a comma separated list
+    os << 
+        karma::format(
+            stream % ", ",                        // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format(
+            '[' << (stream % ", ") << ']',        // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format(
+            '[' << -(stream % ", ") << ']',       // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format(
+            '[' << (+stream | "empty") << ']',    // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a comma separated list of items enclosed in '()'
+    os << 
+        karma::format(
+            ('(' << stream << ')') % ", ",        // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    os << 
+        karma::format(
+            '[' << (  
+                ('(' << stream << ')') % ", "
+             )  << ']',                           // format description
+            c                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a HTML list
+    os << 
+        karma::format_delimited(
+            "<ol>" << 
+                *verbatim["<li>" << stream << "</li>"]
+            << "</ol>",                           // format description
+            '\n',                                 // delimiter
+            c                                     // data
+        ) << std::endl;
+
+    // output the container as right aligned column
+    os << 
+        karma::format_delimited(
+           *verbatim[
+                "|" << right_align[stream] << "|"
+            ],                                    // format description
+            '\n',                                 // delimiter
+            c                                     // data
+        ) << std::endl;
+
+    os << std::endl;
+}
+
+int main()
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // C-style array
+    int i[4] = { 3, 6, 9, 12 };
+    
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "int i[]" << std::endl;
+    output_container(std::cout, boost::make_iterator_range(i, i+4));
+
+    ///////////////////////////////////////////////////////////////////////////
+    // vector
+    std::vector<int> v (5);
+    std::generate(v.begin(), v.end(), std::rand); // randomly fill the vector
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "std::vector<int>" << std::endl;
+    output_container(std::cout, v);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // list
+    std::list<char> l;
+    l.push_back('A');
+    l.push_back('B');
+    l.push_back('C');
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "std::list<char>" << std::endl;
+    output_container(std::cout, l);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // strings
+    std::string str("Hello world!");
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "std::string" << std::endl;
+    output_container(std::cout, str);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // boost::array
+    boost::array<long, 5> arr;
+    std::generate(arr.begin(), arr.end(), std::rand); // randomly fill the array
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "boost::array<long, 5>" << std::endl;
+    output_container(std::cout, arr);
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  vector of boost::date objects
+    //  Note: any registered facets get used!
+    using namespace boost::gregorian;
+    std::vector<date> dates;
+    dates.push_back(date(2005, Jun, 25));
+    dates.push_back(date(2006, Jan, 13));
+    dates.push_back(date(2007, May, 03));
+
+    date_facet* facet(new date_facet("%A %B %d, %Y"));
+    std::cout.imbue(std::locale(std::cout.getloc(), facet));
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "std::vector<boost::date>" << std::endl;
+    output_container(std::cout, dates);
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  map of int --> string mappings
+    std::map<int, std::string> mappings;
+    mappings.insert(std::make_pair(0, "zero"));
+    mappings.insert(std::make_pair(1, "one"));
+    mappings.insert(std::make_pair(2, "two"));
+
+    std::cout << "-------------------------------------------------------------" 
+              << std::endl;
+    std::cout << "std::map<int, std::string>" << std::endl;
+    output_container(std::cout, mappings);
+
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/calc2_ast.hpp b/src/boost/libs/spirit/example/karma/calc2_ast.hpp
new file mode 100644
index 00000000..d1ee92e8
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/calc2_ast.hpp
@@ -0,0 +1,177 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST which gets dumped into
+//  a human readable format afterwards.
+//
+//  [ JDG April 28, 2008 ]
+//  [ HK April 28, 2008 ]
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#if !defined(SPIRIT_EXAMPLE_CALC2_AST_APR_30_2008_1011AM)
+#define SPIRIT_EXAMPLE_CALC2_AST_APR_30_2008_1011AM
+
+#include <boost/variant.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_statement.hpp>
+#include <boost/spirit/include/karma_domain.hpp>
+#include <boost/spirit/include/support_attributes_fwd.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our AST
+///////////////////////////////////////////////////////////////////////////////
+struct binary_op;
+struct unary_op;
+struct nil {};
+
+struct expression_ast
+{
+    typedef
+        boost::variant<
+            nil // can't happen!
+          , int
+          , boost::recursive_wrapper<binary_op>
+          , boost::recursive_wrapper<unary_op>
+        >
+    type;
+
+    // expose variant types 
+    typedef type::types types;
+
+    // expose variant functionality
+    int which() const { return expr.which(); }
+
+    // constructors
+    expression_ast()
+      : expr(nil()) {}
+
+    expression_ast(unary_op const& expr)
+      : expr(expr) {}
+
+    expression_ast(binary_op const& expr)
+      : expr(expr) {}
+
+    expression_ast(unsigned int expr)
+      : expr(expr) {}
+
+    expression_ast(type const& expr)
+      : expr(expr) {}
+
+    expression_ast& operator+=(expression_ast const& rhs);
+    expression_ast& operator-=(expression_ast const& rhs);
+    expression_ast& operator*=(expression_ast const& rhs);
+    expression_ast& operator/=(expression_ast const& rhs);
+
+    type expr;
+};
+
+// expose variant functionality
+namespace boost
+{
+    // this function has to live in namespace boost for ADL to correctly find it
+    template <typename T>
+    inline T get(expression_ast const& expr)
+    {
+        return boost::get<T>(expr.expr);
+    }
+
+    namespace spirit { namespace traits
+    {
+        // the specialization below tells Spirit to handle expression_ast as 
+        // if it where a 'real' variant (if used with Spirit.Karma)
+        template <>
+        struct not_is_variant<expression_ast, karma::domain>
+          : mpl::false_ {};
+
+        // the specialization of variant_which allows to generically extract
+        // the current type stored in the given variant like type
+        template <>
+        struct variant_which<expression_ast>
+        {
+            static int call(expression_ast const& v)
+            {
+                return v.which();
+            }
+        };
+    }}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+struct binary_op
+{
+    binary_op() {}
+
+    binary_op(
+        char op
+      , expression_ast const& left
+      , expression_ast const& right)
+      : op(op), left(left), right(right) {}
+
+    char op;
+    expression_ast left;
+    expression_ast right;
+};
+
+struct unary_op
+{
+    unary_op(
+        char op
+      , expression_ast const& right)
+    : op(op), right(right) {}
+
+    char op;
+    expression_ast right;
+};
+
+inline expression_ast& expression_ast::operator+=(expression_ast const& rhs)
+{
+    expr = binary_op('+', expr, rhs);
+    return *this;
+}
+
+inline expression_ast& expression_ast::operator-=(expression_ast const& rhs)
+{
+    expr = binary_op('-', expr, rhs);
+    return *this;
+}
+
+inline expression_ast& expression_ast::operator*=(expression_ast const& rhs)
+{
+    expr = binary_op('*', expr, rhs);
+    return *this;
+}
+
+inline expression_ast& expression_ast::operator/=(expression_ast const& rhs)
+{
+    expr = binary_op('/', expr, rhs);
+    return *this;
+}
+
+// We should be using expression_ast::operator-. There's a bug
+// in phoenix type deduction mechanism that prevents us from
+// doing so. Phoenix will be switching to BOOST_TYPEOF. In the
+// meantime, we will use a phoenix::function below:
+template <char Op>
+struct unary_expr
+{
+    template <typename T>
+    struct result { typedef T type; };
+
+    expression_ast operator()(expression_ast const& expr) const
+    {
+        return unary_op(Op, expr);
+    }
+};
+
+boost::phoenix::function<unary_expr<'+'> > pos;
+boost::phoenix::function<unary_expr<'-'> > neg;
+
+#endif
diff --git a/src/boost/libs/spirit/example/karma/calc2_ast_dump.cpp b/src/boost/libs/spirit/example/karma/calc2_ast_dump.cpp
new file mode 100644
index 00000000..ac15c7ca
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/calc2_ast_dump.cpp
@@ -0,0 +1,170 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST which gets dumped into
+//  a human readable format afterwards.
+//
+//  [ JDG April 28, 2008 ]
+//  [ HK April 28, 2008 ]
+//
+///////////////////////////////////////////////////////////////////////////////
+#include <boost/config/warning_disable.hpp>
+
+#include <iostream>
+#include <vector>
+#include <string>
+
+#include "calc2_ast.hpp"
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our calculator parser grammar
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct calculator 
+  : qi::grammar<Iterator, expression_ast(), space_type>
+{
+    calculator() : calculator::base_type(expression)
+    {
+        expression =
+            term                            [_val = _1]
+            >> *(   ('+' >> term            [_val += _1])
+                |   ('-' >> term            [_val -= _1])
+                )
+            ;
+
+        term =
+            factor                          [_val = _1]
+            >> *(   ('*' >> factor          [_val *= _1])
+                |   ('/' >> factor          [_val /= _1])
+                )
+            ;
+
+        factor =
+            uint_                           [_val = _1]
+            |   '(' >> expression           [_val = _1] >> ')'
+            |   ('-' >> factor              [_val = neg(_1)])
+            |   ('+' >> factor              [_val = pos(_1)])
+            ;
+    }
+
+    qi::rule<Iterator, expression_ast(), space_type> expression, term, factor;
+};
+
+// We need to tell fusion about our binary_op and unary_op structs
+// to make them a first-class fusion citizen
+//
+// Note: we register the members exactly in the same sequence as we need them 
+//       in the grammar
+BOOST_FUSION_ADAPT_STRUCT(
+    binary_op,
+    (expression_ast, left)
+    (char, op)
+    (expression_ast, right)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    unary_op,
+    (char, op)
+    (expression_ast, right)
+)
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our AST grammar for the generator, this just dumps the AST as a expression
+///////////////////////////////////////////////////////////////////////////////
+template <typename OuputIterator>
+struct dump_ast
+  : karma::grammar<OuputIterator, expression_ast(), space_type>
+{
+    dump_ast() : dump_ast::base_type(ast_node)
+    {
+        ast_node %= int_ | binary_node | unary_node;
+        binary_node %= '(' << ast_node << char_ << ast_node << ')';
+        unary_node %= '(' << char_ << ast_node << ')';
+    }
+
+    karma::rule<OuputIterator, expression_ast(), space_type> ast_node;
+    karma::rule<OuputIterator, binary_op(), space_type> binary_node;
+    karma::rule<OuputIterator, unary_op(), space_type> unary_node;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Dump AST's for simple expressions...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    //  Our parser grammar definitions
+    typedef std::string::const_iterator iterator_type;
+    typedef calculator<iterator_type> calculator;
+
+    calculator calc; 
+
+    // Our generator grammar definitions
+    typedef std::back_insert_iterator<std::string> output_iterator_type;
+    typedef dump_ast<output_iterator_type> dump_ast;
+
+    dump_ast ast_grammar;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        expression_ast ast;
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = qi::phrase_parse(iter, end, calc, space, ast);
+
+        if (r && iter == end)
+        {
+            std::string generated;
+            output_iterator_type outit(generated);
+            r = karma::generate_delimited(outit, ast_grammar, space, ast);
+
+            if (r)
+            {
+                std::cout << "Got AST:" << std::endl << generated 
+                          << std::endl;
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \": " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/calc2_ast_rpn.cpp b/src/boost/libs/spirit/example/karma/calc2_ast_rpn.cpp
new file mode 100644
index 00000000..955f2467
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/calc2_ast_rpn.cpp
@@ -0,0 +1,172 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST which gets dumped into
+//  a reverse polish notation afterwards.
+//
+//  [ JDG April 28, 2008 ]
+//  [ HK April 28, 2008 ]
+//
+///////////////////////////////////////////////////////////////////////////////
+#include <boost/config/warning_disable.hpp>
+
+#include <iostream>
+#include <vector>
+#include <string>
+
+#include "calc2_ast.hpp"
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our calculator parser grammar
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct calculator 
+  : qi::grammar<Iterator, expression_ast(), space_type>
+{
+    calculator() : calculator::base_type(expression)
+    {
+        expression =
+            term                            [_val = _1]
+            >> *(   ('+' >> term            [_val += _1])
+                |   ('-' >> term            [_val -= _1])
+                )
+            ;
+
+        term =
+            factor                          [_val = _1]
+            >> *(   ('*' >> factor          [_val *= _1])
+                |   ('/' >> factor          [_val /= _1])
+                )
+            ;
+
+        factor =
+            uint_                           [_val = _1]
+            |   '(' >> expression           [_val = _1] >> ')'
+            |   ('-' >> factor              [_val = neg(_1)])
+            |   ('+' >> factor              [_val = pos(_1)])
+            ;
+    }
+
+    qi::rule<Iterator, expression_ast(), space_type> expression, term, factor;
+};
+
+// We need to tell fusion about our binary_op and unary_op structs
+// to make them a first-class fusion citizen
+//
+// Note: we register the members exactly in the same sequence as we need them 
+//       in the grammar
+BOOST_FUSION_ADAPT_STRUCT(
+    binary_op,
+    (expression_ast, left)
+    (expression_ast, right)
+    (char, op)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    unary_op,
+    (expression_ast, right)
+    (char, op)
+)
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our AST grammar for the generator, this prints the AST in reverse polish 
+//  notation
+///////////////////////////////////////////////////////////////////////////////
+template <typename OuputIterator>
+struct ast_rpn
+  : karma::grammar<OuputIterator, expression_ast(), space_type>
+{
+    ast_rpn() : ast_rpn::base_type(ast_node)
+    {
+        ast_node %= int_ | binary_node | unary_node;
+        binary_node %= ast_node << ast_node << char_;
+        unary_node %= '(' << ast_node << char_ << ')';
+    }
+
+    karma::rule<OuputIterator, expression_ast(), space_type> ast_node;
+    karma::rule<OuputIterator, binary_op(), space_type> binary_node;
+    karma::rule<OuputIterator, unary_op(), space_type> unary_node;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "RPN generator for simple expressions...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    //  Our parser grammar definitions
+    typedef std::string::const_iterator iterator_type;
+    typedef calculator<iterator_type> calculator;
+
+    calculator calc; 
+
+    // Our generator grammar definitions
+    typedef std::back_insert_iterator<std::string> output_iterator_type;
+    typedef ast_rpn<output_iterator_type> ast_rpn;
+
+    ast_rpn ast_grammar;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        expression_ast ast;   // this will hold the generated AST
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = qi::phrase_parse(iter, end, calc, space, ast);
+
+        if (r && iter == end)
+        {
+            std::string generated;
+            output_iterator_type outit(generated);
+            r = karma::generate_delimited(outit, ast_grammar, space, ast);
+
+            if (r)
+            {
+                std::cout << "RPN for '" << str << "': \n" << generated 
+                          << std::endl;
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \": " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/calc2_ast_vm.cpp b/src/boost/libs/spirit/example/karma/calc2_ast_vm.cpp
new file mode 100644
index 00000000..77fab096
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/calc2_ast_vm.cpp
@@ -0,0 +1,248 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST from which we generate 
+//  a simple byte code representation being interpreted by a similar virtual 
+//  machine.
+//
+//  [ JDG April 28, 2008 ]
+//  [ HK May 05, 2008 ]
+//
+///////////////////////////////////////////////////////////////////////////////
+#include <boost/config/warning_disable.hpp>
+
+#include <iostream>
+#include <vector>
+#include <string>
+
+#include "calc2_ast_vm.hpp"
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our calculator parser grammar
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct calculator 
+  : qi::grammar<Iterator, expression_ast(), space_type>
+{
+    calculator() : calculator::base_type(expression)
+    {
+        expression =
+            term                            [_val = _1]
+            >> *(   ('+' >> term            [_val += _1])
+                |   ('-' >> term            [_val -= _1])
+                )
+            ;
+
+        term =
+            factor                          [_val = _1]
+            >> *(   ('*' >> factor          [_val *= _1])
+                |   ('/' >> factor          [_val /= _1])
+                )
+            ;
+
+        factor =
+            uint_                           [_val = _1]
+            |   '(' >> expression           [_val = _1] >> ')'
+            |   ('-' >> factor              [_val = neg(_1)])
+            |   ('+' >> factor              [_val = pos(_1)])
+            ;
+    }
+
+    qi::rule<Iterator, expression_ast(), space_type> expression, term, factor;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  The Virtual Machine
+///////////////////////////////////////////////////////////////////////////////
+class vmachine
+{
+public:
+    union element {
+        int code;
+        char bytes[sizeof(int)];
+    };
+
+    vmachine(unsigned stackSize = 4096)
+      : stack(stackSize)
+      , stack_ptr(stack.begin())
+    {
+    }
+
+    int top() const { return stack_ptr[-1]; };
+    void execute(std::vector<element> const& code);
+
+private:
+    std::vector<int> stack;
+    std::vector<int>::iterator stack_ptr;
+};
+
+void vmachine::execute(std::vector<element> const& code)
+{
+    std::vector<element>::const_iterator pc = code.begin();
+    stack_ptr = stack.begin();
+
+    while ((*pc).code && pc != code.end())
+    {
+        switch ((*pc++).code)
+        {
+            case op_neg:
+                stack_ptr[-1] = -stack_ptr[-1];
+                break;
+
+            case op_add:
+                --stack_ptr;
+                stack_ptr[-1] += stack_ptr[0];
+                break;
+
+            case op_sub:
+                --stack_ptr;
+                stack_ptr[-1] -= stack_ptr[0];
+                break;
+
+            case op_mul:
+                --stack_ptr;
+                stack_ptr[-1] *= stack_ptr[0];
+                break;
+
+            case op_div:
+                --stack_ptr;
+                stack_ptr[-1] /= stack_ptr[0];
+                break;
+
+            case op_int:
+                *stack_ptr++ = (*pc++).code;
+                break;
+        }
+    }
+}
+
+// We need to tell fusion about our binary_op and unary_op structs
+// to make them a first-class fusion citizen
+//
+// Note: we register the members exactly in the same sequence as we need them 
+//       in the grammar
+BOOST_FUSION_ADAPT_STRUCT(
+    binary_op,
+    (expression_ast, left)
+    (expression_ast, right)
+    (int, op)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    unary_op,
+    (expression_ast, right)
+    (int, op)
+)
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our AST grammar for the generator, this just dumps the AST as a expression
+///////////////////////////////////////////////////////////////////////////////
+template <typename OuputIterator, typename Delimiter>
+struct generate_byte_code
+  : karma::grammar<OuputIterator, expression_ast(), Delimiter>
+{
+    generate_byte_code() : generate_byte_code::base_type(ast_node)
+    {
+        ast_node %= int_node | binary_node | unary_node;
+        int_node %= dword(op_int) << dword;
+        binary_node %= ast_node << ast_node << byte_;
+        unary_node %= ast_node << byte_;
+    }
+
+    karma::rule<OuputIterator, expression_ast(), Delimiter> ast_node;
+    karma::rule<OuputIterator, int(), Delimiter> int_node;
+    karma::rule<OuputIterator, binary_op(), Delimiter> binary_node;
+    karma::rule<OuputIterator, unary_op(), Delimiter> unary_node;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// helper function helping to deduce the delimiter type
+template <typename Delimiter>
+bool generate_vm_code(expression_ast const& ast, 
+    std::vector<vmachine::element>& code, Delimiter const& d)
+{
+    // Our generator grammar definitions
+    typedef char* output_iterator_type;
+    typedef generate_byte_code<output_iterator_type, Delimiter> generate_byte_code;
+
+    char* outbuffer = (*code.begin()).bytes;
+    generate_byte_code gen_vm;
+    return karma::generate_delimited(outbuffer, gen_vm, d, ast);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Compile simple expressions to bytecode...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    //  Our parser grammar definitions
+    typedef std::string::const_iterator iterator_type;
+    typedef calculator<iterator_type> calculator;
+
+    calculator calc; 
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        expression_ast ast;
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = qi::phrase_parse(iter, end, calc, space, ast);
+
+        if (r && iter == end)
+        {
+            // we assume a vm code size of 4096 is sufficient
+            std::vector<vmachine::element> code (4096);
+            r = generate_vm_code(ast, code, pad(4));
+
+            if (r)
+            {
+                vmachine vm;
+                vm.execute(code);
+                std::cout << "\nresult = " << vm.top() << std::endl;
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \": " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/calc2_ast_vm.hpp b/src/boost/libs/spirit/example/karma/calc2_ast_vm.hpp
new file mode 100644
index 00000000..b3a51149
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/calc2_ast_vm.hpp
@@ -0,0 +1,190 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST which gets dumped into
+//  a human readable format afterwards.
+//
+//  [ JDG April 28, 2008 ]
+//  [ HK April 28, 2008 ]
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#if !defined(SPIRIT_EXAMPLE_CALC2_AST_APR_30_2008_1011AM)
+#define SPIRIT_EXAMPLE_CALC2_AST_APR_30_2008_1011AM
+
+#include <boost/variant.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_statement.hpp>
+#include <boost/spirit/include/karma_domain.hpp>
+#include <boost/spirit/include/support_attributes_fwd.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our AST
+///////////////////////////////////////////////////////////////////////////////
+struct binary_op;
+struct unary_op;
+struct nil {};
+
+struct expression_ast
+{
+    typedef
+        boost::variant<
+            nil // can't happen!
+          , int
+          , boost::recursive_wrapper<binary_op>
+          , boost::recursive_wrapper<unary_op>
+        >
+    type;
+
+    // expose variant types 
+    typedef type::types types;
+
+    // expose variant functionality
+    int which() const { return expr.which(); }
+
+    // constructors
+    expression_ast()
+      : expr(nil()) {}
+
+    expression_ast(unary_op const& expr)
+      : expr(expr) {}
+
+    expression_ast(binary_op const& expr)
+      : expr(expr) {}
+
+    expression_ast(unsigned int expr)
+      : expr(expr) {}
+
+    expression_ast(type const& expr)
+      : expr(expr) {}
+
+    expression_ast& operator+=(expression_ast const& rhs);
+    expression_ast& operator-=(expression_ast const& rhs);
+    expression_ast& operator*=(expression_ast const& rhs);
+    expression_ast& operator/=(expression_ast const& rhs);
+
+    type expr;
+};
+
+// expose variant functionality
+namespace boost
+{
+    // this function has to live in namespace boost for ADL to correctly find it
+    template <typename T>
+    inline T get(expression_ast const& expr)
+    {
+        return boost::get<T>(expr.expr);
+    }
+
+    // the specialization below tells Spirit to handle expression_ast as if it 
+    // where a 'real' variant
+    namespace spirit { namespace traits
+    {
+        // the specialization below tells Spirit to handle expression_ast as 
+        // if it where a 'real' variant (if used with Spirit.Karma)
+        template <>
+        struct not_is_variant<expression_ast, karma::domain>
+          : mpl::false_ {};
+
+        // the specialization of variant_which allows to generically extract
+        // the current type stored in the given variant like type
+        template <>
+        struct variant_which<expression_ast>
+        {
+            static int call(expression_ast const& v)
+            {
+                return v.which();
+            }
+        };
+    }}
+}
+
+enum byte_code
+{
+    op_neg = 1,     //  negate the top stack entry
+    op_pos,         //  essentially a no-op (unary plus)
+    op_add,         //  add top two stack entries
+    op_sub,         //  subtract top two stack entries
+    op_mul,         //  multiply top two stack entries
+    op_div,         //  divide top two stack entries
+    op_int,         //  push constant integer into the stack
+};
+
+///////////////////////////////////////////////////////////////////////////////
+struct binary_op
+{
+    binary_op() {}
+    
+    binary_op(
+        int op
+      , expression_ast const& left
+      , expression_ast const& right)
+      : op(op), left(left), right(right) {}
+
+    int op;
+    expression_ast left;
+    expression_ast right;
+};
+
+struct unary_op
+{
+    unary_op(
+        int op
+      , expression_ast const& right)
+    : op(op), right(right) {}
+
+    int op;
+    expression_ast right;
+};
+
+inline expression_ast& expression_ast::operator+=(expression_ast const& rhs)
+{
+    expr = binary_op(op_add, expr, rhs);
+    return *this;
+}
+
+inline expression_ast& expression_ast::operator-=(expression_ast const& rhs)
+{
+    expr = binary_op(op_sub, expr, rhs);
+    return *this;
+}
+
+inline expression_ast& expression_ast::operator*=(expression_ast const& rhs)
+{
+    expr = binary_op(op_mul, expr, rhs);
+    return *this;
+}
+
+inline expression_ast& expression_ast::operator/=(expression_ast const& rhs)
+{
+    expr = binary_op(op_div, expr, rhs);
+    return *this;
+}
+
+// We should be using expression_ast::operator-. There's a bug
+// in phoenix type deduction mechanism that prevents us from
+// doing so. Phoenix will be switching to BOOST_TYPEOF. In the
+// meantime, we will use a phoenix::function below:
+template <char Op>
+struct unary_expr
+{
+    template <typename T>
+    struct result { typedef T type; };
+
+    expression_ast operator()(expression_ast const& expr) const
+    {
+        return unary_op(Op, expr);
+    }
+};
+
+boost::phoenix::function<unary_expr<op_pos> > pos;
+boost::phoenix::function<unary_expr<op_neg> > neg;
+
+#endif
diff --git a/src/boost/libs/spirit/example/karma/classify_char.cpp b/src/boost/libs/spirit/example/karma/classify_char.cpp
new file mode 100644
index 00000000..df113f33
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/classify_char.cpp
@@ -0,0 +1,103 @@
+//   Copyright (c) 2001-2010 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)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A character classification example
+//
+//  [ HK August 12, 2009 ]  spirit2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+
+#include <iostream>
+#include <string>
+#include <complex>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our character classification generator
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_karma_complex_number
+    template <typename OutputIterator>
+    bool classify_character(OutputIterator sink, char c)
+    {
+        using boost::spirit::ascii::char_;
+        using boost::spirit::ascii::digit;
+        using boost::spirit::ascii::xdigit;
+        using boost::spirit::ascii::alpha;
+        using boost::spirit::ascii::punct;
+        using boost::spirit::ascii::space;
+        using boost::spirit::ascii::cntrl;
+        using boost::spirit::karma::omit;
+        using boost::spirit::karma::generate;
+
+        if (!boost::spirit::char_encoding::ascii::isascii_(c))
+            return false;
+
+        return generate(sink,
+            //  Begin grammar
+            (
+                "The character '" << char_ << "' is "
+                <<  (   &digit  << "a digit"
+                    |   &xdigit << "a xdigit"
+                    |   &alpha  << "a alpha"
+                    |   &punct  << "a punct"
+                    |   &space  << "a space"
+                    |   &cntrl  << "a cntrl"
+                    |   "of unknown type"
+                    )
+            ),
+            //  End grammar
+            c, c
+        );
+    }
+    //]
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA character classification micro generator for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a character to classify\n";
+    std::cout << "Type [q or Q] to quit\n\n";
+
+    std::string str;
+    while (getline(std::cin, str))
+    {
+        if (str.empty())
+            break;
+
+        std::string generated;
+        std::back_insert_iterator<std::string> sink(generated);
+        if (!client::classify_character(sink, str[0]))
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Generating failed\n";
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::cout << generated << "\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/complex_number.cpp b/src/boost/libs/spirit/example/karma/complex_number.cpp
new file mode 100644
index 00000000..d832553b
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/complex_number.cpp
@@ -0,0 +1,132 @@
+//   Copyright (c) 2001-2010 Hartmut Kaiser
+//   Copyright (c) 2001-2010 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)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A complex number micro generator.
+//
+//  [ HK July 7, 2009 ]  spirit2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+
+#include <iostream>
+#include <string>
+#include <complex>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our complex number parser/compiler (that's just a copy of the complex 
+    //  number example from Qi (see examples/qi/complex_number.cpp)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    bool parse_complex(Iterator first, Iterator last, std::complex<double>& c)
+    {
+        using boost::spirit::qi::double_;
+        using boost::spirit::qi::_1;
+        using boost::spirit::qi::phrase_parse;
+        using boost::spirit::ascii::space;
+        using boost::phoenix::ref;
+
+        double rN = 0.0;
+        double iN = 0.0;
+        bool r = phrase_parse(first, last,
+            (
+                    '(' >> double_[ref(rN) = _1]
+                        >> -(',' >> double_[ref(iN) = _1]) >> ')'
+                |   double_[ref(rN) = _1]
+            ),
+            space);
+
+        if (!r || first != last) // fail if we did not get a full match
+            return false;
+        c = std::complex<double>(rN, iN);
+        return r;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our complex number generator
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_karma_complex_number
+    template <typename OutputIterator>
+    bool generate_complex(OutputIterator sink, std::complex<double> const& c)
+    {
+        using boost::spirit::karma::eps;
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::_1;
+        using boost::spirit::karma::generate;
+
+        return generate(sink,
+            //  Begin grammar
+            (
+                eps(c.imag() != 0) << 
+                '(' << double_[_1 = c.real()] << ", " << double_[_1 = c.imag()] << ')'
+            |   double_[_1 = c.real()]
+            )
+            //  End grammar
+        );
+    }
+    //]
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA complex number micro generator for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a complex number of the form r or (r) or (r,i) \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::complex<double> c;
+        if (client::parse_complex(str.begin(), str.end(), c))
+        {
+            std::cout << "-------------------------\n";
+
+            std::string generated;
+            std::back_insert_iterator<std::string> sink(generated);
+            if (!client::generate_complex(sink, c))
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generated: " << generated << "\n";
+                std::cout << "-------------------------\n";
+            }
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/complex_number_adapt.cpp b/src/boost/libs/spirit/example/karma/complex_number_adapt.cpp
new file mode 100644
index 00000000..25135e08
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/complex_number_adapt.cpp
@@ -0,0 +1,153 @@
+//   Copyright (c) 2001-2010 Hartmut Kaiser
+//   Copyright (c) 2001-2010 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)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A complex number micro generator - take 3. 
+// 
+//  Look'ma, still no semantic actions! And no explicit access to member 
+//  functions any more.
+//
+//  [ HK April 6, 2010 ]  spirit2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+#include <boost/fusion/include/adapt_adt.hpp>
+#include <boost/spirit/include/support_adapt_adt_attributes.hpp>
+
+#include <iostream>
+#include <string>
+#include <complex>
+
+///////////////////////////////////////////////////////////////////////////////
+// The following macro adapts the type std::complex<double> as a fusion 
+// sequence. 
+//[tutorial_karma_complex_number_adapt_class
+// We can leave off the setters as Karma does not need them.
+BOOST_FUSION_ADAPT_ADT(
+    std::complex<double>,
+    (bool, bool, obj.imag() != 0, /**/)
+    (double, double, obj.real(), /**/)
+    (double, double, obj.imag(), /**/)
+)
+//]
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our complex number parser/compiler (that's just a copy of the complex 
+    //  number example from Qi (see examples/qi/complex_number.cpp)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    bool parse_complex(Iterator first, Iterator last, std::complex<double>& c)
+    {
+        using boost::spirit::qi::double_;
+        using boost::spirit::qi::_1;
+        using boost::spirit::qi::phrase_parse;
+        using boost::spirit::ascii::space;
+        using boost::phoenix::ref;
+
+        double rN = 0.0;
+        double iN = 0.0;
+        bool r = phrase_parse(first, last,
+            (
+                    '(' >> double_[ref(rN) = _1]
+                        >> -(',' >> double_[ref(iN) = _1]) >> ')'
+                |   double_[ref(rN) = _1]
+            ),
+            space);
+
+        if (!r || first != last) // fail if we did not get a full match
+            return false;
+        c = std::complex<double>(rN, iN);
+        return r;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our complex number generator
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_karma_complex_number_adapt
+    template <typename OutputIterator>
+    bool generate_complex(OutputIterator sink, std::complex<double> const& c)
+    {
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::bool_;
+        using boost::spirit::karma::true_;
+        using boost::spirit::karma::omit;
+        using boost::spirit::karma::generate;
+
+        return generate(sink,
+
+            //  Begin grammar
+            (
+               &true_ << '(' << double_ << ", " << double_ << ')'
+            |   omit[bool_]  << double_ 
+            ),
+            //  End grammar
+
+            c     //  Data to output
+        );
+    }
+    //]
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA complex number micro generator for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a complex number of the form r or (r) or (r,i) \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::complex<double> c;
+        if (client::parse_complex(str.begin(), str.end(), c))
+        {
+            std::cout << "-------------------------\n";
+
+            std::string generated;
+            std::back_insert_iterator<std::string> sink(generated);
+            if (!client::generate_complex(sink, c))
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generated: " << generated << "\n";
+                std::cout << "-------------------------\n";
+            }
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/complex_number_easier.cpp b/src/boost/libs/spirit/example/karma/complex_number_easier.cpp
new file mode 100644
index 00000000..0fe05149
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/complex_number_easier.cpp
@@ -0,0 +1,133 @@
+//   Copyright (c) 2001-2010 Hartmut Kaiser
+//   Copyright (c) 2001-2010 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)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A complex number micro generator - take 2. Look'ma no semantic actions!
+//
+//  [ HK July 26, 2009 ]  spirit2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+
+#include <iostream>
+#include <string>
+#include <complex>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our complex number parser/compiler (that's just a copy of the complex 
+    //  number example from Qi (see examples/qi/complex_number.cpp)
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    bool parse_complex(Iterator first, Iterator last, std::complex<double>& c)
+    {
+        using boost::spirit::qi::double_;
+        using boost::spirit::qi::_1;
+        using boost::spirit::qi::phrase_parse;
+        using boost::spirit::ascii::space;
+        using boost::phoenix::ref;
+
+        double rN = 0.0;
+        double iN = 0.0;
+        bool r = phrase_parse(first, last,
+            (
+                    '(' >> double_[ref(rN) = _1]
+                        >> -(',' >> double_[ref(iN) = _1]) >> ')'
+                |   double_[ref(rN) = _1]
+            ),
+            space);
+
+        if (!r || first != last) // fail if we did not get a full match
+            return false;
+        c = std::complex<double>(rN, iN);
+        return r;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our complex number generator
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_karma_complex_number_easier
+    template <typename OutputIterator>
+    bool generate_complex(OutputIterator sink, std::complex<double> const& c)
+    {
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::omit;
+        using boost::spirit::karma::generate;
+
+        return generate(sink,
+
+            //  Begin grammar
+            (
+               !double_(0.0) << '(' << double_ << ", " << double_ << ')'
+            |   omit[double_] << double_
+            ),
+            //  End grammar
+
+            c.imag(), c.real(), c.imag()     //  Data to output
+        );
+    }
+    //]
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA complex number micro generator for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a complex number of the form r or (r) or (r,i) \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::complex<double> c;
+        if (client::parse_complex(str.begin(), str.end(), c))
+        {
+            std::cout << "-------------------------\n";
+
+            std::string generated;
+            std::back_insert_iterator<std::string> sink(generated);
+            if (!client::generate_complex(sink, c))
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generated: " << generated << "\n";
+                std::cout << "-------------------------\n";
+            }
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/customize_counter.cpp b/src/boost/libs/spirit/example/karma/customize_counter.cpp
new file mode 100644
index 00000000..62506928
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/customize_counter.cpp
@@ -0,0 +1,127 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    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)
+=============================================================================*/
+#include <boost/config/warning_disable.hpp>
+
+//[customize_karma_counter_includes
+#include <boost/spirit/include/karma.hpp>
+#include <iostream>
+#include <vector>
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//[customize_karma_counter_data
+namespace client
+{
+    struct counter
+    {
+        // expose the current value of the counter as our iterator
+        typedef int iterator;
+
+        // expose 'int' as the type of each generated element
+        typedef int type;
+
+        counter(int max_count) 
+          : counter_(0), max_count_(max_count)
+        {}
+
+        int counter_;
+        int max_count_;
+    };
+}
+//]
+
+//[customize_karma_counter_traits
+// All specializations of attribute customization points have to be placed into
+// the namespace boost::spirit::traits.
+//
+// Note that all templates below are specialized using the 'const' type.
+// This is necessary as all attributes in Karma are 'const'.
+namespace boost { namespace spirit { namespace traits
+{
+    // The specialization of the template 'is_container<>' will tell the 
+    // library to treat the type 'client::counter' as a container providing 
+    // the items to generate output from.
+    template <>
+    struct is_container<client::counter const>
+      : mpl::true_
+    {};
+
+    // The specialization of the template 'container_iterator<>' will be
+    // invoked by the library to evaluate the iterator type to be used
+    // for iterating the data elements in the container. 
+    template <>
+    struct container_iterator<client::counter const>
+    {
+        typedef client::counter::iterator type;
+    };
+
+    // The specialization of the templates 'begin_container<>' and 
+    // 'end_container<>' below will be used by the library to get the iterators 
+    // pointing to the begin and the end of the data to generate output from. 
+    // These specializations respectively return the initial and maximum 
+    // counter values.
+    //
+    // The passed argument refers to the attribute instance passed to the list 
+    // generator.
+    template <>
+    struct begin_container<client::counter const>
+    {
+        static client::counter::iterator 
+        call(client::counter const& c)
+        {
+            return c.counter_;
+        }
+    };
+
+    template <>
+    struct end_container<client::counter const>
+    {
+        static client::counter::iterator 
+        call(client::counter const& c)
+        {
+            return c.max_count_;
+        }
+    };
+}}}
+//]
+
+//[customize_karma_counter_iterator_traits
+// All specializations of attribute customization points have to be placed into
+// the namespace boost::spirit::traits.
+namespace boost { namespace spirit { namespace traits
+{
+    // The specialization of the template 'deref_iterator<>' will be used to 
+    // dereference the iterator associated with our counter data structure.
+    // Since we expose the current value as the iterator we just return the 
+    // current iterator as the return value.
+    template <>
+    struct deref_iterator<client::counter::iterator>
+    {
+        typedef client::counter::type type;
+
+        static type call(client::counter::iterator const& it)
+        {
+            return it;
+        }
+    };
+}}}
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+namespace karma = boost::spirit::karma;
+
+int main()
+{
+    //[customize_karma_counter
+    // use the instance of a 'client::counter' instead of a STL vector
+    client::counter count(4);
+    std::cout << karma::format(karma::int_ % ", ", count) << std::endl;   // prints: '0, 1, 2, 3'
+    //]
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/customize_embedded_container.cpp b/src/boost/libs/spirit/example/karma/customize_embedded_container.cpp
new file mode 100644
index 00000000..c0c071b4
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/customize_embedded_container.cpp
@@ -0,0 +1,108 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    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)
+=============================================================================*/
+#include <boost/config/warning_disable.hpp>
+
+//[customize_karma_embedded_container_includes
+#include <boost/spirit/include/karma.hpp>
+#include <iostream>
+#include <vector>
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//[customize_karma_embedded_container_data
+namespace client
+{
+    struct embedded_container
+    {
+        // expose the iterator of the embedded vector as our iterator
+        typedef std::vector<int>::const_iterator iterator;
+
+        // expose the type of the held data elements as our type
+        typedef std::vector<int>::value_type type;
+
+        // this is the vector holding the actual elements we need to generate 
+        // output from
+        std::vector<int> data;
+    };
+}
+//]
+
+//[customize_karma_embedded_container_traits
+// All specializations of attribute customization points have to be placed into
+// the namespace boost::spirit::traits.
+//
+// Note that all templates below are specialized using the 'const' type.
+// This is necessary as all attributes in Karma are 'const'.
+namespace boost { namespace spirit { namespace traits
+{
+    // The specialization of the template 'is_container<>' will tell the 
+    // library to treat the type 'client::embedded_container' as a 
+    // container holding the items to generate output from.
+    template <>
+    struct is_container<client::embedded_container const>
+      : mpl::true_
+    {};
+
+    // The specialization of the template 'container_iterator<>' will be
+    // invoked by the library to evaluate the iterator type to be used
+    // for iterating the data elements in the container. We simply return
+    // the type of the iterator exposed by the embedded 'std::vector<int>'.
+    template <>
+    struct container_iterator<client::embedded_container const>
+    {
+        typedef client::embedded_container::iterator type;
+    };
+
+    // The specialization of the templates 'begin_container<>' and 
+    // 'end_container<>' below will be used by the library to get the iterators 
+    // pointing to the begin and the end of the data to generate output from. 
+    // These specializations simply return the 'begin' and 'end' iterators as 
+    // exposed by the embedded 'std::vector<int>'.
+    //
+    // The passed argument refers to the attribute instance passed to the list 
+    // generator.
+    template <>
+    struct begin_container<client::embedded_container const>
+    {
+        static client::embedded_container::iterator 
+        call(client::embedded_container const& d)
+        {
+            return d.data.begin();
+        }
+    };
+
+    template <>
+    struct end_container<client::embedded_container const>
+    {
+        static client::embedded_container::iterator 
+        call(client::embedded_container const& d)
+        {
+            return d.data.end();
+        }
+    };
+}}}
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+namespace karma = boost::spirit::karma;
+
+int main()
+{
+    //[customize_karma_embedded_container
+    client::embedded_container d1;    // create some test data
+    d1.data.push_back(1);
+    d1.data.push_back(2);
+    d1.data.push_back(3);
+
+    // use the instance of an 'client::embedded_container' instead of a 
+    // STL vector
+    std::cout << karma::format(karma::int_ % ", ", d1) << std::endl;   // prints: '1, 2, 3'
+    //]
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/customize_use_as_container.cpp b/src/boost/libs/spirit/example/karma/customize_use_as_container.cpp
new file mode 100644
index 00000000..c0116c8a
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/customize_use_as_container.cpp
@@ -0,0 +1,164 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    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)
+=============================================================================*/
+#include <boost/config/warning_disable.hpp>
+
+//[customize_karma_use_as_container_includes
+#include <boost/spirit/include/karma.hpp>
+#include <iostream>
+#include <string>
+#include <vector>
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//[customize_karma_use_as_container_data
+namespace client
+{
+    struct use_as_container
+    {
+        // Expose a pair holding a pointer to the use_as_container and to the 
+        // current element as our iterator.
+        // We intentionally leave out having it a 'operator==()' to demonstrate
+        // the use of the 'compare_iterators' customization point.
+        struct iterator
+        {
+            iterator(use_as_container const* container, int const* current)
+              : container_(container), current_(current)
+            {}
+
+            use_as_container const* container_;
+            int const* current_;
+        };
+
+        // expose 'int' as the type of each generated element
+        typedef int type;
+
+        use_as_container(int value1, int value2, int value3) 
+          : value1_(value1), value2_(value2), value3_(value3)
+        {}
+
+        int value1_;
+        std::string dummy1_;    // insert some unrelated data
+        int value2_;
+        std::string dummy2_;    // insert some more unrelated data
+        int value3_;
+    };
+}
+//]
+
+//[customize_karma_use_as_container_traits
+// All specializations of attribute customization points have to be placed into
+// the namespace boost::spirit::traits.
+//
+// Note that all templates below are specialized using the 'const' type.
+// This is necessary as all attributes in Karma are 'const'.
+namespace boost { namespace spirit { namespace traits
+{
+    // The specialization of the template 'is_container<>' will tell the 
+    // library to treat the type 'client::use_as_container' as a 
+    // container holding the items to generate output from.
+    template <>
+    struct is_container<client::use_as_container const>
+      : mpl::true_
+    {};
+
+    // The specialization of the template 'container_iterator<>' will be
+    // invoked by the library to evaluate the iterator type to be used
+    // for iterating the data elements in the container. We simply return
+    // the type of the iterator exposed by the embedded 'std::vector<int>'.
+    template <>
+    struct container_iterator<client::use_as_container const>
+    {
+        typedef client::use_as_container::iterator type;
+    };
+
+    // The specialization of the templates 'begin_container<>' and 
+    // 'end_container<>' below will be used by the library to get the iterators 
+    // pointing to the begin and the end of the data to generate output from. 
+    //
+    // The passed argument refers to the attribute instance passed to the list 
+    // generator.
+    template <>
+    struct begin_container<client::use_as_container const>
+    {
+        static client::use_as_container::iterator 
+        call(client::use_as_container const& c)
+        {
+            return client::use_as_container::iterator(&c, &c.value1_);
+        }
+    };
+
+    template <>
+    struct end_container<client::use_as_container const>
+    {
+        static client::use_as_container::iterator 
+        call(client::use_as_container const& c)
+        {
+            return client::use_as_container::iterator(&c, (int const*)0);
+        }
+    };
+}}}
+//]
+
+//[customize_karma_use_as_container_iterator_traits
+// All specializations of attribute customization points have to be placed into
+// the namespace boost::spirit::traits.
+namespace boost { namespace spirit { namespace traits
+{
+    // The specialization of the template 'deref_iterator<>' will be used to 
+    // dereference the iterator associated with our counter data structure.
+    template <>
+    struct deref_iterator<client::use_as_container::iterator>
+    {
+        typedef client::use_as_container::type type;
+
+        static type call(client::use_as_container::iterator const& it)
+        {
+            return *it.current_;
+        }
+    };
+
+    template <>
+    struct next_iterator<client::use_as_container::iterator>
+    {
+        static void call(client::use_as_container::iterator& it)
+        {
+            if (it.current_ == &it.container_->value1_)
+                it.current_ = &it.container_->value2_;
+            else if (it.current_ == &it.container_->value2_)
+                it.current_ = &it.container_->value3_;
+            else
+                it.current_ = 0;
+        }
+    };
+
+    template <>
+    struct compare_iterators<client::use_as_container::iterator>
+    {
+        static bool call(client::use_as_container::iterator const& it1
+          , client::use_as_container::iterator const& it2)
+        {
+            return it1.current_ == it2.current_ && 
+                   it1.container_ == it2.container_;
+        }
+    };
+}}}
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+namespace karma = boost::spirit::karma;
+
+int main()
+{
+    //[customize_karma_use_as_container
+    client::use_as_container d2 (1, 2, 3);
+    // use the instance of a 'client::use_as_container' instead of a STL vector
+    std::cout << karma::format(karma::int_ % ", ", d2) << std::endl;   // prints: '1, 2, 3'
+    //]
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/escaped_string.cpp b/src/boost/libs/spirit/example/karma/escaped_string.cpp
new file mode 100644
index 00000000..f3c2fe6f
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/escaped_string.cpp
@@ -0,0 +1,66 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The purpose of this example is to show how any character sequence can be
+//  printed while being properly quoted.
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/karma.hpp>
+
+namespace client
+{
+    namespace karma = boost::spirit::karma;
+
+    template <typename OutputIterator>
+    struct escaped_string
+      : karma::grammar<OutputIterator, std::string(char const*)>
+    {
+        escaped_string()
+          : escaped_string::base_type(esc_str)
+        {
+            esc_char.add('\a', "\\a")('\b', "\\b")('\f', "\\f")('\n', "\\n")
+                        ('\r', "\\r")('\t', "\\t")('\v', "\\v")('\\', "\\\\")
+                        ('\'', "\\\'")('\"', "\\\"")
+                ;
+
+            esc_str =   karma::lit(karma::_r1) 
+                    << *(esc_char | karma::print | "\\x" << karma::hex) 
+                    <<  karma::lit(karma::_r1)
+                ;
+        }
+
+        karma::rule<OutputIterator, std::string(char const*)> esc_str;
+        karma::symbols<char, char const*> esc_char;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    namespace karma = boost::spirit::karma;
+
+    typedef std::back_insert_iterator<std::string> sink_type;
+
+    std::string generated;
+    sink_type sink(generated);
+
+    std::string str("string to escape: \n\r\t\"'\x19");
+    char const* quote = "'''";
+
+    client::escaped_string<sink_type> g;
+    if (!karma::generate(sink, g(quote), str))
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Generating failed\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Generated: " << generated << "\n";
+        std::cout << "-------------------------\n";
+    }
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/karma/generate_code.cpp b/src/boost/libs/spirit/example/karma/generate_code.cpp
new file mode 100644
index 00000000..3a409a77
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/generate_code.cpp
@@ -0,0 +1,80 @@
+//   Copyright (c) 2001-2010 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)
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Several small snippets generating different C++ code constructs
+//
+//  [ HK October 08, 2009 ]  Spirit V2.2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/phoenix.hpp>
+
+#include <iostream>
+#include <string>
+#include <complex>
+
+namespace client
+{
+    namespace karma = boost::spirit::karma;
+    namespace phoenix = boost::phoenix;
+
+    // create for instance: int name[5] = { 1, 2, 3, 4, 5 };
+    template <typename Iterator>
+    struct int_array : karma::grammar<Iterator, std::vector<int>()>
+    {
+        int_array(char const* name) : int_array::base_type(start)
+        {
+            using karma::int_;
+            using karma::uint_;
+            using karma::eol;
+            using karma::lit;
+            using karma::_val;
+            using karma::_r1;
+
+            start = array_def(phoenix::size(_val)) << " = " << initializer 
+                                                   << ';' << eol;
+            array_def = "int " << lit(name) << "[" << uint_(_r1) << "]";
+            initializer = "{ " << -(int_ % ", ") << " }";
+        }
+
+        karma::rule<Iterator, void(unsigned)> array_def;
+        karma::rule<Iterator, std::vector<int>()> initializer;
+        karma::rule<Iterator, std::vector<int>()> start;
+    };
+
+    typedef std::back_insert_iterator<std::string> iterator_type;
+    bool generate_array(char const* name, std::vector<int> const& v)
+    {
+        std::string generated;
+        iterator_type sink(generated);
+        int_array<iterator_type> g(name);
+        if (karma::generate(sink, g, v))
+        {
+            std::cout << generated;
+            return true;
+        }
+        return false;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    // generate an array of integers with initializers
+    std::vector<int> v;
+    v.push_back(1);
+    v.push_back(2);
+    v.push_back(3);
+    v.push_back(4);
+    client::generate_array("array1", v);
+
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/karma/key_value_sequence.cpp b/src/boost/libs/spirit/example/karma/key_value_sequence.cpp
new file mode 100644
index 00000000..db2de2cc
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/key_value_sequence.cpp
@@ -0,0 +1,74 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The main purpose of this example is to show how we can generate output from 
+//  a container holding key/value pairs.
+//
+//  For more information see here: http://spirit.sourceforge.net/home/?p=400
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/karma_stream.hpp>
+#include <boost/spirit/include/phoenix.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+
+#include <iostream>
+#include <map>
+#include <algorithm>
+#include <cstdlib> 
+
+namespace client
+{
+    namespace karma = boost::spirit::karma;
+
+    typedef std::pair<std::string, boost::optional<std::string> > pair_type;
+
+    template <typename OutputIterator>
+    struct keys_and_values
+      : karma::grammar<OutputIterator, std::vector<pair_type>()>
+    {
+        keys_and_values()
+          : keys_and_values::base_type(query)
+        {
+            query =  pair << *('&' << pair);
+            pair  =  karma::string << -('=' << karma::string);
+        }
+
+        karma::rule<OutputIterator, std::vector<pair_type>()> query;
+        karma::rule<OutputIterator, pair_type()> pair;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    namespace karma = boost::spirit::karma;
+
+    typedef std::vector<client::pair_type>::value_type value_type;
+    typedef std::back_insert_iterator<std::string> sink_type;
+
+    std::vector<client::pair_type> v;
+    v.push_back(value_type("key1", boost::optional<std::string>("value1")));
+    v.push_back(value_type("key2", boost::optional<std::string>()));
+    v.push_back(value_type("key3", boost::optional<std::string>("")));
+
+    std::string generated;
+    sink_type sink(generated);
+    client::keys_and_values<sink_type> g;
+    if (!karma::generate(sink, g, v))
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Generating failed\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Generated: " << generated << "\n";
+        std::cout << "-------------------------\n";
+    }
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/mini_xml_karma.cpp b/src/boost/libs/spirit/example/karma/mini_xml_karma.cpp
new file mode 100644
index 00000000..596fd78c
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/mini_xml_karma.cpp
@@ -0,0 +1,222 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Joel de Guzman
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A mini XML-like parser, Karma is used to print out the generated AST
+//
+//  [ JDG March 25, 2007 ]   spirit2
+//  [ HK April 02, 2007  ]   spirit2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_fusion.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_stl.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/variant/recursive_variant.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+
+namespace fusion = boost::fusion;
+namespace phoenix = boost::phoenix;
+
+using phoenix::at_c;
+using phoenix::push_back;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our mini XML tree representation
+///////////////////////////////////////////////////////////////////////////////
+struct mini_xml;
+
+typedef
+    boost::variant<
+        boost::recursive_wrapper<mini_xml>
+      , std::string
+    >
+mini_xml_node;
+
+struct mini_xml
+{
+    std::string name;                           // tag name
+    std::vector<mini_xml_node> children;        // children
+};
+
+// We need to tell fusion about our mini_xml struct
+// to make it a first-class fusion citizen
+BOOST_FUSION_ADAPT_STRUCT(
+    mini_xml,
+    (std::string, name)
+    (std::vector<mini_xml_node>, children)
+)
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our mini XML grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct mini_xml_parser :
+    qi::grammar<Iterator, mini_xml(), space_type>
+{
+    mini_xml_parser() : mini_xml_parser::base_type(xml)
+    {
+        text = lexeme[+(char_ - '<')        [_val += _1]];
+        node = (xml | text)                 [_val = _1];
+
+        start_tag =
+                '<'
+            >>  !lit('/')
+            >>  lexeme[+(char_ - '>')       [_val += _1]]
+            >>  '>'
+        ;
+
+        end_tag =
+                "</"
+            >>  lit(_r1)
+            >>  '>'
+        ;
+
+        xml =
+                start_tag                   [at_c<0>(_val) = _1]
+            >>  *node                       [push_back(at_c<1>(_val), _1)]
+            >>  end_tag(at_c<0>(_val))
+        ;
+    }
+
+    qi::rule<Iterator, mini_xml(), space_type> xml;
+    qi::rule<Iterator, mini_xml_node(), space_type> node;
+    qi::rule<Iterator, std::string(), space_type> text;
+    qi::rule<Iterator, std::string(), space_type> start_tag;
+    qi::rule<Iterator, void(std::string), space_type> end_tag;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  A couple of phoenix functions helping to access the elements of the 
+//  generated AST
+///////////////////////////////////////////////////////////////////////////////
+template <typename T>
+struct get_element
+{
+    template <typename T1>
+    struct result { typedef T const& type; };
+
+    T const& operator()(mini_xml_node const& node) const
+    {
+        return boost::get<T>(node);
+    }
+};
+
+phoenix::function<get_element<std::string> > _string;
+phoenix::function<get_element<mini_xml> > _xml;
+
+///////////////////////////////////////////////////////////////////////////////
+//  The output grammar defining the format of the generated data
+///////////////////////////////////////////////////////////////////////////////
+template <typename OutputIterator>
+struct mini_xml_generator
+  : karma::grammar<OutputIterator, mini_xml()>
+{
+    mini_xml_generator() : mini_xml_generator::base_type(xml)
+    {
+        node %= string | xml;
+        xml = 
+                '<'  << string[_1 = at_c<0>(_val)] << '>'
+            <<         (*node)[_1 = at_c<1>(_val)]
+            <<  "</" << string[_1 = at_c<0>(_val)] << '>'
+            ;
+    }
+
+    karma::rule<OutputIterator, mini_xml()> xml;
+    karma::rule<OutputIterator, mini_xml_node()> node;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    std::string storage; // We will read the contents here.
+    in.unsetf(std::ios::skipws); // No white space skipping!
+    std::copy(
+        std::istream_iterator<char>(in),
+        std::istream_iterator<char>(),
+        std::back_inserter(storage));
+
+    typedef mini_xml_parser<std::string::const_iterator> mini_xml_parser;
+    mini_xml_parser xmlin;  //  Our grammar definition
+    mini_xml ast; // our tree
+
+    std::string::const_iterator iter = storage.begin();
+    std::string::const_iterator end = storage.end();
+    bool r = qi::phrase_parse(iter, end, xmlin, space, ast);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+
+        typedef std::back_insert_iterator<std::string> outiter_type;
+        typedef mini_xml_generator<outiter_type> mini_xml_generator;
+
+        mini_xml_generator xmlout;                 //  Our grammar definition
+
+        std::string generated;
+        outiter_type outit(generated);
+        bool r = karma::generate(outit, xmlout, ast);
+
+        if (r)
+            std::cout << generated << std::endl;
+        return 0;
+    }
+    else
+    {
+        std::string::const_iterator begin = storage.begin();
+        std::size_t dist = std::distance(begin, iter);
+        std::string::const_iterator some = 
+            iter + (std::min)(storage.size()-dist, std::size_t(30));
+        std::string context(iter, some);
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \": " << context << "...\"\n";
+        std::cout << "-------------------------\n";
+        return 1;
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/num_list1.cpp b/src/boost/libs/spirit/example/karma/num_list1.cpp
new file mode 100644
index 00000000..7b079b04
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/num_list1.cpp
@@ -0,0 +1,121 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 Hartmut Kaiser
+    Copyright (c) 2002-2010 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 demonstrates a generator for a comma separated list of numbers.
+//  No actions. It is based on the example qi/num_lists.cpp for reading in
+//  some numbers to generate.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+
+#include <iostream>
+#include <string>
+#include <list>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace karma = boost::spirit::karma;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list parser, please see the example qi/numlist1.cpp for
+    //  more information
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last, std::list<double>& v)
+    {
+        using qi::double_;
+        using qi::phrase_parse;
+        using ascii::space;
+
+        bool r = phrase_parse(first, last, double_ >> *(',' >> double_), space, v);
+        if (first != last)
+            return false;
+        return r;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list generator
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_karma_numlist1
+    template <typename OutputIterator>
+    bool generate_numbers(OutputIterator& sink, std::list<double> const& v)
+    {
+        using karma::double_;
+        using karma::generate_delimited;
+        using ascii::space;
+
+        bool r = generate_delimited(
+            sink,                           // destination: output iterator
+            double_ << *(',' << double_),   // the generator
+            space,                          // the delimiter-generator
+            v                               // the data to output 
+        );
+        return r;
+    }
+    //]
+}
+
+////////////////////////////////////////////////////////////////////////////
+//  Main program
+////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA comma separated list generator for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a comma separated list 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::list<double> v;      // here we put the data to generate
+        if (client::parse_numbers(str.begin(), str.end(), v))
+        {
+            // ok, we got some numbers, now print them back out
+            std::cout << "-------------------------\n";
+
+            std::string generated;
+            std::back_insert_iterator<std::string> sink(generated);
+            if (!client::generate_numbers(sink, v))
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generated: " << generated << "\n";
+                std::cout << "-------------------------\n";
+            }
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/num_list2.cpp b/src/boost/libs/spirit/example/karma/num_list2.cpp
new file mode 100644
index 00000000..ce16fafe
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/num_list2.cpp
@@ -0,0 +1,117 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 Hartmut Kaiser
+    Copyright (c) 2002-2010 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 demonstrates a generator for a comma separated list of numbers.
+//  No actions. It is based on the example qi/num_lists.cpp for reading in
+//  some numbers to generate.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list parser, please see the example qi/numlist1.cpp for
+    //  more information
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
+    {
+        using boost::spirit::qi::double_;
+        using boost::spirit::qi::phrase_parse;
+        using boost::spirit::ascii::space;
+
+        bool r = phrase_parse(first, last, double_ % ',', space, v);
+        if (first != last)
+            return false;
+        return r;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list generator
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_karma_numlist2
+    template <typename OutputIterator, typename Container>
+    bool generate_numbers(OutputIterator& sink, Container const& v)
+    {
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::generate_delimited;
+        using boost::spirit::ascii::space;
+
+        bool r = generate_delimited(
+            sink,                           // destination: output iterator
+            double_ % ',',                  // the generator
+            space,                          // the delimiter-generator
+            v                               // the data to output 
+        );
+        return r;
+    }
+    //]
+}
+
+////////////////////////////////////////////////////////////////////////////
+//  Main program
+////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA comma separated list generator for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a comma separated list 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;      // here we put the data to generate
+        if (client::parse_numbers(str.begin(), str.end(), v))
+        {
+            // ok, we got some numbers, now print them back out
+            std::cout << "-------------------------\n";
+
+            std::string generated;
+            std::back_insert_iterator<std::string> sink(generated);
+            if (!client::generate_numbers(sink, v))
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generated: " << generated << "\n";
+                std::cout << "-------------------------\n";
+            }
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/num_list3.cpp b/src/boost/libs/spirit/example/karma/num_list3.cpp
new file mode 100644
index 00000000..253de1b4
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/num_list3.cpp
@@ -0,0 +1,150 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 Hartmut Kaiser
+    Copyright (c) 2002-2010 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 demonstrates a generator for a comma separated list of numbers.
+//  No actions. It is based on the example qi/num_lists.cpp for reading in
+//  some numbers to generate.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list parser, please see the example qi/numlist1.cpp for
+    //  more information
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
+    {
+        using boost::spirit::qi::double_;
+        using boost::spirit::qi::phrase_parse;
+        using boost::spirit::ascii::space;
+
+        bool r = phrase_parse(first, last, double_ % ',', space, v);
+        if (first != last)
+            return false;
+        return r;
+    }
+
+    //[tutorial_karma_numlist3_complex
+    // a simple complex number representation z = a + bi
+    struct complex
+    {
+        complex (double a, double b = 0.0) : a(a), b(b) {}
+
+        double a;
+        double b;
+    };
+
+    // the streaming operator for the type complex
+    std::ostream& 
+    operator<< (std::ostream& os, complex const& z)
+    {
+        os << "{" << z.a << "," << z.b << "}";
+        return os;
+    }
+    //]
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list generator
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_karma_numlist3
+    template <typename OutputIterator, typename Container>
+    bool generate_numbers(OutputIterator& sink, Container const& v)
+    {
+        using boost::spirit::karma::stream;
+        using boost::spirit::karma::generate;
+        using boost::spirit::karma::eol;
+
+        bool r = generate(
+            sink,                           // destination: output iterator
+            stream % eol,                   // the generator
+            v                               // the data to output 
+        );
+        return r;
+    }
+    //]
+}
+
+////////////////////////////////////////////////////////////////////////////
+//  Main program
+////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\tA comma separated list generator for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a comma separated list 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;      // here we put the data gotten from input
+        if (client::parse_numbers(str.begin(), str.end(), v))
+        {
+            // ok, we got some numbers, fill a vector of client::complex 
+            // instances and print them back out
+            std::vector<client::complex> vc;
+            std::vector<double>::const_iterator end = v.end();
+            for (std::vector<double>::const_iterator it = v.begin(); 
+                 it != end; ++it)
+            {
+                double real(*it);
+                if (++it != end)
+                    vc.push_back(client::complex(real, *it));
+                else {
+                    vc.push_back(client::complex(real));
+                    break;
+                }
+            }
+
+            std::cout << "-------------------------\n";
+
+            std::string generated;
+            std::back_insert_iterator<std::string> sink(generated);
+            if (!client::generate_numbers(sink, vc))
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generated:\n" << generated << "\n";
+                std::cout << "-------------------------\n";
+            }
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/num_matrix.cpp b/src/boost/libs/spirit/example/karma/num_matrix.cpp
new file mode 100644
index 00000000..0622e096
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/num_matrix.cpp
@@ -0,0 +1,114 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 Hartmut Kaiser
+    Copyright (c) 2002-2010 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 demonstrates a generator formatting and printing a matrix 
+//  of integers taken from a simple vector of vectors. The size and the 
+//  contents of the printed matrix is generated randomly.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/karma.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <cstdlib>
+#include <ctime>
+
+namespace karma = boost::spirit::karma;
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our matrix generator
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_karma_nummatrix_grammar
+    template <typename OutputIterator>
+    struct matrix_grammar 
+      : karma::grammar<OutputIterator, std::vector<std::vector<int> >()>
+    {
+        matrix_grammar()
+          : matrix_grammar::base_type(matrix)
+        {
+            using karma::int_;
+            using karma::right_align;
+            using karma::eol;
+
+            element = right_align(10)[int_];
+            row = '|' << *element << '|';
+            matrix = row % eol;
+        }
+
+        karma::rule<OutputIterator, std::vector<std::vector<int> >()> matrix;
+        karma::rule<OutputIterator, std::vector<int>()> row;
+        karma::rule<OutputIterator, int()> element;
+    };
+    //]
+
+    //[tutorial_karma_nummatrix
+    template <typename OutputIterator>
+    bool generate_matrix(OutputIterator& sink
+      , std::vector<std::vector<int> > const& v)
+    {
+        matrix_grammar<OutputIterator> matrix;
+        return karma::generate(
+            sink,                           // destination: output iterator
+            matrix,                         // the generator
+            v                               // the data to output 
+        );
+    }
+    //]
+}
+
+////////////////////////////////////////////////////////////////////////////
+//  Main program
+////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\tPrinting integers in a matrix using Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    // here we put the data to generate
+    std::vector<std::vector<int> > v;
+
+    // now, generate the size and the contents for the matrix
+    std::srand((unsigned int)std::time(NULL));
+    std::size_t rows = std::rand() / (RAND_MAX / 10);
+    std::size_t columns = std::rand() / (RAND_MAX / 10);
+
+    v.resize(rows);
+    for (std::size_t row = 0; row < rows; ++row)
+    {
+        v[row].resize(columns);
+        std::generate(v[row].begin(), v[row].end(), std::rand);
+    }
+
+    // ok, we got the matrix, now print it out
+    std::string generated;
+    std::back_insert_iterator<std::string> sink(generated);
+    if (!client::generate_matrix(sink, v))
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Generating failed\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Generated:\n" << generated << "\n";
+        std::cout << "-------------------------\n";
+    }
+
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/karma/printf_style_double_format.cpp b/src/boost/libs/spirit/example/karma/printf_style_double_format.cpp
new file mode 100644
index 00000000..b1c094da
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/printf_style_double_format.cpp
@@ -0,0 +1,282 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The main purpose of this example is to show how a single container type can
+//  be formatted using different output grammars. 
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+#include <cmath>
+
+using namespace boost::spirit;
+
+///////////////////////////////////////////////////////////////////////////////
+// This policy allows to use printf style formatting specifiers for Karma
+// floating point generators. This policy understands the following format:
+//
+//  The format string must conform to the following format, otherwise a 
+//  std::runtime_error will be thrown:
+//
+//      %[flags][fill][width][.precision]type
+//
+//  where:
+//      flags (only one possible):
+//          +:      Always denote the sign '+' or '-' of a number 
+//          -:      Left-align the output 
+//      fill:
+//          0:      Uses 0 instead of spaces to left-fill a fixed-length field
+//      width:
+//          number: Left-pad the output with spaces until it is at least number 
+//                  characters wide. if number has a leading '0', that is 
+//                  interpreted as a 'fill', the padding is done with '0' 
+//                  characters instead of spaces.
+//      precision:
+//          number: Causes the decimal portion of the output to be expressed 
+//                  in at least number digits
+//      type (only one possible):
+//          e:      force scientific notation, with a lowercase "e"
+//          E:      force scientific notation, with a uppercase "E"
+//          f:      floating point format
+//          g:      use %e or %f, whichever is shorter
+//          G:      use %E or %f, whichever is shorter
+//
+
+///////////////////////////////////////////////////////////////////////////////
+// define a data structure and a corresponding parser to hold the formatting 
+// information extracted from the format specification string
+namespace client
+{
+    struct format_data
+    {
+        char flag;
+        char fill;
+        int width;
+        int precision;
+        char type;
+    };
+}
+
+// We need to tell fusion about our format_data struct
+// to make it a first-class fusion citizen
+BOOST_FUSION_ADAPT_STRUCT(
+    client::format_data,
+    (char, flag)
+    (char, fill)
+    (int, width)
+    (int, precision)
+    (char, type)
+)
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Grammar for format specification string as described above
+    template <typename Iterator>
+    struct format_grammar : qi::grammar<Iterator, format_data()>
+    {
+        format_grammar() : format_grammar::base_type(format)
+        {
+            using qi::uint_;
+            using qi::attr;
+            using ascii::char_;
+            using ascii::no_case;
+
+            format %= '%' >> flags >> fill >> width >> prec >> type;
+
+            // default flags is right aligned
+            flags  = char_('+') | char_('-') | attr(' ');
+            fill   = char_('0') | attr(' ');     // default fill is space
+            width  = uint_ | attr(-1);
+            prec   = '.' >> uint_ | attr(3);     // default is 3 digits
+            type   = no_case[char_('e')] | char_('f') | no_case[char_('g')];
+        };
+
+        qi::rule<Iterator, format_data()> format;
+        qi::rule<Iterator, char()> flags;
+        qi::rule<Iterator, char()> fill;
+        qi::rule<Iterator, int()> width;
+        qi::rule<Iterator, int()> prec;
+        qi::rule<Iterator, char()> type;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// real_policies implementation allowing to use a printf style format 
+// specification for Karma floating pointing number generators
+template <typename T>
+struct format_policies : karma::real_policies<T>
+{
+    typedef karma::real_policies<T> base_policy_type;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  This real_policies implementation requires the output_iterator to 
+    //  implement buffering and character counting. This needs to be reflected
+    //  in the properties exposed by the generator
+    typedef boost::mpl::int_<
+        karma::generator_properties::countingbuffer
+    > properties;
+
+    ///////////////////////////////////////////////////////////////////////////
+    format_policies(char const* fmt = "%f")
+    {
+        char const* last = fmt;
+        while (*last)
+            last++;
+
+        client::format_grammar<char const*> g;
+        if (!qi::parse(fmt, last, g, format_))
+            throw std::runtime_error("bad format string");
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  returns the overall format: scientific or fixed
+    int floatfield(T n) const
+    {
+        if (format_.type == 'e' || format_.type == 'E')
+            return base_policy_type::fmtflags::scientific;
+
+        if (format_.type == 'f')
+            return base_policy_type::fmtflags::fixed;
+
+        BOOST_ASSERT(format_.type == 'g' || format_.type == 'G');
+        return this->base_policy_type::floatfield(n);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  returns whether to emit a sign even for non-negative numbers
+    bool const force_sign(T) const
+    {
+        return format_.flag == '+';
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  returns the number of required digits for the fractional part
+    unsigned precision(T) const
+    {
+        return format_.precision;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  emit the decimal dot
+    template <typename OutputIterator>
+    static bool dot (OutputIterator& sink, T n, unsigned precision) 
+    {
+        // don't print the dot if no fractional digits are to be emitted
+        if (precision == 0)
+            return true;
+        return base_policy_type::dot(sink, n, precision);
+    }
+
+    template <typename CharEncoding, typename Tag, typename OutputIterator>
+    bool exponent (OutputIterator& sink, long n) const
+    {
+        if (format_.type == 'E' || format_.type == 'G') {
+            // print exponent symbol in upper case
+            return this->base_policy_type::
+                template exponent<char_encoding::ascii, tag::upper>(sink, n);
+        }
+        return this->base_policy_type::
+            template exponent<CharEncoding, Tag>(sink, n);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  this gets called by the numeric generators at the top level, it allows
+    //  to do alignment and other high level things
+    template <typename Inserter, typename OutputIterator, typename Policies>
+    bool call (OutputIterator& sink, T n, Policies const& p) const
+    {
+        bool r = false;
+        if (format_.flag == '-') {    // left align
+            // wrap the given output iterator to allow counting
+            karma::detail::enable_counting<OutputIterator> counting(sink);
+
+            // first generate the actual floating point number
+            r = Inserter::call_n(sink, n, p);
+
+            // pad the output until the max width is reached
+            while(r && int(counting.count()) < format_.width) 
+                r = karma::generate(sink, ' ');
+        }
+        else {                        // right align
+            // wrap the given output iterator to allow left padding
+            karma::detail::enable_buffering<OutputIterator> buffering(
+                sink, format_.width);
+
+            // first generate the actual floating point number
+            {
+                karma::detail::disable_counting<OutputIterator> nocounting(sink);
+                r = Inserter::call_n(sink, n, p);
+            }
+
+            buffering.disable();    // do not perform buffering any more
+
+            // generate the left padding
+            karma::detail::enable_counting<OutputIterator> counting(
+                sink, buffering.buffer_size());
+            while(r && int(counting.count()) < format_.width) 
+                r = karma::generate(sink, format_.fill);
+
+            // copy the buffered output to the target output iterator
+            if (r) 
+                buffering.buffer_copy();
+        }
+        return r;
+    }
+
+    client::format_data format_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// This is the generator usable in any Karma output format expression, it needs
+// to be utilized as
+//
+//    generate(sink, real("%6.3f"), 3.1415926536);    // prints: ' 3.142'
+//
+// and it supports the format specification as described above.
+typedef karma::real_generator<double, format_policies<double> > real;
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////////\n\n";
+    std::cout << "A format driven floating point number generator for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a printf style format\n";
+    std::cout << "Type [enter] to quit\n\n";
+
+    std::string str;
+    while (getline(std::cin, str))
+    {
+        if (str.empty())
+            break;
+
+        try {
+            std::string generated;
+            std::back_insert_iterator<std::string> sink(generated);
+            if (!karma::generate(sink, real(str.c_str()), 4*std::atan(1.0)))
+            {
+                std::cout << "-------------------------\n";
+                std::cout << "Generating failed\n";
+                std::cout << "-------------------------\n";
+            }
+            else
+            {
+                std::cout << ">" << generated << "<\n";
+            }
+        }
+        catch (std::runtime_error const&) {
+            std::cout << "-------------------------\n";
+            std::cout << "Invalid format specified!\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/quick_start1.cpp b/src/boost/libs/spirit/example/karma/quick_start1.cpp
new file mode 100644
index 00000000..4a99b95c
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/quick_start1.cpp
@@ -0,0 +1,119 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The main purpose of this example is to show how a single container type can
+//  be formatted using different output grammars. 
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/karma_stream.hpp>
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <cstdlib> 
+
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // vector
+    std::vector<int> v (8);
+    std::generate(v.begin(), v.end(), std::rand); // randomly fill the vector
+
+    std::cout << "Output 8 integers from a std::vector<int>..." << std::endl;
+
+    // output the container as a sequence without any separation
+    std::cout << "...without any separation" << std::endl;
+    std::cout << 
+        karma::format(
+            *int_,                                // format description
+            v                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a space separated sequence
+    std::cout << "...as space delimited list" << std::endl;
+    std::cout << 
+        karma::format_delimited(
+            *int_,                                // format description
+            space,                                // delimiter
+            v                                     // data
+        ) << std::endl << std::endl;
+
+    std::cout << 
+        karma::format_delimited(
+            '[' << *int_ << ']',                  // format description
+            space,                                // delimiter
+            v                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a comma separated list
+    std::cout << "...as comma separated list" << std::endl;
+    std::cout << 
+        karma::format(
+            int_ % ", ",                          // format description
+            v                                     // data
+        ) << std::endl << std::endl;
+
+    std::cout << 
+        karma::format(
+            '[' << (int_ % ", ") << ']',          // format description
+            v                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a comma separated list of double's
+    std::cout << "...as comma separated list of doubles" << std::endl;
+    std::cout << 
+        karma::format(
+            double_ % ", ",                       // format description
+            v                                     // data
+        ) << std::endl << std::endl;
+
+    // output the container as a comma separated list of items enclosed in '()'
+    std::cout << "..as list of ints enclosed in '()'" << std::endl;
+    std::cout << 
+        karma::format(
+            ('(' << int_ << ')') % ", ",          // format description
+            v                                     // data
+        ) << std::endl << std::endl;
+
+    std::cout << 
+        karma::format(
+            '[' << (  
+                ('(' << int_ << ')') % ", "
+             )  << ']',                           // format description
+            v                                     // data
+        ) << std::endl << std::endl;
+        
+    // output the container as a HTML list
+    std::cout << "...as HTML bullet list" << std::endl;
+    std::cout << 
+        karma::format_delimited(
+            "<ol>" << 
+                // no delimiting within verbatim
+                *verbatim["  <li>" << int_ << "</li>"]
+            << "</ol>",                           // format description
+            '\n',                                 // delimiter
+            v                                     // data
+        ) << std::endl;
+
+    // output the container as right aligned column
+    std::cout << "...right aligned in a column" << std::endl;
+    std::cout << 
+        karma::format_delimited(
+           *verbatim[
+                "|" << right_align[int_] << "|"
+            ],                                    // format description
+            '\n',                                 // delimiter
+            v                                     // data
+        ) << std::endl;
+
+    std::cout << std::endl;
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/quoted_strings.cpp b/src/boost/libs/spirit/example/karma/quoted_strings.cpp
new file mode 100644
index 00000000..ecbdd969
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/quoted_strings.cpp
@@ -0,0 +1,70 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The purpose of this example is to demonstrate how to utilize alternatives 
+//  and the built in matching capabilities of Karma generators to emit output 
+//  in different formats based on the content of an attribute (not its type).
+
+#include <boost/config/warning_disable.hpp>
+
+#include <string>
+#include <vector>
+
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/phoenix_stl.hpp>
+
+namespace client
+{
+    namespace karma = boost::spirit::karma;
+    namespace phx = boost::phoenix;
+
+    template <typename OutputIterator>
+    struct quoted_strings
+      : karma::grammar<OutputIterator, std::vector<std::string>()>
+    {
+        quoted_strings()
+          : quoted_strings::base_type(strings)
+        {
+            strings = (bareword | qstring) % ' ';
+            bareword = karma::repeat(phx::size(karma::_val))
+                          [ karma::alnum | karma::char_("-.,_$") ];
+            qstring = '"' << karma::string << '"';
+        }
+
+        karma::rule<OutputIterator, std::vector<std::string>()> strings;
+        karma::rule<OutputIterator, std::string()> bareword, qstring;
+    };
+}
+
+int main()
+{
+    namespace karma = boost::spirit::karma;
+
+    typedef std::back_insert_iterator<std::string> sink_type;
+
+    std::string generated;
+    sink_type sink(generated);
+
+    std::vector<std::string> v;
+    v.push_back("foo");
+    v.push_back("bar baz");
+    v.push_back("hello");
+
+    client::quoted_strings<sink_type> g;
+    if (!karma::generate(sink, g, v))
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Generating failed\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Generated: " << generated << "\n";
+        std::cout << "-------------------------\n";
+    }
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/karma/reference.cpp b/src/boost/libs/spirit/example/karma/reference.cpp
new file mode 100644
index 00000000..dd11f26e
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/reference.cpp
@@ -0,0 +1,911 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    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)
+=============================================================================*/
+#include <boost/config/warning_disable.hpp>
+
+//[reference_karma_includes
+#include <boost/spirit/include/karma.hpp>
+#include <boost/spirit/include/support_utree.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+#include <iostream>
+#include <string>
+//]
+
+//[reference_karma_includes_simple
+#include <boost/spirit/include/karma.hpp>
+#include <iostream>
+#include <string>
+//]
+
+//[reference_karma_output_iterator
+typedef std::back_insert_iterator<std::string> output_iterator_type;
+//]
+
+//[reference_karma_test
+template <typename G>
+void test_generator(char const* expected, G const& g)
+{
+    std::string s;
+    std::back_insert_iterator<std::string> out(s);
+    if (boost::spirit::karma::generate(out, g) && s == expected)
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+//]
+
+//[reference_karma_test_attr
+template <typename G, typename T>
+void test_generator_attr(char const* expected, G const& g, T const& attr)
+{
+    std::string s;
+    std::back_insert_iterator<std::string> out(s);
+    if (boost::spirit::karma::generate(out, g, attr) && s == expected)
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+//]
+
+//[reference_karma_test_attr2
+template <typename G, typename T1, typename T2>
+void test_generator_attr(char const* expected, G const& g, T1 const& attr1, 
+    T2 const& attr2)
+{
+    std::string s;
+    std::back_insert_iterator<std::string> out(s);
+    if (boost::spirit::karma::generate(out, g, attr1, attr2) && s == expected)
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+//]
+
+//[reference_karma_test_attr_delim
+template <typename G, typename Delimiter, typename T>
+void test_generator_attr_delim(char const* expected, G const& g, Delimiter const& d, T const& attr)
+{
+    std::string s;
+    std::back_insert_iterator<std::string> out(s);
+    if (boost::spirit::karma::generate_delimited(out, g, d, attr) && s == expected)
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+//]
+
+//[reference_karma_binary_test
+template <typename G>
+void test_binary_generator(char const* expected, std::size_t size, G const& g)
+{
+    std::string s;
+    std::back_insert_iterator<std::string> out(s);
+    if (boost::spirit::karma::generate(out, g) && !std::memcmp(s.c_str(), expected, size))
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+//]
+
+//[reference_karma_binary_test_attr
+template <typename G, typename T>
+void test_binary_generator_attr(char const* expected, std::size_t size, G const& g, T const& attr)
+{
+    std::string s;
+    std::back_insert_iterator<std::string> out(s);
+    if (boost::spirit::karma::generate(out, g, attr) && !std::memcmp(s.c_str(), expected, size))
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+//]
+
+//[reference_karma_complex
+// a simple complex number representation z = a + bi
+struct complex
+{
+    complex (double a, double b)
+      : a(a), b(b)
+    {}
+
+    double a;
+    double b;
+};
+//]
+
+//[reference_karma_stream_complex
+// define streaming operator for the type complex
+std::ostream& 
+operator<< (std::ostream& os, complex const& z)
+{
+    os << "{" << z.a << "," << z.b << "}";
+    return os;
+}
+//]
+
+//[reference_karma_auto_complex
+/*`The following construct is required to allow the `complex` data structure
+   to be utilized as a __fusion__ sequence. This is required as we will 
+   emit output for this data structure with a __karma__ sequence:
+   `'{' << karma::double_ << ',' << karma::double_ << '}'`.
+*/
+BOOST_FUSION_ADAPT_STRUCT(
+    complex,
+    (double, a)
+    (double, b)
+)
+
+/*`We add a specialization for the create_generator customization point
+   defining a custom output format for the complex type. Generally, any 
+   specialization for create_generator is expected to return the proto 
+   expression to be used to generate output for the type the customization 
+   point has been specialized for.
+ */
+/*`We need to utilize `proto::deep_copy` as the expression contains literals 
+   (the `'{'`, `','`, and `'}'`) which normally get embedded in the proto 
+   expression by reference only. The deep copy converts the proto tree to 
+   hold this by value. The deep copy operation can be left out for simpler 
+   proto expressions (not containing references to temporaries). Alternatively
+   you could use the `proto::make_expr` facility to build the required
+   proto expression.
+*/
+namespace boost { namespace spirit { namespace traits
+{
+    template <>
+    struct create_generator<complex>
+    {
+        typedef proto::result_of::deep_copy<
+            BOOST_TYPEOF('{' << karma::double_ << ',' << karma::double_ << '}')
+        >::type type;
+
+        static type call()
+        {
+            return proto::deep_copy(
+                '{' << karma::double_ << ',' << karma::double_ << '}');
+        }
+    };
+}}}
+//]
+
+//[reference_karma_auxiliary_attr_cast_data1
+// this is just a test structure we want to use in place of an int
+struct int_data
+{
+    int i;
+};
+
+// we provide a custom attribute transformation to allow its use as an int
+namespace boost { namespace spirit { namespace traits
+{
+    template <>
+    struct transform_attribute<int_data const, int, karma::domain>
+    {
+        typedef int type;
+        static int pre(int_data const& d) { return d.i; }
+    };
+}}}
+//]
+
+namespace client
+{
+    using boost::spirit::karma::grammar;
+    using boost::spirit::karma::rule;
+    using boost::spirit::ascii::space_type;
+
+    //[karma_reference_grammar_definition
+    /*`Basic grammar usage:
+     */
+    struct num_list : grammar<output_iterator_type, space_type, std::vector<int>()>
+    {
+        num_list() : base_type(start)
+        {
+            using boost::spirit::int_;
+            num = int_;
+            start = num << *(',' << num);
+        }
+
+        rule<output_iterator_type, space_type, std::vector<int>()> start;
+        rule<output_iterator_type, space_type, int()> num;
+    };
+    //]
+}
+
+int main()
+{
+    ///////////////////////////////////////////////////////////////////////////
+    // Operators
+    ///////////////////////////////////////////////////////////////////////////
+    {
+        //[reference_karma_using_declarations_sequence
+        using boost::spirit::karma::double_;
+        //]
+
+        //[reference_karma_sequence
+        test_generator_attr("1.0,2.0", double_ << ',' << double_, std::make_pair(1.0, 2.0));
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_alternative
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::ascii::string;
+        //]
+
+        //[reference_karma_alternative1
+        boost::variant<std::string, double> v1(1.0);
+        test_generator_attr("1.0", string | double_, v1);
+        test_generator_attr("2.0", string | double_, 2.0);
+        //]
+
+        //[reference_karma_alternative2
+        boost::variant<std::string, double> v2("example");
+        test_generator_attr("example", string | double_, v2);
+        test_generator_attr("example", string | double_, "example");
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_kleene
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::space;
+        //]
+
+        //[reference_karma_kleene
+        std::vector<double> v;
+        v.push_back(1.0);
+        v.push_back(2.0);
+        v.push_back(3.0);
+        test_generator_attr_delim("1.0 2.0 3.0 ", *double_, space, v);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_plus
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::space;
+        //]
+
+        //[reference_karma_plus1
+        std::vector<double> v1;
+        v1.push_back(1.0);
+        v1.push_back(2.0);
+        v1.push_back(3.0);
+        test_generator_attr_delim("1.0 2.0 3.0 ", +double_, space, v1);
+        //]
+
+        //[reference_karma_plus2
+        std::vector<double> v2;               // empty container
+        test_generator_attr("empty", +double_ | "empty", v2);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_list
+        using boost::spirit::karma::double_;
+        //]
+
+        //[reference_karma_list
+        std::vector<double> v1;
+        v1.push_back(1.0);
+        test_generator_attr("1.0", double_ % ',', v1);
+
+        v1.push_back(2.0);
+        test_generator_attr("1.0,2.0", double_ % ',', v1);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_optional
+        using boost::spirit::karma::double_;
+        //]
+
+        //[reference_karma_optional1
+        boost::optional<double> val(1.0);
+        test_generator_attr("1.0", -double_, val);
+        test_generator_attr("2.0", -double_, 2.0);
+        //]
+    }
+    {
+        using boost::spirit::karma::double_;
+
+        //[reference_karma_optional2
+        boost::optional<double> val;          // empty optional
+        test_generator_attr("", -double_, val);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_and_predicate
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::ascii::char_;
+        using boost::spirit::karma::ascii::string;
+        using boost::phoenix::ref;
+        //]
+
+        //[reference_karma_and_predicate
+        test_generator_attr("b", &char_('a') << 'b' | 'c', 'a');
+        test_generator_attr("c", &char_('a') << 'b' | 'c', 'x');
+
+        test_generator_attr("abc", &string("123") << "abc" | "def", "123");
+        test_generator_attr("def", &string("123") << "abc" | "def", "456");
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_not_predicate
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::ascii::char_;
+        using boost::spirit::karma::ascii::string;
+        using boost::phoenix::ref;
+        //]
+
+        //[reference_karma_not_predicate
+        test_generator_attr("c", !char_('a') << 'b' | 'c', 'a');
+        test_generator_attr("b", !char_('a') << 'b' | 'c', 'x');
+
+        test_generator_attr("def", !string("123") << "abc" | "def", "123");
+        test_generator_attr("abc", !string("123") << "abc" | "def", "456");
+        //]
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Directives
+    ///////////////////////////////////////////////////////////////////////////
+    {
+        //[reference_karma_using_declarations_alignment
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::left_align;
+        using boost::spirit::karma::center;
+        using boost::spirit::karma::right_align;
+        //]
+
+        //[reference_karma_alignment
+        std::pair<double, double> p (1.0, 2.0);
+        test_generator_attr("1.0     |2.0", left_align(8)[double_] << '|' << double_, p);
+        test_generator_attr("   1.0  |2.0", center(8)[double_] << '|' << double_, p);
+        test_generator_attr("     1.0|2.0", right_align(8)[double_] << '|' << double_, p);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_repeat
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::repeat;
+        //]
+
+        //[reference_karma_repeat
+        std::vector<double> v;
+        v.push_back(1.0);
+        v.push_back(2.0);
+        v.push_back(3.0);
+
+        test_generator_attr("[1.0][2.0][3.0]", repeat['[' << double_ << ']'], v);
+        test_generator_attr("[1.0][2.0]", repeat(2)['[' << double_ << ']'], v);
+
+        // fails because of insufficient number of items
+        test_generator_attr("", repeat(4)['[' << double_ << ']'], v);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_delimit
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::delimit;
+        using boost::spirit::karma::verbatim;
+        //]
+
+        //[reference_karma_delimit
+        test_generator_attr("[ 2.0 , 4.3 ] ", 
+            delimit['[' << double_ << ',' << double_ << ']'], 2.0, 4.3);
+        test_generator_attr("[*2.0*,*4.3*]*", 
+            delimit('*')['[' << double_ << ',' << double_ << ']'], 2.0, 4.3);
+        test_generator_attr("[2.0, 4.3 ] ", 
+            delimit[verbatim['[' << double_ << ','] << double_ << ']'], 2.0, 4.3);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_upperlower
+        using boost::spirit::karma::double_;
+        using boost::spirit::ascii::upper;
+        using boost::spirit::ascii::lower;
+        //]
+
+        //[reference_karma_upperlower
+        test_generator_attr("abc:2.0e-06", lower["ABC:" << double_], 2e-6);
+        test_generator_attr("ABC:2.0E-06", upper["abc:" << double_], 2e-6);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_maxwidth
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::maxwidth;
+        using boost::spirit::karma::left_align;
+        using boost::spirit::karma::right_align;
+        //]
+
+        //[reference_karma_maxwidth
+        test_generator("01234", maxwidth(5)["0123456789"]);
+        test_generator("  012", maxwidth(5)[right_align(12)["0123456789"]]);
+        test_generator("0123    ", maxwidth(8)[left_align(8)["0123"]]);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_buffer
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::buffer;
+        //]
+
+        //[reference_karma_buffer
+        std::vector<double> v;                // empty container
+        test_generator_attr("", -buffer['[' << +double_ << ']'], v);
+
+        v.push_back(1.0);                     // now, fill the container
+        v.push_back(2.0);
+        test_generator_attr("[1.02.0]", buffer['[' << +double_ << ']'], v);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_omit
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::omit;
+        //]
+
+        //[reference_karma_omit
+        std::pair<double, double> p (1.0, 2.0);
+        test_generator_attr("2.0", omit[double_] << double_, p);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_duplicate
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::duplicate;
+        using boost::spirit::karma::space;
+        //]
+
+        //[reference_karma_duplicate
+        test_generator_attr("2.02.0", duplicate[double_ << double_], 2.0);
+        test_generator_attr_delim("2.0 2.0 ", duplicate[double_ << double_], space, 2.0);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_columns
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::columns;
+        using boost::spirit::karma::space;
+        //]
+
+        //[reference_karma_columns
+        std::vector<double> v;
+        v.push_back(1.0);
+        v.push_back(2.0);
+        v.push_back(3.0);
+        test_generator_attr("1.0\n2.0\n3.0\n", columns(1)[*double_], v);
+        test_generator_attr_delim("1.0 2.0 \n3.0 \n", columns(2)[*double_], space, v);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_bool
+        using boost::spirit::karma::bool_;
+        using boost::spirit::karma::lit;
+        //]
+
+        //[reference_karma_bool
+        test_generator("true", lit(true));
+        test_generator("false", bool_(false));
+        test_generator_attr("true", bool_(true), true);
+        test_generator_attr("", bool_(true), false);    // fails (as true != false)!
+        test_generator_attr("false", bool_, false);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_int
+        using boost::spirit::karma::int_;
+        using boost::spirit::karma::lit;
+        //]
+
+        //[reference_karma_int
+        test_generator("-2", lit(-2));
+        test_generator("-2", int_(-2));
+        test_generator_attr("-2", int_(-2), -2);
+        test_generator_attr("", int_(-2), 3);    // fails (as -2 != 3)!
+        test_generator_attr("-2", int_, -2);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_uint
+        using boost::spirit::karma::uint_;
+        using boost::spirit::karma::lit;
+        //]
+
+        //[reference_karma_uint
+        test_generator("2", lit(2U));
+        test_generator("2", uint_(2));
+        test_generator_attr("2", uint_(2), 2);
+        test_generator_attr("", uint_(2), 3);    // fails (as 2 != 3)!
+        test_generator_attr("2", uint_, 2);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_real
+        using boost::spirit::karma::double_;
+        using boost::spirit::karma::lit;
+        //]
+
+        //[reference_karma_real
+        test_generator("2.0", lit(2.0));
+        test_generator("2.0", double_(2));
+        test_generator_attr("2.0", double_(2.0), 2.0);
+        test_generator_attr("", double_(2.0), 3.0);    // fails (as 2.0 != 3.0)!
+        test_generator_attr("-2.0", double_, -2.0);
+
+        test_generator_attr("1.234e05", double_, 1234.0e2);
+        test_generator_attr("1.234e-06", double_, 0.000001234);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_char
+        using boost::spirit::karma::lit;
+        using boost::spirit::ascii::char_;
+        //]
+
+        //[reference_karma_char
+        test_generator("A", 'A');
+        test_generator("A", lit('A'));
+
+        test_generator_attr("a", char_, 'a');
+        test_generator("A", char_('A'));
+        test_generator_attr("A", char_('A'), 'A');
+        test_generator_attr("", char_('A'), 'B');         // fails (as 'A' != 'B')
+
+        test_generator_attr("A", char_('A', 'Z'), 'A');
+        test_generator_attr("", char_('A', 'Z'), 'a');    // fails (as 'a' does not belong to 'A'...'Z')
+
+        test_generator_attr("k", char_("a-z0-9"), 'k');
+        test_generator_attr("", char_("a-z0-9"), 'A');    // fails (as 'A' does not belong to "a-z0-9")
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_char_class
+        using boost::spirit::karma::alpha;
+        using boost::spirit::karma::upper;
+        //]
+
+        //[reference_karma_char_class
+        test_generator_attr("a", alpha, 'a');
+        test_generator_attr("A", alpha, 'A');
+        test_generator_attr("", alpha, '1');          // fails (as isalpha('1') is false)
+        test_generator_attr("A", upper[alpha], 'A');
+        test_generator_attr("", upper[alpha], 'a');   // fails (as isupper('a') is false)
+        //]
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // string
+    {
+        //[reference_karma_using_declarations_string
+        using boost::spirit::karma::lit;
+        using boost::spirit::ascii::string;
+        //]
+
+        //[reference_karma_string
+        test_generator("abc", "abc");
+        test_generator("abc", lit("abc"));
+        test_generator("abc", lit(std::string("abc")));
+
+        test_generator_attr("abc", string, "abc");
+        test_generator("abc", string("abc"));
+        test_generator("abc", string(std::string("abc")));
+
+        test_generator_attr("abc", string("abc"), "abc");
+        test_generator_attr("", string("abc"), "cba");     // fails (as "abc" != "cba")
+        //]
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // auxiliary
+    {
+        //[reference_karma_using_declarations_eol
+        using boost::spirit::karma::eol;
+        //]
+
+        //[reference_karma_eol
+        test_generator("\n", eol);
+        test_generator("abc\n", "abc" << eol);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_attr_cast
+        using boost::spirit::karma::int_;
+        //]
+
+        //[reference_karma_attr_cast1
+        int_data d = { 1 };
+        test_generator_attr("1", boost::spirit::karma::attr_cast(int_), d);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_eps
+        using boost::spirit::karma::eps;
+        using boost::phoenix::val;
+        //]
+
+        //[reference_karma_eps
+        test_generator("abc", eps[std::cout << val("starting eps example")] << "abc");
+        test_generator("abc", eps(true) << "abc");
+        test_generator("", eps(false) << "abc");      // fails as eps expression is 'false'
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_lazy
+        namespace karma = boost::spirit::karma;
+        using boost::spirit::karma::_1;
+        using boost::spirit::ascii::string;
+        using boost::phoenix::val;
+        //]
+
+        //[reference_karma_lazy
+        test_generator_attr("abc", karma::lazy(val(string)), "abc");
+        test_generator("abc", karma::lazy(val(string))[_1 = "abc"]);
+        //]
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // stream module
+    {
+        //[reference_karma_using_declarations_stream
+        using boost::spirit::karma::stream;
+        //]
+
+        //[reference_karma_stream
+        test_generator_attr("abc", stream, "abc");
+        test_generator("abc", stream("abc"));
+        test_generator_attr("{1.2,2.4}", stream, complex(1.2, 2.4));
+        test_generator("{1.2,2.4}", stream(complex(1.2, 2.4)));
+        //]
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // auto module
+    {
+        //[reference_karma_using_declarations_auto
+        using boost::spirit::karma::auto_;
+        //]
+
+        //[reference_karma_auto
+        /*`Emit a simple string using the `karma::string` generator:
+         */
+        test_generator_attr("abc", auto_, "abc");
+        test_generator("abc", auto_("abc"));
+
+        /*`Emit instances of the `complex` data type as defined above using the
+           generator defined by the customization point for `complex`:
+         */
+        test_generator_attr("{1.2,2.4}", auto_, complex(1.2, 2.4));
+        test_generator("{1.2,2.4}", auto_(complex(1.2, 2.4)));
+        //]
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // binary module
+    {
+        //[reference_karma_using_declarations_native_binary
+        using boost::spirit::karma::byte_;
+        using boost::spirit::karma::word;
+        using boost::spirit::karma::dword;
+        using boost::spirit::karma::qword;
+        //]
+
+        //[reference_karma_native_binary_little
+        test_binary_generator("\x01", 1, byte_(0x01));
+        test_binary_generator("\x01\x02", 2, word(0x0201));
+        test_binary_generator("\x01\x02\x03\x04", 4, dword(0x04030201));
+        test_binary_generator("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword(0x0807060504030201LL));
+
+        test_binary_generator_attr("\x01", 1, byte_, 0x01);
+        test_binary_generator_attr("\x01\x02", 2, word, 0x0201);
+        test_binary_generator_attr("\x01\x02\x03\x04", 4, dword, 0x04030201);
+        test_binary_generator_attr("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword, 0x0807060504030201LL);
+        //]
+
+        //[reference_karma_native_binary_big
+        test_binary_generator("\x01", 1, byte_(0x01));
+        test_binary_generator("\x02\x01", 2, word(0x0201));
+        test_binary_generator("\x04\x03\x02\x01", 4, dword(0x04030201));
+        test_binary_generator("\x08\x07\x06\x05\x04\x03\x02\x01", 8, qword(0x0807060504030201LL));
+
+        test_binary_generator_attr("\x01", 1, byte_, 0x01);
+        test_binary_generator_attr("\x02\x01", 2, word, 0x0201);
+        test_binary_generator_attr("\x04\x03\x02\x01", 4, dword, 0x04030201);
+        test_binary_generator_attr("\x08\x07\x06\x05\x04\x03\x02\x01", 8, qword, 0x0807060504030201LL);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_little_binary
+        using boost::spirit::karma::little_word;
+        using boost::spirit::karma::little_dword;
+        using boost::spirit::karma::little_qword;
+        //]
+
+        //[reference_karma_little_binary
+        test_binary_generator("\x01\x02", 2, little_word(0x0201));
+        test_binary_generator("\x01\x02\x03\x04", 4, little_dword(0x04030201));
+        test_binary_generator("\x01\x02\x03\x04\x05\x06\x07\x08", 8, little_qword(0x0807060504030201LL));
+
+        test_binary_generator_attr("\x01\x02", 2, little_word, 0x0201);
+        test_binary_generator_attr("\x01\x02\x03\x04", 4, little_dword, 0x04030201);
+        test_binary_generator_attr("\x01\x02\x03\x04\x05\x06\x07\x08", 8, little_qword, 0x0807060504030201LL);
+        //]
+    }
+
+    {
+        //[reference_karma_using_declarations_big_binary
+        using boost::spirit::karma::big_word;
+        using boost::spirit::karma::big_dword;
+        using boost::spirit::karma::big_qword;
+        //]
+
+        //[reference_karma_big_binary
+        test_binary_generator("\x02\x01", 2, big_word(0x0201));
+        test_binary_generator("\x04\x03\x02\x01", 4, big_dword(0x04030201));
+        test_binary_generator("\x08\x07\x06\x05\x04\x03\x02\x01", 8, big_qword(0x0807060504030201LL));
+
+        test_binary_generator_attr("\x02\x01", 2, big_word, 0x0201);
+        test_binary_generator_attr("\x04\x03\x02\x01", 4, big_dword, 0x04030201);
+        test_binary_generator_attr("\x08\x07\x06\x05\x04\x03\x02\x01", 8, big_qword, 0x0807060504030201LL);
+        //]
+    }
+
+    // action
+    {
+        //[reference_karma_using_declarations_action
+        using boost::spirit::karma::int_;
+        using boost::spirit::karma::string;
+        using boost::spirit::karma::_1;
+        using boost::phoenix::ref;
+        using boost::phoenix::val;
+        //]
+
+        //[reference_karma_action
+        int i = 42;
+        test_generator("42", int_[_1 = ref(i)]);
+        test_generator("abc", string[_1 = val("abc")]);
+        //]
+    }
+
+    // rule
+    {
+        //[karma_reference_rule
+        //`Some using declarations:
+        using boost::spirit::karma::rule;
+        using boost::spirit::karma::int_;
+        using boost::spirit::ascii::space;
+        using boost::spirit::ascii::space_type;
+
+        /*`Basic rule:
+         */
+        rule<output_iterator_type> r;
+        r = int_(123);
+        test_generator("123", r);
+
+        /*`Rule with consumed attribute:
+         */
+        rule<output_iterator_type, int()> ra;
+        ra = int_;
+        test_generator_attr("123", ra, 123);
+
+        /*`Rule with delimiter and consumed attribute:
+         */
+        rule<output_iterator_type, std::vector<int>(), space_type> rs;
+        rs = *int_;
+        std::vector<int> v;
+        v.push_back(123);
+        v.push_back(456);
+        v.push_back(789);
+        test_generator_attr_delim("123 456 789", rs, space, v);
+        //]
+    }
+
+    // grammar
+    {
+        using client::num_list;
+
+        //[karma_reference_grammar_using
+        //`Some using declarations:
+        using boost::spirit::ascii::space_type;
+        using boost::spirit::ascii::space;
+        using boost::spirit::int_;
+        using boost::spirit::karma::grammar;
+        using boost::spirit::karma::rule;
+        //]
+
+        //[karma_reference_grammar
+        //`How to use the example grammar:
+        num_list nlist;
+        std::vector<int> v;
+        v.push_back(123);
+        v.push_back(456);
+        v.push_back(789);
+        test_generator_attr_delim("123 , 456 , 789", nlist, space, v);
+        //]
+    }
+
+    // symbols
+    {
+        //[reference_karma_using_declarations_symbols
+        using boost::spirit::karma::symbols;
+        //]
+
+        //[reference_karma_symbols
+        symbols<char, char const*> sym;
+
+        sym.add
+            ('a', "Apple")
+            ('b', "Banana")
+            ('o', "Orange")
+        ;
+
+        test_generator_attr("Banana", sym, 'b');
+        //]
+    }
+
+    // as
+    {
+        //[reference_karma_using_declarations_as
+        using boost::spirit::utree;
+        using boost::spirit::utree_type;
+        using boost::spirit::utf8_symbol_type; 
+        using boost::spirit::karma::as;
+        using boost::spirit::karma::as_string;
+        using boost::spirit::karma::char_;
+        using boost::spirit::karma::double_;
+        //]
+        
+        //[reference_karma_as
+        /*`To properly handle string concatenation with __utree__, we 
+           make use of `as_string[]`. We also use `as<T>` to explicitly extract
+           a __utree__ symbol node.*/
+        
+        typedef as<utf8_symbol_type> as_symbol_type;
+        as_symbol_type const as_symbol = as_symbol_type();
+
+        utree ut;
+        ut.push_back("xyz");
+        ut.push_back(1.23);
+
+        test_generator_attr("xyz1.23", as_string[*char_] << double_, ut);
+        test_generator_attr("xyz1.23", as<std::string>()[*char_] << double_, ut);
+        
+        ut.clear();
+
+        ut.push_back(utf8_symbol_type("xyz"));
+        ut.push_back(1.23);
+
+        test_generator_attr("xyz1.23", as_symbol[*char_] << double_, ut);
+        test_generator_attr("xyz1.23", as<utf8_symbol_type>()[*char_] << double_, ut);
+        //]
+    }
+
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/karma/reorder_struct.cpp b/src/boost/libs/spirit/example/karma/reorder_struct.cpp
new file mode 100644
index 00000000..8e5b0149
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/reorder_struct.cpp
@@ -0,0 +1,105 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The main purpose of this example is to show how a single fusion sequence
+//  can be used to generate output of the elements in different sequences
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/karma.hpp>
+#include <boost/fusion/include/struct.hpp>
+#include <boost/fusion/include/nview.hpp>
+#include <boost/assign/std/vector.hpp>
+
+namespace fusion = boost::fusion;
+namespace karma = boost::spirit::karma;
+
+///////////////////////////////////////////////////////////////////////////////
+namespace client
+{
+    //  Our employee struct
+    struct employee
+    {
+        std::string surname;
+        std::string forename;
+        int age;
+        double salary;
+        std::string department;
+    };
+
+    // define iterator type
+    typedef std::back_insert_iterator<std::string> iterator_type;
+
+    // This is the output routine taking a format description and the data to
+    // print
+    template <typename Generator, typename Sequence>
+    void generate(Generator const& g, Sequence const& s)
+    {
+        std::string generated;
+        iterator_type sink(generated);
+        karma::generate(sink, g, s);
+        std::cout << generated << std::endl;
+    }
+}
+
+// We need to tell fusion about our employee struct to make it a first-class 
+// fusion citizen. This has to be in global scope. Note that we don't need to 
+// list the members of our struct in the same sequence a they are defined
+BOOST_FUSION_ADAPT_STRUCT(
+    client::employee,
+    (int, age)
+    (std::string, surname)
+    (std::string, forename)
+    (std::string, department)
+    (double, salary)
+)
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::string str;
+
+    // some employees
+    client::employee john = { "John", "Smith", 25, 2000.50, "Sales" };
+    client::employee mary = { "Mary", "Higgins", 23, 2200.36, "Marketing" };
+    client::employee tom = { "Tom", "Taylor", 48, 3200.00, "Boss" };
+
+    // print data about employees in different formats
+    {
+        // print forename and age
+        client::generate(
+            karma::string << ", " << karma::int_, 
+            fusion::as_nview<2, 0>(john));
+
+        // print surname, forename, and salary
+        client::generate(
+            karma::string << ' ' << karma::string << ": " << karma::double_, 
+            fusion::as_nview<1, 2, 4>(mary));
+
+        // print forename, age, and department
+        client::generate(
+            karma::string << ": " << karma::int_ << " (" << karma::string << ')', 
+            fusion::as_nview<2, 0, 3>(tom));
+    }
+
+    // now make a list of all employees and print them all
+    std::vector<client::employee> employees;
+    {
+        using namespace boost::assign;
+        employees += john, mary, tom;
+    }
+
+    // print surname, forename, and salary for all employees
+    {
+        typedef 
+            fusion::result_of::as_nview<client::employee const, 1, 2, 4>::type 
+        names_and_salary;
+
+        karma::rule<client::iterator_type, names_and_salary()> r =
+            karma::string << ' ' << karma::string << ": " << karma::double_;
+
+        client::generate(r % karma::eol, employees);
+    }
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/karma/simple_columns_directive.cpp b/src/boost/libs/spirit/example/karma/simple_columns_directive.cpp
new file mode 100644
index 00000000..3a5348af
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/simple_columns_directive.cpp
@@ -0,0 +1,49 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The purpose of this example is to show how a simple custom generator
+//  directive can be written. We develop a custom generator allowing to wrap 
+//  the generated output after each 5th column.
+//
+//  For more information see: http://boost-spirit.com/home/?page_id=659 
+
+#include <boost/spirit/include/karma_generate_attr.hpp>
+#include <boost/spirit/include/karma_char.hpp>
+#include <boost/spirit/include/karma_operator.hpp>
+#include <boost/spirit/include/karma_numeric.hpp>
+
+#include <string>
+#include "simple_columns_directive.hpp"
+
+namespace karma = boost::spirit::karma;
+
+int main()
+{
+    using custom_generator::columns;
+
+    std::vector<int> v;
+    for (int i = 0; i < 17; ++i)
+        v.push_back(i);
+
+    std::string generated;
+    std::back_insert_iterator<std::string> sink(generated);
+
+    bool result = karma::generate_delimited(
+        sink, columns[*karma::int_], karma::space, v);
+    if (result) 
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Generation succeeded\n";
+        std::cout << "generated output: " << "\n" << generated << "\n";
+        std::cout << "-------------------------------- \n";
+    }
+    else 
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Generation failed\n";
+        std::cout << "-------------------------------- \n";
+    }
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/karma/simple_columns_directive.hpp b/src/boost/libs/spirit/example/karma/simple_columns_directive.hpp
new file mode 100644
index 00000000..56403f33
--- /dev/null
+++ b/src/boost/libs/spirit/example/karma/simple_columns_directive.hpp
@@ -0,0 +1,133 @@
+//  Copyright (c) 2001-2010 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)
+
+#if !defined(COLUMNS_DEC_05_2009_0716PM)
+#define COLUMNS_DEC_05_2009_0716PM
+
+#include <boost/spirit/include/karma_generate.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// definition the place holder 
+namespace custom_generator 
+{ 
+    BOOST_SPIRIT_TERMINAL(columns)
+} 
+
+///////////////////////////////////////////////////////////////////////////////
+// implementation the enabler
+namespace boost { namespace spirit 
+{ 
+    // We want custom_generator::columns to be usable as a directive only, 
+    // and only for generator expressions (karma::domain).
+    template <>
+    struct use_directive<karma::domain, custom_generator::tag::columns> 
+      : mpl::true_ {}; 
+}}
+
+///////////////////////////////////////////////////////////////////////////////
+// implementation of the generator
+namespace custom_generator
+{ 
+    // special delimiter wrapping the original one while additionally emitting
+    // the column delimiter after each 5th invocation
+    template <typename Delimiter>
+    struct columns_delimiter 
+    {
+        columns_delimiter(Delimiter const& delim)
+          : delimiter(delim), count(0) {}
+
+        // This function is called during the actual delimiter output 
+        template <typename OutputIterator, typename Context
+          , typename Delimiter_, typename Attribute>
+        bool generate(OutputIterator& sink, Context&, Delimiter_ const&
+          , Attribute const&) const
+        {
+            // first invoke the wrapped delimiter
+            if (!karma::delimit_out(sink, delimiter))
+                return false;
+
+            // now we count the number of invocations and emit the column 
+            // delimiter after each 5th column
+            if ((++count % 5) == 0) 
+                *sink++ = '\n';
+            return true;
+        }
+
+        // Generate a final column delimiter if the last invocation didn't 
+        // emit one
+        template <typename OutputIterator>
+        bool final_delimit_out(OutputIterator& sink) const
+        {
+            if (count % 5)
+                *sink++ = '\n';
+            return true;
+        }
+
+        Delimiter const& delimiter;   // wrapped delimiter
+        mutable unsigned int count;   // invocation counter
+    };
+
+    // That's the actual columns generator
+    template <typename Subject>
+    struct simple_columns_generator
+      : boost::spirit::karma::unary_generator<
+            simple_columns_generator<Subject> >
+    {
+        // Define required output iterator properties
+        typedef typename Subject::properties properties;
+
+        // Define the attribute type exposed by this parser component
+        template <typename Context, typename Iterator>
+        struct attribute 
+          : boost::spirit::traits::attribute_of<Subject, Context, Iterator> 
+        {};
+
+        simple_columns_generator(Subject const& s)
+          : subject(s)
+        {}
+
+        // This function is called during the actual output generation process.
+        // It dispatches to the embedded generator while supplying a new 
+        // delimiter to use, wrapping the outer delimiter.
+        template <typename OutputIterator, typename Context
+          , typename Delimiter, typename Attribute>
+        bool generate(OutputIterator& sink, Context& ctx
+          , Delimiter const& delimiter, Attribute const& attr) const
+        {
+            columns_delimiter<Delimiter> d(delimiter);
+            return subject.generate(sink, ctx, d, attr) && d.final_delimit_out(sink);
+        }
+
+        // This function is called during error handling to create
+        // a human readable string for the error context.
+        template <typename Context>
+        boost::spirit::info what(Context& ctx) const
+        {
+            return boost::spirit::info("columns", subject.what(ctx));
+        }
+
+        Subject subject;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// instantiation of the generator
+namespace boost { namespace spirit { namespace karma
+{
+    // This is the factory function object invoked in order to create 
+    // an instance of our simple_columns_generator.
+    template <typename Subject, typename Modifiers>
+    struct make_directive<custom_generator::tag::columns, Subject, Modifiers>
+    {
+        typedef custom_generator::simple_columns_generator<Subject> result_type;
+
+        result_type operator()(unused_type, Subject const& s, unused_type) const
+        {
+            return result_type(s);
+        }
+    };
+}}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/lex/Jamfile b/src/boost/libs/spirit/example/lex/Jamfile
new file mode 100644
index 00000000..79887762
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/Jamfile
@@ -0,0 +1,32 @@
+#==============================================================================
+#   Copyright (c) 2001-2009 Joel de Guzman
+#   Copyright (c) 2001-2009 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)
+#==============================================================================
+project spirit-lexer-example
+    : requirements 
+        <c++-template-depth>300
+    :
+    :
+    ;
+
+
+exe example1                : example1.cpp ;
+exe example2                : example2.cpp ;
+exe example3                : example3.cpp ;
+exe example4                : example4.cpp ;
+exe example5                : example5.cpp ;
+exe example6                : example6.cpp ;
+exe print_numbers           : print_numbers.cpp ;
+exe print_number_tokenids   : print_number_tokenids.cpp ;
+exe word_count              : word_count.cpp ;
+exe word_count_functor      : word_count_functor.cpp ;
+exe word_count_lexer        : word_count_lexer.cpp ;
+exe word_count_functor_flex : word_count_functor_flex.cpp ;
+exe strip_comments          : strip_comments.cpp ;
+exe strip_comments_lexer    : strip_comments_lexer.cpp ;
+exe custom_token_attribute  : custom_token_attribute.cpp ;
+
+exe lexer_debug_support     : lexer_debug_support.cpp ;
diff --git a/src/boost/libs/spirit/example/lex/custom_token_attribute.cpp b/src/boost/libs/spirit/example/lex/custom_token_attribute.cpp
new file mode 100644
index 00000000..e29bbcee
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/custom_token_attribute.cpp
@@ -0,0 +1,112 @@
+//  Copyright (c) 2001-2010 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)
+
+// The purpose of this example is to demonstrate how custom, user defined types
+// can be easily integrated with the lexer as token value types. Moreover, the
+// custom token values are properly exposed to the parser as well, allowing to 
+// retrieve the custom values using the built in parser attribute propagation
+// rules.
+
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/qi.hpp>
+
+namespace lex = boost::spirit::lex;
+namespace qi = boost::spirit::qi;
+namespace mpl = boost::mpl;
+
+///////////////////////////////////////////////////////////////////////////////
+// This is just a simple custom rational data structure holding two ints to be
+// interpreted as a rational number
+struct rational
+{
+    rational(int n = 0, int d = 0)
+      : nominator_(n), denominator_(d)
+    {}
+
+    int nominator_;
+    int denominator_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// A rational is represented as "{n,d}", where 'n' and 'd' are the nominator
+// and denominator of the number. We use Spirit.Qi to do the low level parsing
+// of the input sequence as matched by the lexer. Certainly, any other 
+// conversion could be used instead.
+//
+// The lexer uses the template assign_to_attribute_from_iterators<> to convert
+// the matched input sequence (pair of iterators) to the token value type as
+// specified while defining the lex::token_def<>. 
+//
+// Our specialization of assign_to_attribute_from_iterators<> for the rational
+// data type defined above has to be placed into the 
+// namespace boost::spirit::traits, otherwise it won't be found by the library.
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<rational, Iterator>
+    {
+        static void 
+        call(Iterator const& first, Iterator const& last, rational& attr)
+        {
+            int x, y;
+            Iterator b = first;
+            qi::parse(b, last, 
+                '{' >> qi::int_ >> ',' >> qi::int_ >> '}', x, y);
+            attr = rational(x, y);
+        }
+    };
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+// a lexer recognizing a single token type: rational
+template <typename Lexer>
+struct lex_rational : lex::lexer<Lexer>
+{
+    lex_rational()
+    {
+        this->self.add_pattern("INT", "[1-9][0-9]*");
+
+        rt = "\\{{INT},{INT}\\}";
+        this->self.add(rt);
+    }
+    lex::token_def<rational> rt;
+};
+
+
+int main()
+{
+    // the token type needs to know the iterator type of the underlying
+    // input and the set of used token value types
+    typedef lex::lexertl::token<std::string::iterator,
+        mpl::vector<rational> > token_type;
+
+    // use actor_lexer<> here if your token definitions have semantic
+    // actions
+    typedef lex::lexertl::lexer<token_type> lexer_type;
+
+    // this is the iterator exposed by the lexer, we use this for parsing
+    typedef lexer_type::iterator_type iterator_type;
+
+    // create a lexer instance
+    std::string input("{3,4}");
+    std::string::iterator s = input.begin();
+
+    lex_rational<lexer_type> lex;
+    iterator_type b = lex.begin(s, input.end());
+
+    // use the embedded token_def as a parser, it exposes its token value type
+    // as its parser attribute type
+    rational r;
+    if (!qi::parse(b, lex.end(), lex.rt, r))
+    {
+        std::cerr << "Parsing failed!" << std::endl;
+        return -1;
+    }
+
+    std::cout << "Parsing succeeded: {" 
+              << r.nominator_ << ", " << r.denominator_ << "}" << std::endl;
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/lex/example.hpp b/src/boost/libs/spirit/example/lex/example.hpp
new file mode 100644
index 00000000..41399a5f
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example.hpp
@@ -0,0 +1,26 @@
+//  Copyright (c) 2001-2010 Hartmut Kaiser
+//  Copyright (c) 2001-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)
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Helper function reading a file into a string
+///////////////////////////////////////////////////////////////////////////////
+inline std::string 
+read_from_file(char const* infile)
+{
+    std::ifstream instream(infile);
+    if (!instream.is_open()) {
+        std::cerr << "Couldn't open file: " << infile << std::endl;
+        exit(-1);
+    }
+    instream.unsetf(std::ios::skipws);      // No white space skipping!
+    return std::string(std::istreambuf_iterator<char>(instream.rdbuf()),
+                       std::istreambuf_iterator<char>());
+}
+
diff --git a/src/boost/libs/spirit/example/lex/example1.cpp b/src/boost/libs/spirit/example/lex/example1.cpp
new file mode 100644
index 00000000..b157b082
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example1.cpp
@@ -0,0 +1,133 @@
+//  Copyright (c) 2001-2010 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)
+
+//  Simple lexer/parser to test the Spirit installation.
+//
+//  This example shows, how to create a simple lexer recognizing 5 different 
+//  tokens, and how to use a single token definition as the skip parser during 
+//  the parsing. Additionally, it demonstrates how to use one of the defined 
+//  tokens as a parser component in the grammar.
+//
+//  The grammar recognizes a simple input structure, for instance:
+//
+//        {
+//            hello world, hello it is me
+//        }
+//
+//  Any number of simple sentences (optionally comma separated) inside a pair 
+//  of curly braces will be matched.
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct example1_tokens : lex::lexer<Lexer>
+{
+    example1_tokens()
+    {
+        // define tokens and associate them with the lexer
+        identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+        this->self = lex::char_(',') | '{' | '}' | identifier;
+
+        // any token definition to be used as the skip parser during parsing 
+        // has to be associated with a separate lexer state (here 'WS') 
+        this->white_space = "[ \\t\\n]+";
+        this->self("WS") = white_space;
+    }
+
+    lex::token_def<> identifier, white_space;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct example1_grammar 
+  : qi::grammar<Iterator, qi::in_state_skipper<lex::token_def<> > >
+{
+    template <typename TokenDef>
+    example1_grammar(TokenDef const& tok)
+      : example1_grammar::base_type(start)
+    {
+        start = '{' >> *(tok.identifier >> -ascii::char_(',')) >> '}';
+    }
+
+    qi::rule<Iterator, qi::in_state_skipper<lex::token_def<> > > start;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // This is the token type to return from the lexer iterator
+    typedef lex::lexertl::token<base_iterator_type> token_type;
+
+    // This is the lexer type to use to tokenize the input.
+    // We use the lexertl based lexer engine.
+    typedef lex::lexertl::lexer<token_type> lexer_type;
+
+    // This is the lexer type (derived from the given lexer type).
+    typedef example1_tokens<lexer_type> example1_lex;
+
+    // This is the iterator type exposed by the lexer 
+    typedef example1_lex::iterator_type iterator_type;
+
+    // This is the type of the grammar to parse
+    typedef example1_grammar<iterator_type> example1_grammar;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    example1_lex lex;                             // Our lexer
+    example1_grammar calc(lex);                   // Our grammar definition
+
+    std::string str (read_from_file("example1.input"));
+
+    // At this point we generate the iterator pair used to expose the
+    // tokenized input stream.
+    std::string::iterator it = str.begin();
+    iterator_type iter = lex.begin(it, str.end());
+    iterator_type end = lex.end();
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    // Note, how we use the token_def defined above as the skip parser. It must
+    // be explicitly wrapped inside a state directive, switching the lexer 
+    // state for the duration of skipping whitespace.
+    bool r = qi::phrase_parse(iter, end, calc, qi::in_state("WS")[lex.white_space]);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::string rest(iter, end);
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \"" << rest << "\"\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/lex/example1.input b/src/boost/libs/spirit/example/lex/example1.input
new file mode 100644
index 00000000..e2aa2b62
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example1.input
@@ -0,0 +1,5 @@
+{
+   hello world,
+   hello world,
+   goodbye
+}
diff --git a/src/boost/libs/spirit/example/lex/example2.cpp b/src/boost/libs/spirit/example/lex/example2.cpp
new file mode 100644
index 00000000..68a47667
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example2.cpp
@@ -0,0 +1,169 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example shows how to create a simple lexer recognizing a couple of 
+//  different tokens and how to use this with a grammar. This example has a 
+//  heavily backtracking grammar which makes it a candidate for lexer based 
+//  parsing (all tokens are scanned and generated only once, even if 
+//  backtracking is required) which speeds up the overall parsing process 
+//  considerably, out-weighting the overhead needed for setting up the lexer.
+//  Additionally it demonstrates how to use one of the defined tokens as a 
+//  parser component in the grammar.
+//
+//  The grammar recognizes a simple input structure: any number of English 
+//  simple sentences (statements, questions and commands) are recognized and
+//  are being counted separately.
+
+// #define BOOST_SPIRIT_DEBUG 
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+using boost::phoenix::ref;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct example2_tokens : lex::lexer<Lexer>
+{
+    example2_tokens()
+    {
+        //  A 'word' is comprised of one or more letters and an optional 
+        //  apostrophe. If it contains an apostrophe, there may only be one and 
+        //  the apostrophe must be preceded and succeeded by at least 1 letter.  
+        //  For example, "I'm" and "doesn't" meet the definition of 'word' we 
+        //  define below.
+        word = "[a-zA-Z]+('[a-zA-Z]+)?";
+
+        // Associate the tokens and the token set with the lexer. Note that 
+        // single character token definitions as used below always get 
+        // interpreted literally and never as special regex characters. This is
+        // done to be able to assign single characters the id of their character
+        // code value, allowing to reference those as literals in Qi grammars.
+        this->self = lex::token_def<>(',') | '!' | '.' | '?' | ' ' | '\n' | word;
+    }
+
+    lex::token_def<> word;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct example2_grammar : qi::grammar<Iterator>
+{
+    template <typename TokenDef>
+    example2_grammar(TokenDef const& tok)
+      : example2_grammar::base_type(story)
+      , paragraphs(0), commands(0), questions(0), statements(0)
+    {
+        story 
+            =  +paragraph
+            ;
+
+        paragraph
+            =   (  +(   command [ ++ref(commands) ] 
+                    |   question [ ++ref(questions) ]
+                    |   statement [ ++ref(statements) ]
+                    ) 
+                    >> *char_(' ') >> +char_('\n')
+                ) 
+                [ ++ref(paragraphs) ]
+            ;
+
+        command 
+            =  +(tok.word | ' ' | ',') >> '!' 
+            ;
+
+        question 
+            =  +(tok.word | ' ' | ',') >> '?' 
+            ;
+
+        statement 
+            =  +(tok.word | ' ' | ',') >> '.' 
+            ;
+
+        BOOST_SPIRIT_DEBUG_NODE(story);
+        BOOST_SPIRIT_DEBUG_NODE(paragraph);
+        BOOST_SPIRIT_DEBUG_NODE(command);
+        BOOST_SPIRIT_DEBUG_NODE(question);
+        BOOST_SPIRIT_DEBUG_NODE(statement);
+    }
+
+    qi::rule<Iterator> story, paragraph, command, question, statement;
+    int paragraphs, commands, questions, statements;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // This is the token type to return from the lexer iterator
+    typedef lex::lexertl::token<base_iterator_type> token_type;
+
+    // This is the lexer type to use to tokenize the input.
+    // Here we use the lexertl based lexer engine.
+    typedef lex::lexertl::lexer<token_type> lexer_type;
+
+    // This is the token definition type (derived from the given lexer type).
+    typedef example2_tokens<lexer_type> example2_tokens;
+
+    // this is the iterator type exposed by the lexer 
+    typedef example2_tokens::iterator_type iterator_type;
+
+    // this is the type of the grammar to parse
+    typedef example2_grammar<iterator_type> example2_grammar;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    example2_tokens tokens;                         // Our lexer
+    example2_grammar calc(tokens);                  // Our parser 
+
+    std::string str (read_from_file("example2.input"));
+
+    // At this point we generate the iterator pair used to expose the
+    // tokenized input stream.
+    std::string::iterator it = str.begin();
+    iterator_type iter = tokens.begin(it, str.end());
+    iterator_type end = tokens.end();
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    bool r = qi::parse(iter, end, calc);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "There were " 
+                  << calc.commands << " commands, " 
+                  << calc.questions << " questions, and " 
+                  << calc.statements << " statements.\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/lex/example2.input b/src/boost/libs/spirit/example/lex/example2.input
new file mode 100644
index 00000000..2f768330
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example2.input
@@ -0,0 +1,7 @@
+Our hiking boots are ready.  So, let's pack!
+
+Have you the plane tickets for there and back?
+
+I do, I do.  We're all ready to go.  Grab my hand and be my beau.
+
+
diff --git a/src/boost/libs/spirit/example/lex/example3.cpp b/src/boost/libs/spirit/example/lex/example3.cpp
new file mode 100644
index 00000000..83800331
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example3.cpp
@@ -0,0 +1,150 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example shows how to create a simple lexer recognizing a couple of 
+//  different tokens and how to use this with a grammar. This example has a 
+//  heavily backtracking grammar which makes it a candidate for lexer based 
+//  parsing (all tokens are scanned and generated only once, even if 
+//  backtracking is required) which speeds up the overall parsing process 
+//  considerably, out-weighting the overhead needed for setting up the lexer.
+//
+//  Additionally, this example demonstrates, how to define a token set usable 
+//  as the skip parser during parsing, allowing to define several tokens to be 
+//  ignored.
+//
+//  This example recognizes couplets, which are sequences of numbers enclosed 
+//  in matching pairs of parenthesis. See the comments below to for details
+//  and examples.
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+// #define BOOST_SPIRIT_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct example3_tokens : lex::lexer<Lexer>
+{
+    example3_tokens()
+    {
+        // define the tokens to match
+        ellipses = "\\.\\.\\.";
+        number = "[0-9]+";
+
+        // associate the tokens and the token set with the lexer
+        this->self = ellipses | '(' | ')' | number;
+
+        // define the whitespace to ignore (spaces, tabs, newlines and C-style 
+        // comments)
+        this->self("WS") 
+            =   lex::token_def<>("[ \\t\\n]+")          // whitespace
+            |   "\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\/"   // C style comments
+            ;
+    }
+
+    // these tokens expose the iterator_range of the matched input sequence
+    lex::token_def<> ellipses, identifier, number;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator, typename Lexer>
+struct example3_grammar 
+  : qi::grammar<Iterator, qi::in_state_skipper<Lexer> >
+{
+    template <typename TokenDef>
+    example3_grammar(TokenDef const& tok)
+      : example3_grammar::base_type(start)
+    {
+        start 
+            =  +(couplet | tok.ellipses)
+            ;
+
+        //  A couplet matches nested left and right parenthesis.
+        //  For example:
+        //    (1) (1 2) (1 2 3) ...
+        //    ((1)) ((1 2)(3 4)) (((1) (2 3) (1 2 (3) 4))) ...
+        //    (((1))) ...
+        couplet
+            =   tok.number
+            |   '(' >> +couplet >> ')'
+            ;
+
+        BOOST_SPIRIT_DEBUG_NODE(start);
+        BOOST_SPIRIT_DEBUG_NODE(couplet);
+    }
+
+    qi::rule<Iterator, qi::in_state_skipper<Lexer> > start, couplet;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // This is the token type to return from the lexer iterator
+    typedef lex::lexertl::token<base_iterator_type> token_type;
+
+    // This is the lexer type to use to tokenize the input.
+    // Here we use the lexertl based lexer engine.
+    typedef lex::lexertl::lexer<token_type> lexer_type;
+
+    // This is the token definition type (derived from the given lexer type).
+    typedef example3_tokens<lexer_type> example3_tokens;
+
+    // this is the iterator type exposed by the lexer 
+    typedef example3_tokens::iterator_type iterator_type;
+
+    // this is the type of the grammar to parse
+    typedef example3_grammar<iterator_type, example3_tokens::lexer_def> example3_grammar;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    example3_tokens tokens;                         // Our lexer
+    example3_grammar calc(tokens);                  // Our parser
+
+    std::string str (read_from_file("example3.input"));
+
+    // At this point we generate the iterator pair used to expose the
+    // tokenized input stream.
+    std::string::iterator it = str.begin();
+    iterator_type iter = tokens.begin(it, str.end());
+    iterator_type end = tokens.end();
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    // Note how we use the lexer defined above as the skip parser.
+    bool r = qi::phrase_parse(iter, end, calc, qi::in_state("WS")[tokens.self]);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/lex/example3.input b/src/boost/libs/spirit/example/lex/example3.input
new file mode 100644
index 00000000..497cab43
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example3.input
@@ -0,0 +1,5 @@
+/* the following are couplets */
+(1) (1 2) (1 2 3) ...
+((1)) ((1 2)(3 4)) (((1) (2 3) (1 2 (3) 4))) ...
+(((1))) ...
+
diff --git a/src/boost/libs/spirit/example/lex/example4.cpp b/src/boost/libs/spirit/example/lex/example4.cpp
new file mode 100644
index 00000000..2970340a
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example4.cpp
@@ -0,0 +1,227 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example shows how to create a simple lexer recognizing a couple of 
+//  different tokens aimed at a simple language and how to use this lexer with 
+//  a grammar. It shows how to associate attributes to tokens and how to access 
+//  the token attributes from inside the grammar.
+//
+//  We use explicit token attribute types, making the corresponding token instances
+//  carry convert the matched input into an instance of that type. The token 
+//  attribute is exposed as the parser attribute if this token is used as a 
+//  parser component somewhere in a grammar.
+//
+//  Additionally, this example demonstrates, how to define a token set usable 
+//  as the skip parser during parsing, allowing to define several tokens to be 
+//  ignored.
+//
+//  This example recognizes a very simple programming language having 
+//  assignment statements and if and while control structures. Look at the file
+//  example4.input for an example.
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+using boost::phoenix::val;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct example4_tokens : lex::lexer<Lexer>
+{
+    example4_tokens()
+    {
+        // define the tokens to match
+        identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+        constant = "[0-9]+";
+        if_ = "if";
+        else_ = "else";
+        while_ = "while";
+
+        // associate the tokens and the token set with the lexer
+        this->self = lex::token_def<>('(') | ')' | '{' | '}' | '=' | ';' | constant;
+        this->self += if_ | else_ | while_ | identifier;
+
+        // define the whitespace to ignore (spaces, tabs, newlines and C-style 
+        // comments)
+        this->self("WS")
+            =   lex::token_def<>("[ \\t\\n]+") 
+            |   "\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\/"
+            ;
+    }
+
+//[example4_token_def
+    // these tokens expose the iterator_range of the matched input sequence
+    lex::token_def<> if_, else_, while_;
+
+    // The following two tokens have an associated attribute type, 'identifier'
+    // carries a string (the identifier name) and 'constant' carries the 
+    // matched integer value.
+    //
+    // Note: any token attribute type explicitly specified in a token_def<>
+    //       declaration needs to be listed during token type definition as 
+    //       well (see the typedef for the token_type below).
+    //
+    // The conversion of the matched input to an instance of this type occurs
+    // once (on first access), which makes token attributes as efficient as 
+    // possible. Moreover, token instances are constructed once by the lexer
+    // library. From this point on tokens are passed by reference only, 
+    // avoiding them being copied around.
+    lex::token_def<std::string> identifier;
+    lex::token_def<unsigned int> constant;
+//]
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator, typename Lexer>
+struct example4_grammar 
+  : qi::grammar<Iterator, qi::in_state_skipper<Lexer> >
+{
+    template <typename TokenDef>
+    example4_grammar(TokenDef const& tok)
+      : example4_grammar::base_type(program)
+    {
+        using boost::spirit::_val;
+
+        program 
+            =  +block
+            ;
+
+        block
+            =   '{' >> *statement >> '}'
+            ;
+
+        statement 
+            =   assignment
+            |   if_stmt
+            |   while_stmt
+            ;
+
+        assignment 
+            =   (tok.identifier >> '=' >> expression >> ';')
+                [
+                    std::cout << val("assignment statement to: ") << _1 << "\n"
+                ]
+            ;
+
+        if_stmt
+            =   (   tok.if_ >> '(' >> expression >> ')' >> block 
+                    >> -(tok.else_ >> block) 
+                )
+                [
+                    std::cout << val("if expression: ") << _2 << "\n"
+                ]
+            ;
+
+        while_stmt 
+            =   (tok.while_ >> '(' >> expression >> ')' >> block)
+                [
+                    std::cout << val("while expression: ") << _2 << "\n"
+                ]
+            ;
+
+        //  since expression has a variant return type accommodating for 
+        //  std::string and unsigned integer, both possible values may be 
+        //  returned to the calling rule
+        expression 
+            =   tok.identifier [ _val = _1 ]
+            |   tok.constant   [ _val = _1 ]
+            ;
+    }
+
+    typedef boost::variant<unsigned int, std::string> expression_type;
+
+    qi::rule<Iterator, qi::in_state_skipper<Lexer> > program, block, statement;
+    qi::rule<Iterator, qi::in_state_skipper<Lexer> > assignment, if_stmt;
+    qi::rule<Iterator, qi::in_state_skipper<Lexer> > while_stmt;
+
+    //  the expression is the only rule having a return value
+    qi::rule<Iterator, expression_type(), qi::in_state_skipper<Lexer> >  expression;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+//[example4_token
+    // This is the lexer token type to use. The second template parameter lists 
+    // all attribute types used for token_def's during token definition (see 
+    // calculator_tokens<> above). Here we use the predefined lexertl token 
+    // type, but any compatible token type may be used instead.
+    //
+    // If you don't list any token attribute types in the following declaration 
+    // (or just use the default token type: lexertl_token<base_iterator_type>)  
+    // it will compile and work just fine, just a bit less efficient. This is  
+    // because the token attribute will be generated from the matched input  
+    // sequence every time it is requested. But as soon as you specify at 
+    // least one token attribute type you'll have to list all attribute types 
+    // used for token_def<> declarations in the token definition class above, 
+    // otherwise compilation errors will occur.
+    typedef lex::lexertl::token<
+        base_iterator_type, boost::mpl::vector<unsigned int, std::string> 
+    > token_type;
+//]
+    // Here we use the lexertl based lexer engine.
+    typedef lex::lexertl::lexer<token_type> lexer_type;
+
+    // This is the token definition type (derived from the given lexer type).
+    typedef example4_tokens<lexer_type> example4_tokens;
+
+    // this is the iterator type exposed by the lexer 
+    typedef example4_tokens::iterator_type iterator_type;
+
+    // this is the type of the grammar to parse
+    typedef example4_grammar<iterator_type, example4_tokens::lexer_def> example4_grammar;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    example4_tokens tokens;                         // Our lexer
+    example4_grammar calc(tokens);                  // Our parser
+
+    std::string str (read_from_file("example4.input"));
+
+    // At this point we generate the iterator pair used to expose the
+    // tokenized input stream.
+    std::string::iterator it = str.begin();
+    iterator_type iter = tokens.begin(it, str.end());
+    iterator_type end = tokens.end();
+        
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    // Note how we use the lexer defined above as the skip parser. It must
+    // be explicitly wrapped inside a state directive, switching the lexer 
+    // state for the duration of skipping whitespace.
+    bool r = qi::phrase_parse(iter, end, calc, qi::in_state("WS")[tokens.self]);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/lex/example4.input b/src/boost/libs/spirit/example/lex/example4.input
new file mode 100644
index 00000000..7a5ff76d
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example4.input
@@ -0,0 +1,17 @@
+/* example4.input */
+{
+
+  if (variable) { a = b ; }
+
+  while (10) { 
+
+    if (2) { b = 10 ; }
+    if (x) { c = x ; } else { d = 10 ; }
+
+  }
+
+  variable = 42;
+
+}
+
+
diff --git a/src/boost/libs/spirit/example/lex/example5.cpp b/src/boost/libs/spirit/example/lex/example5.cpp
new file mode 100644
index 00000000..8083042c
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example5.cpp
@@ -0,0 +1,273 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example shows how to create a simple lexer recognizing a couple of 
+//  different tokens aimed at a simple language and how to use this lexer with 
+//  a grammar. It shows how to associate attributes to tokens and how to access the 
+//  token attributes from inside the grammar.
+//
+//  Additionally, this example demonstrates, how to define a token set usable 
+//  as the skip parser during parsing, allowing to define several tokens to be 
+//  ignored.
+//
+//  The main purpose of this example is to show how inheritance can be used to 
+//  overload parts of a base grammar and add token definitions to a base lexer.
+//
+//  Further, it shows how you can use the 'omit' attribute type specifier 
+//  for token definitions to force the token to have no attribute (expose an 
+//  unused attribute).
+//
+//  This example recognizes a very simple programming language having 
+//  assignment statements and if and while control structures. Look at the file
+//  example5.input for an example.
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+using boost::phoenix::val;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition base, defines all tokens for the base grammar below
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct example5_base_tokens : lex::lexer<Lexer>
+{
+protected:
+    // this lexer is supposed to be used as a base type only
+    example5_base_tokens() {}
+
+public:
+    void init_token_definitions()
+    {
+        // define the tokens to match
+        identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+        constant = "[0-9]+";
+        if_ = "if";
+        while_ = "while";
+
+        // associate the tokens and the token set with the lexer
+        this->self += lex::token_def<>('(') | ')' | '{' | '}' | '=' | ';' | constant;
+        this->self += if_ | while_ | identifier;
+
+        // define the whitespace to ignore (spaces, tabs, newlines and C-style 
+        // comments)
+        this->self("WS")
+            =   lex::token_def<>("[ \\t\\n]+") 
+            |   "\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\/"
+            ;
+    }
+
+    // these tokens have no attribute
+    lex::token_def<lex::omit> if_, while_;
+
+    // The following two tokens have an associated attribute type, 'identifier'
+    // carries a string (the identifier name) and 'constant' carries the 
+    // matched integer value.
+    //
+    // Note: any token attribute type explicitly specified in a token_def<>
+    //       declaration needs to be listed during token type definition as 
+    //       well (see the typedef for the token_type below).
+    //
+    // The conversion of the matched input to an instance of this type occurs
+    // once (on first access), which makes token attributes as efficient as 
+    // possible. Moreover, token instances are constructed once by the lexer
+    // library. From this point on tokens are passed by reference only, 
+    // avoiding them being copied around.
+    lex::token_def<std::string> identifier;
+    lex::token_def<unsigned int> constant;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition base, defines a basic language
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator, typename Lexer>
+struct example5_base_grammar 
+  : qi::grammar<Iterator, qi::in_state_skipper<Lexer> >
+{
+    template <typename TokenDef>
+    example5_base_grammar(TokenDef const& tok)
+      : example5_base_grammar::base_type(program)
+    {
+        using boost::spirit::_val;
+
+        program 
+            =  +block
+            ;
+
+        block
+            =   '{' >> *statement >> '}'
+            ;
+
+        statement 
+            =   assignment
+            |   if_stmt
+            |   while_stmt
+            ;
+
+        assignment 
+            =   (tok.identifier >> '=' >> expression >> ';')
+                [
+                    std::cout << val("assignment statement to: ") << _1 << "\n"
+                ]
+            ;
+
+        if_stmt
+            =   (tok.if_ >> '(' >> expression >> ')' >> block)
+                [
+                    std::cout << val("if expression: ") << _1 << "\n"
+                ]
+            ;
+
+        while_stmt 
+            =   (tok.while_ >> '(' >> expression >> ')' >> block)
+                [
+                    std::cout << val("while expression: ") << _1 << "\n"
+                ]
+            ;
+
+        //  since expression has a variant return type accommodating for 
+        //  std::string and unsigned integer, both possible values may be 
+        //  returned to the calling rule
+        expression 
+            =   tok.identifier [ _val = _1 ]
+            |   tok.constant   [ _val = _1 ]
+            ;
+    }
+
+    typedef qi::in_state_skipper<Lexer> skipper_type;
+
+    qi::rule<Iterator, skipper_type> program, block, statement;
+    qi::rule<Iterator, skipper_type> assignment, if_stmt;
+    qi::rule<Iterator, skipper_type> while_stmt;
+
+    //  the expression is the only rule having a return value
+    typedef boost::variant<unsigned int, std::string> expression_type;
+    qi::rule<Iterator, expression_type(), skipper_type>  expression;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition for derived lexer, defines additional tokens 
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct example5_tokens : example5_base_tokens<Lexer>
+{
+    typedef example5_base_tokens<Lexer> base_type;
+
+    example5_tokens()
+    {
+        // define the additional token to match
+        else_ = "else";
+
+        // associate the new token with the lexer, note we add 'else' before 
+        // anything else to add it to the token set before the identifier 
+        // token, otherwise "else" would be matched as an identifier
+        this->self = else_;
+
+        // now add the token definitions from the base class
+        this->base_type::init_token_definitions();
+    }
+
+    // this token has no attribute
+    lex::token_def<lex::omit> else_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Derived grammar definition, defines a language extension
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator, typename Lexer>
+struct example5_grammar : example5_base_grammar<Iterator, Lexer>
+{
+    template <typename TokenDef>
+    example5_grammar(TokenDef const& tok)
+      : example5_base_grammar<Iterator, Lexer>(tok)
+    {
+        // we alter the if_stmt only
+        this->if_stmt
+            =   this->if_stmt.copy() >> -(tok.else_ >> this->block)
+            ;
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // This is the lexer token type to use. The second template parameter lists 
+    // all attribute types used for token_def's during token definition (see 
+    // example5_base_tokens<> above). Here we use the predefined lexertl token 
+    // type, but any compatible token type may be used instead.
+    //
+    // If you don't list any token attribute types in the following declaration 
+    // (or just use the default token type: lexertl_token<base_iterator_type>)  
+    // it will compile and work just fine, just a bit less efficient. This is  
+    // because the token attribute will be generated from the matched input  
+    // sequence every time it is requested. But as soon as you specify at 
+    // least one token attribute type you'll have to list all attribute types 
+    // used for token_def<> declarations in the token definition class above,  
+    // otherwise compilation errors will occur.
+    typedef lex::lexertl::token<
+        base_iterator_type, boost::mpl::vector<unsigned int, std::string> 
+    > token_type;
+
+    // Here we use the lexertl based lexer engine.
+    typedef lex::lexertl::lexer<token_type> lexer_type;
+
+    // This is the token definition type (derived from the given lexer type).
+    typedef example5_tokens<lexer_type> example5_tokens;
+
+    // this is the iterator type exposed by the lexer 
+    typedef example5_tokens::iterator_type iterator_type;
+
+    // this is the type of the grammar to parse
+    typedef example5_grammar<iterator_type, example5_tokens::lexer_def> example5_grammar;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    example5_tokens tokens;                         // Our lexer
+    example5_grammar calc(tokens);                  // Our parser
+
+    std::string str (read_from_file("example5.input"));
+
+    // At this point we generate the iterator pair used to expose the
+    // tokenized input stream.
+    std::string::iterator it = str.begin();
+    iterator_type iter = tokens.begin(it, str.end());
+    iterator_type end = tokens.end();
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    // Note how we use the lexer defined above as the skip parser. It must
+    // be explicitly wrapped inside a state directive, switching the lexer 
+    // state for the duration of skipping whitespace.
+    std::string ws("WS");
+    bool r = qi::phrase_parse(iter, end, calc, qi::in_state(ws)[tokens.self]);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/lex/example5.input b/src/boost/libs/spirit/example/lex/example5.input
new file mode 100644
index 00000000..1cbecf52
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example5.input
@@ -0,0 +1,16 @@
+/* example5.input */
+{
+
+  if (variable) { a = b ; }
+
+  while (10) { 
+
+    if (2) { b = 10 ; }
+    if (x) { c = x ; } else { d = 10 ; }
+
+  }
+
+  variable = 42;
+  if (variable) { a = b ; } else { }
+}
+
diff --git a/src/boost/libs/spirit/example/lex/example6.cpp b/src/boost/libs/spirit/example/lex/example6.cpp
new file mode 100644
index 00000000..843b2d98
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example6.cpp
@@ -0,0 +1,249 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example shows how to create a simple lexer recognizing a couple of 
+//  different tokens aimed at a simple language and how to use this lexer with 
+//  a grammar. It shows how to associate attributes to tokens and how to access the 
+//  token attributes from inside the grammar.
+//
+//  Additionally, this example demonstrates, how to define a token set usable 
+//  as the skip parser during parsing, allowing to define several tokens to be 
+//  ignored.
+//
+//  The example demonstrates how to use the add(...)(...) syntax to associate 
+//  token definitions with the lexer and how token ids can be used in the 
+//  parser to refer to a token, without having to directly reference its 
+//  definition.
+//
+//  This example recognizes a very simple programming language having 
+//  assignment statements and if and while control structures. Look at the file
+//  example6.input for an example.
+//
+//  This example is essentially identical to example4.cpp. The only difference 
+//  is that we use the self.add() syntax to define tokens and to associate them
+//  with the lexer.
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+using boost::phoenix::val;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token id definitions
+///////////////////////////////////////////////////////////////////////////////
+enum token_ids
+{
+    ID_CONSTANT = 1000,
+    ID_IF,
+    ID_ELSE,
+    ID_WHILE,
+    ID_IDENTIFIER
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definitions
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct example6_tokens : lex::lexer<Lexer>
+{
+    example6_tokens()
+    {
+        // define the tokens to match
+        identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
+        constant = "[0-9]+";
+
+        // associate the tokens and the token set with the lexer
+        this->self = lex::token_def<>('(') | ')' | '{' | '}' | '=' | ';';
+
+        // Token definitions can be added by using some special syntactic 
+        // construct as shown below.
+        // Note, that the token definitions added this way expose the iterator
+        // pair pointing to the matched input stream as their attribute.
+        this->self.add
+            (constant, ID_CONSTANT)
+            ("if", ID_IF)
+            ("else", ID_ELSE)
+            ("while", ID_WHILE)
+            (identifier, ID_IDENTIFIER)
+        ;
+
+        // define the whitespace to ignore (spaces, tabs, newlines and C-style 
+        // comments) and add those to another lexer state (here: "WS")
+        this->self("WS") 
+            =   lex::token_def<>("[ \\t\\n]+") 
+            |   "\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\/"
+            ;
+    }
+
+    // The following two tokens have an associated attribute type, identifier 
+    // carries a string (the identifier name) and constant carries the matched 
+    // integer value.
+    //
+    // Note: any token attribute type explicitly specified in a token_def<>
+    //       declaration needs to be listed during token type definition as 
+    //       well (see the typedef for the token_type below).
+    //
+    // The conversion of the matched input to an instance of this type occurs
+    // once (on first access), which makes token attributes as efficient as 
+    // possible. Moreover, token instances are constructed once by the lexer
+    // library. From this point on tokens are passed by reference only, 
+    // avoiding them being copied around.
+    lex::token_def<std::string> identifier;
+    lex::token_def<unsigned int> constant;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator, typename Lexer>
+struct example6_grammar 
+  : qi::grammar<Iterator, qi::in_state_skipper<Lexer> >
+{
+    template <typename TokenDef>
+    example6_grammar(TokenDef const& tok)
+      : example6_grammar::base_type(program)
+    {
+        using boost::spirit::_val;
+
+        program 
+            =  +block
+            ;
+
+        block
+            =   '{' >> *statement >> '}'
+            ;
+
+        statement 
+            =   assignment
+            |   if_stmt
+            |   while_stmt
+            ;
+
+        assignment 
+            =   (tok.identifier >> '=' >> expression >> ';')
+                [
+                    std::cout << val("assignment statement to: ")
+                              << _1 << "\n"
+                ]
+            ;
+
+        if_stmt
+            =   (   token(ID_IF) >> '(' >> expression >> ')' >> block 
+                >> -(token(ID_ELSE) >> block) 
+                )
+                [
+                    std::cout << val("if expression: ")
+                              << _2 << "\n"
+                ]
+            ;
+
+        while_stmt 
+            =   (token(ID_WHILE) >> '(' >> expression >> ')' >> block)
+                [
+                    std::cout << val("while expression: ")
+                              << _2 << "\n"
+                ]
+            ;
+
+        //  since expression has a variant return type accommodating for 
+        //  std::string and unsigned integer, both possible values may be 
+        //  returned to the calling rule
+        expression 
+            =   tok.identifier [ _val = _1 ]
+            |   tok.constant   [ _val = _1 ]
+            ;
+    }
+
+    typedef boost::variant<unsigned int, std::string> expression_type;
+
+    qi::rule<Iterator, qi::in_state_skipper<Lexer> > program, block, statement;
+    qi::rule<Iterator, qi::in_state_skipper<Lexer> > assignment, if_stmt;
+    qi::rule<Iterator, qi::in_state_skipper<Lexer> > while_stmt;
+
+    //  the expression is the only rule having a return value
+    qi::rule<Iterator, expression_type(), qi::in_state_skipper<Lexer> >  expression;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // This is the lexer token type to use. The second template parameter lists 
+    // all attribute types used for token_def's during token definition (see 
+    // calculator_tokens<> above). Here we use the predefined lexertl token 
+    // type, but any compatible token type may be used instead.
+    //
+    // If you don't list any token attribute types in the following declaration 
+    // (or just use the default token type: lexertl_token<base_iterator_type>)  
+    // it will compile and work just fine, just a bit less efficient. This is  
+    // because the token attribute will be generated from the matched input  
+    // sequence every time it is requested. But as soon as you specify at 
+    // least one token attribute type you'll have to list all attribute types 
+    // used for token_def<> declarations in the token definition class above,  
+    // otherwise compilation errors will occur.
+    typedef lex::lexertl::token<
+        base_iterator_type, boost::mpl::vector<unsigned int, std::string> 
+    > token_type;
+
+    // Here we use the lexertl based lexer engine.
+    typedef lex::lexertl::lexer<token_type> lexer_type;
+
+    // This is the token definition type (derived from the given lexer type).
+    typedef example6_tokens<lexer_type> example6_tokens;
+
+    // this is the iterator type exposed by the lexer 
+    typedef example6_tokens::iterator_type iterator_type;
+
+    // this is the type of the grammar to parse
+    typedef example6_grammar<iterator_type, example6_tokens::lexer_def> example6_grammar;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    example6_tokens tokens;                         // Our lexer
+    example6_grammar calc(tokens);                  // Our parser
+
+    std::string str (read_from_file("example6.input"));
+
+    // At this point we generate the iterator pair used to expose the
+    // tokenized input stream.
+    std::string::iterator it = str.begin();
+    iterator_type iter = tokens.begin(it, str.end());
+    iterator_type end = tokens.end();
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    // Note how we use the lexer defined above as the skip parser. It must
+    // be explicitly wrapped inside a state directive, switching the lexer 
+    // state for the duration of skipping whitespace.
+    std::string ws("WS");
+    bool r = qi::phrase_parse(iter, end, calc, qi::in_state(ws)[tokens.self]);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/lex/example6.input b/src/boost/libs/spirit/example/lex/example6.input
new file mode 100644
index 00000000..992cbeb3
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/example6.input
@@ -0,0 +1,17 @@
+/* example6.input */
+{
+
+  if (variable) { a = b ; }
+
+  while (10) { 
+
+    if (2) { b = 10 ; }
+    if (x) { c = x ; } else { d = 10 ; }
+
+  }
+
+  variable = 42;
+
+}
+
+
diff --git a/src/boost/libs/spirit/example/lex/lexer_debug_support.cpp b/src/boost/libs/spirit/example/lex/lexer_debug_support.cpp
new file mode 100644
index 00000000..c6d3f76d
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/lexer_debug_support.cpp
@@ -0,0 +1,109 @@
+//  Copyright (c) 2001-2011 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)
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG 1
+
+#include <boost/config/warning_disable.hpp>
+
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix.hpp>
+
+namespace lex = boost::spirit::lex;
+namespace qi = boost::spirit::qi;
+namespace phoenix = boost::phoenix;
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct language_tokens : lex::lexer<Lexer>
+{
+    language_tokens()
+    {
+        tok_float = "float";
+        tok_int = "int";
+        floatlit = "[0-9]+\\.[0-9]*";
+        intlit = "[0-9]+";
+        ws = "[ \t\n]+";
+        identifier = "[a-zA-Z_][a-zA-Z_0-9]*";
+      
+        this->self = ws [lex::_pass = lex::pass_flags::pass_ignore];
+        this->self += tok_float | tok_int | floatlit | intlit | identifier;
+        this->self += lex::char_('=');
+    }
+
+    lex::token_def<> tok_float, tok_int;
+    lex::token_def<> ws;
+    lex::token_def<double> floatlit;
+    lex::token_def<int> intlit;
+    lex::token_def<> identifier;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct language_grammar : qi::grammar<Iterator>
+{
+    template <typename Lexer>
+    language_grammar(language_tokens<Lexer> const& tok) 
+      : language_grammar::base_type(declarations)
+    {
+        declarations = +number;
+        number = 
+                tok.tok_float >> tok.identifier >> '=' >> tok.floatlit
+            |   tok.tok_int >> tok.identifier >> '=' >> tok.intlit
+            ;
+
+        declarations.name("declarations");
+        number.name("number");
+        debug(declarations);
+        debug(number);
+    }
+
+    qi::rule<Iterator> declarations;
+    qi::rule<Iterator> number;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // lexer type
+    typedef lex::lexertl::actor_lexer<
+        lex::lexertl::token<
+            base_iterator_type, boost::mpl::vector2<double, int> 
+        > > lexer_type;
+
+    // iterator type exposed by the lexer 
+    typedef language_tokens<lexer_type>::iterator_type iterator_type;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    language_tokens<lexer_type> tokenizer;           // Our lexer
+    language_grammar<iterator_type> g (tokenizer);   // Our parser 
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    std::string str ("float f = 3.4\nint i = 6\n");
+    base_iterator_type first = str.begin();
+
+    bool r = lex::tokenize_and_parse(first, str.end(), tokenizer, g);
+
+    if (r) {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else {
+        std::string rest(first, str.end());
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \"" << rest << "\"\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/lex/print_number_tokenids.cpp b/src/boost/libs/spirit/example/lex/print_number_tokenids.cpp
new file mode 100644
index 00000000..3789f0eb
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/print_number_tokenids.cpp
@@ -0,0 +1,121 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example is the equivalent to the following lex program:
+//
+//     %{
+//     #include <stdio.h>
+//     %}
+//     %%
+//     [0-9]+   { printf("%s\n", yytext); }
+//     .|\n     ;
+//     %%
+//     main()
+//     {
+//             yylex();
+//     }
+//
+//  Its purpose is to print all the (integer) numbers found in a file
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+#include <iostream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition: We use the lexertl based lexer engine as the underlying 
+//                    lexer type.
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct print_numbers_tokenids : lex::lexer<Lexer>
+{
+    // define tokens and associate it with the lexer, we set the lexer flags
+    // not to match newlines while matching a dot, so we need to add the
+    // '\n' explicitly below
+    print_numbers_tokenids()
+      : print_numbers_tokenids::base_type(lex::match_flags::match_not_dot_newline)
+    {
+        this->self = lex::token_def<int>("[0-9]+") | ".|\n";
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct print_numbers_grammar : qi::grammar<Iterator>
+{
+    print_numbers_grammar()
+      : print_numbers_grammar::base_type(start)
+    {
+        // we just know, that the token ids get assigned starting min_token_id
+        // so, "[0-9]+" gets the id 'min_token_id' and ".|\n" gets the id
+        // 'min_token_id+1'.
+
+        // this prints the token ids of the matched tokens
+        start =  *(   qi::tokenid(lex::min_token_id) 
+                  |   qi::tokenid(lex::min_token_id+1)
+                  ) 
+                  [ std::cout << _1  << "\n" ]
+              ;
+    }
+
+    qi::rule<Iterator> start;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char* argv[])
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // the token type to be used, 'int' is available as the type of the token 
+    // attribute and no lexer state is supported
+    typedef lex::lexertl::token<base_iterator_type, boost::mpl::vector<int>
+      , boost::mpl::false_> token_type;
+
+    // lexer type
+    typedef lex::lexertl::lexer<token_type> lexer_type;
+
+    // iterator type exposed by the lexer 
+    typedef print_numbers_tokenids<lexer_type>::iterator_type iterator_type;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    print_numbers_tokenids<lexer_type> print_tokens;  // Our lexer
+    print_numbers_grammar<iterator_type> print;       // Our parser 
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    std::string str (read_from_file(1 == argc ? "print_numbers.input" : argv[1]));
+    base_iterator_type first = str.begin();
+    bool r = lex::tokenize_and_parse(first, str.end(), print_tokens, print);
+
+    if (r) {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else {
+        std::string rest(first, str.end());
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \"" << rest << "\"\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
+
diff --git a/src/boost/libs/spirit/example/lex/print_numbers.cpp b/src/boost/libs/spirit/example/lex/print_numbers.cpp
new file mode 100644
index 00000000..e128af97
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/print_numbers.cpp
@@ -0,0 +1,118 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example is the equivalent to the following lex program:
+//
+//     %{
+//     #include <stdio.h>
+//     %}
+//     %%
+//     [0-9]+   { printf("%s\n", yytext); }
+//     .|\n     ;
+//     %%
+//     main()
+//     {
+//             yylex();
+//     }
+//
+//  Its purpose is to print all the (integer) numbers found in a file
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+#include <iostream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition: We use the lexertl based lexer engine as the underlying 
+//                    lexer type.
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct print_numbers_tokens : lex::lexer<Lexer>
+{
+    // define tokens and associate it with the lexer, we set the lexer flags
+    // not to match newlines while matching a dot, so we need to add the
+    // '\n' explicitly below
+    print_numbers_tokens()
+      : print_numbers_tokens::base_type(lex::match_flags::match_not_dot_newline)
+    {
+        this->self = lex::token_def<int>("[0-9]+") | ".|\n";
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct print_numbers_grammar : qi::grammar<Iterator>
+{
+    print_numbers_grammar()
+      : print_numbers_grammar::base_type(start)
+    {
+        // we just know, that the token ids get assigned starting min_token_id
+        // so, "[0-9]+" gets the id 'min_token_id' and ".|\n" gets the id
+        // 'min_token_id+1'.
+        start =  *(   qi::token(lex::min_token_id)  [ std::cout << _1  << "\n" ] 
+                  |   qi::token(lex::min_token_id+1)
+                  )
+              ;
+    }
+
+    qi::rule<Iterator> start;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char* argv[])
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // the token type to be used, 'int' is available as the type of the token 
+    // attribute and no lexer state is supported
+    typedef lex::lexertl::token<base_iterator_type, boost::mpl::vector<int>
+      , boost::mpl::false_> token_type;
+
+    // lexer type
+    typedef lex::lexertl::lexer<token_type> lexer_type;
+
+    // iterator type exposed by the lexer 
+    typedef print_numbers_tokens<lexer_type>::iterator_type iterator_type;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    print_numbers_tokens<lexer_type> print_tokens;    // Our lexer
+    print_numbers_grammar<iterator_type> print;       // Our parser 
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    std::string str (read_from_file(1 == argc ? "print_numbers.input" : argv[1]));
+    base_iterator_type first = str.begin();
+    bool r = lex::tokenize_and_parse(first, str.end(), print_tokens, print);
+
+    if (r) {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else {
+        std::string rest(first, str.end());
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \"" << rest << "\"\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
+
diff --git a/src/boost/libs/spirit/example/lex/print_numbers.input b/src/boost/libs/spirit/example/lex/print_numbers.input
new file mode 100644
index 00000000..992cbeb3
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/print_numbers.input
@@ -0,0 +1,17 @@
+/* example6.input */
+{
+
+  if (variable) { a = b ; }
+
+  while (10) { 
+
+    if (2) { b = 10 ; }
+    if (x) { c = x ; } else { d = 10 ; }
+
+  }
+
+  variable = 42;
+
+}
+
+
diff --git a/src/boost/libs/spirit/example/lex/reference.cpp b/src/boost/libs/spirit/example/lex/reference.cpp
new file mode 100644
index 00000000..0a878e24
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/reference.cpp
@@ -0,0 +1,30 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    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)
+=============================================================================*/
+//[reference_lex_includes
+#include <boost/spirit/include/lex.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <iostream>
+#include <string>
+//]
+
+//[reference_lex_test
+//]
+
+int main()
+{
+    {
+        //[reference_lex_using_declarations_char
+        //]
+
+        //[reference_lex_char
+        //]
+    }
+
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/Jamfile b/src/boost/libs/spirit/example/lex/static_lexer/Jamfile
new file mode 100644
index 00000000..25c30d0d
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/Jamfile
@@ -0,0 +1,15 @@
+#==============================================================================
+#   Copyright (c) 2001-2009 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)
+#==============================================================================
+
+project spirit-static-lexer-example ;
+
+exe word_count_generate : word_count_generate.cpp ;
+exe word_count_static   : word_count_static.cpp ;
+
+exe word_count_lexer_generate : word_count_lexer_generate.cpp ;
+exe word_count_lexer_static   : word_count_lexer_static.cpp ;
+
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/word_count.input b/src/boost/libs/spirit/example/lex/static_lexer/word_count.input
new file mode 100644
index 00000000..2f768330
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/word_count.input
@@ -0,0 +1,7 @@
+Our hiking boots are ready.  So, let's pack!
+
+Have you the plane tickets for there and back?
+
+I do, I do.  We're all ready to go.  Grab my hand and be my beau.
+
+
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/word_count_generate.cpp b/src/boost/libs/spirit/example/lex/static_lexer/word_count_generate.cpp
new file mode 100644
index 00000000..87f0527f
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/word_count_generate.cpp
@@ -0,0 +1,45 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The purpose of this example is to show, how it is possible to use a lexer 
+//  token definition for two purposes:
+//
+//    . To generate C++ code implementing a static lexical analyzer allowing
+//      to recognize all defined tokens (this file)
+//    . To integrate the generated C++ lexer into the /Spirit/ framework.
+//      (see the file: word_count_static.cpp)
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/lex_generate_static_lexertl.hpp>
+
+#include <fstream>
+
+#include "word_count_tokens.hpp"
+
+using namespace boost::spirit;
+
+///////////////////////////////////////////////////////////////////////////////
+//[wc_static_generate_main
+int main(int argc, char* argv[])
+{
+    // create the lexer object instance needed to invoke the generator
+    word_count_tokens<lex::lexertl::lexer<> > word_count; // the token definition
+
+    // open the output file, where the generated tokenizer function will be 
+    // written to
+    std::ofstream out(argc < 2 ? "word_count_static.hpp" : argv[1]);
+
+    // invoke the generator, passing the token definition, the output stream 
+    // and the name suffix of the tables and functions to be generated
+    //
+    // The suffix "wc" used below results in a type lexertl::static_::lexer_wc
+    // to be generated, which needs to be passed as a template parameter to the 
+    // lexertl::static_lexer template (see word_count_static.cpp).
+    return lex::lexertl::generate_static_dfa(word_count, out, "wc") ? 0 : -1;
+}
+//]
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_generate.cpp b/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_generate.cpp
new file mode 100644
index 00000000..65593cda
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_generate.cpp
@@ -0,0 +1,45 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The purpose of this example is to show, how it is possible to use a lexer 
+//  token definition for two purposes:
+//
+//    . To generate C++ code implementing a static lexical analyzer allowing
+//      to recognize all defined tokens (this file)
+//    . To integrate the generated C++ lexer into the /Spirit/ framework.
+//      (see the file: word_count_lexer_static.cpp)
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/lex_generate_static_lexertl.hpp>
+
+#include <fstream>
+
+#include "word_count_lexer_tokens.hpp"
+
+using namespace boost::spirit;
+
+///////////////////////////////////////////////////////////////////////////////
+//[wcl_static_generate_main
+int main(int argc, char* argv[])
+{
+    // create the lexer object instance needed to invoke the generator
+    word_count_lexer_tokens<lex::lexertl::actor_lexer<> > word_count; // the token definition
+
+    // open the output file, where the generated tokenizer function will be 
+    // written to
+    std::ofstream out(argc < 2 ? "word_count_lexer_static.hpp" : argv[1]);
+
+    // invoke the generator, passing the token definition, the output stream 
+    // and the name prefix of the tokenizing function to be generated
+    //
+    // The suffix "wcl" used below results in a type lexertl::static_::lexer_wcl
+    // to be generated, which needs to be passed as a template parameter to the 
+    // lexertl::static_lexer template (see word_count_lexer_static.cpp).
+    return lex::lexertl::generate_static_dfa(word_count, out, "wcl") ? 0 : -1;
+}
+//]
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_static.cpp b/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_static.cpp
new file mode 100644
index 00000000..2bda5adc
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_static.cpp
@@ -0,0 +1,84 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The purpose of this example is to show, how it is possible to use a lexer 
+//  token definition for two purposes:
+//
+//    . To generate C++ code implementing a static lexical analyzer allowing
+//      to recognize all defined tokens 
+//    . To integrate the generated C++ lexer into the /Spirit/ framework.
+//
+
+// #define BOOST_SPIRIT_DEBUG
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/lex_static_lexertl.hpp>
+
+#include <iostream>
+#include <string>
+
+#include "../example.hpp"
+#include "word_count_lexer_tokens.hpp"          // token definition
+#include "word_count_lexer_static.hpp"          // generated tokenizer
+
+using namespace boost::spirit;
+
+///////////////////////////////////////////////////////////////////////////////
+//[wcl_static_main
+int main(int argc, char* argv[])
+{
+    // read input from the given file
+    std::string str (read_from_file(1 == argc ? "word_count.input" : argv[1]));
+
+    // Specifying 'omit' as the token attribute type generates a token class 
+    // notholding any token attribute at all (not even the iterator_range of the 
+    // matched input sequence), therefor optimizing the token, the lexer, and 
+    // possibly the parser implementation as much as possible. 
+    //
+    // Specifying mpl::false_ as the 3rd template parameter generates a token
+    // type and an iterator, both holding no lexer state, allowing for even more 
+    // aggressive optimizations.
+    //
+    // As a result the token instances contain the token ids as the only data 
+    // member.
+    typedef lex::lexertl::token<char const*, lex::omit, boost::mpl::false_> token_type;
+
+    // Define the lexer type to be used as the base class for our token 
+    // definition.
+    //
+    // This is the only place where the code is different from an equivalent
+    // dynamic lexical analyzer. We use the `lexertl::static_lexer<>` instead of
+    // the `lexertl::lexer<>` as the base class for our token defintion type.
+    //
+    // As we specified the suffix "wcl" while generating the static tables we 
+    // need to pass the type lexertl::static_::lexer_wcl as the second template
+    // parameter below (see word_count_lexer_generate.cpp).
+    typedef lex::lexertl::static_actor_lexer<
+        token_type, lex::lexertl::static_::lexer_wcl
+    > lexer_type;
+
+    // create the lexer object instance needed to invoke the lexical analysis 
+    word_count_lexer_tokens<lexer_type> word_count_lexer;
+
+    // tokenize the given string, all generated tokens are discarded
+    char const* first = str.c_str();
+    char const* last = &first[str.size()];
+    bool r = lex::tokenize(first, last, word_count_lexer);
+
+    if (r) {
+        std::cout << "lines: " << word_count_lexer.l 
+                  << ", words: " << word_count_lexer.w 
+                  << ", characters: " << word_count_lexer.c 
+                  << "\n";
+    }
+    else {
+        std::string rest(first, last);
+        std::cout << "Lexical analysis failed\n" << "stopped at: \"" 
+                  << rest << "\"\n";
+    }
+    return 0;
+}
+//]
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_static.hpp b/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_static.hpp
new file mode 100644
index 00000000..e69b936e
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_static.hpp
@@ -0,0 +1,164 @@
+// Copyright (c) 2008-2009 Ben Hanson
+// Copyright (c) 2008-2010 Hartmut Kaiser
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Auto-generated by boost::lexer, do not edit
+
+#if !defined(BOOST_SPIRIT_LEXER_NEXT_TOKEN_WCL_NOV_10_2009_17_20_29)
+#define BOOST_SPIRIT_LEXER_NEXT_TOKEN_WCL_NOV_10_2009_17_20_29
+
+#include <boost/spirit/home/support/detail/lexer/char_traits.hpp>
+
+////////////////////////////////////////////////////////////////////////////////
+// the generated table of state names and the tokenizer have to be
+// defined in the boost::spirit::lex::lexertl::static_ namespace
+namespace boost { namespace spirit { namespace lex { namespace lexertl { namespace static_ {
+
+////////////////////////////////////////////////////////////////////////////////
+// this table defines the names of the lexer states
+char const* const lexer_state_names_wcl[1] = 
+{
+    "INITIAL"
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// this variable defines the number of lexer states
+std::size_t const lexer_state_count_wcl = 1;
+
+////////////////////////////////////////////////////////////////////////////////
+// this function returns the next matched token
+template<typename Iterator>
+std::size_t next_token_wcl (std::size_t& /*start_state_*/, bool& /*bol_*/, 
+    Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+{
+    enum {end_state_index, id_index, unique_id_index, state_index, bol_index,
+        eol_index, dead_state_index, dfa_offset};
+
+    static const std::size_t npos = static_cast<std::size_t>(~0);
+    static const std::size_t lookup_[256] = {
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 8, 7, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        8, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9,
+        9, 9, 9, 9, 9, 9, 9, 9 };
+    static const std::size_t dfa_alphabet_ = 10;
+    static const std::size_t dfa_[50] = {
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 3, 4, 2, 1, 65536, 0, 0,
+        0, 0, 0, 0, 0, 2, 1, 65537,
+        1, 0, 0, 0, 0, 0, 0, 0,
+        1, 65538, 2, 0, 0, 0, 0, 0,
+        0, 0 };
+
+    if (start_token_ == end_)
+    {
+        unique_id_ = npos;
+        return 0;
+    }
+
+    std::size_t const* ptr_ = dfa_ + dfa_alphabet_;
+    Iterator curr_ = start_token_;
+    bool end_state_ = *ptr_ != 0;
+    std::size_t id_ = *(ptr_ + id_index);
+    std::size_t uid_ = *(ptr_ + unique_id_index);
+    Iterator end_token_ = start_token_;
+
+    while (curr_ != end_)
+    {
+        std::size_t const state_ =
+            ptr_[lookup_[static_cast<unsigned char>(*curr_++)]];
+
+        if (state_ == 0) break;
+
+        ptr_ = &dfa_[state_ * dfa_alphabet_];
+
+        if (*ptr_)
+        {
+            end_state_ = true;
+            id_ = *(ptr_ + id_index);
+            uid_ = *(ptr_ + unique_id_index);
+            end_token_ = curr_;
+        }
+    }
+
+    if (end_state_)
+    {
+        // return longest match
+        start_token_ = end_token_;
+    }
+    else
+    {
+        id_ = npos;
+        uid_ = npos;
+    }
+
+    unique_id_ = uid_;
+    return id_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// this defines a generic accessors for the information above
+struct lexer_wcl
+{
+    // version number and feature-set of compatible static lexer engine
+    enum
+    {
+        static_version = 65536,
+        supports_bol = false,
+        supports_eol = false
+    };
+
+    // return the number of lexer states
+    static std::size_t state_count()
+    {
+        return lexer_state_count_wcl; 
+    }
+
+    // return the name of the lexer state as given by 'idx'
+    static char const* state_name(std::size_t idx)
+    {
+        return lexer_state_names_wcl[idx]; 
+    }
+
+    // return the next matched token
+    template<typename Iterator>
+    static std::size_t next(std::size_t &start_state_, bool& bol_
+      , Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+    {
+        return next_token_wcl(start_state_, bol_, start_token_, end_, unique_id_);
+    }
+};
+
+}}}}}  // namespace boost::spirit::lex::lexertl::static_
+
+#endif
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_tokens.hpp b/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_tokens.hpp
new file mode 100644
index 00000000..af52a209
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/word_count_lexer_tokens.hpp
@@ -0,0 +1,62 @@
+//  Copyright (c) 2001-2010 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)
+
+#if !defined(SPIRIT_LEXER_EXAMPLE_WORD_COUNT_LEXER_TOKENS_FEB_10_2008_0739PM)
+#define SPIRIT_LEXER_EXAMPLE_WORD_COUNT_LEXER_TOKENS_FEB_10_2008_0739PM
+
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_statement.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition: We use the lexertl based lexer engine as the underlying 
+//                    lexer type.
+//
+//  Note, the token definition type is derived from the 'lexertl_actor_lexer'
+//  template, which is a necessary to being able to use lexer semantic actions.
+///////////////////////////////////////////////////////////////////////////////
+struct distance_func
+{
+    template <typename Iterator1, typename Iterator2>
+    struct result : boost::iterator_difference<Iterator1> {};
+
+    template <typename Iterator1, typename Iterator2>
+    typename result<Iterator1, Iterator2>::type 
+    operator()(Iterator1& begin, Iterator2& end) const
+    {
+        return std::distance(begin, end);
+    }
+};
+boost::phoenix::function<distance_func> const distance = distance_func();
+
+//[wcl_static_token_definition
+template <typename Lexer>
+struct word_count_lexer_tokens : boost::spirit::lex::lexer<Lexer>
+{
+    word_count_lexer_tokens()
+      : c(0), w(0), l(0)
+      , word("[^ \t\n]+")     // define tokens
+      , eol("\n")
+      , any(".")
+    {
+        using boost::spirit::lex::_start;
+        using boost::spirit::lex::_end;
+        using boost::phoenix::ref;
+
+        // associate tokens with the lexer
+        this->self 
+            =   word  [++ref(w), ref(c) += distance(_start, _end)]
+            |   eol   [++ref(c), ++ref(l)] 
+            |   any   [++ref(c)]
+            ;
+    }
+
+    std::size_t c, w, l;
+    boost::spirit::lex::token_def<> word, eol, any;
+};
+//]
+
+#endif
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/word_count_static.cpp b/src/boost/libs/spirit/example/lex/static_lexer/word_count_static.cpp
new file mode 100644
index 00000000..4ba3bb53
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/word_count_static.cpp
@@ -0,0 +1,120 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The purpose of this example is to show, how it is possible to use a lexer 
+//  token definition for two purposes:
+//
+//    . To generate C++ code implementing a static lexical analyzer allowing
+//      to recognize all defined tokens 
+//    . To integrate the generated C++ lexer into the /Spirit/ framework.
+//
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+#define BOOST_VARIANT_MINIMIZE_SIZE
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+//[wc_static_include
+#include <boost/spirit/include/lex_static_lexertl.hpp>
+//]
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_statement.hpp>
+#include <boost/spirit/include/phoenix_container.hpp>
+
+#include <iostream>
+#include <string>
+
+#include "../example.hpp"
+#include "word_count_tokens.hpp"          // token definition
+#include "word_count_static.hpp"          // generated tokenizer
+
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+//[wc_static_grammar
+//  This is an ordinary grammar definition following the rules defined by 
+//  Spirit.Qi. There is nothing specific about it, except it gets the token
+//  definition class instance passed to the constructor to allow accessing the
+//  embedded token_def<> instances.
+template <typename Iterator>
+struct word_count_grammar : qi::grammar<Iterator>
+{
+    template <typename TokenDef>
+    word_count_grammar(TokenDef const& tok)
+      : word_count_grammar::base_type(start)
+      , c(0), w(0), l(0)
+    {
+        using boost::phoenix::ref;
+        using boost::phoenix::size;
+
+        //  associate the defined tokens with the lexer, at the same time 
+        //  defining the actions to be executed 
+        start =  *(   tok.word          [ ++ref(w), ref(c) += size(_1) ]
+                  |   lit('\n')         [ ++ref(l), ++ref(c) ] 
+                  |   qi::token(IDANY)  [ ++ref(c) ]
+                  )
+              ;
+    }
+
+    std::size_t c, w, l;      // counter for characters, words, and lines
+    qi::rule<Iterator> start;
+};
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//[wc_static_main
+int main(int argc, char* argv[])
+{
+    // Define the token type to be used: 'std::string' is available as the type 
+    // of the token value.
+    typedef lex::lexertl::token<
+        char const*, boost::mpl::vector<std::string>
+    > token_type;
+
+    // Define the lexer type to be used as the base class for our token 
+    // definition.
+    //
+    // This is the only place where the code is different from an equivalent
+    // dynamic lexical analyzer. We use the `lexertl::static_lexer<>` instead of
+    // the `lexertl::lexer<>` as the base class for our token defintion type.
+    //
+    // As we specified the suffix "wc" while generating the static tables we 
+    // need to pass the type lexertl::static_::lexer_wc as the second template
+    // parameter below (see word_count_generate.cpp).
+    typedef lex::lexertl::static_lexer<
+        token_type, lex::lexertl::static_::lexer_wc
+    > lexer_type;
+
+    // Define the iterator type exposed by the lexer.
+    typedef word_count_tokens<lexer_type>::iterator_type iterator_type;
+
+    // Now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process.
+    word_count_tokens<lexer_type> word_count;           // Our lexer
+    word_count_grammar<iterator_type> g (word_count);   // Our parser
+
+    // Read in the file into memory.
+    std::string str (read_from_file(1 == argc ? "word_count.input" : argv[1]));
+    char const* first = str.c_str();
+    char const* last = &first[str.size()];
+
+    // Parsing is done based on the token stream, not the character stream.
+    bool r = lex::tokenize_and_parse(first, last, word_count, g);
+
+    if (r) {    // success
+        std::cout << "lines: " << g.l << ", words: " << g.w 
+                  << ", characters: " << g.c << "\n";
+    }
+    else {
+        std::string rest(first, last);
+        std::cerr << "Parsing failed\n" << "stopped at: \"" 
+                  << rest << "\"\n";
+    }
+    return 0;
+}
+//]
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/word_count_static.hpp b/src/boost/libs/spirit/example/lex/static_lexer/word_count_static.hpp
new file mode 100644
index 00000000..4a7aa3c6
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/word_count_static.hpp
@@ -0,0 +1,164 @@
+// Copyright (c) 2008-2009 Ben Hanson
+// Copyright (c) 2008-2010 Hartmut Kaiser
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Auto-generated by boost::lexer, do not edit
+
+#if !defined(BOOST_SPIRIT_LEXER_NEXT_TOKEN_WC_NOV_10_2009_17_20_04)
+#define BOOST_SPIRIT_LEXER_NEXT_TOKEN_WC_NOV_10_2009_17_20_04
+
+#include <boost/spirit/home/support/detail/lexer/char_traits.hpp>
+
+////////////////////////////////////////////////////////////////////////////////
+// the generated table of state names and the tokenizer have to be
+// defined in the boost::spirit::lex::lexertl::static_ namespace
+namespace boost { namespace spirit { namespace lex { namespace lexertl { namespace static_ {
+
+////////////////////////////////////////////////////////////////////////////////
+// this table defines the names of the lexer states
+char const* const lexer_state_names_wc[1] = 
+{
+    "INITIAL"
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// this variable defines the number of lexer states
+std::size_t const lexer_state_count_wc = 1;
+
+////////////////////////////////////////////////////////////////////////////////
+// this function returns the next matched token
+template<typename Iterator>
+std::size_t next_token_wc (std::size_t& /*start_state_*/, bool& /*bol_*/, 
+    Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+{
+    enum {end_state_index, id_index, unique_id_index, state_index, bol_index,
+        eol_index, dead_state_index, dfa_offset};
+
+    static const std::size_t npos = static_cast<std::size_t>(~0);
+    static const std::size_t lookup_[256] = {
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 9, 7, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        9, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8,
+        8, 8, 8, 8, 8, 8, 8, 8 };
+    static const std::size_t dfa_alphabet_ = 10;
+    static const std::size_t dfa_[50] = {
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 3, 2, 4, 1, 65536, 0, 0,
+        0, 0, 0, 0, 2, 0, 1, 10,
+        1, 0, 0, 0, 0, 0, 0, 0,
+        1, 65537, 2, 0, 0, 0, 0, 0,
+        0, 0 };
+
+    if (start_token_ == end_)
+    {
+        unique_id_ = npos;
+        return 0;
+    }
+
+    std::size_t const* ptr_ = dfa_ + dfa_alphabet_;
+    Iterator curr_ = start_token_;
+    bool end_state_ = *ptr_ != 0;
+    std::size_t id_ = *(ptr_ + id_index);
+    std::size_t uid_ = *(ptr_ + unique_id_index);
+    Iterator end_token_ = start_token_;
+
+    while (curr_ != end_)
+    {
+        std::size_t const state_ =
+            ptr_[lookup_[static_cast<unsigned char>(*curr_++)]];
+
+        if (state_ == 0) break;
+
+        ptr_ = &dfa_[state_ * dfa_alphabet_];
+
+        if (*ptr_)
+        {
+            end_state_ = true;
+            id_ = *(ptr_ + id_index);
+            uid_ = *(ptr_ + unique_id_index);
+            end_token_ = curr_;
+        }
+    }
+
+    if (end_state_)
+    {
+        // return longest match
+        start_token_ = end_token_;
+    }
+    else
+    {
+        id_ = npos;
+        uid_ = npos;
+    }
+
+    unique_id_ = uid_;
+    return id_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// this defines a generic accessors for the information above
+struct lexer_wc
+{
+    // version number and feature-set of compatible static lexer engine
+    enum
+    {
+        static_version = 65536,
+        supports_bol = false,
+        supports_eol = false
+    };
+
+    // return the number of lexer states
+    static std::size_t state_count()
+    {
+        return lexer_state_count_wc; 
+    }
+
+    // return the name of the lexer state as given by 'idx'
+    static char const* state_name(std::size_t idx)
+    {
+        return lexer_state_names_wc[idx]; 
+    }
+
+    // return the next matched token
+    template<typename Iterator>
+    static std::size_t next(std::size_t &start_state_, bool& bol_
+      , Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+    {
+        return next_token_wc(start_state_, bol_, start_token_, end_, unique_id_);
+    }
+};
+
+}}}}}  // namespace boost::spirit::lex::lexertl::static_
+
+#endif
diff --git a/src/boost/libs/spirit/example/lex/static_lexer/word_count_tokens.hpp b/src/boost/libs/spirit/example/lex/static_lexer/word_count_tokens.hpp
new file mode 100644
index 00000000..5828adde
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/static_lexer/word_count_tokens.hpp
@@ -0,0 +1,41 @@
+//  Copyright (c) 2001-2010 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)
+
+#if !defined(SPIRIT_LEXER_EXAMPLE_WORD_COUNT_TOKENS_FEB_10_2008_0739PM)
+#define SPIRIT_LEXER_EXAMPLE_WORD_COUNT_TOKENS_FEB_10_2008_0739PM
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition: We keep the base class for the token definition as a 
+//                    template parameter to allow this class to be used for
+//                    both: the code generation and the lexical analysis
+///////////////////////////////////////////////////////////////////////////////
+//[wc_static_tokenids
+enum tokenids 
+{
+    IDANY = boost::spirit::lex::min_token_id + 1,
+};
+//]
+
+//[wc_static_tokendef
+// This token definition class can be used without any change for all three
+// possible use cases: a dynamic lexical analyzer, a code generator, and a
+// static lexical analyzer.
+template <typename BaseLexer>
+struct word_count_tokens : boost::spirit::lex::lexer<BaseLexer> 
+{
+    word_count_tokens()
+      : word_count_tokens::base_type(
+          boost::spirit::lex::match_flags::match_not_dot_newline)
+    {
+        // define tokens and associate them with the lexer
+        word = "[^ \t\n]+";
+        this->self = word | '\n' | boost::spirit::lex::token_def<>(".", IDANY);
+    }
+
+    boost::spirit::lex::token_def<std::string> word;
+};
+//]
+
+#endif
diff --git a/src/boost/libs/spirit/example/lex/strip_comments.cpp b/src/boost/libs/spirit/example/lex/strip_comments.cpp
new file mode 100644
index 00000000..c4e0913a
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/strip_comments.cpp
@@ -0,0 +1,163 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example is the equivalent to the following lex program:
+//
+//       %{
+//       /* INITIAL is the default start state.  COMMENT is our new  */
+//       /* state where we remove comments.                          */
+//       %}
+// 
+//       %s COMMENT
+//       %%
+//       <INITIAL>"//".*    ;
+//       <INITIAL>"/*"      BEGIN COMMENT; 
+//       <INITIAL>.         ECHO;
+//       <INITIAL>[\n]      ECHO;
+//       <COMMENT>"*/"      BEGIN INITIAL;
+//       <COMMENT>.         ;
+//       <COMMENT>[\n]      ;
+//       %%
+// 
+//       main() 
+//       {
+//         yylex();
+//       }
+//
+//  Its purpose is to strip comments out of C code.
+//
+//  Additionally this example demonstrates the use of lexer states to structure
+//  the lexer definition.
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_container.hpp>
+
+#include <iostream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition: We use the lexertl based lexer engine as the underlying 
+//                    lexer type.
+///////////////////////////////////////////////////////////////////////////////
+enum tokenids 
+{
+    IDANY = lex::min_token_id + 10
+};
+
+template <typename Lexer>
+struct strip_comments_tokens : lex::lexer<Lexer>
+{
+    strip_comments_tokens() 
+      : strip_comments_tokens::base_type(lex::match_flags::match_default)
+    {
+        // define tokens and associate them with the lexer
+        cppcomment = "\"//\"[^\n]*";    // '//[^\n]*'
+        ccomment = "\"/*\"";            // '/*'
+        endcomment = "\"*/\"";          // '*/'
+
+        // The following tokens are associated with the default lexer state 
+        // (the "INITIAL" state). Specifying 'INITIAL' as a lexer state is 
+        // strictly optional.
+        this->self.add
+            (cppcomment)    // no explicit token id is associated
+            (ccomment)
+            (".", IDANY)    // IDANY is the token id associated with this token 
+                            // definition
+        ;
+
+        // The following tokens are associated with the lexer state "COMMENT".
+        // We switch lexer states from inside the parsing process using the 
+        // in_state("COMMENT")[] parser component as shown below.
+        this->self("COMMENT").add
+            (endcomment)
+            (".", IDANY)
+        ;
+    }
+
+    lex::token_def<> cppcomment, ccomment, endcomment;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct strip_comments_grammar : qi::grammar<Iterator>
+{
+    template <typename TokenDef>
+    strip_comments_grammar(TokenDef const& tok)
+      : strip_comments_grammar::base_type(start)
+    {
+        // The in_state("COMMENT")[...] parser component switches the lexer 
+        // state to be 'COMMENT' during the matching of the embedded parser.
+        start =  *(   tok.ccomment 
+                      >>  qi::in_state("COMMENT") 
+                          [
+                              // the lexer is in the 'COMMENT' state during
+                              // matching of the following parser components
+                              *token(IDANY) >> tok.endcomment 
+                          ]
+                  |   tok.cppcomment
+                  |   qi::token(IDANY)   [ std::cout << _1 ]
+                  )
+              ;
+    }
+
+    qi::rule<Iterator> start;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char* argv[])
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // lexer type
+    typedef 
+        lex::lexertl::lexer<lex::lexertl::token<base_iterator_type> > 
+    lexer_type;
+
+    // iterator type exposed by the lexer 
+    typedef strip_comments_tokens<lexer_type>::iterator_type iterator_type;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    strip_comments_tokens<lexer_type> strip_comments;           // Our lexer
+    strip_comments_grammar<iterator_type> g (strip_comments);   // Our parser 
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    std::string str (read_from_file(1 == argc ? "strip_comments.input" : argv[1]));
+    base_iterator_type first = str.begin();
+
+    bool r = lex::tokenize_and_parse(first, str.end(), strip_comments, g);
+
+    if (r) {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else {
+        std::string rest(first, str.end());
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \"" << rest << "\"\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
+
diff --git a/src/boost/libs/spirit/example/lex/strip_comments.input b/src/boost/libs/spirit/example/lex/strip_comments.input
new file mode 100644
index 00000000..bed0f071
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/strip_comments.input
@@ -0,0 +1,162 @@
+//  Copyright (c) 2001-2009 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)
+
+//  This example is the equivalent to the following lex program:
+//
+//       %{
+//       /* INITIAL is the default start state.  COMMENT is our new  */
+//       /* state where we remove comments.                          */
+//       %}
+// 
+//       %s COMMENT
+//       %%
+//       <INITIAL>"//".*    ;
+//       <INITIAL>"/*"      BEGIN COMMENT; 
+//       <INITIAL>.         ECHO;
+//       <INITIAL>[\n]      ECHO;
+//       <COMMENT>"*/"      BEGIN INITIAL;
+//       <COMMENT>.         ;
+//       <COMMENT>[\n]      ;
+//       %%
+// 
+//       main() 
+//       {
+//         yylex();
+//       }
+//
+//  Its purpose is to strip comments out of C code.
+//
+//  Additionally this example demonstrates the use of lexer states to structure
+//  the lexer definition.
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexer_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_container.hpp>
+
+#include <iostream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;
+using namespace boost::spirit::qi;
+using namespace boost::spirit::lex;
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition: We use the lexertl based lexer engine as the underlying 
+//                    lexer type.
+///////////////////////////////////////////////////////////////////////////////
+enum tokenids 
+{
+    IDANY = lex::min_token_id + 10
+};
+
+template <typename Lexer>
+struct strip_comments_tokens : lexer<Lexer>
+{
+    strip_comments_tokens()
+    {
+        // define tokens and associate them with the lexer
+        cppcomment = "//[^\n]*";
+        ccomment = "/\\*";
+        endcomment = "\\*/";
+
+        // The following tokens are associated with the default lexer state 
+        // (the "INITIAL" state). Specifying 'INITIAL' as a lexer state is 
+        // strictly optional.
+        this->self.add
+            (cppcomment)    // no explicit token id is associated
+            (ccomment)
+            (".", IDANY)    // IDANY is the token id associated with this token 
+                            // definition
+        ;
+
+        // The following tokens are associated with the lexer state "COMMENT".
+        // We switch lexer states from inside the parsing process using the 
+        // in_state("COMMENT")[] parser component as shown below.
+        this->self("COMMENT").add
+            (endcomment)
+            (".", IDANY)
+        ;
+    }
+
+    token_def<> cppcomment, ccomment, endcomment;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+template <typename Iterator>
+struct strip_comments_grammar : grammar<Iterator>
+{
+    template <typename TokenDef>
+    strip_comments_grammar(TokenDef const& tok)
+      : strip_comments_grammar::base_type(start)
+    {
+        // The in_state("COMMENT")[...] parser component switches the lexer 
+        // state to be 'COMMENT' during the matching of the embedded parser.
+        start =  *(   tok.ccomment 
+                      >>  in_state("COMMENT") 
+                          [
+                              // the lexer is in the 'COMMENT' state during
+                              // matching of the following parser components
+                              *token(IDANY) >> tok.endcomment 
+                          ]
+                  |   tok.cppcomment
+                  |   token(IDANY)   [ std::cout << _1 ]
+                  )
+              ;
+    }
+
+    rule<Iterator> start;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char* argv[])
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // lexer type
+    typedef lexertl::lexer<lexertl::token<base_iterator_type> > lexer_type;
+
+    // iterator type exposed by the lexer 
+    typedef strip_comments_tokens<lexer_type>::iterator_type iterator_type;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    strip_comments_tokens<lexer_type> strip_comments;           // Our lexer
+    strip_comments_grammar<iterator_type> g (strip_comments);   // Our grammar 
+
+    // Parsing is done based on the token stream, not the character 
+    // stream read from the input.
+    std::string str (read_from_file(1 == argc ? "strip_comments.input" : argv[1]));
+    base_iterator_type first = str.begin();
+
+    bool r = tokenize_and_parse(first, str.end(), strip_comments, g);
+
+    if (r) {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else {
+        std::string rest(first, str.end());
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \"" << rest << "\"\n";
+        std::cout << "-------------------------\n";
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
+
diff --git a/src/boost/libs/spirit/example/lex/strip_comments_lexer.cpp b/src/boost/libs/spirit/example/lex/strip_comments_lexer.cpp
new file mode 100644
index 00000000..30e0b34b
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/strip_comments_lexer.cpp
@@ -0,0 +1,172 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example is the equivalent to the following lex program:
+//
+//       %{
+//       /* INITIAL is the default start state.  COMMENT is our new  */
+//       /* state where we remove comments.                          */
+//       %}
+// 
+//       %s COMMENT
+//       %%
+//       <INITIAL>"//".*    ;
+//       <INITIAL>"/*"      BEGIN COMMENT; 
+//       <INITIAL>.         ECHO;
+//       <INITIAL>[\n]      ECHO;
+//       <COMMENT>"*/"      BEGIN INITIAL;
+//       <COMMENT>.         ;
+//       <COMMENT>[\n]      ;
+//       %%
+// 
+//       main() 
+//       {
+//         yylex();
+//       }
+//
+//  Its purpose is to strip comments out of C code.
+//
+//  Additionally this example demonstrates the use of lexer states to structure
+//  the lexer definition.
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_statement.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+
+#include <iostream>
+#include <string>
+
+#include "example.hpp"
+
+using namespace boost::spirit;  
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition: We use the lexertl based lexer engine as the underlying 
+//                    lexer type.
+///////////////////////////////////////////////////////////////////////////////
+enum tokenids 
+{
+    IDANY = lex::min_token_id + 10,
+    IDEOL = lex::min_token_id + 11
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Simple custom semantic action function object used to print the matched
+// input sequence for a particular token
+template <typename Char, typename Traits>
+struct echo_input_functor
+{
+    echo_input_functor (std::basic_ostream<Char, Traits>& os_)
+      : os(os_) {}
+
+    // This is called by the semantic action handling code during the lexing
+    template <typename Iterator, typename Context>
+    void operator()(Iterator const& b, Iterator const& e
+      , BOOST_SCOPED_ENUM(boost::spirit::lex::pass_flags)&
+      , std::size_t&, Context&) const
+    {
+        os << std::string(b, e);
+    }
+
+    std::basic_ostream<Char, Traits>& os;
+};
+
+template <typename Char, typename Traits>
+inline echo_input_functor<Char, Traits> 
+echo_input(std::basic_ostream<Char, Traits>& os)
+{
+    return echo_input_functor<Char, Traits>(os);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Another simple custom semantic action function object used to switch the 
+// state of the lexer 
+struct set_lexer_state
+{
+    set_lexer_state(char const* state_)
+      : state(state_) {}
+
+    // This is called by the semantic action handling code during the lexing
+    template <typename Iterator, typename Context>
+    void operator()(Iterator const&, Iterator const&
+      , BOOST_SCOPED_ENUM(boost::spirit::lex::pass_flags)&
+      , std::size_t&, Context& ctx) const
+    {
+        ctx.set_state_name(state.c_str());
+    }
+
+    std::string state;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+template <typename Lexer>
+struct strip_comments_tokens : lex::lexer<Lexer>
+{
+    strip_comments_tokens()
+      : strip_comments_tokens::base_type(lex::match_flags::match_default)
+    {
+        // define tokens and associate them with the lexer
+        cppcomment = "\"//\"[^\n]*";    // '//[^\n]*'
+        ccomment = "\"/*\"";            // '/*'
+        endcomment = "\"*/\"";          // '*/'
+        any = std::string(".");
+        eol = "\n";
+
+        // The following tokens are associated with the default lexer state 
+        // (the "INITIAL" state). Specifying 'INITIAL' as a lexer state is 
+        // strictly optional.
+        this->self 
+            =   cppcomment
+            |   ccomment    [ set_lexer_state("COMMENT") ]
+            |   eol         [ echo_input(std::cout) ]
+            |   any         [ echo_input(std::cout) ]
+            ;
+
+        // The following tokens are associated with the lexer state 'COMMENT'.
+        this->self("COMMENT") 
+            =   endcomment  [ set_lexer_state("INITIAL") ]
+            |   "\n"
+            |   std::string(".") 
+            ;
+    }
+
+    lex::token_def<> cppcomment, ccomment, endcomment, any, eol;
+};
+
+  ///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char* argv[])
+{
+    // iterator type used to expose the underlying input stream
+    typedef std::string::iterator base_iterator_type;
+
+    // lexer type
+    typedef 
+        lex::lexertl::actor_lexer<lex::lexertl::token<base_iterator_type> > 
+    lexer_type;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    strip_comments_tokens<lexer_type> strip_comments;             // Our lexer
+
+    // No parsing is done alltogether, everything happens in the lexer semantic
+    // actions.
+    std::string str (read_from_file(1 == argc ? "strip_comments.input" : argv[1]));
+    base_iterator_type first = str.begin();
+    bool r = lex::tokenize(first, str.end(), strip_comments);
+
+    if (!r) {
+        std::string rest(first, str.end());
+        std::cerr << "Lexical analysis failed\n" << "stopped at: \"" 
+                  << rest << "\"\n";
+    }
+    return 0;
+}
+
+
+
diff --git a/src/boost/libs/spirit/example/lex/word_count.cpp b/src/boost/libs/spirit/example/lex/word_count.cpp
new file mode 100644
index 00000000..c6b21d95
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/word_count.cpp
@@ -0,0 +1,166 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example is the equivalent to the following lex program:
+/*
+//[wcp_flex_version
+    %{
+        int c = 0, w = 0, l = 0;
+    %}
+    word   [^ \t\n]+
+    eol    \n
+    %%
+    {word} { ++w; c += yyleng; }
+    {eol}  { ++c; ++l; }
+    .      { ++c; }
+    %%
+    main()
+    {
+        yylex();
+        printf("%d %d %d\n", l, w, c);
+    }
+//]
+*/
+//  Its purpose is to do the word count function of the wc command in UNIX. It 
+//  prints the number of lines, words and characters in a file. 
+//
+//  The example additionally demonstrates how to use the add_pattern(...)(...)
+//  syntax to define lexer patterns. These patterns are essentially parameter-
+//  less 'macros' for regular expressions, allowing to simplify their 
+//  definition.
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+#define BOOST_VARIANT_MINIMIZE_SIZE
+
+#include <boost/config/warning_disable.hpp>
+//[wcp_includes
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_statement.hpp>
+#include <boost/spirit/include/phoenix_container.hpp>
+//]
+
+#include <iostream>
+#include <string>
+
+#include "example.hpp"
+
+//[wcp_namespaces
+using namespace boost::spirit;
+using namespace boost::spirit::ascii;
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition: We use the lexertl based lexer engine as the underlying 
+//                    lexer type.
+///////////////////////////////////////////////////////////////////////////////
+//[wcp_token_ids
+enum tokenids 
+{
+    IDANY = lex::min_token_id + 10
+};
+//]
+
+//[wcp_token_definition
+template <typename Lexer>
+struct word_count_tokens : lex::lexer<Lexer>
+{
+    word_count_tokens()
+    {
+        // define patterns (lexer macros) to be used during token definition 
+        // below
+        this->self.add_pattern
+            ("WORD", "[^ \t\n]+")
+        ;
+
+        // define tokens and associate them with the lexer
+        word = "{WORD}";    // reference the pattern 'WORD' as defined above
+
+        // this lexer will recognize 3 token types: words, newlines, and 
+        // everything else
+        this->self.add
+            (word)          // no token id is needed here
+            ('\n')          // characters are usable as tokens as well
+            (".", IDANY)    // string literals will not be escaped by the library
+        ;
+    }
+
+    // the token 'word' exposes the matched string as its parser attribute
+    lex::token_def<std::string> word;
+};
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//  Grammar definition
+///////////////////////////////////////////////////////////////////////////////
+//[wcp_grammar_definition
+template <typename Iterator>
+struct word_count_grammar : qi::grammar<Iterator>
+{
+    template <typename TokenDef>
+    word_count_grammar(TokenDef const& tok)
+      : word_count_grammar::base_type(start)
+      , c(0), w(0), l(0)
+    {
+        using boost::phoenix::ref;
+        using boost::phoenix::size;
+
+        start =  *(   tok.word          [++ref(w), ref(c) += size(_1)]
+                  |   lit('\n')         [++ref(c), ++ref(l)] 
+                  |   qi::token(IDANY)  [++ref(c)]
+                  )
+              ;
+    }
+
+    std::size_t c, w, l;
+    qi::rule<Iterator> start;
+};
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//[wcp_main
+int main(int argc, char* argv[])
+{
+/*<  Define the token type to be used: `std::string` is available as the 
+     type of the token attribute 
+>*/  typedef lex::lexertl::token<
+        char const*, boost::mpl::vector<std::string>
+    > token_type;
+
+/*<  Define the lexer type to use implementing the state machine
+>*/  typedef lex::lexertl::lexer<token_type> lexer_type;
+
+/*<  Define the iterator type exposed by the lexer type
+>*/  typedef word_count_tokens<lexer_type>::iterator_type iterator_type;
+
+    // now we use the types defined above to create the lexer and grammar
+    // object instances needed to invoke the parsing process
+    word_count_tokens<lexer_type> word_count;          // Our lexer
+    word_count_grammar<iterator_type> g (word_count);  // Our parser 
+
+    // read in the file int memory
+    std::string str (read_from_file(1 == argc ? "word_count.input" : argv[1]));
+    char const* first = str.c_str();
+    char const* last = &first[str.size()];
+
+/*<  Parsing is done based on the token stream, not the character 
+     stream read from the input. The function `tokenize_and_parse()` wraps
+     the passed iterator range `[first, last)` by the lexical analyzer and 
+     uses its exposed iterators to parse the token stream.
+>*/  bool r = lex::tokenize_and_parse(first, last, word_count, g);
+
+    if (r) {
+        std::cout << "lines: " << g.l << ", words: " << g.w 
+                  << ", characters: " << g.c << "\n";
+    }
+    else {
+        std::string rest(first, last);
+        std::cerr << "Parsing failed\n" << "stopped at: \"" 
+                  << rest << "\"\n";
+    }
+    return 0;
+}
+//]
diff --git a/src/boost/libs/spirit/example/lex/word_count.input b/src/boost/libs/spirit/example/lex/word_count.input
new file mode 100644
index 00000000..2f768330
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/word_count.input
@@ -0,0 +1,7 @@
+Our hiking boots are ready.  So, let's pack!
+
+Have you the plane tickets for there and back?
+
+I do, I do.  We're all ready to go.  Grab my hand and be my beau.
+
+
diff --git a/src/boost/libs/spirit/example/lex/word_count_functor.cpp b/src/boost/libs/spirit/example/lex/word_count_functor.cpp
new file mode 100644
index 00000000..f1969aac
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/word_count_functor.cpp
@@ -0,0 +1,183 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example is the equivalent to the following flex program:
+/*
+//[wcf_flex_version
+    %{
+        #define ID_WORD 1000
+        #define ID_EOL  1001
+        #define ID_CHAR 1002
+        int c = 0, w = 0, l = 0;
+    %}
+    %%
+    [^ \t\n]+  { return ID_WORD; }
+    \n         { return ID_EOL; }
+    .          { return ID_CHAR; }
+    %%
+    bool count(int tok)
+    {
+        switch (tok) {
+        case ID_WORD: ++w; c += yyleng; break;
+        case ID_EOL:  ++l; ++c; break;
+        case ID_CHAR: ++c; break;
+        default:
+            return false;
+        }
+        return true;
+    }
+    void main()
+    {
+        int tok = EOF;
+        do {
+            tok = yylex();
+            if (!count(tok))
+                break;
+        } while (EOF != tok);
+        printf("%d %d %d\n", l, w, c);
+    }
+//]
+*/
+//  Its purpose is to do the word count function of the wc command in UNIX. It 
+//  prints the number of lines, words and characters in a file. 
+//
+//  This examples shows how to use the tokenize() function together with a 
+//  simple functor, which gets executed whenever a token got matched in the 
+//  input sequence. 
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+//[wcf_includes
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+//]
+
+#include <iostream>
+#include <string>
+
+#include "example.hpp"
+
+//[wcf_namespaces
+namespace lex = boost::spirit::lex;
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token id definitions
+///////////////////////////////////////////////////////////////////////////////
+//[wcf_token_ids
+enum token_ids
+{
+    ID_WORD = 1000,
+    ID_EOL,
+    ID_CHAR
+};
+//]
+
+//[wcf_token_definition
+/*` The template `word_count_tokens` defines three different tokens: 
+    `ID_WORD`, `ID_EOL`, and `ID_CHAR`, representing a word (anything except 
+    a whitespace or a newline), a newline character, and any other character 
+    (`ID_WORD`, `ID_EOL`, and `ID_CHAR` are enum values representing the token 
+    ids, but could be anything else convertible to an integer as well).
+    The direct base class of any token definition class needs to be the 
+    template `lex::lexer<>`, where the corresponding template parameter (here:
+    `lex::lexertl::lexer<BaseIterator>`) defines which underlying lexer engine has 
+    to be used to provide the required state machine functionality. In this 
+    example we use the Lexertl based lexer engine as the underlying lexer type. 
+*/
+template <typename Lexer>
+struct word_count_tokens : lex::lexer<Lexer>
+{
+    word_count_tokens()
+    {
+        // define tokens (the regular expression to match and the corresponding
+        // token id) and add them to the lexer 
+        this->self.add
+            ("[^ \t\n]+", ID_WORD) // words (anything except ' ', '\t' or '\n')
+            ("\n", ID_EOL)         // newline characters
+            (".", ID_CHAR)         // anything else is a plain character
+        ;
+    }
+};
+//]
+
+//[wcf_functor
+/*` In this example the struct 'counter' is used as a functor counting the 
+    characters, words and lines in the analyzed input sequence by identifying 
+    the matched tokens as passed from the /Spirit.Lex/ library. 
+*/
+struct counter
+{
+//<- this is an implementation detail specific to boost::bind and doesn't show 
+//   up in the documentation
+    typedef bool result_type;
+//->
+    // the function operator gets called for each of the matched tokens
+    // c, l, w are references to the counters used to keep track of the numbers
+    template <typename Token>
+    bool operator()(Token const& t, std::size_t& c, std::size_t& w, std::size_t& l) const
+    {
+        switch (t.id()) {
+        case ID_WORD:       // matched a word
+        // since we're using a default token type in this example, every 
+        // token instance contains a `iterator_range<BaseIterator>` as its token
+        // attribute pointing to the matched character sequence in the input 
+            ++w; c += t.value().size(); 
+            break;
+        case ID_EOL:        // matched a newline character
+            ++l; ++c; 
+            break;
+        case ID_CHAR:       // matched something else
+            ++c; 
+            break;
+        }
+        return true;        // always continue to tokenize
+    }
+};
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//[wcf_main
+/*` The main function simply loads the given file into memory (as a 
+    `std::string`), instantiates an instance of the token definition template
+    using the correct iterator type (`word_count_tokens<char const*>`),
+    and finally calls `lex::tokenize`, passing an instance of the counter function
+    object. The return value of `lex::tokenize()` will be `true` if the 
+    whole input sequence has been successfully tokenized, and `false` otherwise.
+*/
+int main(int argc, char* argv[])
+{
+    // these variables are used to count characters, words and lines
+    std::size_t c = 0, w = 0, l = 0;
+
+    // read input from the given file
+    std::string str (read_from_file(1 == argc ? "word_count.input" : argv[1]));
+
+    // create the token definition instance needed to invoke the lexical analyzer
+    word_count_tokens<lex::lexertl::lexer<> > word_count_functor;
+
+    // tokenize the given string, the bound functor gets invoked for each of 
+    // the matched tokens
+    char const* first = str.c_str();
+    char const* last = &first[str.size()];
+    bool r = lex::tokenize(first, last, word_count_functor, 
+        boost::bind(counter(), _1, boost::ref(c), boost::ref(w), boost::ref(l)));
+
+    // print results
+    if (r) {
+        std::cout << "lines: " << l << ", words: " << w 
+                  << ", characters: " << c << "\n";
+    }
+    else {
+        std::string rest(first, last);
+        std::cout << "Lexical analysis failed\n" << "stopped at: \"" 
+                  << rest << "\"\n";
+    }
+    return 0;
+}
+//]
+
diff --git a/src/boost/libs/spirit/example/lex/word_count_functor.flex b/src/boost/libs/spirit/example/lex/word_count_functor.flex
new file mode 100644
index 00000000..d9c00503
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/word_count_functor.flex
@@ -0,0 +1,59 @@
+%{
+//  Copyright (c) 2001-2009 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)
+
+#include <boost/timer.hpp>
+#if defined(_WIN32)
+    #include <io.h>
+#endif
+    #define ID_WORD 1000
+    #define ID_EOL  1001
+    #define ID_CHAR 1002
+%}
+
+%%
+[^ \t\n]+  { return ID_WORD; }
+\n         { return ID_EOL; }
+.          { return ID_CHAR; }
+%%
+
+bool count(int tok, int* c, int* w, int* l)
+{
+    switch (tok) {
+    case ID_WORD: ++*w; *c += yyleng; break;
+    case ID_EOL:  ++*l; ++*c; break;
+    case ID_CHAR: ++*c; break;
+    default:
+        return false;
+    }
+    return true;
+}
+
+int main(int argc, char* argv[])
+{
+    int tok = EOF;
+    int c = 0, w = 0, l = 0;
+    yyin = fopen(1 == argc ? "word_count.input" : argv[1], "r");
+    if (NULL == yyin) {
+        fprintf(stderr, "Couldn't open input file!\n");
+        exit(-1); 
+    }
+
+    boost::timer tim;
+    do {
+        tok = yylex();
+        if (!count(tok, &c, &w, &l))
+            break;
+    } while (EOF != tok);
+    printf("lines: %d, words: %d, characters: %d\n", l, w, c);
+    fclose(yyin);
+    return 0;
+}
+
+extern "C" int yywrap()  
+{
+    return 1;
+}
+
diff --git a/src/boost/libs/spirit/example/lex/word_count_functor_flex.cpp b/src/boost/libs/spirit/example/lex/word_count_functor_flex.cpp
new file mode 100644
index 00000000..5fc9e734
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/word_count_functor_flex.cpp
@@ -0,0 +1,1576 @@
+#line 2 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor_flex.cpp"
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
+ */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+
+#include <stdio.h>
+#include <errno.h>
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else  /* ! __cplusplus */
+
+#if __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+#endif  /* __STDC__ */
+#endif  /* ! __cplusplus */
+
+#ifdef __TURBOC__
+ #pragma warn -rch
+ #pragma warn -use
+#include <io.h>
+#include <stdlib.h>
+#define YY_USE_CONST
+#define YY_USE_PROTOS
+#endif
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+ *   if ( condition_holds )
+ *    yyless( 5 );
+ *  else
+ *    do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+    do \
+        { \
+        /* Undo effects of setting up yytext. */ \
+        *yy_cp = yy_hold_char; \
+        YY_RESTORE_YY_MORE_OFFSET \
+        yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+        YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+        } \
+    while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+/* The following is because we cannot portably get our hands on size_t
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
+typedef unsigned int yy_size_t;
+
+
+struct yy_buffer_state
+    {
+    FILE *yy_input_file;
+
+    char *yy_ch_buf;    /* input buffer */
+    char *yy_buf_pos;    /* current position in input buffer */
+
+    /* Size of input buffer in bytes, not including room for EOB
+     * characters.
+     */
+    yy_size_t yy_buf_size;
+
+    /* Number of characters read into yy_ch_buf, not including EOB
+     * characters.
+     */
+    int yy_n_chars;
+
+    /* Whether we "own" the buffer - i.e., we know we created it,
+     * and can realloc() it to grow it, and should free() it to
+     * delete it.
+     */
+    int yy_is_our_buffer;
+
+    /* Whether this is an "interactive" input source; if so, and
+     * if we're using stdio for input, then we want to use getc()
+     * instead of fread(), to make sure we stop fetching input after
+     * each newline.
+     */
+    int yy_is_interactive;
+
+    /* Whether we're considered to be at the beginning of a line.
+     * If so, '^' rules will be active on the next match, otherwise
+     * not.
+     */
+    int yy_at_bol;
+
+    /* Whether to try to fill the input buffer when we reach the
+     * end of it.
+     */
+    int yy_fill_buffer;
+
+    int yy_buffer_status;
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+    /* When an EOF's been seen but there's still some text to process
+     * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+     * shouldn't try reading from the input source any more.  We might
+     * still have a bunch of tokens to match, though, because of
+     * possible backing-up.
+     *
+     * When we actually see the EOF, we change the status to "new"
+     * (via yyrestart()), so that the user can continue scanning by
+     * just pointing yyin at a new input file.
+     */
+#define YY_BUFFER_EOF_PENDING 2
+    };
+
+static YY_BUFFER_STATE yy_current_buffer = 0;
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+
+static int yy_n_chars;    /* number of characters read into yy_ch_buf */
+
+
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 1;    /* whether we need to initialize */
+static int yy_start = 0;  /* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart YY_PROTO(( FILE *input_file ));
+
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+
+static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+#define yy_set_interactive(is_interactive) \
+    { \
+    if ( ! yy_current_buffer ) \
+        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+    yy_current_buffer->yy_is_interactive = is_interactive; \
+    }
+
+#define yy_set_bol(at_bol) \
+    { \
+    if ( ! yy_current_buffer ) \
+        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+    yy_current_buffer->yy_at_bol = at_bol; \
+    }
+
+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+
+typedef unsigned char YY_CHAR;
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+typedef int yy_state_type;
+extern char *yytext;
+#define yytext_ptr yytext
+
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+    yytext_ptr = yy_bp; \
+    yyleng = (int) (yy_cp - yy_bp); \
+    yy_hold_char = *yy_cp; \
+    *yy_cp = '\0'; \
+    yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 4
+#define YY_END_OF_BUFFER 5
+static yyconst short int yy_accept[9] =
+    {   0,
+        0,    0,    5,    1,    3,    2,    1,    0
+    } ;
+
+static yyconst int yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static yyconst int yy_meta[4] =
+    {   0,
+        1,    2,    2
+    } ;
+
+static yyconst short int yy_base[10] =
+    {   0,
+        0,    0,    5,    0,    6,    6,    0,    6,    3
+    } ;
+
+static yyconst short int yy_def[10] =
+    {   0,
+        8,    1,    8,    9,    8,    8,    9,    0,    8
+    } ;
+
+static yyconst short int yy_nxt[10] =
+    {   0,
+        4,    5,    6,    7,    8,    3,    8,    8,    8
+    } ;
+
+static yyconst short int yy_chk[10] =
+    {   0,
+        1,    1,    1,    9,    3,    8,    8,    8,    8
+    } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+char *yytext;
+#line 1 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor.flex"
+#define INITIAL 0
+#line 2 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor.flex"
+//  Copyright (c) 2001-2010 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)
+
+#include <boost/timer.hpp>
+#if defined(_WIN32)
+    #include <io.h>
+#endif
+    #define ID_WORD 1000
+    #define ID_EOL  1001
+    #define ID_CHAR 1002
+#line 380 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor_flex.cpp"
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap YY_PROTO(( void ));
+#else
+extern int yywrap YY_PROTO(( void ));
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+#endif
+
+#if YY_STACK_USED
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+#ifndef YY_NO_PUSH_STATE
+static void yy_push_state YY_PROTO(( int new_state ));
+#endif
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state YY_PROTO(( void ));
+#endif
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state YY_PROTO(( void ));
+#endif
+
+#else
+#define YY_NO_PUSH_STATE 1
+#define YY_NO_POP_STATE 1
+#define YY_NO_TOP_STATE 1
+#endif
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines.  This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+    if ( yy_current_buffer->yy_is_interactive ) \
+        { \
+        int c = '*', n; \
+        for ( n = 0; n < max_size && \
+                 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+            buf[n] = (char) c; \
+        if ( c == '\n' ) \
+            buf[n++] = (char) c; \
+        if ( c == EOF && ferror( yyin ) ) \
+            YY_FATAL_ERROR( "input in flex scanner failed" ); \
+        result = n; \
+        } \
+    else \
+        { \
+        errno=0; \
+        while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
+            { \
+            if( errno != EINTR) \
+                { \
+                YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                break; \
+                } \
+            errno=0; \
+            clearerr(yyin); \
+            } \
+        }
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL int yylex YY_PROTO(( void ))
+#endif
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+#define YY_RULE_SETUP \
+    YY_USER_ACTION
+
+YY_DECL
+    {
+    register yy_state_type yy_current_state;
+    register char *yy_cp, *yy_bp;
+    register int yy_act;
+
+#line 16 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor.flex"
+
+#line 544 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor_flex.cpp"
+
+    if ( yy_init )
+        {
+        yy_init = 0;
+
+#ifdef YY_USER_INIT
+        YY_USER_INIT;
+#endif
+
+        if ( ! yy_start )
+            yy_start = 1;  /* first start state */
+
+        if ( ! yyin )
+            yyin = stdin;
+
+        if ( ! yyout )
+            yyout = stdout;
+
+        if ( ! yy_current_buffer )
+            yy_current_buffer =
+                yy_create_buffer( yyin, YY_BUF_SIZE );
+
+        yy_load_buffer_state();
+        }
+
+    while ( 1 )    /* loops until end-of-file is reached */
+        {
+        yy_cp = yy_c_buf_p;
+
+        /* Support of yytext. */
+        *yy_cp = yy_hold_char;
+
+        /* yy_bp points to the position in yy_ch_buf of the start of
+         * the current run.
+         */
+        yy_bp = yy_cp;
+
+        yy_current_state = yy_start;
+yy_match:
+        do
+            {
+            register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+            if ( yy_accept[yy_current_state] )
+                {
+                yy_last_accepting_state = yy_current_state;
+                yy_last_accepting_cpos = yy_cp;
+                }
+            while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                {
+                yy_current_state = (int) yy_def[yy_current_state];
+                if ( yy_current_state >= 9 )
+                    yy_c = yy_meta[(unsigned int) yy_c];
+                }
+            yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+            ++yy_cp;
+            }
+        while ( yy_base[yy_current_state] != 6 );
+
+yy_find_action:
+        yy_act = yy_accept[yy_current_state];
+        if ( yy_act == 0 )
+            { /* have to back up */
+            yy_cp = yy_last_accepting_cpos;
+            yy_current_state = yy_last_accepting_state;
+            yy_act = yy_accept[yy_current_state];
+            }
+
+        YY_DO_BEFORE_ACTION;
+
+
+do_action:  /* This label is used only to access EOF actions. */
+
+
+        switch ( yy_act )
+    { /* beginning of action switch */
+            case 0: /* must back up */
+            /* undo the effects of YY_DO_BEFORE_ACTION */
+            *yy_cp = yy_hold_char;
+            yy_cp = yy_last_accepting_cpos;
+            yy_current_state = yy_last_accepting_state;
+            goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 17 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor.flex"
+{ return ID_WORD; }
+    YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 18 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor.flex"
+{ return ID_EOL; }
+    YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 19 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor.flex"
+{ return ID_CHAR; }
+    YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 20 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor.flex"
+ECHO;
+    YY_BREAK
+#line 647 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor_flex.cpp"
+case YY_STATE_EOF(INITIAL):
+    yyterminate();
+
+    case YY_END_OF_BUFFER:
+        {
+        /* Amount of text matched not including the EOB char. */
+        int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+
+        /* Undo the effects of YY_DO_BEFORE_ACTION. */
+        *yy_cp = yy_hold_char;
+        YY_RESTORE_YY_MORE_OFFSET
+
+        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+            {
+            /* We're scanning a new file or input source.  It's
+             * possible that this happened because the user
+             * just pointed yyin at a new source and called
+             * yylex().  If so, then we have to assure
+             * consistency between yy_current_buffer and our
+             * globals.  Here is the right place to do so, because
+             * this is the first action (other than possibly a
+             * back-up) that will match for the new input source.
+             */
+            yy_n_chars = yy_current_buffer->yy_n_chars;
+            yy_current_buffer->yy_input_file = yyin;
+            yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+            }
+
+        /* Note that here we test for yy_c_buf_p "<=" to the position
+         * of the first EOB in the buffer, since yy_c_buf_p will
+         * already have been incremented past the NUL character
+         * (since all states make transitions on EOB to the
+         * end-of-buffer state).  Contrast this with the test
+         * in input().
+         */
+        if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+            { /* This was really a NUL. */
+            yy_state_type yy_next_state;
+
+            yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+            yy_current_state = yy_get_previous_state();
+
+            /* Okay, we're now positioned to make the NUL
+             * transition.  We couldn't have
+             * yy_get_previous_state() go ahead and do it
+             * for us because it doesn't know how to deal
+             * with the possibility of jamming (and we don't
+             * want to build jamming into it because then it
+             * will run more slowly).
+             */
+
+            yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+            yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+            if ( yy_next_state )
+                {
+                /* Consume the NUL. */
+                yy_cp = ++yy_c_buf_p;
+                yy_current_state = yy_next_state;
+                goto yy_match;
+                }
+
+            else
+                {
+                yy_cp = yy_c_buf_p;
+                goto yy_find_action;
+                }
+            }
+
+        else switch ( yy_get_next_buffer() )
+            {
+            case EOB_ACT_END_OF_FILE:
+                {
+                yy_did_buffer_switch_on_eof = 0;
+
+                if ( yywrap() )
+                    {
+                    /* Note: because we've taken care in
+                     * yy_get_next_buffer() to have set up
+                     * yytext, we can now set up
+                     * yy_c_buf_p so that if some total
+                     * hoser (like flex itself) wants to
+                     * call the scanner after we return the
+                     * YY_NULL, it'll still work - another
+                     * YY_NULL will get returned.
+                     */
+                    yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+                    yy_act = YY_STATE_EOF(YY_START);
+                    goto do_action;
+                    }
+
+                else
+                    {
+                    if ( ! yy_did_buffer_switch_on_eof )
+                        YY_NEW_FILE;
+                    }
+                break;
+                }
+
+            case EOB_ACT_CONTINUE_SCAN:
+                yy_c_buf_p =
+                    yytext_ptr + yy_amount_of_matched_text;
+
+                yy_current_state = yy_get_previous_state();
+
+                yy_cp = yy_c_buf_p;
+                yy_bp = yytext_ptr + YY_MORE_ADJ;
+                goto yy_match;
+
+            case EOB_ACT_LAST_MATCH:
+                yy_c_buf_p =
+                &yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+                yy_current_state = yy_get_previous_state();
+
+                yy_cp = yy_c_buf_p;
+                yy_bp = yytext_ptr + YY_MORE_ADJ;
+                goto yy_find_action;
+            }
+        break;
+        }
+
+    default:
+        YY_FATAL_ERROR(
+            "fatal flex scanner internal error--no action found" );
+    } /* end of action switch */
+        } /* end of scanning one token */
+    } /* end of yylex */
+
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *  EOB_ACT_LAST_MATCH -
+ *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *  EOB_ACT_END_OF_FILE - end of file
+ */
+
+static int yy_get_next_buffer()
+    {
+    register char *dest = yy_current_buffer->yy_ch_buf;
+    register char *source = yytext_ptr;
+    register int number_to_move, i;
+    int ret_val;
+
+    if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+        YY_FATAL_ERROR(
+        "fatal flex scanner internal error--end of buffer missed" );
+
+    if ( yy_current_buffer->yy_fill_buffer == 0 )
+        { /* Don't try to fill the buffer, so this is an EOF. */
+        if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+            {
+            /* We matched a single character, the EOB, so
+             * treat this as a final EOF.
+             */
+            return EOB_ACT_END_OF_FILE;
+            }
+
+        else
+            {
+            /* We matched some text prior to the EOB, first
+             * process it.
+             */
+            return EOB_ACT_LAST_MATCH;
+            }
+        }
+
+    /* Try to read more data. */
+
+    /* First move last chars to start of buffer. */
+    number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+
+    for ( i = 0; i < number_to_move; ++i )
+        *(dest++) = *(source++);
+
+    if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+        /* don't do the read, it's not guaranteed to return an EOF,
+         * just force an EOF
+         */
+        yy_current_buffer->yy_n_chars = yy_n_chars = 0;
+
+    else
+        {
+        int num_to_read =
+            yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+        while ( num_to_read <= 0 )
+            { /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+            YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+            /* just a shorter name for the current buffer */
+            YY_BUFFER_STATE b = yy_current_buffer;
+
+            int yy_c_buf_p_offset =
+                (int) (yy_c_buf_p - b->yy_ch_buf);
+
+            if ( b->yy_is_our_buffer )
+                {
+                int new_size = b->yy_buf_size * 2;
+
+                if ( new_size <= 0 )
+                    b->yy_buf_size += b->yy_buf_size / 8;
+                else
+                    b->yy_buf_size *= 2;
+
+                b->yy_ch_buf = (char *)
+                    /* Include room in for 2 EOB chars. */
+                    yy_flex_realloc( (void *) b->yy_ch_buf,
+                             b->yy_buf_size + 2 );
+                }
+            else
+                /* Can't grow it, we don't own it. */
+                b->yy_ch_buf = 0;
+
+            if ( ! b->yy_ch_buf )
+                YY_FATAL_ERROR(
+                "fatal error - scanner input buffer overflow" );
+
+            yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+            num_to_read = yy_current_buffer->yy_buf_size -
+                        number_to_move - 1;
+#endif
+            }
+
+        if ( num_to_read > YY_READ_BUF_SIZE )
+            num_to_read = YY_READ_BUF_SIZE;
+
+        /* Read in more data. */
+        YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+            yy_n_chars, num_to_read );
+
+        yy_current_buffer->yy_n_chars = yy_n_chars;
+        }
+
+    if ( yy_n_chars == 0 )
+        {
+        if ( number_to_move == YY_MORE_ADJ )
+            {
+            ret_val = EOB_ACT_END_OF_FILE;
+            yyrestart( yyin );
+            }
+
+        else
+            {
+            ret_val = EOB_ACT_LAST_MATCH;
+            yy_current_buffer->yy_buffer_status =
+                YY_BUFFER_EOF_PENDING;
+            }
+        }
+
+    else
+        ret_val = EOB_ACT_CONTINUE_SCAN;
+
+    yy_n_chars += number_to_move;
+    yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+    yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+    yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+
+    return ret_val;
+    }
+
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+static yy_state_type yy_get_previous_state()
+    {
+    register yy_state_type yy_current_state;
+    register char *yy_cp;
+
+    yy_current_state = yy_start;
+
+    for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+        {
+        register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+        if ( yy_accept[yy_current_state] )
+            {
+            yy_last_accepting_state = yy_current_state;
+            yy_last_accepting_cpos = yy_cp;
+            }
+        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+            {
+            yy_current_state = (int) yy_def[yy_current_state];
+            if ( yy_current_state >= 9 )
+                yy_c = yy_meta[(unsigned int) yy_c];
+            }
+        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+        }
+
+    return yy_current_state;
+    }
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *  next_state = yy_try_NUL_trans( current_state );
+ */
+
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+yy_state_type yy_current_state;
+#endif
+    {
+    register int yy_is_jam;
+    register char *yy_cp = yy_c_buf_p;
+
+    register YY_CHAR yy_c = 1;
+    if ( yy_accept[yy_current_state] )
+        {
+        yy_last_accepting_state = yy_current_state;
+        yy_last_accepting_cpos = yy_cp;
+        }
+    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+        {
+        yy_current_state = (int) yy_def[yy_current_state];
+        if ( yy_current_state >= 9 )
+            yy_c = yy_meta[(unsigned int) yy_c];
+        }
+    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+    yy_is_jam = (yy_current_state == 8);
+
+    return yy_is_jam ? 0 : yy_current_state;
+    }
+
+
+#ifndef YY_NO_UNPUT
+#ifdef YY_USE_PROTOS
+static void yyunput( int c, register char *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+int c;
+register char *yy_bp;
+#endif
+    {
+    register char *yy_cp = yy_c_buf_p;
+
+    /* undo effects of setting up yytext */
+    *yy_cp = yy_hold_char;
+
+    if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+        { /* need to shift things up to make room */
+        /* +2 for EOB chars. */
+        register int number_to_move = yy_n_chars + 2;
+        register char *dest = &yy_current_buffer->yy_ch_buf[
+                    yy_current_buffer->yy_buf_size + 2];
+        register char *source =
+                &yy_current_buffer->yy_ch_buf[number_to_move];
+
+        while ( source > yy_current_buffer->yy_ch_buf )
+            *--dest = *--source;
+
+        yy_cp += (int) (dest - source);
+        yy_bp += (int) (dest - source);
+        yy_current_buffer->yy_n_chars =
+            yy_n_chars = yy_current_buffer->yy_buf_size;
+
+        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+            YY_FATAL_ERROR( "flex scanner push-back overflow" );
+        }
+
+    *--yy_cp = (char) c;
+
+
+    yytext_ptr = yy_bp;
+    yy_hold_char = *yy_cp;
+    yy_c_buf_p = yy_cp;
+    }
+#endif  /* ifndef YY_NO_UNPUT */
+
+
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+    {
+    int c;
+
+    *yy_c_buf_p = yy_hold_char;
+
+    if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+        {
+        /* yy_c_buf_p now points to the character we want to return.
+         * If this occurs *before* the EOB characters, then it's a
+         * valid NUL; if not, then we've hit the end of the buffer.
+         */
+        if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+            /* This was really a NUL. */
+            *yy_c_buf_p = '\0';
+
+        else
+            { /* need more input */
+            int offset = yy_c_buf_p - yytext_ptr;
+            ++yy_c_buf_p;
+
+            switch ( yy_get_next_buffer() )
+                {
+                case EOB_ACT_LAST_MATCH:
+                    /* This happens because yy_g_n_b()
+                     * sees that we've accumulated a
+                     * token and flags that we need to
+                     * try matching the token before
+                     * proceeding.  But for input(),
+                     * there's no matching to consider.
+                     * So convert the EOB_ACT_LAST_MATCH
+                     * to EOB_ACT_END_OF_FILE.
+                     */
+
+                    /* Reset buffer status. */
+                    yyrestart( yyin );
+
+                    /* fall through */
+
+                case EOB_ACT_END_OF_FILE:
+                    {
+                    if ( yywrap() )
+                        return EOF;
+
+                    if ( ! yy_did_buffer_switch_on_eof )
+                        YY_NEW_FILE;
+#ifdef __cplusplus
+                    return yyinput();
+#else
+                    return input();
+#endif
+                    }
+
+                case EOB_ACT_CONTINUE_SCAN:
+                    yy_c_buf_p = yytext_ptr + offset;
+                    break;
+                }
+            }
+        }
+
+    c = *(unsigned char *) yy_c_buf_p;  /* cast for 8-bit char's */
+    *yy_c_buf_p = '\0';  /* preserve yytext */
+    yy_hold_char = *++yy_c_buf_p;
+
+
+    return c;
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+    {
+    if ( ! yy_current_buffer )
+        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+    yy_init_buffer( yy_current_buffer, input_file );
+    yy_load_buffer_state();
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+    {
+    if ( yy_current_buffer == new_buffer )
+        return;
+
+    if ( yy_current_buffer )
+        {
+        /* Flush out information for old buffer. */
+        *yy_c_buf_p = yy_hold_char;
+        yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+        yy_current_buffer->yy_n_chars = yy_n_chars;
+        }
+
+    yy_current_buffer = new_buffer;
+    yy_load_buffer_state();
+
+    /* We don't actually know whether we did this switch during
+     * EOF (yywrap()) processing, but the only time this flag
+     * is looked at is after yywrap() is called, so it's safe
+     * to go ahead and always set it.
+     */
+    yy_did_buffer_switch_on_eof = 1;
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+    {
+    yy_n_chars = yy_current_buffer->yy_n_chars;
+    yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+    yyin = yy_current_buffer->yy_input_file;
+    yy_hold_char = *yy_c_buf_p;
+    }
+
+
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+    {
+    YY_BUFFER_STATE b;
+
+    b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+    if ( ! b )
+        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+    b->yy_buf_size = size;
+
+    /* yy_ch_buf has to be 2 characters longer than the size given because
+     * we need to put in 2 end-of-buffer characters.
+     */
+    b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+    if ( ! b->yy_ch_buf )
+        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+    b->yy_is_our_buffer = 1;
+
+    yy_init_buffer( b, file );
+
+    return b;
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+    {
+    if ( ! b )
+        return;
+
+    if ( b == yy_current_buffer )
+        yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+    if ( b->yy_is_our_buffer )
+        yy_flex_free( (void *) b->yy_ch_buf );
+
+    yy_flex_free( (void *) b );
+    }
+
+
+#ifndef _WIN32
+#include <unistd.h>
+#else
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
+#endif
+
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+
+
+    {
+    yy_flush_buffer( b );
+
+    b->yy_input_file = file;
+    b->yy_fill_buffer = 1;
+
+#if YY_ALWAYS_INTERACTIVE
+    b->yy_is_interactive = 1;
+#else
+#if YY_NEVER_INTERACTIVE
+    b->yy_is_interactive = 0;
+#else
+    b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+#endif
+#endif
+    }
+
+
+#ifdef YY_USE_PROTOS
+void yy_flush_buffer( YY_BUFFER_STATE b )
+#else
+void yy_flush_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+
+    {
+    if ( ! b )
+        return;
+
+    b->yy_n_chars = 0;
+
+    /* We always need two end-of-buffer characters.  The first causes
+     * a transition to the end-of-buffer state.  The second causes
+     * a jam in that state.
+     */
+    b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+    b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+    b->yy_buf_pos = &b->yy_ch_buf[0];
+
+    b->yy_at_bol = 1;
+    b->yy_buffer_status = YY_BUFFER_NEW;
+
+    if ( b == yy_current_buffer )
+        yy_load_buffer_state();
+    }
+
+
+#ifndef YY_NO_SCAN_BUFFER
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
+#else
+YY_BUFFER_STATE yy_scan_buffer( base, size )
+char *base;
+yy_size_t size;
+#endif
+    {
+    YY_BUFFER_STATE b;
+
+    if ( size < 2 ||
+         base[size-2] != YY_END_OF_BUFFER_CHAR ||
+         base[size-1] != YY_END_OF_BUFFER_CHAR )
+        /* They forgot to leave room for the EOB's. */
+        return 0;
+
+    b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+    if ( ! b )
+        YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+    b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
+    b->yy_buf_pos = b->yy_ch_buf = base;
+    b->yy_is_our_buffer = 0;
+    b->yy_input_file = 0;
+    b->yy_n_chars = b->yy_buf_size;
+    b->yy_is_interactive = 0;
+    b->yy_at_bol = 1;
+    b->yy_fill_buffer = 0;
+    b->yy_buffer_status = YY_BUFFER_NEW;
+
+    yy_switch_to_buffer( b );
+
+    return b;
+    }
+#endif
+
+
+#ifndef YY_NO_SCAN_STRING
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
+#else
+YY_BUFFER_STATE yy_scan_string( yy_str )
+yyconst char *yy_str;
+#endif
+    {
+    int len;
+    for ( len = 0; yy_str[len]; ++len )
+        ;
+
+    return yy_scan_bytes( yy_str, len );
+    }
+#endif
+
+
+#ifndef YY_NO_SCAN_BYTES
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
+#else
+YY_BUFFER_STATE yy_scan_bytes( bytes, len )
+yyconst char *bytes;
+int len;
+#endif
+    {
+    YY_BUFFER_STATE b;
+    char *buf;
+    yy_size_t n;
+    int i;
+
+    /* Get memory for full buffer, including space for trailing EOB's. */
+    n = len + 2;
+    buf = (char *) yy_flex_alloc( n );
+    if ( ! buf )
+        YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+    for ( i = 0; i < len; ++i )
+        buf[i] = bytes[i];
+
+    buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+
+    b = yy_scan_buffer( buf, n );
+    if ( ! b )
+        YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+    /* It's okay to grow etc. this buffer, and we should throw it
+     * away when we're done.
+     */
+    b->yy_is_our_buffer = 1;
+
+    return b;
+    }
+#endif
+
+
+#ifndef YY_NO_PUSH_STATE
+#ifdef YY_USE_PROTOS
+static void yy_push_state( int new_state )
+#else
+static void yy_push_state( new_state )
+int new_state;
+#endif
+    {
+    if ( yy_start_stack_ptr >= yy_start_stack_depth )
+        {
+        yy_size_t new_size;
+
+        yy_start_stack_depth += YY_START_STACK_INCR;
+        new_size = yy_start_stack_depth * sizeof( int );
+
+        if ( ! yy_start_stack )
+            yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+        else
+            yy_start_stack = (int *) yy_flex_realloc(
+                    (void *) yy_start_stack, new_size );
+
+        if ( ! yy_start_stack )
+            YY_FATAL_ERROR(
+            "out of memory expanding start-condition stack" );
+        }
+
+    yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+    BEGIN(new_state);
+    }
+#endif
+
+
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state()
+    {
+    if ( --yy_start_stack_ptr < 0 )
+        YY_FATAL_ERROR( "start-condition stack underflow" );
+
+    BEGIN(yy_start_stack[yy_start_stack_ptr]);
+    }
+#endif
+
+
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state()
+    {
+    return yy_start_stack[yy_start_stack_ptr - 1];
+    }
+#endif
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+#ifdef YY_USE_PROTOS
+static void yy_fatal_error( yyconst char msg[] )
+#else
+static void yy_fatal_error( msg )
+char msg[];
+#endif
+    {
+    (void) fprintf( stderr, "%s\n", msg );
+    exit( YY_EXIT_FAILURE );
+    }
+
+
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+    do \
+        { \
+        /* Undo effects of setting up yytext. */ \
+        yytext[yyleng] = yy_hold_char; \
+        yy_c_buf_p = yytext + n; \
+        yy_hold_char = *yy_c_buf_p; \
+        *yy_c_buf_p = '\0'; \
+        yyleng = n; \
+        } \
+    while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+yyconst char *s2;
+int n;
+#endif
+    {
+    register int i;
+    for ( i = 0; i < n; ++i )
+        s1[i] = s2[i];
+    }
+#endif
+
+#ifdef YY_NEED_STRLEN
+#ifdef YY_USE_PROTOS
+static int yy_flex_strlen( yyconst char *s )
+#else
+static int yy_flex_strlen( s )
+yyconst char *s;
+#endif
+    {
+    register int n;
+    for ( n = 0; s[n]; ++n )
+        ;
+
+    return n;
+    }
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( yy_size_t size )
+#else
+static void *yy_flex_alloc( size )
+yy_size_t size;
+#endif
+    {
+    return (void *) malloc( size );
+    }
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, yy_size_t size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+yy_size_t size;
+#endif
+    {
+    /* The cast to (char *) in the following accommodates both
+     * implementations that use char* generic pointers, and those
+     * that use void* generic pointers.  It works with the latter
+     * because both ANSI C and C++ allow castless assignment from
+     * any pointer type to void*, and deal with argument conversions
+     * as though doing an assignment.
+     */
+    return (void *) realloc( (char *) ptr, size );
+    }
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+    {
+    free( ptr );
+    }
+
+#if YY_MAIN
+int main()
+    {
+    yylex();
+    return 0;
+    }
+#endif
+#line 20 "c:\\CVS\\boost\\libs\\spirit\\example\\lex\\word_count_functor.flex"
+
+
+bool count(int tok, int* c, int* w, int* l)
+{
+    switch (tok) {
+    case ID_WORD: ++*w; *c += yyleng; break;
+    case ID_EOL:  ++*l; ++*c; break;
+    case ID_CHAR: ++*c; break;
+    default:
+        return false;
+    }
+    return true;
+}
+
+int main(int argc, char* argv[])
+{
+    int tok = EOF;
+    int c = 0, w = 0, l = 0;
+    yyin = fopen(1 == argc ? "word_count.input" : argv[1], "r");
+    if (NULL == yyin) {
+        fprintf(stderr, "Couldn't open input file!\n");
+        exit(-1); 
+    }
+
+    boost::timer tim;
+    do {
+        tok = yylex();
+        if (!count(tok, &c, &w, &l))
+            break;
+    } while (EOF != tok);
+    printf("lines: %d, words: %d, characters: %d\n", l, w, c);
+    fclose(yyin);
+    return 0;
+}
+
+extern "C" int yywrap()  
+{
+    return 1;
+}
+
diff --git a/src/boost/libs/spirit/example/lex/word_count_lexer.cpp b/src/boost/libs/spirit/example/lex/word_count_lexer.cpp
new file mode 100644
index 00000000..57225e40
--- /dev/null
+++ b/src/boost/libs/spirit/example/lex/word_count_lexer.cpp
@@ -0,0 +1,152 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example is the equivalent to the following lex program:
+/*
+//[wcl_flex_version
+    %{
+        int c = 0, w = 0, l = 0;
+    %}
+    %%
+    [^ \t\n]+  { ++w; c += yyleng; }
+    \n         { ++c; ++l; }
+    .          { ++c; }
+    %%
+    main()
+    {
+        yylex();
+        printf("%d %d %d\n", l, w, c);
+    }
+//]
+*/
+//  Its purpose is to do the word count function of the wc command in UNIX. It 
+//  prints the number of lines, words and characters in a file. 
+//
+//  This examples shows how to use semantic actions associated with token 
+//  definitions to directly attach actions to tokens. These get executed 
+//  whenever the corresponding token got matched in the input sequence. Note,
+//  how this example implements all functionality directly in the lexer 
+//  definition without any need for a parser.
+
+// #define BOOST_SPIRIT_LEXERTL_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+//[wcl_includes
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_statement.hpp>
+#include <boost/spirit/include/phoenix_algorithm.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+//]
+
+#include <iostream>
+#include <string>
+
+#include "example.hpp"
+
+//[wcl_namespaces
+namespace lex = boost::spirit::lex;
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//  Token definition: We use the lexertl based lexer engine as the underlying 
+//                    lexer type.
+//
+//  Note, the token definition type is derived from the 'lexertl_actor_lexer'
+//  template, which is a necessary to being able to use lexer semantic actions.
+///////////////////////////////////////////////////////////////////////////////
+struct distance_func
+{
+    template <typename Iterator1, typename Iterator2>
+    struct result : boost::iterator_difference<Iterator1> {};
+
+    template <typename Iterator1, typename Iterator2>
+    typename result<Iterator1, Iterator2>::type 
+    operator()(Iterator1 const& begin, Iterator2 const& end) const
+    {
+        return std::distance(begin, end);
+    }
+};
+boost::phoenix::function<distance_func> const distance = distance_func();
+
+//[wcl_token_definition
+template <typename Lexer>
+struct word_count_tokens : lex::lexer<Lexer>
+{
+    word_count_tokens()
+      : c(0), w(0), l(0)
+      , word("[^ \t\n]+")     // define tokens
+      , eol("\n")
+      , any(".")
+    {
+        using boost::spirit::lex::_start;
+        using boost::spirit::lex::_end;
+        using boost::phoenix::ref;
+
+        // associate tokens with the lexer
+        this->self 
+            =   word  [++ref(w), ref(c) += distance(_start, _end)]
+            |   eol   [++ref(c), ++ref(l)] 
+            |   any   [++ref(c)]
+            ;
+    }
+
+    std::size_t c, w, l;
+    lex::token_def<> word, eol, any;
+};
+//]
+
+///////////////////////////////////////////////////////////////////////////////
+//[wcl_main
+int main(int argc, char* argv[])
+{
+
+/*<  Specifying `omit` as the token attribute type generates a token class 
+     not holding any token attribute at all (not even the iterator range of the 
+     matched input sequence), therefore optimizing the token, the lexer, and 
+     possibly the parser implementation as much as possible. Specifying 
+     `mpl::false_` as the 3rd template parameter generates a token
+     type and an iterator, both holding no lexer state, allowing for even more 
+     aggressive optimizations. As a result the token instances contain the token 
+     ids as the only data member.
+>*/  typedef 
+        lex::lexertl::token<char const*, lex::omit, boost::mpl::false_> 
+     token_type;
+
+/*<  This defines the lexer type to use
+>*/  typedef lex::lexertl::actor_lexer<token_type> lexer_type;
+
+/*<  Create the lexer object instance needed to invoke the lexical analysis 
+>*/  word_count_tokens<lexer_type> word_count_lexer;
+
+/*<  Read input from the given file, tokenize all the input, while discarding
+     all generated tokens
+>*/  std::string str (read_from_file(1 == argc ? "word_count.input" : argv[1]));
+    char const* first = str.c_str();
+    char const* last = &first[str.size()];
+
+/*<  Create a pair of iterators returning the sequence of generated tokens
+>*/  lexer_type::iterator_type iter = word_count_lexer.begin(first, last);
+    lexer_type::iterator_type end = word_count_lexer.end();
+
+/*<  Here we simply iterate over all tokens, making sure to break the loop
+     if an invalid token gets returned from the lexer
+>*/  while (iter != end && token_is_valid(*iter))
+        ++iter;
+
+    if (iter == end) {
+        std::cout << "lines: " << word_count_lexer.l 
+                  << ", words: " << word_count_lexer.w 
+                  << ", characters: " << word_count_lexer.c 
+                  << "\n";
+    }
+    else {
+        std::string rest(first, last);
+        std::cout << "Lexical analysis failed\n" << "stopped at: \"" 
+                  << rest << "\"\n";
+    }
+    return 0;
+}
+//]
diff --git a/src/boost/libs/spirit/example/qi/Jamfile b/src/boost/libs/spirit/example/qi/Jamfile
new file mode 100644
index 00000000..a071c0d2
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/Jamfile
@@ -0,0 +1,48 @@
+#==============================================================================
+#   Copyright (c) 2001-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)
+#==============================================================================
+project spirit-qi-example
+    : requirements
+        <c++-template-depth>300
+    :
+    :
+    ;
+
+exe actions_ : actions.cpp ;
+exe sum : sum.cpp ;
+exe complex_number : complex_number.cpp ;
+exe employee : employee.cpp  ;
+exe roman : roman.cpp ;
+exe reference : reference.cpp ;
+exe mini_xml1 : mini_xml1.cpp ;
+exe mini_xml2 : mini_xml2.cpp ;
+exe mini_xml3 : mini_xml3.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 reorder_struct : reorder_struct.cpp ;
+exe parse_date : parse_date.cpp ;
+exe expect : expect.cpp ;
+
+exe key_value_sequence : key_value_sequence.cpp ;
+exe key_value_sequence_ordered : key_value_sequence_ordered.cpp ;
+exe key_value_sequence_empty_value : key_value_sequence_empty_value.cpp ;
+
+exe iter_pos_parser : iter_pos_parser.cpp ;
+exe boost_array : boost_array.cpp ;
+exe display_attribute_type : display_attribute_type.cpp ;
+exe adapt_template_struct : adapt_template_struct.cpp ;
+
+exe unescaped_string : unescaped_string.cpp ;
+
+exe calc_utree_naive : calc_utree_naive.cpp ;
+exe calc_utree_ast : calc_utree_ast.cpp ;
+exe calc_utree : calc_utree.cpp ;
+
+exe nabialek : nabialek.cpp ;
+exe typeof : typeof.cpp ;
+
diff --git a/src/boost/libs/spirit/example/qi/actions.cpp b/src/boost/libs/spirit/example/qi/actions.cpp
new file mode 100644
index 00000000..c5379703
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/actions.cpp
@@ -0,0 +1,108 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/bind.hpp>
+
+#include <iostream>
+
+// Presented are various ways to attach semantic actions
+//  * Using plain function pointer
+//  * Using simple function object
+//  * Using boost.bind with a plain function
+//  * Using boost.bind with a member function
+//  * Using boost.lambda
+
+//[tutorial_semantic_action_functions
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+
+    // A plain function
+    void print(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 print_action
+    {
+        void operator()(int const& i, qi::unused_type, qi::unused_type) const
+        {
+            std::cout << i << std::endl;
+        }
+    };
+}
+//]
+
+int main()
+{
+    using boost::spirit::qi::int_;
+    using boost::spirit::qi::parse;
+    using client::print;
+    using client::writer;
+    using client::print_action;
+
+    { // example using plain function
+
+        char const *first = "{42}", *last = first + std::strlen(first);
+        //[tutorial_attach_actions1
+        parse(first, last, '{' >> int_[&print] >> '}');
+        //]
+    }
+
+    { // example using simple function object
+
+        char const *first = "{43}", *last = first + std::strlen(first);
+        //[tutorial_attach_actions2
+        parse(first, last, '{' >> int_[print_action()] >> '}');
+        //]
+    }
+
+    { // example using boost.bind with a plain function
+
+        char const *first = "{44}", *last = first + std::strlen(first);
+        //[tutorial_attach_actions3
+        parse(first, last, '{' >> int_[boost::bind(&print, _1)] >> '}');
+        //]
+    }
+
+    { // example using boost.bind with a member function
+
+        char const *first = "{44}", *last = first + std::strlen(first);
+        //[tutorial_attach_actions4
+        writer w;
+        parse(first, last, '{' >> int_[boost::bind(&writer::print, &w, _1)] >> '}');
+        //]
+    }
+
+    { // example using boost.lambda
+
+        namespace lambda = boost::lambda;
+        char const *first = "{45}", *last = first + std::strlen(first);
+        using lambda::_1;
+        //[tutorial_attach_actions5
+        parse(first, last, '{' >> int_[std::cout << _1 << '\n'] >> '}');
+        //]
+    }
+
+    return 0;
+}
+
+
+
+
diff --git a/src/boost/libs/spirit/example/qi/adapt_template_struct.cpp b/src/boost/libs/spirit/example/qi/adapt_template_struct.cpp
new file mode 100644
index 00000000..360707d1
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/adapt_template_struct.cpp
@@ -0,0 +1,92 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example demonstrates a trick allowing to adapt a template data 
+//  structure as a Fusion sequence in order to use is for direct attribute
+//  propagation. For more information see 
+//  http://boost-spirit.com/home/2010/02/08/how-to-adapt-templates-as-a-fusion-sequence
+
+#include <boost/spirit/include/qi.hpp>
+
+namespace qi = boost::spirit::qi;
+namespace fusion = boost::fusion;
+
+namespace client
+{
+    template <typename A, typename B>
+    struct data
+    {
+        A a;
+        B b;
+    };
+
+    template <typename Iterator, typename A, typename B>
+    struct data_grammar : qi::grammar<Iterator, data<A, B>()>
+    {
+        data_grammar() : data_grammar::base_type(start) 
+        {
+            start = real_start;
+            real_start = qi::auto_ >> ',' >> qi::auto_;
+        }
+
+        qi::rule<Iterator, data<A, B>()> start;
+        qi::rule<Iterator, fusion::vector<A&, B&>()> real_start;
+    };
+}
+
+namespace boost { namespace spirit { namespace traits 
+{
+    template <typename A, typename B>
+    struct transform_attribute<client::data<A, B>, fusion::vector<A&, B&>, qi::domain>
+    {
+        typedef fusion::vector<A&, B&> type;
+
+        static type pre(client::data<A, B>& val) { return type(val.a, val.b); }
+        static void post(client::data<A, B>&, fusion::vector<A&, B&> const&) {}
+        static void fail(client::data<A, B>&) {}
+    };
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA parser for Spirit utilizing an adapted template ...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me two comma separated integers:\n";
+    std::cout << "Type [q or Q] to quit\n\n";
+
+    std::string str;
+    client::data_grammar<std::string::const_iterator, long, int> g; // Our grammar
+    while (getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        client::data<long, int> d;
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = phrase_parse(iter, end, g, qi::space, d);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "got: " << d.a << "," << d.b << std::endl;
+            std::cout << "\n-------------------------\n";
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/boost_array.cpp b/src/boost/libs/spirit/example/qi/boost_array.cpp
new file mode 100644
index 00000000..66485b97
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/boost_array.cpp
@@ -0,0 +1,119 @@
+// Copyright (c) 2009 Erik Bryan
+// Copyright (c) 2007-2010 Hartmut Kaiser
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <string>
+#include <vector>
+
+#include <boost/array.hpp>
+
+#include <boost/spirit/include/qi.hpp>
+
+namespace qi = boost::spirit::qi;
+namespace ascii = boost::spirit::ascii;
+
+///////////////////////////////////////////////////////////////////////////////
+// create a wrapper holding the boost::array and a current insertion point
+namespace client 
+{ 
+    namespace detail
+    {
+        template <typename T>
+        struct adapt_array;
+
+        template <typename T, std::size_t N>
+        struct adapt_array<boost::array<T, N> >
+        {
+            typedef boost::array<T, N> array_type;
+
+            adapt_array(array_type& arr)
+              : arr_(arr), current_(0) {}
+
+            // expose a push_back function compatible with std containers
+            bool push_back(typename array_type::value_type const& val)
+            {
+                // if the array is full, we need to bail out
+                // returning false will fail the parse
+                if (current_ >= N) 
+                    return false;
+
+                arr_[current_++] = val;
+                return true;
+            }
+
+            array_type& arr_;
+            std::size_t current_;
+        };
+    }
+
+    namespace result_of
+    {
+        template <typename T>
+        struct adapt_array;
+
+        template <typename T, std::size_t N>
+        struct adapt_array<boost::array<T, N> >
+        {
+            typedef detail::adapt_array<boost::array<T, N> > type;
+        };
+    }
+
+    template <typename T, std::size_t N>
+    inline detail::adapt_array<boost::array<T, N> > 
+    adapt_array(boost::array<T, N>& arr)
+    {
+        return detail::adapt_array<boost::array<T, N> >(arr);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// specialize Spirit's container specific customization points for our adaptor
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T, std::size_t N>
+     struct is_container<client::detail::adapt_array<boost::array<T, N> > > 
+       : boost::mpl::true_
+     {};
+
+    template <typename T, std::size_t N>
+    struct container_value<client::detail::adapt_array<boost::array<T, N> > >
+    {
+        typedef T type;     // value type of container
+    };
+
+    template <typename T, std::size_t N>
+    struct push_back_container<
+      client::detail::adapt_array<boost::array<T, N> >, T>
+    {
+        static bool call(client::detail::adapt_array<boost::array<T, N> >& c
+          , T const& val)
+        {
+            return c.push_back(val);
+        }
+    };
+}}}
+
+int main()
+{
+    typedef std::string::const_iterator iterator_type;
+    typedef boost::array<int, 2> array_type; 
+    typedef client::result_of::adapt_array<array_type>::type adapted_type; 
+
+    array_type arr;
+
+    std::string str = "1 2";
+    iterator_type iter = str.begin();
+    iterator_type end = str.end();
+
+    qi::rule<iterator_type, adapted_type(), ascii::space_type> r = *qi::int_;
+
+    adapted_type attr = client::adapt_array(arr);
+    bool result = qi::phrase_parse(iter, end, r, ascii::space, attr);
+
+    if (result) 
+        std::cout << "Parsed: " << arr[0] << ", " << arr[1] << std::endl;
+
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/qi/calc_utree.cpp b/src/boost/libs/spirit/example/qi/calc_utree.cpp
new file mode 100644
index 00000000..00293df3
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/calc_utree.cpp
@@ -0,0 +1,166 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Plain calculator example demonstrating the grammar. The parser is a
+//  syntax checker only and does not do any semantic evaluation.
+//
+//  [ JDG May 10, 2002 ]        spirit1
+//  [ JDG March 4, 2007 ]       spirit2
+//  [ HK November 30, 2010 ]    spirit2/utree
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// #define BOOST_SPIRIT_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/support_utree.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+
+#include <iostream>
+#include <string>
+
+#if BOOST_PHOENIX_VERSION == 0x2000
+namespace boost { namespace phoenix 
+{
+    // There's a bug in the Phoenix V2 type deduction mechanism that prevents 
+    // correct return type deduction for the math operations below. Newer
+    // versions of Phoenix will be switching to BOOST_TYPEOF. In the meantime, 
+    // we will use the specializations helping with return type deduction 
+    // below:
+    template <>
+    struct result_of_plus<spirit::utree&, spirit::utree&> 
+    { 
+        typedef spirit::utree type; 
+    };
+
+    template <>
+    struct result_of_minus<spirit::utree&, spirit::utree&> 
+    { 
+        typedef spirit::utree type; 
+    };
+
+    template <>
+    struct result_of_multiplies<spirit::utree&, spirit::utree&> 
+    { 
+        typedef spirit::utree type; 
+    };
+
+    template <>
+    struct result_of_divides<spirit::utree&, spirit::utree&> 
+    { 
+        typedef spirit::utree type; 
+    };
+
+    template <>
+    struct result_of_negate<spirit::utree&> 
+    { 
+        typedef spirit::utree type; 
+    };
+}}
+#endif
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+    namespace spirit = boost::spirit;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct calculator : qi::grammar<Iterator, ascii::space_type, spirit::utree()>
+    {
+        calculator() : calculator::base_type(expression)
+        {
+            using qi::uint_;
+            using qi::_val;
+            using qi::_1;
+
+            expression =
+                term                            [_val = _1]
+                >> *(   ('+' >> term            [_val = _val + _1])
+                    |   ('-' >> term            [_val = _val - _1])
+                    )
+                ;
+
+            term =
+                factor                          [_val = _1]
+                >> *(   ('*' >> factor          [_val = _val * _1])
+                    |   ('/' >> factor          [_val = _val / _1])
+                    )
+                ;
+
+            factor =
+                uint_                           [_val = _1]
+                |   '(' >> expression           [_val = _1] >> ')'
+                |   ('-' >> factor              [_val = -_1])
+                |   ('+' >> factor              [_val = _1])
+                ;
+
+            BOOST_SPIRIT_DEBUG_NODE(expression);
+            BOOST_SPIRIT_DEBUG_NODE(term);
+            BOOST_SPIRIT_DEBUG_NODE(factor);
+        }
+
+        qi::rule<Iterator, ascii::space_type, spirit::utree()> expression, term, factor;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    using boost::spirit::ascii::space;
+    using boost::spirit::utree;
+    typedef std::string::const_iterator iterator_type;
+    typedef client::calculator<iterator_type> calculator;
+
+    calculator calc; // Our grammar
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        utree ut;
+        bool r = phrase_parse(iter, end, calc, space, ut);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded: " << ut << "\n";
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \": " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/calc_utree_ast.cpp b/src/boost/libs/spirit/example/qi/calc_utree_ast.cpp
new file mode 100644
index 00000000..3465ba08
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/calc_utree_ast.cpp
@@ -0,0 +1,164 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Plain calculator example demonstrating the grammar. The parser is a
+//  syntax checker only and does not do any semantic evaluation.
+//
+//  [ JDG May 10, 2002 ]        spirit1
+//  [ JDG March 4, 2007 ]       spirit2
+//  [ HK November 30, 2010 ]    spirit2/utree
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// #define BOOST_SPIRIT_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/support_utree.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+    namespace spirit = boost::spirit;
+
+    struct expr
+    {
+        template <typename T1, typename T2 = void>
+        struct result { typedef void type; };
+
+        expr(char op) : op(op) {}
+
+        void operator()(spirit::utree& expr, spirit::utree const& rhs) const
+        {
+            spirit::utree lhs;
+            lhs.swap(expr);
+            expr.push_back(spirit::utf8_symbol_range_type(&op, &op+1));
+            expr.push_back(lhs);
+            expr.push_back(rhs);
+        }
+
+        char const op;
+    };
+    boost::phoenix::function<expr> const plus = expr('+');
+    boost::phoenix::function<expr> const minus = expr('-');
+    boost::phoenix::function<expr> const times = expr('*');
+    boost::phoenix::function<expr> const divide = expr('/');
+
+    struct negate_expr
+    {
+        template <typename T1, typename T2 = void>
+        struct result { typedef void type; };
+
+        void operator()(spirit::utree& expr, spirit::utree const& rhs) const
+        {
+            char const op = '-';
+            expr.clear();
+            expr.push_back(spirit::utf8_symbol_range_type(&op, &op+1));
+            expr.push_back(rhs);
+        }
+    };
+    boost::phoenix::function<negate_expr> neg;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct calculator : qi::grammar<Iterator, ascii::space_type, spirit::utree()>
+    {
+        calculator() : calculator::base_type(expression)
+        {
+            using qi::uint_;
+            using qi::_val;
+            using qi::_1;
+
+            expression =
+                term                            [_val = _1]
+                >> *(   ('+' >> term            [plus(_val, _1)])
+                    |   ('-' >> term            [minus(_val, _1)])
+                    )
+                ;
+
+            term =
+                factor                          [_val = _1]
+                >> *(   ('*' >> factor          [times(_val, _1)])
+                    |   ('/' >> factor          [divide(_val, _1)])
+                    )
+                ;
+
+            factor =
+                uint_                           [_val = _1]
+                |   '(' >> expression           [_val = _1] >> ')'
+                |   ('-' >> factor              [neg(_val, _1)])
+                |   ('+' >> factor              [_val = _1])
+                ;
+
+            BOOST_SPIRIT_DEBUG_NODE(expression);
+            BOOST_SPIRIT_DEBUG_NODE(term);
+            BOOST_SPIRIT_DEBUG_NODE(factor);
+        }
+
+        qi::rule<Iterator, ascii::space_type, spirit::utree()> expression, term, factor;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    using boost::spirit::ascii::space;
+    using boost::spirit::utree;
+    typedef std::string::const_iterator iterator_type;
+    typedef client::calculator<iterator_type> calculator;
+
+    calculator calc; // Our grammar
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        utree ut;
+        bool r = phrase_parse(iter, end, calc, space, ut);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded: " << ut << "\n";
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \": " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/calc_utree_naive.cpp b/src/boost/libs/spirit/example/qi/calc_utree_naive.cpp
new file mode 100644
index 00000000..c6ac3ddb
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/calc_utree_naive.cpp
@@ -0,0 +1,134 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Plain calculator example demonstrating the grammar. The parser is a
+//  syntax checker only and does not do any semantic evaluation.
+//
+//  [ JDG May 10, 2002 ]        spirit1
+//  [ JDG March 4, 2007 ]       spirit2
+//  [ HK November 30, 2010 ]    spirit2/utree
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// This rather naive example demonstrates that you can pass an instance of a
+// utree as the attribute for almost any grammar. As the result the utree will
+// be filled with the parse tree as generated during the parsing. This is most
+// of the time not what's desired, but is usually a good first step in order to
+// prepare your grammar to generate a customized AST. See the calc_utree_ast
+// example for a modified version of this grammar filling the attribute with a
+// AST (abstract syntax tree) representing the math expression as matched from
+// the input.
+
+// #define BOOST_SPIRIT_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/support_utree.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+    namespace spirit = boost::spirit;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct calculator : qi::grammar<Iterator, ascii::space_type, spirit::utree()>
+    {
+        calculator() : calculator::base_type(expression)
+        {
+            using qi::uint_;
+            using qi::char_;
+
+            expression =
+                term
+                >> *(   (char_('+') >> term)
+                    |   (char_('-') >> term)
+                    )
+                ;
+
+            term =
+                factor
+                >> *(   (char_('*') >> factor)
+                    |   (char_('/') >> factor)
+                    )
+                ;
+
+            factor =
+                uint_
+                |   '(' >> expression >> ')'
+                |   (char_('-') >> factor)
+                |   (char_('+') >> factor)
+                ;
+
+            BOOST_SPIRIT_DEBUG_NODE(expression);
+            BOOST_SPIRIT_DEBUG_NODE(term);
+            BOOST_SPIRIT_DEBUG_NODE(factor);
+        }
+
+        qi::rule<Iterator, ascii::space_type, spirit::utree()> expression;
+        qi::rule<Iterator, ascii::space_type, spirit::utree::list_type()> term;
+        qi::rule<Iterator, ascii::space_type, spirit::utree::list_type()> factor;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    using boost::spirit::ascii::space;
+    using boost::spirit::utree;
+    typedef std::string::const_iterator iterator_type;
+    typedef client::calculator<iterator_type> calculator;
+
+    calculator calc; // Our grammar
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        utree ut;
+        bool r = phrase_parse(iter, end, calc, space, ut);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded: " << ut << "\n";
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \": " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/Jamfile b/src/boost/libs/spirit/example/qi/compiler_tutorial/Jamfile
new file mode 100644
index 00000000..bda2fad4
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/Jamfile
@@ -0,0 +1,132 @@
+#==============================================================================
+#   Copyright (c) 2001-2011 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)
+#==============================================================================
+project spirit-qi-compiler_tutorial
+    : requirements
+        <c++-template-depth>300
+    :
+    ;
+
+import modules ;
+
+exe calc1 : calc1.cpp ;
+exe calc2 : calc2.cpp ;
+exe calc3 : calc3.cpp ;
+exe calc4 : calc4.cpp ;
+exe calc5 : calc5.cpp ;
+exe calc6 : calc6.cpp ;
+
+exe calc7 :
+    calc7/vm.cpp
+    calc7/compiler.cpp
+    calc7/expression.cpp
+    calc7/statement.cpp
+    calc7/main.cpp
+;
+
+exe calc8 :
+    calc8/vm.cpp
+    calc8/compiler.cpp
+    calc8/expression.cpp
+    calc8/statement.cpp
+    calc8/main.cpp
+;
+
+exe mini_c :
+    mini_c/vm.cpp
+    mini_c/compiler.cpp
+    mini_c/expression.cpp
+    mini_c/statement.cpp
+    mini_c/function.cpp
+    mini_c/main.cpp
+;
+
+exe conjure1 :
+    conjure1/vm.cpp
+    conjure1/compiler.cpp
+    conjure1/expression.cpp
+    conjure1/statement.cpp
+    conjure1/function.cpp
+    conjure1/main.cpp
+;
+
+exe conjure2 :
+    conjure2/compiler.cpp
+    conjure2/expression.cpp
+    conjure2/function.cpp
+    conjure2/lexer.cpp
+    conjure2/main.cpp
+    conjure2/statement.cpp
+    conjure2/vm.cpp
+;
+
+#==============================================================================
+# conjure3 and above require LLVM. Make sure you provide the
+# LLVM_PATH in your bjam invocation. E.g.:
+#
+#     bjam -sLLVM_PATH=C:/dev/llvm conjure3
+#
+#==============================================================================
+
+if [ modules.peek : LLVM_PATH ]
+{
+    LLVM_PATH =  [ modules.peek : LLVM_PATH ] ;
+}
+
+if $(LLVM_PATH)
+{
+    path-constant LLVM_LIB_DEBUG_PATH : $(LLVM_PATH)/lib/Debug ;
+    path-constant LLVM_LIB_RELEASE_PATH : $(LLVM_PATH)/lib/Release ;
+
+    llvm_linker_flags =
+         "advapi32.lib"
+         "shell32.lib"
+        ;
+
+    llvm_debug_libs = [ glob $(LLVM_LIB_DEBUG_PATH)/LLVM*.lib ] ;
+    llvm_release_libs = [ glob $(LLVM_LIB_RELEASE_PATH)/LLVM*.lib ] ;
+
+    rule build_exe_1 ( target-name : sources + : requirements * )
+    {
+        local llvm_lib ;
+        if <variant>debug in $(requirements)
+        {
+            llvm_lib = $(llvm_debug_libs) ;
+        }
+        else
+        {
+            llvm_lib = $(llvm_release_libs) ;
+        }
+
+        exe $(target-name)
+        :   $(sources)
+            $(llvm_lib)
+        :   $(requirements)
+            <toolset>msvc
+            <include>$(LLVM_PATH)/include
+            <linkflags>$(llvm_linker_flags)
+        ;
+    }
+
+    rule build_exe ( target-name : sources + )
+    {
+        build_exe_1 $(target-name) : $(sources) : <variant>debug ;
+        build_exe_1 $(target-name) : $(sources) : <variant>release ;
+    }
+
+    build_exe conjure3 :
+        conjure3/compiler.cpp
+        conjure3/expression.cpp
+        conjure3/function.cpp
+        conjure3/lexer.cpp
+        conjure3/main.cpp
+        conjure3/statement.cpp
+        conjure3/vm.cpp
+    ;
+}
+
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc1.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc1.cpp
new file mode 100644
index 00000000..d070172f
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc1.cpp
@@ -0,0 +1,118 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Plain calculator example demonstrating the grammar. The parser is a
+//  syntax checker only and does not do any semantic evaluation.
+//
+//  [ JDG May 10, 2002 ]        spirit1
+//  [ JDG March 4, 2007 ]       spirit2
+//  [ JDG February 21, 2011 ]   spirit2.5
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <iostream>
+#include <string>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct calculator : qi::grammar<Iterator, ascii::space_type>
+    {
+        calculator() : calculator::base_type(expression)
+        {
+            qi::uint_type uint_;
+
+            expression =
+                term
+                >> *(   ('+' >> term)
+                    |   ('-' >> term)
+                    )
+                ;
+
+            term =
+                factor
+                >> *(   ('*' >> factor)
+                    |   ('/' >> factor)
+                    )
+                ;
+
+            factor =
+                uint_
+                |   '(' >> expression >> ')'
+                |   ('-' >> factor)
+                |   ('+' >> factor)
+                ;
+        }
+
+        qi::rule<Iterator, ascii::space_type> expression, term, factor;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::calculator<iterator_type> calculator;
+
+    boost::spirit::ascii::space_type space; // Our skipper
+    calculator calc; // Our grammar
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = phrase_parse(iter, end, calc, space);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \" " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc2.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc2.cpp
new file mode 100644
index 00000000..92e03f49
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc2.cpp
@@ -0,0 +1,131 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating the grammar and semantic actions
+//  using plain functions. The parser prints code suitable for a stack
+//  based virtual machine.
+//
+//  [ JDG May 10, 2002 ]        spirit1
+//  [ JDG March 4, 2007 ]       spirit2
+//  [ JDG February 21, 2011 ]   spirit2.5
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Semantic actions
+    ////////////////////////////////////////////////////////1///////////////////////
+    namespace
+    {
+        void do_int(int n)  { std::cout << "push " << n << std::endl; }
+        void do_add()       { std::cout << "add\n"; }
+        void do_subt()      { std::cout << "subtract\n"; }
+        void do_mult()      { std::cout << "mult\n"; }
+        void do_div()       { std::cout << "divide\n"; }
+        void do_neg()       { std::cout << "negate\n"; }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct calculator : qi::grammar<Iterator, ascii::space_type>
+    {
+        calculator() : calculator::base_type(expression)
+        {
+            qi::uint_type uint_;
+
+            expression =
+                term
+                >> *(   ('+' >> term            [&do_add])
+                    |   ('-' >> term            [&do_subt])
+                    )
+                ;
+
+            term =
+                factor
+                >> *(   ('*' >> factor          [&do_mult])
+                    |   ('/' >> factor          [&do_div])
+                    )
+                ;
+
+            factor =
+                uint_                           [&do_int]
+                |   '(' >> expression >> ')'
+                |   ('-' >> factor              [&do_neg])
+                |   ('+' >> factor)
+                ;
+        }
+
+        qi::rule<Iterator, ascii::space_type> expression, term, factor;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::calculator<iterator_type> calculator;
+
+    boost::spirit::ascii::space_type space; // Our skipper
+    calculator calc; // Our grammar
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = phrase_parse(iter, end, calc, space);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \" " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc3.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc3.cpp
new file mode 100644
index 00000000..4f214e30
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc3.cpp
@@ -0,0 +1,124 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A calculator example demonstrating the grammar and semantic actions
+//  using phoenix to do the actual expression evaluation. The parser is
+//  essentially an "interpreter" that evaluates expressions on the fly.
+//
+//  [ JDG June 29, 2002 ]   spirit1
+//  [ JDG March 5, 2007 ]   spirit2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our calculator grammar
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct calculator : qi::grammar<Iterator, int(), ascii::space_type>
+    {
+        calculator() : calculator::base_type(expression)
+        {
+            qi::_val_type _val;
+            qi::_1_type _1;
+            qi::uint_type uint_;
+
+            expression =
+                term                            [_val = _1]
+                >> *(   ('+' >> term            [_val += _1])
+                    |   ('-' >> term            [_val -= _1])
+                    )
+                ;
+
+            term =
+                factor                          [_val = _1]
+                >> *(   ('*' >> factor          [_val *= _1])
+                    |   ('/' >> factor          [_val /= _1])
+                    )
+                ;
+
+            factor =
+                uint_                           [_val = _1]
+                |   '(' >> expression           [_val = _1] >> ')'
+                |   ('-' >> factor              [_val = -_1])
+                |   ('+' >> factor              [_val = _1])
+                ;
+        }
+
+        qi::rule<Iterator, int(), ascii::space_type> expression, term, factor;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::calculator<iterator_type> calculator;
+
+    boost::spirit::ascii::space_type space; // Our skipper
+    calculator calc; // Our grammar
+
+    std::string str;
+    int result;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = phrase_parse(iter, end, calc, space, result);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "result = " << result << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \" " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc4.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc4.cpp
new file mode 100644
index 00000000..645926f7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc4.cpp
@@ -0,0 +1,285 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST. The AST,
+//  once created, is traversed, 1) To print its contents and
+//  2) To evaluate the result.
+//
+//  [ JDG April 28, 2008 ]      For BoostCon 2008
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/foreach.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct nil {};
+    struct signed_;
+    struct program;
+
+    typedef boost::variant<
+            nil
+          , unsigned int
+          , boost::recursive_wrapper<signed_>
+          , boost::recursive_wrapper<program>
+        >
+    operand;
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct program
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::signed_,
+    (char, sign)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::operation,
+    (char, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::program,
+    (client::ast::operand, first)
+    (std::list<client::ast::operation>, rest)
+)
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST Printer
+    ///////////////////////////////////////////////////////////////////////////
+    struct printer
+    {
+        typedef void result_type;
+
+        void operator()(nil) const {}
+        void operator()(unsigned int n) const { std::cout << n; }
+
+        void operator()(operation const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': std::cout << " add"; break;
+                case '-': std::cout << " subt"; break;
+                case '*': std::cout << " mult"; break;
+                case '/': std::cout << " div"; break;
+            }
+        }
+
+        void operator()(signed_ const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': std::cout << " neg"; break;
+                case '+': std::cout << " pos"; break;
+            }
+        }
+
+        void operator()(program const& x) const
+        {
+            boost::apply_visitor(*this, x.first);
+            BOOST_FOREACH(operation const& oper, x.rest)
+            {
+                std::cout << ' ';
+                (*this)(oper);
+            }
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST evaluator
+    ///////////////////////////////////////////////////////////////////////////
+    struct eval
+    {
+        typedef int result_type;
+
+        int operator()(nil) const { BOOST_ASSERT(0); return 0; }
+        int operator()(unsigned int n) const { return n; }
+
+        int operator()(operation const& x, int lhs) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': return lhs + rhs;
+                case '-': return lhs - rhs;
+                case '*': return lhs * rhs;
+                case '/': return lhs / rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(signed_ const& x) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': return -rhs;
+                case '+': return +rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(program const& x) const
+        {
+            int state = boost::apply_visitor(*this, x.first);
+            BOOST_FOREACH(operation const& oper, x.rest)
+            {
+                state = (*this)(oper, state);
+            }
+            return state;
+        }
+    };
+}}
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct calculator : qi::grammar<Iterator, ast::program(), ascii::space_type>
+    {
+        calculator() : calculator::base_type(expression)
+        {
+            qi::uint_type uint_;
+            qi::char_type char_;
+
+            expression =
+                term
+                >> *(   (char_('+') >> term)
+                    |   (char_('-') >> term)
+                    )
+                ;
+
+            term =
+                factor
+                >> *(   (char_('*') >> factor)
+                    |   (char_('/') >> factor)
+                    )
+                ;
+
+            factor =
+                    uint_
+                |   '(' >> expression >> ')'
+                |   (char_('-') >> factor)
+                |   (char_('+') >> factor)
+                ;
+        }
+
+        qi::rule<Iterator, ast::program(), ascii::space_type> expression;
+        qi::rule<Iterator, ast::program(), ascii::space_type> term;
+        qi::rule<Iterator, ast::operand(), ascii::space_type> factor;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::calculator<iterator_type> calculator;
+    typedef client::ast::program ast_program;
+    typedef client::ast::printer ast_print;
+    typedef client::ast::eval ast_eval;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        calculator calc;        // Our grammar
+        ast_program program;    // Our program (AST)
+        ast_print print;        // Prints the program
+        ast_eval eval;          // Evaluates the program
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        boost::spirit::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space, program);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            print(program);
+            std::cout << "\nResult: " << eval(program) << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \" " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc5.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc5.cpp
new file mode 100644
index 00000000..8aa71342
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc5.cpp
@@ -0,0 +1,339 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Same as Calc4, this time, we'll incorporate debugging support,
+//  plus error handling and reporting.
+//
+//  [ JDG April 28, 2008 ]      For BoostCon 2008
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Define this to enable debugging
+#define BOOST_SPIRIT_QI_DEBUG
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+//#define BOOST_SPIRIT_QI_DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/foreach.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct nil {};
+    struct signed_;
+    struct program;
+
+    typedef boost::variant<
+            nil
+          , unsigned int
+          , boost::recursive_wrapper<signed_>
+          , boost::recursive_wrapper<program>
+        >
+    operand;
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct program
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    // print function for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil) { out << "nil"; return out; }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::signed_,
+    (char, sign)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::operation,
+    (char, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::program,
+    (client::ast::operand, first)
+    (std::list<client::ast::operation>, rest)
+)
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST Printer
+    ///////////////////////////////////////////////////////////////////////////
+    struct printer
+    {
+        typedef void result_type;
+
+        void operator()(nil) const {}
+        void operator()(unsigned int n) const { std::cout << n; }
+
+        void operator()(operation const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': std::cout << " add"; break;
+                case '-': std::cout << " subt"; break;
+                case '*': std::cout << " mult"; break;
+                case '/': std::cout << " div"; break;
+            }
+        }
+
+        void operator()(signed_ const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': std::cout << " neg"; break;
+                case '+': std::cout << " pos"; break;
+            }
+        }
+
+        void operator()(program const& x) const
+        {
+            boost::apply_visitor(*this, x.first);
+            BOOST_FOREACH(operation const& oper, x.rest)
+            {
+                std::cout << ' ';
+                (*this)(oper);
+            }
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST evaluator
+    ///////////////////////////////////////////////////////////////////////////
+    struct eval
+    {
+        typedef int result_type;
+
+        int operator()(nil) const { BOOST_ASSERT(0); return 0; }
+        int operator()(unsigned int n) const { return n; }
+
+        int operator()(operation const& x, int lhs) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': return lhs + rhs;
+                case '-': return lhs - rhs;
+                case '*': return lhs * rhs;
+                case '/': return lhs / rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(signed_ const& x) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': return -rhs;
+                case '+': return +rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(program const& x) const
+        {
+            int state = boost::apply_visitor(*this, x.first);
+            BOOST_FOREACH(operation const& oper, x.rest)
+            {
+                state = (*this)(oper, state);
+            }
+            return state;
+        }
+    };
+}}
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+    using boost::phoenix::function;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our error handler
+    ///////////////////////////////////////////////////////////////////////////////
+    struct error_handler_
+    {
+        template <typename, typename, typename>
+        struct result { typedef void type; };
+
+        template <typename Iterator>
+        void operator()(
+            qi::info const& what
+          , Iterator err_pos, Iterator last) const
+        {
+            std::cout
+                << "Error! Expecting "
+                << what                         // what failed?
+                << " here: \""
+                << std::string(err_pos, last)   // iterators to error-pos, end
+                << "\""
+                << std::endl
+            ;
+        }
+    };
+
+    function<error_handler_> const error_handler = error_handler_();
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct calculator : qi::grammar<Iterator, ast::program(), ascii::space_type>
+    {
+        calculator() : calculator::base_type(expression)
+        {
+            qi::char_type char_;
+            qi::uint_type uint_;
+            qi::_2_type _2;
+            qi::_3_type _3;
+            qi::_4_type _4;
+
+            using qi::on_error;
+            using qi::fail;
+
+            expression =
+                term
+                >> *(   (char_('+') > term)
+                    |   (char_('-') > term)
+                    )
+                ;
+
+            term =
+                factor
+                >> *(   (char_('*') > factor)
+                    |   (char_('/') > factor)
+                    )
+                ;
+
+            factor =
+                    uint_
+                |   '(' > expression > ')'
+                |   (char_('-') > factor)
+                |   (char_('+') > factor)
+                ;
+
+            // Debugging and error handling and reporting support.
+            BOOST_SPIRIT_DEBUG_NODE(expression);
+            BOOST_SPIRIT_DEBUG_NODE(term);
+            BOOST_SPIRIT_DEBUG_NODE(factor);
+
+            // Error handling
+            on_error<fail>(expression, error_handler(_4, _3, _2));
+        }
+
+        qi::rule<Iterator, ast::program(), ascii::space_type> expression;
+        qi::rule<Iterator, ast::program(), ascii::space_type> term;
+        qi::rule<Iterator, ast::operand(), ascii::space_type> factor;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::calculator<iterator_type> calculator;
+    typedef client::ast::program ast_program;
+    typedef client::ast::printer ast_print;
+    typedef client::ast::eval ast_eval;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        calculator calc;        // Our grammar
+        ast_program program;    // Our program (AST)
+        ast_print print;        // Prints the program
+        ast_eval eval;          // Evaluates the program
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        boost::spirit::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space, program);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            print(program);
+            std::cout << "\nResult: " << eval(program) << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc6.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc6.cpp
new file mode 100644
index 00000000..af362f3d
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc6.cpp
@@ -0,0 +1,373 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Yet another calculator example! This time, we will compile to a simple
+//  virtual machine. This is actually one of the very first Spirit example
+//  circa 2000. Now, it's ported to Spirit2.
+//
+//  [ JDG Sometime 2000 ]       pre-boost
+//  [ JDG September 18, 2002 ]  spirit1
+//  [ JDG April 8, 2007 ]       spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Define this to enable debugging
+//#define BOOST_SPIRIT_QI_DEBUG
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+//#define BOOST_SPIRIT_QI_DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/foreach.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct nil {};
+    struct signed_;
+    struct expression;
+
+    typedef boost::variant<
+            nil
+          , unsigned int
+          , boost::recursive_wrapper<signed_>
+          , boost::recursive_wrapper<expression>
+        >
+    operand;
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct expression
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    // print function for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil) { out << "nil"; return out; }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::signed_,
+    (char, sign)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::operation,
+    (char, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::expression,
+    (client::ast::operand, first)
+    (std::list<client::ast::operation>, rest)
+)
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ///////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,     //  negate the top stack entry
+        op_add,     //  add top two stack entries
+        op_sub,     //  subtract top two stack entries
+        op_mul,     //  multiply top two stack entries
+        op_div,     //  divide top two stack entries
+        op_int,     //  push constant integer into the stack
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+          , stack_ptr(stack.begin())
+        {
+        }
+
+        int top() const { return stack_ptr[-1]; };
+        void execute(std::vector<int> const& code);
+
+    private:
+
+        std::vector<int> stack;
+        std::vector<int>::iterator stack_ptr;
+    };
+
+    void vmachine::execute(std::vector<int> const& code)
+    {
+        std::vector<int>::const_iterator pc = code.begin();
+        stack_ptr = stack.begin();
+
+        while (pc != code.end())
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+            }
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ///////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef void result_type;
+
+        std::vector<int>& code;
+        compiler(std::vector<int>& code)
+          : code(code) {}
+
+        void operator()(ast::nil) const { BOOST_ASSERT(0); }
+        void operator()(unsigned int n) const
+        {
+            code.push_back(op_int);
+            code.push_back(n);
+        }
+
+        void operator()(ast::operation const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': code.push_back(op_add); break;
+                case '-': code.push_back(op_sub); break;
+                case '*': code.push_back(op_mul); break;
+                case '/': code.push_back(op_div); break;
+                default: BOOST_ASSERT(0); break;
+            }
+        }
+
+        void operator()(ast::signed_ const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': code.push_back(op_neg); break;
+                case '+': break;
+                default: BOOST_ASSERT(0); break;
+            }
+        }
+
+        void operator()(ast::expression const& x) const
+        {
+            boost::apply_visitor(*this, x.first);
+            BOOST_FOREACH(ast::operation const& oper, x.rest)
+            {
+                (*this)(oper);
+            }
+        }
+    };
+
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+    using boost::phoenix::function;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The error handler
+    ///////////////////////////////////////////////////////////////////////////////
+    struct error_handler_
+    {
+        template <typename, typename, typename>
+        struct result { typedef void type; };
+
+        template <typename Iterator>
+        void operator()(
+            qi::info const& what
+          , Iterator err_pos, Iterator last) const
+        {
+            std::cout
+                << "Error! Expecting "
+                << what                         // what failed?
+                << " here: \""
+                << std::string(err_pos, last)   // iterators to error-pos, end
+                << "\""
+                << std::endl
+            ;
+        }
+    };
+
+    function<error_handler_> const error_handler = error_handler_();
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct calculator : qi::grammar<Iterator, ast::expression(), ascii::space_type>
+    {
+        calculator() : calculator::base_type(expression)
+        {
+            qi::char_type char_;
+            qi::uint_type uint_;
+            qi::_2_type _2;
+            qi::_3_type _3;
+            qi::_4_type _4;
+
+            using qi::on_error;
+            using qi::fail;
+
+            expression =
+                term
+                >> *(   (char_('+') > term)
+                    |   (char_('-') > term)
+                    )
+                ;
+
+            term =
+                factor
+                >> *(   (char_('*') > factor)
+                    |   (char_('/') > factor)
+                    )
+                ;
+
+            factor =
+                    uint_
+                |   '(' > expression > ')'
+                |   (char_('-') > factor)
+                |   (char_('+') > factor)
+                ;
+
+            // Debugging and error handling and reporting support.
+            BOOST_SPIRIT_DEBUG_NODES(
+                (expression)(term)(factor));
+
+            // Error handling
+            on_error<fail>(expression, error_handler(_4, _3, _2));
+        }
+
+        qi::rule<Iterator, ast::expression(), ascii::space_type> expression;
+        qi::rule<Iterator, ast::expression(), ascii::space_type> term;
+        qi::rule<Iterator, ast::operand(), ascii::space_type> factor;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::calculator<iterator_type> calculator;
+    typedef client::ast::expression ast_expression;
+    typedef client::compiler compiler;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        client::vmachine mach;      // Our virtual machine
+        std::vector<int> code;      // Our VM code
+        calculator calc;            // Our grammar
+        ast_expression expression;  // Our program (AST)
+        compiler compile(code);     // Compiles the program
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        boost::spirit::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space, expression);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            compile(expression);
+            mach.execute(code);
+            std::cout << "\nResult: " << mach.top() << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/annotation.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/annotation.hpp
new file mode 100644
index 00000000..37365283
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/annotation.hpp
@@ -0,0 +1,78 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC7_ANNOTATION_HPP)
+#define BOOST_SPIRIT_CALC7_ANNOTATION_HPP
+
+#include <map>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/bool.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The annotation handler links the AST to a map of iterator positions
+    //  for the purpose of subsequent semantic error handling when the
+    //  program is being compiled.
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct annotation
+    {
+        template <typename, typename>
+        struct result { typedef void type; };
+
+        std::vector<Iterator>& iters;
+        annotation(std::vector<Iterator>& iters)
+          : iters(iters) {}
+
+        struct set_id
+        {
+            typedef void result_type;
+
+            int id;
+            set_id(int id) : id(id) {}
+
+            template <typename T>
+            void operator()(T& x) const
+            {
+                this->dispatch(x, boost::is_base_of<ast::tagged, T>());
+            }
+
+            // This will catch all nodes except those inheriting from ast::tagged
+            template <typename T>
+            void dispatch(T& x, boost::mpl::false_) const
+            {
+                // (no-op) no need for tags
+            }
+
+            // This will catch all nodes inheriting from ast::tagged
+            template <typename T>
+            void dispatch(T& x, boost::mpl::true_) const
+            {
+                x.id = id;
+            }
+        };
+
+        void operator()(ast::operand& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            boost::apply_visitor(set_id(id), ast);
+        }
+
+        void operator()(ast::assignment& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/ast.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/ast.hpp
new file mode 100644
index 00000000..82fba496
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/ast.hpp
@@ -0,0 +1,117 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC7_AST_HPP)
+#define BOOST_SPIRIT_CALC7_AST_HPP
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <list>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct tagged
+    {
+        int id; // Used to annotate the AST with the iterator position.
+                // This id is used as a key to a map<int, Iterator>
+                // (not really part of the AST.)
+    };
+
+    struct nil {};
+    struct signed_;
+    struct expression;
+
+    struct variable : tagged
+    {
+        variable(std::string const& name = "") : name(name) {}
+        std::string name;
+    };
+
+    typedef boost::variant<
+            nil
+          , unsigned int
+          , variable
+          , boost::recursive_wrapper<signed_>
+          , boost::recursive_wrapper<expression>
+        >
+    operand;
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct expression
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    struct assignment
+    {
+        variable lhs;
+        expression rhs;
+    };
+
+    struct variable_declaration
+    {
+        assignment assign;
+    };
+
+    typedef boost::variant<
+            variable_declaration
+          , assignment>
+    statement;
+
+    typedef std::list<statement> statement_list;
+
+    // print functions for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil) { out << "nil"; return out; }
+    inline std::ostream& operator<<(std::ostream& out, variable const& var) { out << var.name; return out; }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::signed_,
+    (char, sign)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::operation,
+    (char, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::expression,
+    (client::ast::operand, first)
+    (std::list<client::ast::operation>, rest)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::variable_declaration,
+    (client::ast::assignment, assign)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::assignment,
+    (client::ast::variable, lhs)
+    (client::ast::expression, rhs)
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.cpp
new file mode 100644
index 00000000..8aa23017
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.cpp
@@ -0,0 +1,222 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "compiler.hpp"
+#include "vm.hpp"
+#include <boost/foreach.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/assert.hpp>
+
+namespace client { namespace code_gen
+{
+    void program::op(int a)
+    {
+        code.push_back(a);
+    }
+
+    void program::op(int a, int b)
+    {
+        code.push_back(a);
+        code.push_back(b);
+    }
+
+    void program::op(int a, int b, int c)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        code.push_back(c);
+    }
+
+    int const* program::find_var(std::string const& name) const
+    {
+        std::map<std::string, int>::const_iterator i = variables.find(name);
+        if (i == variables.end())
+            return 0;
+        return &i->second;
+    }
+
+    void program::add_var(std::string const& name)
+    {
+        std::size_t n = variables.size();
+        variables[name] = n;
+    }
+
+    void program::print_variables(std::vector<int> const& stack) const
+    {
+        typedef std::pair<std::string, int> pair;
+        BOOST_FOREACH(pair const& p, variables)
+        {
+            std::cout << "    " << p.first << ": " << stack[p.second] << std::endl;
+        }
+    }
+
+    void program::print_assembler() const
+    {
+        std::vector<int>::const_iterator pc = code.begin();
+
+        std::vector<std::string> locals(variables.size());
+        typedef std::pair<std::string, int> pair;
+        BOOST_FOREACH(pair const& p, variables)
+        {
+            locals[p.second] = p.first;
+            std::cout << "local       "
+                << p.first << ", @" << p.second << std::endl;
+        }
+
+        while (pc != code.end())
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    std::cout << "op_neg" << std::endl;
+                    break;
+
+                case op_add:
+                    std::cout << "op_add" << std::endl;
+                    break;
+
+                case op_sub:
+                    std::cout << "op_sub" << std::endl;
+                    break;
+
+                case op_mul:
+                    std::cout << "op_mul" << std::endl;
+                    break;
+
+                case op_div:
+                    std::cout << "op_div" << std::endl;
+                    break;
+
+                case op_load:
+                    std::cout << "op_load     " << locals[*pc++] << std::endl;
+                    break;
+
+                case op_store:
+                    std::cout << "op_store    " << locals[*pc++] << std::endl;
+                    break;
+
+                case op_int:
+                    std::cout << "op_int      " << *pc++ << std::endl;
+                    break;
+
+                case op_stk_adj:
+                    std::cout << "op_stk_adj  " << *pc++ << std::endl;
+                    break;
+            }
+        }
+    }
+
+    bool compiler::operator()(unsigned int x) const
+    {
+        program.op(op_int, x);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable const& x) const
+    {
+        int const* p = program.find_var(x.name);
+        if (p == 0)
+        {
+            std::cout << x.id << std::endl;
+            error_handler(x.id, "Undeclared variable: " + x.name);
+            return false;
+        }
+        program.op(op_load, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::operation const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case '+': program.op(op_add); break;
+            case '-': program.op(op_sub); break;
+            case '*': program.op(op_mul); break;
+            case '/': program.op(op_div); break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::signed_ const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.sign)
+        {
+            case '-': program.op(op_neg); break;
+            case '+': break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::expression const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.first))
+            return false;
+        BOOST_FOREACH(ast::operation const& oper, x.rest)
+        {
+            if (!(*this)(oper))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::assignment const& x) const
+    {
+        if (!(*this)(x.rhs))
+            return false;
+        int const* p = program.find_var(x.lhs.name);
+        if (p == 0)
+        {
+            std::cout << x.lhs.id << std::endl;
+            error_handler(x.lhs.id, "Undeclared variable: " + x.lhs.name);
+            return false;
+        }
+        program.op(op_store, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable_declaration const& x) const
+    {
+        int const* p = program.find_var(x.assign.lhs.name);
+        if (p != 0)
+        {
+            std::cout << x.assign.lhs.id << std::endl;
+            error_handler(x.assign.lhs.id, "Duplicate variable: " + x.assign.lhs.name);
+            return false;
+        }
+        bool r = (*this)(x.assign.rhs);
+        if (r) // don't add the variable if the RHS fails
+        {
+            program.add_var(x.assign.lhs.name);
+            program.op(op_store, *program.find_var(x.assign.lhs.name));
+        }
+        return r;
+    }
+
+    bool compiler::operator()(ast::statement_list const& x) const
+    {
+        program.clear();
+
+        // op_stk_adj 0 for now. we'll know how many variables we'll have later
+        program.op(op_stk_adj, 0);
+        BOOST_FOREACH(ast::statement const& s, x)
+        {
+            if (!boost::apply_visitor(*this, s))
+            {
+                program.clear();
+                return false;
+            }
+        }
+        program[1] = program.nvars(); // now store the actual number of variables
+        return true;
+    }
+}}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.hpp
new file mode 100644
index 00000000..179a315a
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/compiler.hpp
@@ -0,0 +1,85 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC7_COMPILER_HPP)
+#define BOOST_SPIRIT_CALC7_COMPILER_HPP
+
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+#include <map>
+#include <boost/function.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+namespace client { namespace code_gen
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Program
+    ///////////////////////////////////////////////////////////////////////////
+    struct program
+    {
+        void op(int a);
+        void op(int a, int b);
+        void op(int a, int b, int c);
+
+        int& operator[](std::size_t i) { return code[i]; }
+        int const& operator[](std::size_t i) const { return code[i]; }
+        void clear() { code.clear(); variables.clear(); }
+        std::vector<int> const& operator()() const { return code; }
+
+        int nvars() const { return variables.size(); }
+        int const* find_var(std::string const& name) const;
+        void add_var(std::string const& name);
+
+        void print_variables(std::vector<int> const& stack) const;
+        void print_assembler() const;
+
+    private:
+
+        std::map<std::string, int> variables;
+        std::vector<int> code;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ///////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef bool result_type;
+
+        template <typename ErrorHandler>
+        compiler(client::code_gen::program& program, ErrorHandler& error_handler_)
+          : program(program)
+        {
+            using namespace boost::phoenix::arg_names;
+            namespace phx = boost::phoenix;
+            using boost::phoenix::function;
+
+            error_handler = function<ErrorHandler>(error_handler_)(
+                "Error! ", _2, phx::cref(error_handler_.iters)[_1]);
+        }
+
+        bool operator()(ast::nil) const { BOOST_ASSERT(0); return false; }
+        bool operator()(unsigned int x) const;
+        bool operator()(ast::variable const& x) const;
+        bool operator()(ast::operation const& x) const;
+        bool operator()(ast::signed_ const& x) const;
+        bool operator()(ast::expression const& x) const;
+        bool operator()(ast::assignment const& x) const;
+        bool operator()(ast::variable_declaration const& x) const;
+        bool operator()(ast::statement_list const& x) const;
+
+        client::code_gen::program& program;
+
+        boost::function<
+            void(int tag, std::string const& what)>
+        error_handler;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/error_handler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/error_handler.hpp
new file mode 100644
index 00000000..867e9ee7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/error_handler.hpp
@@ -0,0 +1,93 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC7_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_CALC7_ERROR_HANDLER_HPP
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The error handler
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct error_handler
+    {
+        template <typename, typename, typename>
+        struct result { typedef void type; };
+
+        error_handler(Iterator first, Iterator last)
+          : first(first), last(last) {}
+
+        template <typename Message, typename What>
+        void operator()(
+            Message const& message,
+            What const& what,
+            Iterator err_pos) const
+        {
+            int line;
+            Iterator line_start = get_pos(err_pos, line);
+            if (err_pos != last)
+            {
+                std::cout << message << what << " line " << line << ':' << std::endl;
+                std::cout << get_line(line_start) << std::endl;
+                for (; line_start != err_pos; ++line_start)
+                    std::cout << ' ';
+                std::cout << '^' << std::endl;
+            }
+            else
+            {
+                std::cout << "Unexpected end of file. ";
+                std::cout << message << what << " line " << line << std::endl;
+            }
+        }
+
+        Iterator get_pos(Iterator err_pos, int& line) const
+        {
+            line = 1;
+            Iterator i = first;
+            Iterator line_start = first;
+            while (i != err_pos)
+            {
+                bool eol = false;
+                if (i != err_pos && *i == '\r') // CR
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (i != err_pos && *i == '\n') // LF
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (eol)
+                    ++line;
+                else
+                    ++i;
+            }
+            return line_start;
+        }
+
+        std::string get_line(Iterator err_pos) const
+        {
+            Iterator i = err_pos;
+            // position i to the next EOL
+            while (i != last && (*i != '\r' && *i != '\n'))
+                ++i;
+            return std::string(err_pos, i);
+        }
+
+        Iterator first;
+        Iterator last;
+        std::vector<Iterator> iters;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/expression.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/expression.cpp
new file mode 100644
index 00000000..32f44adc
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/expression.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "expression_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::expression<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/expression.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/expression.hpp
new file mode 100644
index 00000000..916e26e7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/expression.hpp
@@ -0,0 +1,53 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC7_EXPRESSION_HPP)
+#define BOOST_SPIRIT_CALC7_EXPRESSION_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+// #define BOOST_SPIRIT_QI_DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/spirit/include/qi.hpp>
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+
+namespace client { namespace parser
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The expression grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct expression : qi::grammar<Iterator, ast::expression(), ascii::space_type>
+    {
+        expression(error_handler<Iterator>& error_handler);
+
+        qi::rule<Iterator, ast::expression(), ascii::space_type> expr;
+        qi::rule<Iterator, ast::expression(), ascii::space_type> additive_expr;
+        qi::rule<Iterator, ast::expression(), ascii::space_type> multiplicative_expr;
+        qi::rule<Iterator, ast::operand(), ascii::space_type> unary_expr;
+        qi::rule<Iterator, ast::operand(), ascii::space_type> primary_expr;
+        qi::rule<Iterator, std::string(), ascii::space_type> identifier;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/expression_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/expression_def.hpp
new file mode 100644
index 00000000..2770677c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/expression_def.hpp
@@ -0,0 +1,94 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "expression.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+#include <boost/spirit/include/phoenix_function.hpp>
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    expression<Iterator>::expression(error_handler<Iterator>& error_handler)
+      : expression::base_type(expr)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::char_type char_;
+        qi::uint_type uint_;
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        expr =
+            additive_expr.alias()
+            ;
+
+        additive_expr =
+            multiplicative_expr
+            >> *(   (char_('+') > multiplicative_expr)
+                |   (char_('-') > multiplicative_expr)
+                )
+            ;
+
+        multiplicative_expr =
+            unary_expr
+            >> *(   (char_('*') > unary_expr)
+                |   (char_('/') > unary_expr)
+                )
+            ;
+
+        unary_expr =
+                primary_expr
+            |   (char_('-') > primary_expr)
+            |   (char_('+') > primary_expr)
+            ;
+
+        primary_expr =
+                uint_
+            |   identifier
+            |   '(' > expr > ')'
+            ;
+
+        identifier =
+            raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (expr)
+            (additive_expr)
+            (multiplicative_expr)
+            (unary_expr)
+            (primary_expr)
+            (identifier)
+        );
+
+        // Error handling: on error in expr, call error_handler.
+        on_error<fail>(expr,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in primary_expr, call annotation.
+        on_success(primary_expr,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/main.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/main.cpp
new file mode 100644
index 00000000..4e139eb2
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/main.cpp
@@ -0,0 +1,101 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Now we'll introduce variables and assignment. This time, we'll also
+//  be renaming some of the rules -- a strategy for a grander scheme
+//  to come ;-)
+//
+//  This version also shows off grammar modularization. Here you will
+//  see how expressions and statements are built as modular grammars.
+//
+//  [ JDG April 9, 2007 ]       spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "statement.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Statement parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type some statements... ";
+    std::cout << "An empty line ends input, compiles, runs and prints results\n\n";
+    std::cout << "Example:\n\n";
+    std::cout << "    var a = 123;\n";
+    std::cout << "    var b = 456;\n";
+    std::cout << "    var c = a + b * 2;\n\n";
+    std::cout << "-------------------------\n";
+
+    std::string str;
+    std::string source;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty())
+            break;
+        source += str + '\n';
+    }
+
+    typedef std::string::const_iterator iterator_type;
+    iterator_type iter = source.begin();
+    iterator_type end = source.end();
+
+    client::vmachine vm;                                    // Our virtual machine
+    client::code_gen::program program;                      // Our VM program
+    client::ast::statement_list ast;                        // Our AST
+
+    client::error_handler<iterator_type>
+        error_handler(iter, end);                           // Our error handler
+    client::parser::statement<iterator_type>
+        parser(error_handler);                              // Our parser
+    client::code_gen::compiler
+        compile(program, error_handler);                    // Our compiler
+
+    boost::spirit::ascii::space_type space;
+    bool success = phrase_parse(iter, end, parser, space, ast);
+
+    std::cout << "-------------------------\n";
+
+    if (success && iter == end)
+    {
+        if (compile(ast))
+        {
+            std::cout << "Success\n";
+            std::cout << "-------------------------\n";
+            vm.execute(program());
+
+            std::cout << "-------------------------\n";
+            std::cout << "Assembler----------------\n\n";
+            program.print_assembler();
+
+            std::cout << "-------------------------\n";
+            std::cout << "Results------------------\n\n";
+            program.print_variables(vm.get_stack());
+        }
+        else
+        {
+            std::cout << "Compile failure\n";
+        }
+    }
+    else
+    {
+        std::cout << "Parse failure\n";
+    }
+
+    std::cout << "-------------------------\n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/statement.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/statement.cpp
new file mode 100644
index 00000000..54bc9ac3
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/statement.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "statement_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::statement<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/statement.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/statement.hpp
new file mode 100644
index 00000000..12baf38f
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/statement.hpp
@@ -0,0 +1,32 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC7_STATEMENT_HPP)
+#define BOOST_SPIRIT_CALC7_STATEMENT_HPP
+
+#include "expression.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The statement grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct statement : qi::grammar<Iterator, ast::statement_list(), ascii::space_type>
+    {
+        statement(error_handler<Iterator>& error_handler);
+
+        expression<Iterator> expr;
+        qi::rule<Iterator, ast::statement_list(), ascii::space_type> statement_list;
+        qi::rule<Iterator, ast::variable_declaration(), ascii::space_type> variable_declaration;
+        qi::rule<Iterator, ast::assignment(), ascii::space_type> assignment;
+        qi::rule<Iterator, std::string(), ascii::space_type> identifier;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/statement_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/statement_def.hpp
new file mode 100644
index 00000000..408a2368
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/statement_def.hpp
@@ -0,0 +1,75 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "statement.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    statement<Iterator>::statement(error_handler<Iterator>& error_handler)
+      : statement::base_type(statement_list), expr(error_handler)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        statement_list =
+            +(variable_declaration | assignment)
+            ;
+
+        identifier =
+            raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        variable_declaration =
+                lexeme["var" >> !(alnum | '_')] // make sure we have whole words
+            >   assignment
+            ;
+
+        assignment =
+                identifier
+            >   '='
+            >   expr
+            >   ';'
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (statement_list)
+            (identifier)
+            (variable_declaration)
+            (assignment)
+        );
+
+        // Error handling: on error in statement_list, call error_handler.
+        on_error<fail>(statement_list,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in assignment, call annotation.
+        on_success(assignment,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/vm.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/vm.cpp
new file mode 100644
index 00000000..c481f2b7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/vm.cpp
@@ -0,0 +1,66 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "vm.hpp"
+
+namespace client
+{
+    void vmachine::execute(std::vector<int> const& code)
+    {
+        std::vector<int>::const_iterator pc = code.begin();
+        std::vector<int>::iterator locals = stack.begin();
+        stack_ptr = stack.begin();
+
+        while (pc != code.end())
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_load:
+                    *stack_ptr++ = locals[*pc++];
+                    break;
+
+                case op_store:
+                    --stack_ptr;
+                    locals[*pc++] = stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+
+                case op_stk_adj:
+                    stack_ptr = stack.begin() + *pc++;
+                    break;
+            }
+        }
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/vm.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/vm.hpp
new file mode 100644
index 00000000..853aa9c7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc7/vm.hpp
@@ -0,0 +1,52 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC7_VM_HPP)
+#define BOOST_SPIRIT_CALC7_VM_HPP
+
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ///////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,     //  negate the top stack entry
+        op_add,     //  add top two stack entries
+        op_sub,     //  subtract top two stack entries
+        op_mul,     //  multiply top two stack entries
+        op_div,     //  divide top two stack entries
+
+        op_load,    //  load a variable
+        op_store,   //  store a variable
+        op_int,     //  push constant integer into the stack
+        op_stk_adj  //  adjust the stack for local variables
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+          , stack_ptr(stack.begin())
+        {
+        }
+
+        void execute(std::vector<int> const& code);
+        std::vector<int> const& get_stack() const { return stack; };
+
+    private:
+
+        std::vector<int> stack;
+        std::vector<int>::iterator stack_ptr;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/annotation.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/annotation.hpp
new file mode 100644
index 00000000..8cd00973
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/annotation.hpp
@@ -0,0 +1,78 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_ANNOTATION_HPP)
+#define BOOST_SPIRIT_CALC8_ANNOTATION_HPP
+
+#include <map>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/bool.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The annotation handler links the AST to a map of iterator positions
+    //  for the purpose of subsequent semantic error handling when the
+    //  program is being compiled.
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct annotation
+    {
+        template <typename, typename>
+        struct result { typedef void type; };
+
+        std::vector<Iterator>& iters;
+        annotation(std::vector<Iterator>& iters)
+          : iters(iters) {}
+
+        struct set_id
+        {
+            typedef void result_type;
+
+            int id;
+            set_id(int id) : id(id) {}
+
+            template <typename T>
+            void operator()(T& x) const
+            {
+                this->dispatch(x, boost::is_base_of<ast::tagged, T>());
+            }
+
+            // This will catch all nodes except those inheriting from ast::tagged
+            template <typename T>
+            void dispatch(T& x, boost::mpl::false_) const
+            {
+                // (no-op) no need for tags
+            }
+
+            // This will catch all nodes inheriting from ast::tagged
+            template <typename T>
+            void dispatch(T& x, boost::mpl::true_) const
+            {
+                x.id = id;
+            }
+        };
+
+        void operator()(ast::operand& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            boost::apply_visitor(set_id(id), ast);
+        }
+
+        void operator()(ast::assignment& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/ast.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/ast.hpp
new file mode 100644
index 00000000..3e6e2d79
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/ast.hpp
@@ -0,0 +1,172 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_AST_HPP)
+#define BOOST_SPIRIT_CALC8_AST_HPP
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <boost/optional.hpp>
+#include <list>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct tagged
+    {
+        int id; // Used to annotate the AST with the iterator position.
+                // This id is used as a key to a map<int, Iterator>
+                // (not really part of the AST.)
+    };
+
+    struct nil {};
+    struct unary;
+    struct expression;
+
+    struct variable : tagged
+    {
+        variable(std::string const& name = "") : name(name) {}
+        std::string name;
+    };
+
+    typedef boost::variant<
+            nil
+          , bool
+          , unsigned int
+          , variable
+          , boost::recursive_wrapper<unary>
+          , boost::recursive_wrapper<expression>
+        >
+    operand;
+
+    enum optoken
+    {
+        op_plus,
+        op_minus,
+        op_times,
+        op_divide,
+        op_positive,
+        op_negative,
+        op_not,
+        op_equal,
+        op_not_equal,
+        op_less,
+        op_less_equal,
+        op_greater,
+        op_greater_equal,
+        op_and,
+        op_or
+    };
+
+    struct unary
+    {
+        optoken operator_;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        optoken operator_;
+        operand operand_;
+    };
+
+    struct expression
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    struct assignment
+    {
+        variable lhs;
+        expression rhs;
+    };
+
+    struct variable_declaration
+    {
+        assignment assign;
+    };
+
+    struct if_statement;
+    struct while_statement;
+    struct statement_list;
+
+    typedef boost::variant<
+            variable_declaration
+          , assignment
+          , boost::recursive_wrapper<if_statement>
+          , boost::recursive_wrapper<while_statement>
+          , boost::recursive_wrapper<statement_list>
+        >
+    statement;
+
+    struct statement_list : std::list<statement> {};
+
+    struct if_statement
+    {
+        expression condition;
+        statement then;
+        boost::optional<statement> else_;
+    };
+
+    struct while_statement
+    {
+        expression condition;
+        statement body;
+    };
+
+    // print functions for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil) { out << "nil"; return out; }
+    inline std::ostream& operator<<(std::ostream& out, variable const& var) { out << var.name; return out; }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::unary,
+    (client::ast::optoken, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::operation,
+    (client::ast::optoken, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::expression,
+    (client::ast::operand, first)
+    (std::list<client::ast::operation>, rest)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::variable_declaration,
+    (client::ast::assignment, assign)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::assignment,
+    (client::ast::variable, lhs)
+    (client::ast::expression, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::if_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, then)
+    (boost::optional<client::ast::statement>, else_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::while_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, body)
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.cpp
new file mode 100644
index 00000000..2d8b3eb1
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.cpp
@@ -0,0 +1,382 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "compiler.hpp"
+#include "vm.hpp"
+#include <boost/foreach.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/assert.hpp>
+#include <boost/lexical_cast.hpp>
+#include <set>
+
+namespace client { namespace code_gen
+{
+    void program::op(int a)
+    {
+        code.push_back(a);
+    }
+
+    void program::op(int a, int b)
+    {
+        code.push_back(a);
+        code.push_back(b);
+    }
+
+    void program::op(int a, int b, int c)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        code.push_back(c);
+    }
+
+    int const* program::find_var(std::string const& name) const
+    {
+        std::map<std::string, int>::const_iterator i = variables.find(name);
+        if (i == variables.end())
+            return 0;
+        return &i->second;
+    }
+
+    void program::add_var(std::string const& name)
+    {
+        std::size_t n = variables.size();
+        variables[name] = n;
+    }
+
+    void program::print_variables(std::vector<int> const& stack) const
+    {
+        typedef std::pair<std::string, int> pair;
+        BOOST_FOREACH(pair const& p, variables)
+        {
+            std::cout << "    " << p.first << ": " << stack[p.second] << std::endl;
+        }
+    }
+
+    void program::print_assembler() const
+    {
+        std::vector<int>::const_iterator pc = code.begin();
+
+        std::vector<std::string> locals(variables.size());
+        typedef std::pair<std::string, int> pair;
+        BOOST_FOREACH(pair const& p, variables)
+        {
+            locals[p.second] = p.first;
+            std::cout << "      local       "
+                << p.first << ", @" << p.second << std::endl;
+        }
+
+        std::map<std::size_t, std::string> lines;
+        std::set<std::size_t> jumps;
+
+        while (pc != code.end())
+        {
+            std::string line;
+            std::size_t address = pc - code.begin();
+
+            switch (*pc++)
+            {
+                case op_neg:
+                    line += "      op_neg";
+                    break;
+
+                case op_not:
+                    line += "      op_not";
+                    break;
+
+                case op_add:
+                    line += "      op_add";
+                    break;
+
+                case op_sub:
+                    line += "      op_sub";
+                    break;
+
+                case op_mul:
+                    line += "      op_mul";
+                    break;
+
+                case op_div:
+                    line += "      op_div";
+                    break;
+
+                case op_eq:
+                    line += "      op_eq";
+                    break;
+
+                case op_neq:
+                    line += "      op_neq";
+                    break;
+
+                case op_lt:
+                    line += "      op_lt";
+                    break;
+
+                case op_lte:
+                    line += "      op_lte";
+                    break;
+
+                case op_gt:
+                    line += "      op_gt";
+                    break;
+
+                case op_gte:
+                    line += "      op_gte";
+                    break;
+
+                case op_and:
+                    line += "      op_and";
+                    break;
+
+                case op_or:
+                    line += "      op_or";
+                    break;
+
+                case op_load:
+                    line += "      op_load     ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_store:
+                    line += "      op_store    ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_int:
+                    line += "      op_int      ";
+                    line += boost::lexical_cast<std::string>(*pc++);
+                    break;
+
+                case op_true:
+                    line += "      op_true";
+                    break;
+
+                case op_false:
+                    line += "      op_false";
+                    break;
+
+                case op_jump:
+                    {
+                        line += "      op_jump     ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += boost::lexical_cast<std::string>(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_jump_if:
+                    {
+                        line += "      op_jump_if  ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += boost::lexical_cast<std::string>(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_stk_adj:
+                    line += "      op_stk_adj  ";
+                    line += boost::lexical_cast<std::string>(*pc++);
+                    break;
+            }
+            lines[address] = line;
+        }
+
+        std::cout << "start:" << std::endl;
+        typedef std::pair<std::size_t, std::string> line_info;
+        BOOST_FOREACH(line_info const& l, lines)
+        {
+            std::size_t pos = l.first;
+            if (jumps.find(pos) != jumps.end())
+                std::cout << pos << ':' << std::endl;
+            std::cout << l.second << std::endl;
+        }
+
+        std::cout << "end:" << std::endl;
+    }
+
+    bool compiler::operator()(unsigned int x) const
+    {
+        program.op(op_int, x);
+        return true;
+    }
+
+    bool compiler::operator()(bool x) const
+    {
+        program.op(x ? op_true : op_false);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable const& x) const
+    {
+        int const* p = program.find_var(x.name);
+        if (p == 0)
+        {
+            std::cout << x.id << std::endl;
+            error_handler(x.id, "Undeclared variable: " + x.name);
+            return false;
+        }
+        program.op(op_load, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::operation const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case ast::op_plus: program.op(op_add); break;
+            case ast::op_minus: program.op(op_sub); break;
+            case ast::op_times: program.op(op_mul); break;
+            case ast::op_divide: program.op(op_div); break;
+
+            case ast::op_equal: program.op(op_eq); break;
+            case ast::op_not_equal: program.op(op_neq); break;
+            case ast::op_less: program.op(op_lt); break;
+            case ast::op_less_equal: program.op(op_lte); break;
+            case ast::op_greater: program.op(op_gt); break;
+            case ast::op_greater_equal: program.op(op_gte); break;
+
+            case ast::op_and: program.op(op_and); break;
+            case ast::op_or: program.op(op_or); break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::unary const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case ast::op_negative: program.op(op_neg); break;
+            case ast::op_not: program.op(op_not); break;
+            case ast::op_positive: break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::expression const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.first))
+            return false;
+        BOOST_FOREACH(ast::operation const& oper, x.rest)
+        {
+            if (!(*this)(oper))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::assignment const& x) const
+    {
+        if (!(*this)(x.rhs))
+            return false;
+        int const* p = program.find_var(x.lhs.name);
+        if (p == 0)
+        {
+            std::cout << x.lhs.id << std::endl;
+            error_handler(x.lhs.id, "Undeclared variable: " + x.lhs.name);
+            return false;
+        }
+        program.op(op_store, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable_declaration const& x) const
+    {
+        int const* p = program.find_var(x.assign.lhs.name);
+        if (p != 0)
+        {
+            std::cout << x.assign.lhs.id << std::endl;
+            error_handler(x.assign.lhs.id, "Duplicate variable: " + x.assign.lhs.name);
+            return false;
+        }
+        bool r = (*this)(x.assign.rhs);
+        if (r) // don't add the variable if the RHS fails
+        {
+            program.add_var(x.assign.lhs.name);
+            program.op(op_store, *program.find_var(x.assign.lhs.name));
+        }
+        return r;
+    }
+
+    bool compiler::operator()(ast::statement const& x) const
+    {
+        return boost::apply_visitor(*this, x);
+    }
+
+    bool compiler::operator()(ast::statement_list const& x) const
+    {
+        BOOST_FOREACH(ast::statement const& s, x)
+        {
+            if (!(*this)(s))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::if_statement const& x) const
+    {
+        if (!(*this)(x.condition))
+            return false;
+        program.op(op_jump_if, 0);                  // we shall fill this (0) in later
+        std::size_t skip = program.size()-1;        // mark its position
+        if (!(*this)(x.then))
+            return false;
+        program[skip] = program.size()-skip;        // now we know where to jump to (after the if branch)
+
+        if (x.else_)                                // We got an alse
+        {
+            program[skip] += 2;                     // adjust for the "else" jump
+            program.op(op_jump, 0);                 // we shall fill this (0) in later
+            std::size_t exit = program.size()-1;    // mark its position
+            if (!(*this)(*x.else_))
+                return false;
+            program[exit] = program.size()-exit;    // now we know where to jump to (after the else branch)
+        }
+
+        return true;
+    }
+
+    bool compiler::operator()(ast::while_statement const& x) const
+    {
+        std::size_t loop = program.size();          // mark our position
+        if (!(*this)(x.condition))
+            return false;
+        program.op(op_jump_if, 0);                  // we shall fill this (0) in later
+        std::size_t exit = program.size()-1;        // mark its position
+        if (!(*this)(x.body))
+            return false;
+        program.op(op_jump,
+            int(loop-1) - int(program.size()));     // loop back
+        program[exit] = program.size()-exit;        // now we know where to jump to (to exit the loop)
+        return true;
+    }
+
+    bool compiler::start(ast::statement_list const& x) const
+    {
+        program.clear();
+        // op_stk_adj 0 for now. we'll know how many variables we'll have later
+        program.op(op_stk_adj, 0);
+
+        if (!(*this)(x))
+        {
+            program.clear();
+            return false;
+        }
+        program[1] = program.nvars(); // now store the actual number of variables
+        return true;
+    }
+}}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.hpp
new file mode 100644
index 00000000..915a87d0
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/compiler.hpp
@@ -0,0 +1,92 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_COMPILER_HPP)
+#define BOOST_SPIRIT_CALC8_COMPILER_HPP
+
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+#include <map>
+#include <boost/function.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+namespace client { namespace code_gen
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Program
+    ///////////////////////////////////////////////////////////////////////////
+    struct program
+    {
+        void op(int a);
+        void op(int a, int b);
+        void op(int a, int b, int c);
+
+        int& operator[](std::size_t i) { return code[i]; }
+        int const& operator[](std::size_t i) const { return code[i]; }
+        void clear() { code.clear(); variables.clear(); }
+        std::size_t size() const { return code.size(); }
+        std::vector<int> const& operator()() const { return code; }
+
+        int nvars() const { return variables.size(); }
+        int const* find_var(std::string const& name) const;
+        void add_var(std::string const& name);
+
+        void print_variables(std::vector<int> const& stack) const;
+        void print_assembler() const;
+
+    private:
+
+        std::map<std::string, int> variables;
+        std::vector<int> code;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ///////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef bool result_type;
+
+        template <typename ErrorHandler>
+        compiler(client::code_gen::program& program, ErrorHandler& error_handler_)
+          : program(program)
+        {
+            using namespace boost::phoenix::arg_names;
+            namespace phx = boost::phoenix;
+            using boost::phoenix::function;
+
+            error_handler = function<ErrorHandler>(error_handler_)(
+                "Error! ", _2, phx::cref(error_handler_.iters)[_1]);
+        }
+
+        bool operator()(ast::nil) const { BOOST_ASSERT(0); return false; }
+        bool operator()(unsigned int x) const;
+        bool operator()(bool x) const;
+        bool operator()(ast::variable const& x) const;
+        bool operator()(ast::operation const& x) const;
+        bool operator()(ast::unary const& x) const;
+        bool operator()(ast::expression const& x) const;
+        bool operator()(ast::assignment const& x) const;
+        bool operator()(ast::variable_declaration const& x) const;
+        bool operator()(ast::statement_list const& x) const;
+        bool operator()(ast::statement const& x) const;
+        bool operator()(ast::if_statement const& x) const;
+        bool operator()(ast::while_statement const& x) const;
+
+        bool start(ast::statement_list const& x) const;
+
+        client::code_gen::program& program;
+
+        boost::function<
+            void(int tag, std::string const& what)>
+        error_handler;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/error_handler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/error_handler.hpp
new file mode 100644
index 00000000..0cc42ca9
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/error_handler.hpp
@@ -0,0 +1,93 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_CALC8_ERROR_HANDLER_HPP
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The error handler
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct error_handler
+    {
+        template <typename, typename, typename>
+        struct result { typedef void type; };
+
+        error_handler(Iterator first, Iterator last)
+          : first(first), last(last) {}
+
+        template <typename Message, typename What>
+        void operator()(
+            Message const& message,
+            What const& what,
+            Iterator err_pos) const
+        {
+            int line;
+            Iterator line_start = get_pos(err_pos, line);
+            if (err_pos != last)
+            {
+                std::cout << message << what << " line " << line << ':' << std::endl;
+                std::cout << get_line(line_start) << std::endl;
+                for (; line_start != err_pos; ++line_start)
+                    std::cout << ' ';
+                std::cout << '^' << std::endl;
+            }
+            else
+            {
+                std::cout << "Unexpected end of file. ";
+                std::cout << message << what << " line " << line << std::endl;
+            }
+        }
+
+        Iterator get_pos(Iterator err_pos, int& line) const
+        {
+            line = 1;
+            Iterator i = first;
+            Iterator line_start = first;
+            while (i != err_pos)
+            {
+                bool eol = false;
+                if (i != err_pos && *i == '\r') // CR
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (i != err_pos && *i == '\n') // LF
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (eol)
+                    ++line;
+                else
+                    ++i;
+            }
+            return line_start;
+        }
+
+        std::string get_line(Iterator err_pos) const
+        {
+            Iterator i = err_pos;
+            // position i to the next EOL
+            while (i != last && (*i != '\r' && *i != '\n'))
+                ++i;
+            return std::string(err_pos, i);
+        }
+
+        Iterator first;
+        Iterator last;
+        std::vector<Iterator> iters;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/expression.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/expression.cpp
new file mode 100644
index 00000000..32f44adc
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/expression.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "expression_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::expression<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/expression.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/expression.hpp
new file mode 100644
index 00000000..e5770bb1
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/expression.hpp
@@ -0,0 +1,68 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_EXPRESSION_HPP)
+#define BOOST_SPIRIT_CALC8_EXPRESSION_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+// #define BOOST_SPIRIT_QI_DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/spirit/include/qi.hpp>
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+
+namespace client { namespace parser
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The expression grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct expression : qi::grammar<Iterator, ast::expression(), ascii::space_type>
+    {
+        expression(error_handler<Iterator>& error_handler);
+
+        qi::rule<Iterator, ast::expression(), ascii::space_type>
+            expr, equality_expr, relational_expr,
+            logical_expr, additive_expr, multiplicative_expr
+            ;
+
+        qi::rule<Iterator, ast::operand(), ascii::space_type>
+            unary_expr, primary_expr
+            ;
+
+        qi::rule<Iterator, std::string(), ascii::space_type>
+            identifier
+            ;
+
+        qi::symbols<char, ast::optoken>
+            equality_op, relational_op, logical_op,
+            additive_op, multiplicative_op, unary_op
+            ;
+
+        qi::symbols<char>
+            keywords
+            ;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/expression_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/expression_def.hpp
new file mode 100644
index 00000000..608992c3
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/expression_def.hpp
@@ -0,0 +1,159 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "expression.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+#include <boost/spirit/include/phoenix_function.hpp>
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    expression<Iterator>::expression(error_handler<Iterator>& error_handler)
+      : expression::base_type(expr)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::char_type char_;
+        qi::uint_type uint_;
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+        qi::bool_type bool_;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Tokens
+        logical_op.add
+            ("&&", ast::op_and)
+            ("||", ast::op_or)
+            ;
+
+        equality_op.add
+            ("==", ast::op_equal)
+            ("!=", ast::op_not_equal)
+            ;
+
+        relational_op.add
+            ("<", ast::op_less)
+            ("<=", ast::op_less_equal)
+            (">", ast::op_greater)
+            (">=", ast::op_greater_equal)
+            ;
+
+        additive_op.add
+            ("+", ast::op_plus)
+            ("-", ast::op_minus)
+            ;
+
+        multiplicative_op.add
+            ("*", ast::op_times)
+            ("/", ast::op_divide)
+            ;
+
+        unary_op.add
+            ("+", ast::op_positive)
+            ("-", ast::op_negative)
+            ("!", ast::op_not)
+            ;
+
+        keywords.add
+            ("var")
+            ("true")
+            ("false")
+            ("if")
+            ("else")
+            ("while")
+            ;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Main expression grammar
+        expr =
+            logical_expr.alias()
+            ;
+        
+        logical_expr =
+                equality_expr
+            >> *(logical_op > equality_expr)
+            ;
+
+        equality_expr =
+                relational_expr
+            >> *(equality_op > relational_expr)
+            ;
+
+        relational_expr =
+                additive_expr
+            >> *(relational_op > additive_expr)
+            ;
+
+        additive_expr =
+                multiplicative_expr
+            >> *(additive_op > multiplicative_expr)
+            ;
+
+        multiplicative_expr =
+                unary_expr
+            >> *(multiplicative_op > unary_expr)
+            ;
+
+        unary_expr =
+                primary_expr
+            |   (unary_op > primary_expr)
+            ;
+
+        primary_expr =
+                uint_
+            |   identifier
+            |   bool_
+            |   '(' > expr > ')'
+            ;
+
+        identifier =
+                !keywords
+            >>  raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (expr)
+            (equality_expr)
+            (relational_expr)
+            (logical_expr)
+            (additive_expr)
+            (multiplicative_expr)
+            (unary_expr)
+            (primary_expr)
+            (identifier)
+        );
+
+        ///////////////////////////////////////////////////////////////////////
+        // Error handling: on error in expr, call error_handler.
+        on_error<fail>(expr,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        ///////////////////////////////////////////////////////////////////////
+        // Annotation: on success in primary_expr, call annotation.
+        on_success(primary_expr,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/main.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/main.cpp
new file mode 100644
index 00000000..9c3b7346
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/main.cpp
@@ -0,0 +1,97 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Now we'll introduce boolean expressions and control structures.
+//  Is it obvious now what we are up to? ;-)
+//
+//  [ JDG April 9, 2007 ]       spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "statement.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Statement parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type some statements... ";
+    std::cout << "An empty line ends input, compiles, runs and prints results\n\n";
+    std::cout << "Example:\n\n";
+    std::cout << "    var a = 123;\n";
+    std::cout << "    var b = 456;\n";
+    std::cout << "    var c = a + b * 2;\n\n";
+    std::cout << "-------------------------\n";
+
+    std::string str;
+    std::string source;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty())
+            break;
+        source += str + '\n';
+    }
+
+    typedef std::string::const_iterator iterator_type;
+    iterator_type iter = source.begin();
+    iterator_type end = source.end();
+
+    client::vmachine vm;                        // Our virtual machine
+    client::code_gen::program program;          // Our VM program
+    client::ast::statement_list ast;            // Our AST
+
+    client::error_handler<iterator_type>
+        error_handler(iter, end);               // Our error handler
+    client::parser::statement<iterator_type>
+        parser(error_handler);                  // Our parser
+    client::code_gen::compiler
+        compile(program, error_handler);       // Our compiler
+
+    boost::spirit::ascii::space_type space;
+    bool success = phrase_parse(iter, end, parser, space, ast);
+
+    std::cout << "-------------------------\n";
+
+    if (success && iter == end)
+    {
+        if (compile.start(ast))
+        {
+            std::cout << "Success\n";
+            std::cout << "-------------------------\n";
+            vm.execute(program());
+
+            std::cout << "-------------------------\n";
+            std::cout << "Assembler----------------\n\n";
+            program.print_assembler();
+
+            std::cout << "-------------------------\n";
+            std::cout << "Results------------------\n\n";
+            program.print_variables(vm.stack);
+        }
+        else
+        {
+            std::cout << "Compile failure\n";
+        }
+    }
+    else
+    {
+        std::cout << "Parse failure\n";
+    }
+
+    std::cout << "-------------------------\n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/statement.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/statement.cpp
new file mode 100644
index 00000000..54bc9ac3
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/statement.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "statement_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::statement<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/statement.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/statement.hpp
new file mode 100644
index 00000000..8b6c6b77
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/statement.hpp
@@ -0,0 +1,37 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_STATEMENT_HPP)
+#define BOOST_SPIRIT_CALC8_STATEMENT_HPP
+
+#include "expression.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The statement grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct statement : qi::grammar<Iterator, ast::statement_list(), ascii::space_type>
+    {
+        statement(error_handler<Iterator>& error_handler);
+
+        expression<Iterator> expr;
+        qi::rule<Iterator, ast::statement_list(), ascii::space_type>
+            statement_list, compound_statement;
+
+        qi::rule<Iterator, ast::statement(), ascii::space_type> statement_;
+        qi::rule<Iterator, ast::variable_declaration(), ascii::space_type> variable_declaration;
+        qi::rule<Iterator, ast::assignment(), ascii::space_type> assignment;
+        qi::rule<Iterator, ast::if_statement(), ascii::space_type> if_statement;
+        qi::rule<Iterator, ast::while_statement(), ascii::space_type> while_statement;
+        qi::rule<Iterator, std::string(), ascii::space_type> identifier;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/statement_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/statement_def.hpp
new file mode 100644
index 00000000..d007ac06
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/statement_def.hpp
@@ -0,0 +1,111 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "statement.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    statement<Iterator>::statement(error_handler<Iterator>& error_handler)
+      : statement::base_type(statement_list), expr(error_handler)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+        qi::lit_type lit;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        statement_list =
+            +statement_
+            ;
+
+        statement_ =
+                variable_declaration
+            |   assignment
+            |   compound_statement
+            |   if_statement
+            |   while_statement
+            ;
+
+        identifier =
+                !expr.keywords
+            >>  raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        variable_declaration =
+                lexeme["var" >> !(alnum | '_')] // make sure we have whole words
+            >   &identifier // expect an identifier
+            >   assignment
+            ;
+
+        assignment =
+                identifier
+            >   '='
+            >   expr
+            >   ';'
+            ;
+
+        if_statement =
+                lit("if")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            >
+               -(
+                    lexeme["else" >> !(alnum | '_')] // make sure we have whole words
+                >   statement_
+                )
+            ;
+
+        while_statement =
+                lit("while")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            ;
+
+        compound_statement =
+            '{' >> -statement_list >> '}'
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (statement_list)
+            (identifier)
+            (variable_declaration)
+            (assignment)
+        );
+
+        // Error handling: on error in statement_list, call error_handler.
+        on_error<fail>(statement_list,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in assignment, call annotation.
+        on_success(assignment,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/vm.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/vm.cpp
new file mode 100644
index 00000000..70589fa1
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/vm.cpp
@@ -0,0 +1,163 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "vm.hpp"
+#include <boost/assert.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4800) // forcing value to bool 'true' or 'false'
+                                // (performance warning)
+#endif
+
+namespace client
+{
+    int vmachine::execute(
+        std::vector<int> const& code
+      , std::vector<int>::const_iterator pc
+      , std::vector<int>::iterator frame_ptr
+    )
+    {
+        std::vector<int>::iterator stack_ptr = frame_ptr;
+
+        while (pc != code.end())
+        {
+            BOOST_ASSERT(pc != code.end());
+
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_not:
+                    stack_ptr[-1] = !bool(stack_ptr[-1]);
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_eq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] == stack_ptr[0]);
+                    break;
+
+                case op_neq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] != stack_ptr[0]);
+                    break;
+
+                case op_lt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] < stack_ptr[0]);
+                    break;
+
+                case op_lte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] <= stack_ptr[0]);
+                    break;
+
+                case op_gt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] > stack_ptr[0]);
+                    break;
+
+                case op_gte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] >= stack_ptr[0]);
+                    break;
+
+                case op_and:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) && bool(stack_ptr[0]);
+                    break;
+
+                case op_or:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) || bool(stack_ptr[0]);
+                    break;
+
+                case op_load:
+                    *stack_ptr++ = frame_ptr[*pc++];
+                    break;
+
+                case op_store:
+                    --stack_ptr;
+                    frame_ptr[*pc++] = stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+
+                case op_true:
+                    *stack_ptr++ = true;
+                    break;
+
+                case op_false:
+                    *stack_ptr++ = false;
+                    break;
+
+                case op_jump:
+                    pc += *pc;
+                    break;
+
+                case op_jump_if:
+                    if (!bool(stack_ptr[-1]))
+                        pc += *pc;
+                    else
+                        ++pc;
+                    --stack_ptr;
+                    break;
+
+                case op_stk_adj:
+                    stack_ptr = stack.begin() + *pc++;
+                    break;
+
+                case op_call:
+                    {
+                        int nargs = *pc++;
+                        int jump = *pc++;
+
+                        // a function call is a recursive call to execute
+                        int r = execute(
+                            code
+                          , code.begin() + jump
+                          , stack_ptr - nargs
+                        );
+
+                        // cleanup after return from function
+                        stack_ptr[-nargs] = r;      //  get return value
+                        stack_ptr -= (nargs - 1);   //  the stack will now contain
+                                                    //  the return value
+                    }
+                    break;
+
+                case op_return:
+                    return stack_ptr[-1];
+            }
+        }
+        return -1;
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/vm.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/vm.hpp
new file mode 100644
index 00000000..bab387f7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/calc8/vm.hpp
@@ -0,0 +1,77 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CALC8_VM_HPP)
+#define BOOST_SPIRIT_CALC8_VM_HPP
+
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ///////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,         //  negate the top stack entry
+        op_add,         //  add top two stack entries
+        op_sub,         //  subtract top two stack entries
+        op_mul,         //  multiply top two stack entries
+        op_div,         //  divide top two stack entries
+
+        op_not,         //  boolean negate the top stack entry
+        op_eq,          //  compare the top two stack entries for ==
+        op_neq,         //  compare the top two stack entries for !=
+        op_lt,          //  compare the top two stack entries for <
+        op_lte,         //  compare the top two stack entries for <=
+        op_gt,          //  compare the top two stack entries for >
+        op_gte,         //  compare the top two stack entries for >=
+
+        op_and,         //  logical and top two stack entries
+        op_or,          //  logical or top two stack entries
+
+        op_load,        //  load a variable
+        op_store,       //  store a variable
+
+        op_int,         //  push constant integer into the stack
+        op_true,        //  push constant 0 into the stack
+        op_false,       //  push constant 1 into the stack
+
+        op_jump_if,     //  jump to a relative position in the code if top stack
+                        //  evaluates to false
+        op_jump,        //  jump to a relative position in the code
+
+        op_stk_adj,     // adjust the stack (for args and locals)
+        op_call,        // function call
+        op_return       // return from function
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+        {
+        }
+
+        int execute(
+            std::vector<int> const& code            // the program code
+          , std::vector<int>::const_iterator pc     // program counter
+          , std::vector<int>::iterator frame_ptr    // start of arguments and locals
+        );
+
+        int execute(std::vector<int> const& code)
+        {
+            return execute(code, code.begin(), stack.begin());
+        };
+
+        std::vector<int> stack;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/annotation.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/annotation.hpp
new file mode 100644
index 00000000..2361a7f4
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/annotation.hpp
@@ -0,0 +1,95 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_ANNOTATION_HPP)
+#define BOOST_SPIRIT_CONJURE_ANNOTATION_HPP
+
+#include <map>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/bool.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The annotation handler links the AST to a map of iterator positions
+    //  for the purpose of subsequent semantic error handling when the
+    //  program is being compiled.
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct annotation
+    {
+        template <typename, typename>
+        struct result { typedef void type; };
+
+        std::vector<Iterator>& iters;
+        annotation(std::vector<Iterator>& iters)
+          : iters(iters) {}
+
+        struct set_id
+        {
+            typedef void result_type;
+
+            int id;
+            set_id(int id) : id(id) {}
+
+            void operator()(ast::function_call& x) const
+            {
+                x.function_name.id = id;
+            }
+
+            void operator()(ast::identifier& x) const
+            {
+                x.id = id;
+            }
+
+            template <typename T>
+            void operator()(T& x) const
+            {
+                // no-op
+            }
+        };
+
+        void operator()(ast::operand& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            boost::apply_visitor(set_id(id), ast);
+        }
+
+        void operator()(ast::variable_declaration& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+
+        void operator()(ast::assignment& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+
+        void operator()(ast::return_statement& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.id = id;
+        }
+
+        void operator()(ast::identifier& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.id = id;
+        }
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/ast.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/ast.hpp
new file mode 100644
index 00000000..e5022472
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/ast.hpp
@@ -0,0 +1,275 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_AST_HPP)
+#define BOOST_SPIRIT_CONJURE_AST_HPP
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <boost/optional.hpp>
+#include <list>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct tagged
+    {
+        int id; // Used to annotate the AST with the iterator position.
+                // This id is used as a key to a map<int, Iterator>
+                // (not really part of the AST.)
+    };
+
+    struct nil {};
+    struct unary;
+    struct function_call;
+    struct expression;
+
+    struct identifier : tagged
+    {
+        identifier(std::string const& name = "") : name(name) {}
+        std::string name;
+    };
+
+    typedef boost::variant<
+            nil
+          , bool
+          , unsigned int
+          , identifier
+          , boost::recursive_wrapper<unary>
+          , boost::recursive_wrapper<function_call>
+          , boost::recursive_wrapper<expression>
+        >
+    operand;
+
+    enum optoken
+    {
+        // precedence 1
+        op_comma,
+
+        // precedence 2
+        op_assign,
+        op_plus_assign,
+        op_minus_assign,
+        op_times_assign,
+        op_divide_assign,
+        op_mod_assign,
+        op_bit_and_assign,
+        op_bit_xor_assign,
+        op_bitor_assign,
+        op_shift_left_assign,
+        op_shift_right_assign,
+
+        // precedence 3
+        op_logical_or,
+
+        // precedence 4
+        op_logical_and,
+
+        // precedence 5
+        op_bit_or,
+
+        // precedence 6
+        op_bit_xor,
+
+        // precedence 7
+        op_bit_and,
+
+        // precedence 8
+        op_equal,
+        op_not_equal,
+
+        // precedence 9
+        op_less,
+        op_less_equal,
+        op_greater,
+        op_greater_equal,
+
+        // precedence 10
+        op_shift_left,
+        op_shift_right,
+
+        // precedence 11
+        op_plus,
+        op_minus,
+
+        // precedence 12
+        op_times,
+        op_divide,
+        op_mod,
+
+        // precedence 13
+        op_positive,
+        op_negative,
+        op_pre_incr,
+        op_pre_decr,
+        op_compl,
+        op_not,
+
+        // precedence 14
+        op_post_incr,
+        op_post_decr,
+    };
+
+    struct unary
+    {
+        optoken operator_;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        optoken operator_;
+        operand operand_;
+    };
+
+    struct function_call
+    {
+        identifier function_name;
+        std::list<expression> args;
+    };
+
+    struct expression
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    struct assignment
+    {
+        identifier lhs;
+        expression rhs;
+    };
+
+    struct variable_declaration
+    {
+        identifier lhs;
+        boost::optional<expression> rhs;
+    };
+
+    struct if_statement;
+    struct while_statement;
+    struct statement_list;
+    struct return_statement;
+
+    typedef boost::variant<
+            variable_declaration
+          , assignment
+          , boost::recursive_wrapper<if_statement>
+          , boost::recursive_wrapper<while_statement>
+          , boost::recursive_wrapper<return_statement>
+          , boost::recursive_wrapper<statement_list>
+        >
+    statement;
+
+    struct statement_list : std::list<statement> {};
+
+    struct if_statement
+    {
+        expression condition;
+        statement then;
+        boost::optional<statement> else_;
+    };
+
+    struct while_statement
+    {
+        expression condition;
+        statement body;
+    };
+
+    struct return_statement : tagged
+    {
+        boost::optional<expression> expr;
+    };
+
+    struct function
+    {
+        std::string return_type;
+        identifier function_name;
+        std::list<identifier> args;
+        statement_list body;
+    };
+
+    typedef std::list<function> function_list;
+
+    // print functions for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil)
+    {
+        out << "nil"; return out;
+    }
+
+    inline std::ostream& operator<<(std::ostream& out, identifier const& id)
+    {
+        out << id.name; return out;
+    }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::unary,
+    (client::ast::optoken, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::operation,
+    (client::ast::optoken, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::function_call,
+    (client::ast::identifier, function_name)
+    (std::list<client::ast::expression>, args)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::expression,
+    (client::ast::operand, first)
+    (std::list<client::ast::operation>, rest)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::variable_declaration,
+    (client::ast::identifier, lhs)
+    (boost::optional<client::ast::expression>, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::assignment,
+    (client::ast::identifier, lhs)
+    (client::ast::expression, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::if_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, then)
+    (boost::optional<client::ast::statement>, else_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::while_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, body)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::return_statement,
+    (boost::optional<client::ast::expression>, expr)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::function,
+    (std::string, return_type)
+    (client::ast::identifier, function_name)
+    (std::list<client::ast::identifier>, args)
+    (client::ast::statement_list, body)
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/compiler.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/compiler.cpp
new file mode 100644
index 00000000..22a036d4
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/compiler.cpp
@@ -0,0 +1,628 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "compiler.hpp"
+#include "vm.hpp"
+#include <boost/foreach.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/assert.hpp>
+#include <boost/lexical_cast.hpp>
+#include <set>
+
+namespace client { namespace code_gen
+{
+    void function::op(int a)
+    {
+        code.push_back(a);
+        size_ += 1;
+    }
+
+    void function::op(int a, int b)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        size_ += 2;
+    }
+
+    void function::op(int a, int b, int c)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        code.push_back(c);
+        size_ += 3;
+    }
+
+    int const* function::find_var(std::string const& name) const
+    {
+        std::map<std::string, int>::const_iterator i = variables.find(name);
+        if (i == variables.end())
+            return 0;
+        return &i->second;
+    }
+
+    void function::add_var(std::string const& name)
+    {
+        std::size_t n = variables.size();
+        variables[name] = n;
+    }
+
+    void function::link_to(std::string const& name, std::size_t address)
+    {
+        function_calls[address] = name;
+    }
+
+    void function::print_assembler() const
+    {
+        std::vector<int>::const_iterator pc = code.begin() + address;
+
+        std::vector<std::string> locals(variables.size());
+        typedef std::pair<std::string, int> pair;
+        BOOST_FOREACH(pair const& p, variables)
+        {
+            locals[p.second] = p.first;
+            std::cout << "      local       "
+                << p.first << ", @" << p.second << std::endl;
+        }
+
+        std::map<std::size_t, std::string> lines;
+        std::set<std::size_t> jumps;
+
+        while (pc != (code.begin() + address + size_))
+        {
+            std::string line;
+            std::size_t address = pc - code.begin();
+
+            switch (*pc++)
+            {
+                case op_neg:
+                    line += "      op_neg";
+                    break;
+
+                case op_not:
+                    line += "      op_not";
+                    break;
+
+                case op_add:
+                    line += "      op_add";
+                    break;
+
+                case op_sub:
+                    line += "      op_sub";
+                    break;
+
+                case op_mul:
+                    line += "      op_mul";
+                    break;
+
+                case op_div:
+                    line += "      op_div";
+                    break;
+
+                case op_eq:
+                    line += "      op_eq";
+                    break;
+
+                case op_neq:
+                    line += "      op_neq";
+                    break;
+
+                case op_lt:
+                    line += "      op_lt";
+                    break;
+
+                case op_lte:
+                    line += "      op_lte";
+                    break;
+
+                case op_gt:
+                    line += "      op_gt";
+                    break;
+
+                case op_gte:
+                    line += "      op_gte";
+                    break;
+
+                case op_and:
+                    line += "      op_and";
+                    break;
+
+                case op_or:
+                    line += "      op_or";
+                    break;
+
+                case op_load:
+                    line += "      op_load     ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_store:
+                    line += "      op_store    ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_int:
+                    line += "      op_int      ";
+                    line += boost::lexical_cast<std::string>(*pc++);
+                    break;
+
+                case op_true:
+                    line += "      op_true";
+                    break;
+
+                case op_false:
+                    line += "      op_false";
+                    break;
+
+                case op_jump:
+                    {
+                        line += "      op_jump     ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += boost::lexical_cast<std::string>(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_jump_if:
+                    {
+                        line += "      op_jump_if  ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += boost::lexical_cast<std::string>(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_call:
+                    {
+                        line += "      op_call     ";
+                        int nargs = *pc++;
+                        std::size_t jump = *pc++;
+                        line += boost::lexical_cast<std::string>(nargs) + ", ";
+                        BOOST_ASSERT(function_calls.find(jump) != function_calls.end());
+                        line += function_calls.find(jump)->second;
+                    }
+                    break;
+
+                case op_stk_adj:
+                    line += "      op_stk_adj  ";
+                    line += boost::lexical_cast<std::string>(*pc++);
+                    break;
+
+
+                case op_return:
+                    line += "      op_return";
+                    break;
+            }
+            lines[address] = line;
+        }
+
+        std::cout << "start:" << std::endl;
+        typedef std::pair<std::size_t, std::string> line_info;
+        BOOST_FOREACH(line_info const& l, lines)
+        {
+            std::size_t pos = l.first;
+            if (jumps.find(pos) != jumps.end())
+                std::cout << pos << ':' << std::endl;
+            std::cout << l.second << std::endl;
+        }
+
+        std::cout << "end:" << std::endl << std::endl;
+    }
+
+    bool compiler::operator()(unsigned int x)
+    {
+        BOOST_ASSERT(current != 0);
+        current->op(op_int, x);
+        return true;
+    }
+
+    bool compiler::operator()(bool x)
+    {
+        BOOST_ASSERT(current != 0);
+        current->op(x ? op_true : op_false);
+        return true;
+    }
+
+    bool compiler::operator()(ast::identifier const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        int const* p = current->find_var(x.name);
+        if (p == 0)
+        {
+            error_handler(x.id, "Undeclared variable: " + x.name);
+            return false;
+        }
+        current->op(op_load, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::optoken const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        switch (x)
+        {
+            case ast::op_plus: current->op(op_add); break;
+            case ast::op_minus: current->op(op_sub); break;
+            case ast::op_times: current->op(op_mul); break;
+            case ast::op_divide: current->op(op_div); break;
+
+            case ast::op_equal: current->op(op_eq); break;
+            case ast::op_not_equal: current->op(op_neq); break;
+            case ast::op_less: current->op(op_lt); break;
+            case ast::op_less_equal: current->op(op_lte); break;
+            case ast::op_greater: current->op(op_gt); break;
+            case ast::op_greater_equal: current->op(op_gte); break;
+
+            case ast::op_logical_or: current->op(op_or); break;
+            case ast::op_logical_and: current->op(op_and); break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::unary const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case ast::op_negative: current->op(op_neg); break;
+            case ast::op_not: current->op(op_not); break;
+            case ast::op_positive: break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::function_call const& x)
+    {
+        BOOST_ASSERT(current != 0);
+
+        if (functions.find(x.function_name.name) == functions.end())
+        {
+            error_handler(x.function_name.id, "Function not found: " + x.function_name.name);
+            return false;
+        }
+
+        boost::shared_ptr<code_gen::function> p = functions[x.function_name.name];
+
+        if (p->nargs() != x.args.size())
+        {
+            error_handler(x.function_name.id, "Wrong number of arguments: " + x.function_name.name);
+            return false;
+        }
+
+        BOOST_FOREACH(ast::expression const& expr, x.args)
+        {
+            if (!(*this)(expr))
+                return false;
+        }
+
+        current->op(
+            op_call,
+            p->nargs(),
+            p->get_address());
+        current->link_to(x.function_name.name, p->get_address());
+
+        return true;
+    }
+
+    namespace
+    {
+        int precedence[] = {
+            // precedence 1
+            1, // op_comma
+
+            // precedence 2
+            2, // op_assign
+            2, // op_plus_assign
+            2, // op_minus_assign
+            2, // op_times_assign
+            2, // op_divide_assign
+            2, // op_mod_assign
+            2, // op_bit_and_assign
+            2, // op_bit_xor_assign
+            2, // op_bitor_assign
+            2, // op_shift_left_assign
+            2, // op_shift_right_assign
+
+            // precedence 3
+            3, // op_logical_or
+
+            // precedence 4
+            4, // op_logical_and
+
+            // precedence 5
+            5, // op_bit_or
+
+            // precedence 6
+            6, // op_bit_xor
+
+            // precedence 7
+            7, // op_bit_and
+
+            // precedence 8
+            8, // op_equal
+            8, // op_not_equal
+
+            // precedence 9
+            9, // op_less
+            9, // op_less_equal
+            9, // op_greater
+            9, // op_greater_equal
+
+            // precedence 10
+            10, // op_shift_left
+            10, // op_shift_right
+
+            // precedence 11
+            11, // op_plus
+            11, // op_minus
+
+            // precedence 12
+            12, // op_times
+            12, // op_divide
+            12, // op_mod
+
+            // precedence 13
+            13, // op_positive
+            13, // op_negative
+            13, // op_pre_incr
+            13, // op_pre_decr
+            13, // op_compl
+            13, // op_not
+
+            // precedence 14
+            14, // op_post_incr
+            14  // op_post_decr
+        };
+    }
+
+    // The Shunting-yard algorithm
+    bool compiler::compile_expression(
+        int min_precedence,
+        std::list<ast::operation>::const_iterator& rbegin,
+        std::list<ast::operation>::const_iterator rend)
+    {
+        while ((rbegin != rend) && (precedence[rbegin->operator_] >= min_precedence))
+        {
+            ast::optoken op = rbegin->operator_;
+            if (!boost::apply_visitor(*this, rbegin->operand_))
+                return false;
+            ++rbegin;
+
+            while ((rbegin != rend) && (precedence[rbegin->operator_] > precedence[op]))
+            {
+                ast::optoken next_op = rbegin->operator_;
+                compile_expression(precedence[next_op], rbegin, rend);
+            }
+            (*this)(op);
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::expression const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!boost::apply_visitor(*this, x.first))
+            return false;
+        std::list<ast::operation>::const_iterator rbegin = x.rest.begin();
+        if (!compile_expression(0, rbegin, x.rest.end()))
+            return false;
+        return true;
+    }
+
+    bool compiler::operator()(ast::assignment const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!(*this)(x.rhs))
+            return false;
+        int const* p = current->find_var(x.lhs.name);
+        if (p == 0)
+        {
+            error_handler(x.lhs.id, "Undeclared variable: " + x.lhs.name);
+            return false;
+        }
+        current->op(op_store, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable_declaration const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        int const* p = current->find_var(x.lhs.name);
+        if (p != 0)
+        {
+            error_handler(x.lhs.id, "Duplicate variable: " + x.lhs.name);
+            return false;
+        }
+        if (x.rhs) // if there's an RHS initializer
+        {
+            bool r = (*this)(*x.rhs);
+            if (r) // don't add the variable if the RHS fails
+            {
+                current->add_var(x.lhs.name);
+                current->op(op_store, *current->find_var(x.lhs.name));
+            }
+            return r;
+        }
+        else
+        {
+            current->add_var(x.lhs.name);
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::statement const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        return boost::apply_visitor(*this, x);
+    }
+
+    bool compiler::operator()(ast::statement_list const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        BOOST_FOREACH(ast::statement const& s, x)
+        {
+            if (!(*this)(s))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::if_statement const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!(*this)(x.condition))
+            return false;
+        current->op(op_jump_if, 0);                 // we shall fill this (0) in later
+        std::size_t skip = current->size()-1;       // mark its position
+        if (!(*this)(x.then))
+            return false;
+        (*current)[skip] = current->size()-skip;    // now we know where to jump to (after the if branch)
+
+        if (x.else_)                                // We got an alse
+        {
+            (*current)[skip] += 2;                  // adjust for the "else" jump
+            current->op(op_jump, 0);                // we shall fill this (0) in later
+            std::size_t exit = current->size()-1;   // mark its position
+            if (!(*this)(*x.else_))
+                return false;
+            (*current)[exit] = current->size()-exit;// now we know where to jump to (after the else branch)
+        }
+
+        return true;
+    }
+
+    bool compiler::operator()(ast::while_statement const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        std::size_t loop = current->size();         // mark our position
+        if (!(*this)(x.condition))
+            return false;
+        current->op(op_jump_if, 0);                 // we shall fill this (0) in later
+        std::size_t exit = current->size()-1;       // mark its position
+        if (!(*this)(x.body))
+            return false;
+        current->op(op_jump,
+            int(loop-1) - int(current->size()));    // loop back
+        (*current)[exit] = current->size()-exit;    // now we know where to jump to (to exit the loop)
+        return true;
+    }
+
+    bool compiler::operator()(ast::return_statement const& x)
+    {
+        if (void_return)
+        {
+            if (x.expr)
+            {
+                error_handler(x.id, "'void' function returning a value: ");
+                return false;
+            }
+        }
+        else
+        {
+            if (!x.expr)
+            {
+                error_handler(x.id, current_function_name + " function must return a value: ");
+                return false;
+            }
+        }
+
+        if (x.expr)
+        {
+            if (!(*this)(*x.expr))
+                return false;
+        }
+        current->op(op_return);
+        return true;
+    }
+
+    bool compiler::operator()(ast::function const& x)
+    {
+        void_return = x.return_type == "void";
+        if (functions.find(x.function_name.name) != functions.end())
+        {
+            error_handler(x.function_name.id, "Duplicate function: " + x.function_name.name);
+            return false;
+        }
+        boost::shared_ptr<code_gen::function>& p = functions[x.function_name.name];
+        p.reset(new code_gen::function(code, x.args.size()));
+        current = p.get();
+        current_function_name = x.function_name.name;
+
+        // op_stk_adj 0 for now. we'll know how many variables
+        // we'll have later and add them
+        current->op(op_stk_adj, 0);
+        BOOST_FOREACH(ast::identifier const& arg, x.args)
+        {
+            current->add_var(arg.name);
+        }
+
+        if (!(*this)(x.body))
+            return false;
+        (*current)[1] = current->nvars();   // now store the actual number of variables
+                                            // this includes the arguments
+        return true;
+    }
+
+    bool compiler::operator()(ast::function_list const& x)
+    {
+        // Jump to the main function
+        code.push_back(op_jump);
+        code.push_back(0); // we will fill this in later when we finish compiling
+                           // and we know where the main function is
+
+        BOOST_FOREACH(ast::function const& f, x)
+        {
+            if (!(*this)(f))
+            {
+                code.clear();
+                return false;
+            }
+        }
+        // find the main function
+        boost::shared_ptr<code_gen::function> p =
+            find_function("main");
+
+        if (!p) // main function not found
+        {
+            std::cerr << "Error: main function not defined" << std::endl;
+            return false;
+        }
+        code[1] = p->get_address()-1; // jump to this (main function) address
+
+        return true;
+    }
+
+    void compiler::print_assembler() const
+    {
+        typedef std::pair<std::string, boost::shared_ptr<code_gen::function> > pair;
+        BOOST_FOREACH(pair const& p, functions)
+        {
+            std::cout << ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" << std::endl;
+            std::cout << p.second->get_address() << ": function " << p.first << std::endl;
+            p.second->print_assembler();
+        }
+    }
+
+    boost::shared_ptr<code_gen::function>
+    compiler::find_function(std::string const& name) const
+    {
+        function_table::const_iterator i = functions.find(name);
+        if (i == functions.end())
+            return boost::shared_ptr<code_gen::function>();
+        else
+            return i->second;
+    }
+}}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/compiler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/compiler.hpp
new file mode 100644
index 00000000..461f7a7c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/compiler.hpp
@@ -0,0 +1,123 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_COMPILER_HPP)
+#define BOOST_SPIRIT_CONJURE_COMPILER_HPP
+
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+#include <map>
+#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+namespace client { namespace code_gen
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Function
+    ///////////////////////////////////////////////////////////////////////////
+    struct function
+    {
+        function(std::vector<int>& code, int nargs)
+          : code(code), address(code.size()), size_(0), nargs_(nargs) {}
+
+        void op(int a);
+        void op(int a, int b);
+        void op(int a, int b, int c);
+
+        int& operator[](std::size_t i) { return code[address+i]; }
+        int const& operator[](std::size_t i) const { return code[address+i]; }
+        std::size_t size() const { return size_; }
+        std::size_t get_address() const { return address; }
+
+        int nargs() const { return nargs_; }
+        int nvars() const { return variables.size(); }
+        int const* find_var(std::string const& name) const;
+        void add_var(std::string const& name);
+        void link_to(std::string const& name, std::size_t address);
+
+        void print_assembler() const;
+
+    private:
+
+        std::map<std::string, int> variables;
+        std::map<std::size_t, std::string> function_calls;
+        std::vector<int>& code;
+        std::size_t address;
+        std::size_t size_;
+        std::size_t nargs_;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ///////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef bool result_type;
+
+        template <typename ErrorHandler>
+        compiler(ErrorHandler& error_handler_)
+          : current(0)
+        {
+            using namespace boost::phoenix::arg_names;
+            namespace phx = boost::phoenix;
+            using boost::phoenix::function;
+
+            error_handler = function<ErrorHandler>(error_handler_)(
+                "Error! ", _2, phx::cref(error_handler_.iters)[_1]);
+        }
+
+        bool operator()(ast::nil) { BOOST_ASSERT(0); return false; }
+        bool operator()(unsigned int x);
+        bool operator()(bool x);
+        bool operator()(ast::identifier const& x);
+        bool operator()(ast::optoken const& x);
+        bool operator()(ast::unary const& x);
+        bool operator()(ast::function_call const& x);
+        bool operator()(ast::expression const& x);
+        bool operator()(ast::assignment const& x);
+        bool operator()(ast::variable_declaration const& x);
+        bool operator()(ast::statement_list const& x);
+        bool operator()(ast::statement const& x);
+        bool operator()(ast::if_statement const& x);
+        bool operator()(ast::while_statement const& x);
+        bool operator()(ast::return_statement const& x);
+        bool operator()(ast::function const& x);
+        bool operator()(ast::function_list const& x);
+
+        void print_assembler() const;
+
+        boost::shared_ptr<code_gen::function>
+        find_function(std::string const& name) const;
+
+        std::vector<int>& get_code() { return code; }
+        std::vector<int> const& get_code() const { return code; }
+
+    private:
+
+        bool compile_expression(
+            int min_precedence,
+            std::list<ast::operation>::const_iterator& rbegin,
+            std::list<ast::operation>::const_iterator rend);
+
+        typedef std::map<std::string, boost::shared_ptr<code_gen::function> > function_table;
+
+        std::vector<int> code;
+        code_gen::function* current;
+        std::string current_function_name;
+        function_table functions;
+        bool void_return;
+
+        boost::function<
+            void(int tag, std::string const& what)>
+        error_handler;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/error_handler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/error_handler.hpp
new file mode 100644
index 00000000..2c1aa44e
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/error_handler.hpp
@@ -0,0 +1,93 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_CONJURE_ERROR_HANDLER_HPP
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The error handler
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct error_handler
+    {
+        template <typename, typename, typename>
+        struct result { typedef void type; };
+
+        error_handler(Iterator first, Iterator last)
+          : first(first), last(last) {}
+
+        template <typename Message, typename What>
+        void operator()(
+            Message const& message,
+            What const& what,
+            Iterator err_pos) const
+        {
+            int line;
+            Iterator line_start = get_pos(err_pos, line);
+            if (err_pos != last)
+            {
+                std::cout << message << what << " line " << line << ':' << std::endl;
+                std::cout << get_line(line_start) << std::endl;
+                for (; line_start != err_pos; ++line_start)
+                    std::cout << ' ';
+                std::cout << '^' << std::endl;
+            }
+            else
+            {
+                std::cout << "Unexpected end of file. ";
+                std::cout << message << what << " line " << line << std::endl;
+            }
+        }
+
+        Iterator get_pos(Iterator err_pos, int& line) const
+        {
+            line = 1;
+            Iterator i = first;
+            Iterator line_start = first;
+            while (i != err_pos)
+            {
+                bool eol = false;
+                if (i != err_pos && *i == '\r') // CR
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (i != err_pos && *i == '\n') // LF
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (eol)
+                    ++line;
+                else
+                    ++i;
+            }
+            return line_start;
+        }
+
+        std::string get_line(Iterator err_pos) const
+        {
+            Iterator i = err_pos;
+            // position i to the next EOL
+            while (i != last && (*i != '\r' && *i != '\n'))
+                ++i;
+            return std::string(err_pos, i);
+        }
+
+        Iterator first;
+        Iterator last;
+        std::vector<Iterator> iters;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/expression.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/expression.cpp
new file mode 100644
index 00000000..32f44adc
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/expression.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "expression_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::expression<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/expression.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/expression.hpp
new file mode 100644
index 00000000..985b972c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/expression.hpp
@@ -0,0 +1,75 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_EXPRESSION_HPP)
+#define BOOST_SPIRIT_CONJURE_EXPRESSION_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+// #define BOOST_SPIRIT_QI_DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/spirit/include/qi.hpp>
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include "skipper.hpp"
+#include <vector>
+
+namespace client { namespace parser
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The expression grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct expression : qi::grammar<Iterator, ast::expression(), skipper<Iterator> >
+    {
+        expression(error_handler<Iterator>& error_handler);
+
+        qi::rule<Iterator, ast::expression(), skipper<Iterator> >
+            expr
+            ;
+
+        qi::rule<Iterator, ast::operand(), skipper<Iterator> >
+            unary_expr, primary_expr
+            ;
+
+        qi::rule<Iterator, ast::function_call(), skipper<Iterator> >
+            function_call
+            ;
+
+        qi::rule<Iterator, std::list<ast::expression>(), skipper<Iterator> >
+            argument_list
+            ;
+
+        qi::rule<Iterator, std::string(), skipper<Iterator> >
+            identifier
+            ;
+
+        qi::symbols<char, ast::optoken>
+            unary_op, binary_op
+            ;
+
+        qi::symbols<char>
+            keywords
+            ;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/expression_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/expression_def.hpp
new file mode 100644
index 00000000..21ccc9bd
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/expression_def.hpp
@@ -0,0 +1,131 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "expression.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+#include <boost/spirit/include/phoenix_function.hpp>
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    expression<Iterator>::expression(error_handler<Iterator>& error_handler)
+      : expression::base_type(expr)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::char_type char_;
+        qi::uint_type uint_;
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+        qi::bool_type bool_;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Tokens
+        binary_op.add
+            ("||", ast::op_logical_or)
+            ("&&", ast::op_logical_and)
+            ("==", ast::op_equal)
+            ("!=", ast::op_not_equal)
+            ("<", ast::op_less)
+            ("<=", ast::op_less_equal)
+            (">", ast::op_greater)
+            (">=", ast::op_greater_equal)
+            ("+", ast::op_plus)
+            ("-", ast::op_minus)
+            ("*", ast::op_times)
+            ("/", ast::op_divide)
+            ;
+
+        unary_op.add
+            ("+", ast::op_positive)
+            ("-", ast::op_negative)
+            ("!", ast::op_not)
+            ;
+
+        keywords.add
+            ("true")
+            ("false")
+            ("if")
+            ("else")
+            ("while")
+            ("int")
+            ("void")
+            ("return")
+            ;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Main expression grammar
+        expr =
+                unary_expr
+            >> *(binary_op > unary_expr)
+            ;
+
+        unary_expr =
+                primary_expr
+            |   (unary_op > unary_expr)
+            ;
+
+        primary_expr =
+                uint_
+            |   function_call
+            |   identifier
+            |   bool_
+            |   '(' > expr > ')'
+            ;
+
+        function_call =
+                (identifier >> '(')
+            >   argument_list
+            >   ')'
+            ;
+
+        argument_list = -(expr % ',');
+
+        identifier =
+                !lexeme[keywords >> !(alnum | '_')]
+            >>  raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (expr)
+            (unary_expr)
+            (primary_expr)
+            (function_call)
+            (argument_list)
+            (identifier)
+        );
+
+        ///////////////////////////////////////////////////////////////////////
+        // Error handling: on error in expr, call error_handler.
+        on_error<fail>(expr,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        ///////////////////////////////////////////////////////////////////////
+        // Annotation: on success in primary_expr, call annotation.
+        on_success(primary_expr,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/function.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/function.cpp
new file mode 100644
index 00000000..ababd4ad
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/function.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "function_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::function<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/function.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/function.hpp
new file mode 100644
index 00000000..9eddd66c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/function.hpp
@@ -0,0 +1,32 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_FUNCTION_HPP)
+#define BOOST_SPIRIT_CONJURE_FUNCTION_HPP
+
+#include "statement.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The function grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct function : qi::grammar<Iterator, ast::function(), skipper<Iterator> >
+    {
+        function(error_handler<Iterator>& error_handler);
+
+        statement<Iterator> body;
+        qi::rule<Iterator, std::string(), skipper<Iterator> > name;
+        qi::rule<Iterator, ast::identifier(), skipper<Iterator> > identifier;
+        qi::rule<Iterator, std::list<ast::identifier>(), skipper<Iterator> > argument_list;
+        qi::rule<Iterator, ast::function(), skipper<Iterator> > start;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/function_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/function_def.hpp
new file mode 100644
index 00000000..bd2c7d02
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/function_def.hpp
@@ -0,0 +1,71 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "function.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    function<Iterator>::function(error_handler<Iterator>& error_handler)
+      : function::base_type(start), body(error_handler)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+        qi::string_type string;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        name =
+                !body.expr.keywords
+            >>  raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        identifier = name;
+        argument_list = -(identifier % ',');
+
+        start =
+                lexeme[(string("void") | string("int"))
+                    >> !(alnum | '_')]  // make sure we have whole words
+            >   identifier
+            >   '(' > argument_list > ')'
+            >   '{' > body > '}'
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (identifier)
+            (argument_list)
+            (start)
+        );
+
+        // Error handling: on error in start, call error_handler.
+        on_error<fail>(start,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in start, call annotation.
+        on_success(identifier,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/main.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/main.cpp
new file mode 100644
index 00000000..8b2a8007
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/main.cpp
@@ -0,0 +1,121 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Not a calculator anymore, right? :-)
+//
+//  [ JDG April 10, 2007 ]      spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "function.hpp"
+#include "skipper.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+#include <boost/lexical_cast.hpp>
+#include <fstream>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    std::string source_code; // We will read the contents here.
+    in.unsetf(std::ios::skipws); // No white space skipping!
+    std::copy(
+        std::istream_iterator<char>(in),
+        std::istream_iterator<char>(),
+        std::back_inserter(source_code));
+
+    typedef std::string::const_iterator iterator_type;
+    iterator_type iter = source_code.begin();
+    iterator_type end = source_code.end();
+
+    client::vmachine vm;                        // Our virtual machine
+    client::ast::function_list ast;             // Our AST
+
+    client::error_handler<iterator_type>
+        error_handler(iter, end);               // Our error handler
+    client::parser::function<iterator_type>
+        function(error_handler);                // Our parser
+    client::parser::skipper<iterator_type>
+        skipper;                                // Our skipper
+    client::code_gen::compiler
+        compiler(error_handler);                // Our compiler
+
+
+    bool success = phrase_parse(iter, end, +function, skipper, ast);
+
+    std::cout << "-------------------------\n";
+
+    if (success && iter == end)
+    {
+        if (compiler(ast))
+        {
+            boost::shared_ptr<client::code_gen::function>
+                p  = compiler.find_function("main");
+            if (!p)
+                return 1;
+
+            int nargs = argc-2;
+            if (p->nargs() != nargs)
+            {
+                std::cerr << "Error: main function requires " << p->nargs() << " arguments." << std::endl;
+                std::cerr << nargs << " supplied." << std::endl;
+                return 1;
+            }
+
+            std::cout << "Success\n";
+            std::cout << "-------------------------\n";
+            std::cout << "Assembler----------------\n\n";
+            compiler.print_assembler();
+
+            // Push the arguments into our stack
+            for (int i = 0; i < nargs; ++i)
+                vm.get_stack()[i] = boost::lexical_cast<int>(argv[i+2]);
+
+            // Call the interpreter
+            int r = vm.execute(compiler.get_code());
+
+            std::cout << "-------------------------\n";
+            std::cout << "Result: " << r << std::endl;
+            std::cout << "-------------------------\n\n";
+        }
+        else
+        {
+            std::cout << "Compile failure\n";
+        }
+    }
+    else
+    {
+        std::cout << "Parse failure\n";
+    }
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/skipper.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/skipper.hpp
new file mode 100644
index 00000000..bb1acc21
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/skipper.hpp
@@ -0,0 +1,40 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_SKIPPER_HPP)
+#define BOOST_SPIRIT_CONJURE_SKIPPER_HPP
+
+#include <boost/spirit/include/qi.hpp>
+
+namespace client { namespace parser
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The skipper grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct skipper : qi::grammar<Iterator>
+    {
+        skipper() : skipper::base_type(start)
+        {
+            qi::char_type char_;
+            ascii::space_type space;
+
+            start =
+                    space                               // tab/space/cr/lf
+                |   "/*" >> *(char_ - "*/") >> "*/"     // C-style comments
+                ;
+        }
+
+        qi::rule<Iterator> start;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/statement.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/statement.cpp
new file mode 100644
index 00000000..54bc9ac3
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/statement.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "statement_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::statement<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/statement.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/statement.hpp
new file mode 100644
index 00000000..72485cbf
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/statement.hpp
@@ -0,0 +1,38 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_STATEMENT_HPP)
+#define BOOST_SPIRIT_CONJURE_STATEMENT_HPP
+
+#include "expression.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The statement grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct statement : qi::grammar<Iterator, ast::statement_list(), skipper<Iterator> >
+    {
+        statement(error_handler<Iterator>& error_handler);
+
+        expression<Iterator> expr;
+        qi::rule<Iterator, ast::statement_list(), skipper<Iterator> >
+            statement_list, compound_statement;
+
+        qi::rule<Iterator, ast::statement(), skipper<Iterator> > statement_;
+        qi::rule<Iterator, ast::variable_declaration(), skipper<Iterator> > variable_declaration;
+        qi::rule<Iterator, ast::assignment(), skipper<Iterator> > assignment;
+        qi::rule<Iterator, ast::if_statement(), skipper<Iterator> > if_statement;
+        qi::rule<Iterator, ast::while_statement(), skipper<Iterator> > while_statement;
+        qi::rule<Iterator, ast::return_statement(), skipper<Iterator> > return_statement;
+        qi::rule<Iterator, std::string(), skipper<Iterator> > identifier;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/statement_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/statement_def.hpp
new file mode 100644
index 00000000..29e40942
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/statement_def.hpp
@@ -0,0 +1,128 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "statement.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    statement<Iterator>::statement(error_handler<Iterator>& error_handler)
+      : statement::base_type(statement_list), expr(error_handler)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+        qi::lit_type lit;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        statement_list =
+            +statement_
+            ;
+
+        statement_ =
+                variable_declaration
+            |   assignment
+            |   compound_statement
+            |   if_statement
+            |   while_statement
+            |   return_statement
+            ;
+
+        identifier =
+                !expr.keywords
+            >>  raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        variable_declaration =
+                lexeme["int" >> !(alnum | '_')] // make sure we have whole words
+            >   identifier
+            >   -('=' > expr)
+            >   ';'
+            ;
+
+        assignment =
+                identifier
+            >   '='
+            >   expr
+            >   ';'
+            ;
+
+        if_statement =
+                lit("if")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            >
+               -(
+                    lexeme["else" >> !(alnum | '_')] // make sure we have whole words
+                >   statement_
+                )
+            ;
+
+        while_statement =
+                lit("while")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            ;
+
+        compound_statement =
+            '{' >> -statement_list >> '}'
+            ;
+
+        return_statement =
+                lexeme["return" >> !(alnum | '_')] // make sure we have whole words
+            >  -expr
+            >   ';'
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (statement_list)
+            (statement_)
+            (variable_declaration)
+            (assignment)
+            (if_statement)
+            (while_statement)
+            (compound_statement)
+            (return_statement)
+        );
+
+        // Error handling: on error in statement_list, call error_handler.
+        on_error<fail>(statement_list,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in variable_declaration,
+        // assignment and return_statement, call annotation.
+        on_success(variable_declaration,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(assignment,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(return_statement,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/vm.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/vm.cpp
new file mode 100644
index 00000000..8740bf9c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/vm.cpp
@@ -0,0 +1,159 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "vm.hpp"
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4800) // forcing value to bool 'true' or 'false'
+                                // (performance warning)
+#endif
+
+namespace client
+{
+    int vmachine::execute(
+        std::vector<int> const& code
+      , std::vector<int>::const_iterator pc
+      , std::vector<int>::iterator frame_ptr
+    )
+    {
+        std::vector<int>::iterator stack_ptr = frame_ptr;
+
+        while (true)
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_not:
+                    stack_ptr[-1] = !bool(stack_ptr[-1]);
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_eq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] == stack_ptr[0]);
+                    break;
+
+                case op_neq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] != stack_ptr[0]);
+                    break;
+
+                case op_lt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] < stack_ptr[0]);
+                    break;
+
+                case op_lte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] <= stack_ptr[0]);
+                    break;
+
+                case op_gt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] > stack_ptr[0]);
+                    break;
+
+                case op_gte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] >= stack_ptr[0]);
+                    break;
+
+                case op_and:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) && bool(stack_ptr[0]);
+                    break;
+
+                case op_or:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) || bool(stack_ptr[0]);
+                    break;
+
+                case op_load:
+                    *stack_ptr++ = frame_ptr[*pc++];
+                    break;
+
+                case op_store:
+                    --stack_ptr;
+                    frame_ptr[*pc++] = stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+
+                case op_true:
+                    *stack_ptr++ = true;
+                    break;
+
+                case op_false:
+                    *stack_ptr++ = false;
+                    break;
+
+                case op_jump:
+                    pc += *pc;
+                    break;
+
+                case op_jump_if:
+                    if (!bool(stack_ptr[-1]))
+                        pc += *pc;
+                    else
+                        ++pc;
+                    --stack_ptr;
+                    break;
+
+                case op_stk_adj:
+                    stack_ptr += *pc++;
+                    break;
+
+                case op_call:
+                    {
+                        int nargs = *pc++;
+                        int jump = *pc++;
+
+                        // a function call is a recursive call to execute
+                        int r = execute(
+                            code
+                          , code.begin() + jump
+                          , stack_ptr - nargs
+                        );
+
+                        // cleanup after return from function
+                        stack_ptr[-nargs] = r;      //  get return value
+                        stack_ptr -= (nargs - 1);   //  the stack will now contain
+                                                    //  the return value
+                    }
+                    break;
+
+                case op_return:
+                    return stack_ptr[-1];
+            }
+        }
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/vm.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/vm.hpp
new file mode 100644
index 00000000..0362eaf8
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure1/vm.hpp
@@ -0,0 +1,82 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_VM_HPP)
+#define BOOST_SPIRIT_CONJURE_VM_HPP
+
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ///////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,         //  negate the top stack entry
+        op_add,         //  add top two stack entries
+        op_sub,         //  subtract top two stack entries
+        op_mul,         //  multiply top two stack entries
+        op_div,         //  divide top two stack entries
+
+        op_not,         //  boolean negate the top stack entry
+        op_eq,          //  compare the top two stack entries for ==
+        op_neq,         //  compare the top two stack entries for !=
+        op_lt,          //  compare the top two stack entries for <
+        op_lte,         //  compare the top two stack entries for <=
+        op_gt,          //  compare the top two stack entries for >
+        op_gte,         //  compare the top two stack entries for >=
+
+        op_and,         //  logical and top two stack entries
+        op_or,          //  logical or top two stack entries
+
+        op_load,        //  load a variable
+        op_store,       //  store a variable
+
+        op_int,         //  push constant integer into the stack
+        op_true,        //  push constant 0 into the stack
+        op_false,       //  push constant 1 into the stack
+
+        op_jump_if,     //  jump to a relative position in the code if top stack
+                        //  evaluates to false
+        op_jump,        //  jump to a relative position in the code
+
+        op_stk_adj,     //  adjust the stack (for args and locals)
+        op_call,        //  function call
+        op_return       //  return from function
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+        {
+        }
+
+        int execute(std::vector<int> const& code)
+        {
+            return execute(code, code.begin(), stack.begin());
+        }
+
+        std::vector<int> const& get_stack() const { return stack; };
+        std::vector<int>& get_stack() { return stack; };
+
+    private:
+
+        int execute(
+            std::vector<int> const& code            // the program code
+          , std::vector<int>::const_iterator pc     // program counter
+          , std::vector<int>::iterator frame_ptr    // start of arguments and locals
+        );
+
+        std::vector<int> stack;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/annotation.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/annotation.hpp
new file mode 100644
index 00000000..2361a7f4
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/annotation.hpp
@@ -0,0 +1,95 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_ANNOTATION_HPP)
+#define BOOST_SPIRIT_CONJURE_ANNOTATION_HPP
+
+#include <map>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/bool.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The annotation handler links the AST to a map of iterator positions
+    //  for the purpose of subsequent semantic error handling when the
+    //  program is being compiled.
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct annotation
+    {
+        template <typename, typename>
+        struct result { typedef void type; };
+
+        std::vector<Iterator>& iters;
+        annotation(std::vector<Iterator>& iters)
+          : iters(iters) {}
+
+        struct set_id
+        {
+            typedef void result_type;
+
+            int id;
+            set_id(int id) : id(id) {}
+
+            void operator()(ast::function_call& x) const
+            {
+                x.function_name.id = id;
+            }
+
+            void operator()(ast::identifier& x) const
+            {
+                x.id = id;
+            }
+
+            template <typename T>
+            void operator()(T& x) const
+            {
+                // no-op
+            }
+        };
+
+        void operator()(ast::operand& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            boost::apply_visitor(set_id(id), ast);
+        }
+
+        void operator()(ast::variable_declaration& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+
+        void operator()(ast::assignment& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+
+        void operator()(ast::return_statement& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.id = id;
+        }
+
+        void operator()(ast::identifier& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.id = id;
+        }
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/ast.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/ast.hpp
new file mode 100644
index 00000000..d2f893b0
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/ast.hpp
@@ -0,0 +1,209 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_AST_HPP)
+#define BOOST_SPIRIT_CONJURE_AST_HPP
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <boost/optional.hpp>
+#include <list>
+
+#include "ids.hpp"
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct tagged
+    {
+        int id; // Used to annotate the AST with the iterator position.
+                // This id is used as a key to a map<int, Iterator>
+                // (not really part of the AST.)
+    };
+
+    struct nil {};
+    struct unary;
+    struct function_call;
+    struct expression;
+
+    struct identifier : tagged
+    {
+        identifier(std::string const& name = "") : name(name) {}
+        std::string name;
+    };
+
+    typedef boost::variant<
+            nil
+          , bool
+          , unsigned int
+          , identifier
+          , boost::recursive_wrapper<unary>
+          , boost::recursive_wrapper<function_call>
+          , boost::recursive_wrapper<expression>
+        >
+    operand;
+
+    struct unary
+    {
+        token_ids::type operator_;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        token_ids::type operator_;
+        operand operand_;
+    };
+
+    struct function_call
+    {
+        identifier function_name;
+        std::list<expression> args;
+    };
+
+    struct expression
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    struct assignment
+    {
+        identifier lhs;
+        expression rhs;
+    };
+
+    struct variable_declaration
+    {
+        identifier lhs;
+        boost::optional<expression> rhs;
+    };
+
+    struct if_statement;
+    struct while_statement;
+    struct statement_list;
+    struct return_statement;
+
+    typedef boost::variant<
+            variable_declaration
+          , assignment
+          , boost::recursive_wrapper<if_statement>
+          , boost::recursive_wrapper<while_statement>
+          , boost::recursive_wrapper<return_statement>
+          , boost::recursive_wrapper<statement_list>
+        >
+    statement;
+
+    struct statement_list : std::list<statement> {};
+
+    struct if_statement
+    {
+        expression condition;
+        statement then;
+        boost::optional<statement> else_;
+    };
+
+    struct while_statement
+    {
+        expression condition;
+        statement body;
+    };
+
+    struct return_statement : tagged
+    {
+        boost::optional<expression> expr;
+    };
+
+    struct function
+    {
+        std::string return_type;
+        identifier function_name;
+        std::list<identifier> args;
+        statement_list body;
+    };
+
+    typedef std::list<function> function_list;
+
+    // print functions for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil)
+    {
+        out << "nil"; return out;
+    }
+
+    inline std::ostream& operator<<(std::ostream& out, identifier const& id)
+    {
+        out << id.name; return out;
+    }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::unary,
+    (client::token_ids::type, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::operation,
+    (client::token_ids::type, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::function_call,
+    (client::ast::identifier, function_name)
+    (std::list<client::ast::expression>, args)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::expression,
+    (client::ast::operand, first)
+    (std::list<client::ast::operation>, rest)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::variable_declaration,
+    (client::ast::identifier, lhs)
+    (boost::optional<client::ast::expression>, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::assignment,
+    (client::ast::identifier, lhs)
+    (client::ast::expression, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::if_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, then)
+    (boost::optional<client::ast::statement>, else_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::while_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, body)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::return_statement,
+    (boost::optional<client::ast::expression>, expr)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::function,
+    (std::string, return_type)
+    (client::ast::identifier, function_name)
+    (std::list<client::ast::identifier>, args)
+    (client::ast::statement_list, body)
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/compiler.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/compiler.cpp
new file mode 100644
index 00000000..87459b35
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/compiler.cpp
@@ -0,0 +1,622 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "config.hpp"
+#include "compiler.hpp"
+#include "vm.hpp"
+#include <boost/foreach.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/assert.hpp>
+#include <boost/lexical_cast.hpp>
+#include <set>
+
+namespace client { namespace code_gen
+{
+    void function::op(int a)
+    {
+        code.push_back(a);
+        size_ += 1;
+    }
+
+    void function::op(int a, int b)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        size_ += 2;
+    }
+
+    void function::op(int a, int b, int c)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        code.push_back(c);
+        size_ += 3;
+    }
+
+    int const* function::find_var(std::string const& name) const
+    {
+        std::map<std::string, int>::const_iterator i = variables.find(name);
+        if (i == variables.end())
+            return 0;
+        return &i->second;
+    }
+
+    void function::add_var(std::string const& name)
+    {
+        std::size_t n = variables.size();
+        variables[name] = n;
+    }
+
+    void function::link_to(std::string const& name, std::size_t address)
+    {
+        function_calls[address] = name;
+    }
+
+    void function::print_assembler() const
+    {
+        std::vector<int>::const_iterator pc = code.begin() + address;
+
+        std::vector<std::string> locals(variables.size());
+        typedef std::pair<std::string, int> pair;
+        BOOST_FOREACH(pair const& p, variables)
+        {
+            locals[p.second] = p.first;
+            std::cout << "      local       "
+                << p.first << ", @" << p.second << std::endl;
+        }
+
+        std::map<std::size_t, std::string> lines;
+        std::set<std::size_t> jumps;
+
+        while (pc != (code.begin() + address + size_))
+        {
+            std::string line;
+            std::size_t address = pc - code.begin();
+
+            switch (*pc++)
+            {
+                case op_neg:
+                    line += "      op_neg";
+                    break;
+
+                case op_not:
+                    line += "      op_not";
+                    break;
+
+                case op_add:
+                    line += "      op_add";
+                    break;
+
+                case op_sub:
+                    line += "      op_sub";
+                    break;
+
+                case op_mul:
+                    line += "      op_mul";
+                    break;
+
+                case op_div:
+                    line += "      op_div";
+                    break;
+
+                case op_eq:
+                    line += "      op_eq";
+                    break;
+
+                case op_neq:
+                    line += "      op_neq";
+                    break;
+
+                case op_lt:
+                    line += "      op_lt";
+                    break;
+
+                case op_lte:
+                    line += "      op_lte";
+                    break;
+
+                case op_gt:
+                    line += "      op_gt";
+                    break;
+
+                case op_gte:
+                    line += "      op_gte";
+                    break;
+
+                case op_and:
+                    line += "      op_and";
+                    break;
+
+                case op_or:
+                    line += "      op_or";
+                    break;
+
+                case op_load:
+                    line += "      op_load     ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_store:
+                    line += "      op_store    ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_int:
+                    line += "      op_int      ";
+                    line += boost::lexical_cast<std::string>(*pc++);
+                    break;
+
+                case op_true:
+                    line += "      op_true";
+                    break;
+
+                case op_false:
+                    line += "      op_false";
+                    break;
+
+                case op_jump:
+                    {
+                        line += "      op_jump     ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += boost::lexical_cast<std::string>(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_jump_if:
+                    {
+                        line += "      op_jump_if  ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += boost::lexical_cast<std::string>(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_call:
+                    {
+                        line += "      op_call     ";
+                        int nargs = *pc++;
+                        std::size_t jump = *pc++;
+                        line += boost::lexical_cast<std::string>(nargs) + ", ";
+                        BOOST_ASSERT(function_calls.find(jump) != function_calls.end());
+                        line += function_calls.find(jump)->second;
+                    }
+                    break;
+
+                case op_stk_adj:
+                    line += "      op_stk_adj  ";
+                    line += boost::lexical_cast<std::string>(*pc++);
+                    break;
+
+
+                case op_return:
+                    line += "      op_return";
+                    break;
+            }
+            lines[address] = line;
+        }
+
+        std::cout << "start:" << std::endl;
+        typedef std::pair<std::size_t, std::string> line_info;
+        BOOST_FOREACH(line_info const& l, lines)
+        {
+            std::size_t pos = l.first;
+            if (jumps.find(pos) != jumps.end())
+                std::cout << pos << ':' << std::endl;
+            std::cout << l.second << std::endl;
+        }
+
+        std::cout << "end:" << std::endl << std::endl;
+    }
+
+    bool compiler::operator()(unsigned int x)
+    {
+        BOOST_ASSERT(current != 0);
+        current->op(op_int, x);
+        return true;
+    }
+
+    bool compiler::operator()(bool x)
+    {
+        BOOST_ASSERT(current != 0);
+        current->op(x ? op_true : op_false);
+        return true;
+    }
+
+    bool compiler::operator()(ast::identifier const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        int const* p = current->find_var(x.name);
+        if (p == 0)
+        {
+            error_handler(x.id, "Undeclared variable: " + x.name);
+            return false;
+        }
+        current->op(op_load, *p);
+        return true;
+    }
+
+    bool compiler::operator()(token_ids::type const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        switch (x)
+        {
+            case token_ids::plus: current->op(op_add); break;
+            case token_ids::minus: current->op(op_sub); break;
+            case token_ids::times: current->op(op_mul); break;
+            case token_ids::divide: current->op(op_div); break;
+
+            case token_ids::equal: current->op(op_eq); break;
+            case token_ids::not_equal: current->op(op_neq); break;
+            case token_ids::less: current->op(op_lt); break;
+            case token_ids::less_equal: current->op(op_lte); break;
+            case token_ids::greater: current->op(op_gt); break;
+            case token_ids::greater_equal: current->op(op_gte); break;
+
+            case token_ids::logical_or: current->op(op_or); break;
+            case token_ids::logical_and: current->op(op_and); break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::unary const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case token_ids::minus: current->op(op_neg); break;
+            case token_ids::not_: current->op(op_not); break;
+            case token_ids::plus: break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::function_call const& x)
+    {
+        BOOST_ASSERT(current != 0);
+
+        if (functions.find(x.function_name.name) == functions.end())
+        {
+            error_handler(x.function_name.id, "Function not found: " + x.function_name.name);
+            return false;
+        }
+
+        boost::shared_ptr<code_gen::function> p = functions[x.function_name.name];
+
+        if (p->nargs() != x.args.size())
+        {
+            error_handler(x.function_name.id, "Wrong number of arguments: " + x.function_name.name);
+            return false;
+        }
+
+        BOOST_FOREACH(ast::expression const& expr, x.args)
+        {
+            if (!(*this)(expr))
+                return false;
+        }
+
+        current->op(
+            op_call,
+            p->nargs(),
+            p->get_address());
+        current->link_to(x.function_name.name, p->get_address());
+
+        return true;
+    }
+
+    namespace
+    {
+        int precedence[] = {
+            // precedence 1
+            1, // op_comma
+
+            // precedence 2
+            2, // op_assign
+            2, // op_plus_assign
+            2, // op_minus_assign
+            2, // op_times_assign
+            2, // op_divide_assign
+            2, // op_mod_assign
+            2, // op_bit_and_assign
+            2, // op_bit_xor_assign
+            2, // op_bitor_assign
+            2, // op_shift_left_assign
+            2, // op_shift_right_assign
+
+            // precedence 3
+            3, // op_logical_or
+
+            // precedence 4
+            4, // op_logical_and
+
+            // precedence 5
+            5, // op_bit_or
+
+            // precedence 6
+            6, // op_bit_xor
+
+            // precedence 7
+            7, // op_bit_and
+
+            // precedence 8
+            8, // op_equal
+            8, // op_not_equal
+
+            // precedence 9
+            9, // op_less
+            9, // op_less_equal
+            9, // op_greater
+            9, // op_greater_equal
+
+            // precedence 10
+            10, // op_shift_left
+            10, // op_shift_right
+
+            // precedence 11
+            11, // op_plus
+            11, // op_minus
+
+            // precedence 12
+            12, // op_times
+            12, // op_divide
+            12  // op_mod
+        };
+    }
+
+    inline int precedence_of(token_ids::type op)
+    {
+        return precedence[op & 0xFF];
+    }
+
+    // The Shunting-yard algorithm
+    bool compiler::compile_expression(
+        int min_precedence,
+        std::list<ast::operation>::const_iterator& rbegin,
+        std::list<ast::operation>::const_iterator rend)
+    {
+        while ((rbegin != rend) && (precedence_of(rbegin->operator_) >= min_precedence))
+        {
+            token_ids::type op = rbegin->operator_;
+            if (!boost::apply_visitor(*this, rbegin->operand_))
+                return false;
+            ++rbegin;
+
+            while ((rbegin != rend) && (precedence_of(rbegin->operator_) > precedence_of(op)))
+            {
+                token_ids::type next_op = rbegin->operator_;
+                compile_expression(precedence_of(next_op), rbegin, rend);
+            }
+            (*this)(op);
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::expression const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!boost::apply_visitor(*this, x.first))
+            return false;
+        std::list<ast::operation>::const_iterator rbegin = x.rest.begin();
+        if (!compile_expression(0, rbegin, x.rest.end()))
+            return false;
+        return true;
+    }
+
+    bool compiler::operator()(ast::assignment const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!(*this)(x.rhs))
+            return false;
+        int const* p = current->find_var(x.lhs.name);
+        if (p == 0)
+        {
+            error_handler(x.lhs.id, "Undeclared variable: " + x.lhs.name);
+            return false;
+        }
+        current->op(op_store, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable_declaration const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        int const* p = current->find_var(x.lhs.name);
+        if (p != 0)
+        {
+            error_handler(x.lhs.id, "Duplicate variable: " + x.lhs.name);
+            return false;
+        }
+        if (x.rhs) // if there's an RHS initializer
+        {
+            bool r = (*this)(*x.rhs);
+            if (r) // don't add the variable if the RHS fails
+            {
+                current->add_var(x.lhs.name);
+                current->op(op_store, *current->find_var(x.lhs.name));
+            }
+            return r;
+        }
+        else
+        {
+            current->add_var(x.lhs.name);
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::statement const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        return boost::apply_visitor(*this, x);
+    }
+
+    bool compiler::operator()(ast::statement_list const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        BOOST_FOREACH(ast::statement const& s, x)
+        {
+            if (!(*this)(s))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::if_statement const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!(*this)(x.condition))
+            return false;
+        current->op(op_jump_if, 0);                 // we shall fill this (0) in later
+        std::size_t skip = current->size()-1;       // mark its position
+        if (!(*this)(x.then))
+            return false;
+        (*current)[skip] = current->size()-skip;    // now we know where to jump to (after the if branch)
+
+        if (x.else_)                                // We got an alse
+        {
+            (*current)[skip] += 2;                  // adjust for the "else" jump
+            current->op(op_jump, 0);                // we shall fill this (0) in later
+            std::size_t exit = current->size()-1;   // mark its position
+            if (!(*this)(*x.else_))
+                return false;
+            (*current)[exit] = current->size()-exit;// now we know where to jump to (after the else branch)
+        }
+
+        return true;
+    }
+
+    bool compiler::operator()(ast::while_statement const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        std::size_t loop = current->size();         // mark our position
+        if (!(*this)(x.condition))
+            return false;
+        current->op(op_jump_if, 0);                 // we shall fill this (0) in later
+        std::size_t exit = current->size()-1;       // mark its position
+        if (!(*this)(x.body))
+            return false;
+        current->op(op_jump,
+            int(loop-1) - int(current->size()));    // loop back
+        (*current)[exit] = current->size()-exit;    // now we know where to jump to (to exit the loop)
+        return true;
+    }
+
+    bool compiler::operator()(ast::return_statement const& x)
+    {
+        if (void_return)
+        {
+            if (x.expr)
+            {
+                error_handler(x.id, "'void' function returning a value: ");
+                return false;
+            }
+        }
+        else
+        {
+            if (!x.expr)
+            {
+                error_handler(x.id, current_function_name + " function must return a value: ");
+                return false;
+            }
+        }
+
+        if (x.expr)
+        {
+            if (!(*this)(*x.expr))
+                return false;
+        }
+        current->op(op_return);
+        return true;
+    }
+
+    bool compiler::operator()(ast::function const& x)
+    {
+        void_return = x.return_type == "void";
+        if (functions.find(x.function_name.name) != functions.end())
+        {
+            error_handler(x.function_name.id, "Duplicate function: " + x.function_name.name);
+            return false;
+        }
+        boost::shared_ptr<code_gen::function>& p = functions[x.function_name.name];
+        p.reset(new code_gen::function(code, x.args.size()));
+        current = p.get();
+        current_function_name = x.function_name.name;
+
+        // op_stk_adj 0 for now. we'll know how many variables
+        // we'll have later and add them
+        current->op(op_stk_adj, 0);
+        BOOST_FOREACH(ast::identifier const& arg, x.args)
+        {
+            current->add_var(arg.name);
+        }
+
+        if (!(*this)(x.body))
+            return false;
+        (*current)[1] = current->nvars();   // now store the actual number of variables
+                                            // this includes the arguments
+        return true;
+    }
+
+    bool compiler::operator()(ast::function_list const& x)
+    {
+        // Jump to the main function
+        code.push_back(op_jump);
+        code.push_back(0); // we will fill this in later when we finish compiling
+                           // and we know where the main function is
+
+        BOOST_FOREACH(ast::function const& f, x)
+        {
+            if (!(*this)(f))
+            {
+                code.clear();
+                return false;
+            }
+        }
+        // find the main function
+        boost::shared_ptr<code_gen::function> p =
+            find_function("main");
+
+        if (!p) // main function not found
+        {
+            std::cerr << "Error: main function not defined" << std::endl;
+            return false;
+        }
+        code[1] = p->get_address()-1; // jump to this (main function) address
+
+        return true;
+    }
+
+    void compiler::print_assembler() const
+    {
+        typedef std::pair<std::string, boost::shared_ptr<code_gen::function> > pair;
+        BOOST_FOREACH(pair const& p, functions)
+        {
+            std::cout << ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" << std::endl;
+            std::cout << p.second->get_address() << ": function " << p.first << std::endl;
+            p.second->print_assembler();
+        }
+    }
+
+    boost::shared_ptr<code_gen::function>
+    compiler::find_function(std::string const& name) const
+    {
+        function_table::const_iterator i = functions.find(name);
+        if (i == functions.end())
+            return boost::shared_ptr<code_gen::function>();
+        else
+            return i->second;
+    }
+}}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/compiler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/compiler.hpp
new file mode 100644
index 00000000..b49c0ac4
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/compiler.hpp
@@ -0,0 +1,123 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_COMPILER_HPP)
+#define BOOST_SPIRIT_CONJURE_COMPILER_HPP
+
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+#include <map>
+#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+namespace client { namespace code_gen
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Function
+    ///////////////////////////////////////////////////////////////////////////
+    struct function
+    {
+        function(std::vector<int>& code, int nargs)
+          : code(code), address(code.size()), size_(0), nargs_(nargs) {}
+
+        void op(int a);
+        void op(int a, int b);
+        void op(int a, int b, int c);
+
+        int& operator[](std::size_t i) { return code[address+i]; }
+        int const& operator[](std::size_t i) const { return code[address+i]; }
+        std::size_t size() const { return size_; }
+        std::size_t get_address() const { return address; }
+
+        int nargs() const { return nargs_; }
+        int nvars() const { return variables.size(); }
+        int const* find_var(std::string const& name) const;
+        void add_var(std::string const& name);
+        void link_to(std::string const& name, std::size_t address);
+
+        void print_assembler() const;
+
+    private:
+
+        std::map<std::string, int> variables;
+        std::map<std::size_t, std::string> function_calls;
+        std::vector<int>& code;
+        std::size_t address;
+        std::size_t size_;
+        std::size_t nargs_;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ///////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef bool result_type;
+
+        template <typename ErrorHandler>
+        compiler(ErrorHandler& error_handler_)
+          : current(0)
+        {
+            using namespace boost::phoenix::arg_names;
+            namespace phx = boost::phoenix;
+            using boost::phoenix::function;
+
+            error_handler = function<ErrorHandler>(error_handler_)(
+                "Error! ", _2, phx::cref(error_handler_.iters)[_1]);
+        }
+
+        bool operator()(ast::nil) { BOOST_ASSERT(0); return false; }
+        bool operator()(unsigned int x);
+        bool operator()(bool x);
+        bool operator()(ast::identifier const& x);
+        bool operator()(token_ids::type const& x);
+        bool operator()(ast::unary const& x);
+        bool operator()(ast::function_call const& x);
+        bool operator()(ast::expression const& x);
+        bool operator()(ast::assignment const& x);
+        bool operator()(ast::variable_declaration const& x);
+        bool operator()(ast::statement_list const& x);
+        bool operator()(ast::statement const& x);
+        bool operator()(ast::if_statement const& x);
+        bool operator()(ast::while_statement const& x);
+        bool operator()(ast::return_statement const& x);
+        bool operator()(ast::function const& x);
+        bool operator()(ast::function_list const& x);
+
+        void print_assembler() const;
+
+        boost::shared_ptr<code_gen::function>
+        find_function(std::string const& name) const;
+
+        std::vector<int>& get_code() { return code; }
+        std::vector<int> const& get_code() const { return code; }
+
+    private:
+
+        bool compile_expression(
+            int min_precedence,
+            std::list<ast::operation>::const_iterator& rbegin,
+            std::list<ast::operation>::const_iterator rend);
+
+        typedef std::map<std::string, boost::shared_ptr<code_gen::function> > function_table;
+
+        std::vector<int> code;
+        code_gen::function* current;
+        std::string current_function_name;
+        function_table functions;
+        bool void_return;
+
+        boost::function<
+            void(int tag, std::string const& what)>
+        error_handler;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/config.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/config.hpp
new file mode 100644
index 00000000..70af0db0
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/config.hpp
@@ -0,0 +1,51 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_LEXER_CONFIG_HPP)
+#define BOOST_SPIRIT_CONJURE_LEXER_CONFIG_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+// The conjure lexer example can be built in 3 different variations:
+//
+//    - With a lexer using runtime generated DFA tables
+//    - With a lexer using pre-generated (static) DFA tables
+//    - With a lexer using a pre-generated custom switch based state machine
+//
+// Use one of the following preprocessor constants to define, which of those 
+// will be built:
+
+///////////////////////////////////////////////////////////////////////////////
+// Use the lexer based on runtime generated DFA tables
+// #define CONJURE_LEXER_DYNAMIC_TABLES 1
+
+///////////////////////////////////////////////////////////////////////////////
+// Use the lexer based on pre-generated static DFA tables
+// #define CONJURE_LEXER_STATIC_TABLES 1
+
+///////////////////////////////////////////////////////////////////////////////
+// Use the lexer based on runtime generated DFA tables
+// #define CONJURE_LEXER_STATIC_SWITCH 1
+
+///////////////////////////////////////////////////////////////////////////////
+// The default is to use the dynamic table driven lexer
+#if CONJURE_LEXER_DYNAMIC_TABLES == 0 && \
+    CONJURE_LEXER_STATIC_TABLES == 0 && \
+    CONJURE_LEXER_STATIC_SWITCH == 0
+
+#define CONJURE_LEXER_DYNAMIC_TABLES 1
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Make sure we have only one lexer type selected
+#if (CONJURE_LEXER_DYNAMIC_TABLES != 0 && CONJURE_LEXER_STATIC_TABLES != 0) || \
+    (CONJURE_LEXER_DYNAMIC_TABLES != 0 && CONJURE_LEXER_STATIC_SWITCH != 0) || \
+    (CONJURE_LEXER_STATIC_TABLES != 0 && CONJURE_LEXER_STATIC_SWITCH != 0)
+
+#error "Configuration problem: please select exactly one type of lexer to build"
+#endif
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/conjure_static_lexer.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/conjure_static_lexer.hpp
new file mode 100644
index 00000000..d626840b
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/conjure_static_lexer.hpp
@@ -0,0 +1,483 @@
+// Copyright (c) 2008-2009 Ben Hanson
+// Copyright (c) 2008-2011 Hartmut Kaiser
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Auto-generated by boost::lexer, do not edit
+
+#if !defined(BOOST_SPIRIT_LEXER_NEXT_TOKEN_CONJURE_STATIC_JUL_25_2011_07_03_08)
+#define BOOST_SPIRIT_LEXER_NEXT_TOKEN_CONJURE_STATIC_JUL_25_2011_07_03_08
+
+#include <boost/spirit/home/support/detail/lexer/char_traits.hpp>
+
+////////////////////////////////////////////////////////////////////////////////
+// the generated table of state names and the tokenizer have to be
+// defined in the boost::spirit::lex::lexertl::static_ namespace
+namespace boost { namespace spirit { namespace lex { namespace lexertl { namespace static_ {
+
+////////////////////////////////////////////////////////////////////////////////
+// this table defines the names of the lexer states
+char const* const lexer_state_names_conjure_static[1] = 
+{
+    "INITIAL"
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// this variable defines the number of lexer states
+std::size_t const lexer_state_count_conjure_static = 1;
+
+////////////////////////////////////////////////////////////////////////////////
+// this function returns the next matched token
+template<typename Iterator>
+std::size_t next_token_conjure_static (std::size_t& /*start_state_*/, bool& /*bol_*/, 
+    Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+{
+    enum {end_state_index, id_index, unique_id_index, state_index, bol_index,
+        eol_index, dead_state_index, dfa_offset};
+
+    static std::size_t const npos = static_cast<std::size_t>(~0);
+    static std::size_t const lookup_[256] = {
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 7, 7, 41, 41, 7, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        7, 8, 41, 41, 41, 41, 9, 41,
+        10, 11, 12, 13, 14, 15, 41, 16,
+        17, 17, 17, 17, 17, 17, 17, 17,
+        17, 17, 41, 19, 20, 21, 22, 41,
+        41, 18, 18, 18, 18, 18, 18, 18,
+        18, 18, 18, 18, 18, 18, 18, 18,
+        18, 18, 18, 18, 18, 18, 18, 18,
+        18, 18, 18, 41, 41, 41, 41, 18,
+        41, 23, 18, 18, 24, 25, 26, 18,
+        27, 28, 18, 18, 29, 18, 30, 31,
+        18, 18, 32, 33, 34, 35, 36, 37,
+        18, 18, 18, 38, 39, 40, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41 };
+    static std::size_t const dfa_alphabet_ = 42;
+    static std::size_t const dfa_[2604] = {
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 27, 13, 11, 20, 21, 18, 16,
+        24, 17, 19, 2, 26, 25, 14, 12,
+        15, 26, 26, 7, 4, 26, 6, 26,
+        26, 26, 9, 26, 3, 26, 5, 8,
+        22, 10, 23, 0, 1, 35, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 2, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 28, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 29,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 30, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 32, 26,
+        26, 26, 31, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 33, 26, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 34, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 35, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 36, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 37,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 61, 26, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 38, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 262177, 20, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 39,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 131091, 12, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 40, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 131093,
+        14, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 41, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 393241, 16, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 393242, 17, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 131099, 18, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 131100,
+        19, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 42, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 40, 21, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 41, 22, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 123, 23, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 125,
+        24, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 44, 25, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 59, 27, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 34,
+        30, 0, 0, 0, 0, 27, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 43, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 44,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        45, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        46, 26, 26, 26, 0, 0, 0, 0,
+        1, 65538, 4, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 47, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        48, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        49, 26, 26, 26, 0, 0, 0, 0,
+        1, 131084, 8, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 131085, 9, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 131089, 10, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 131090,
+        11, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 131092, 13, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 131094, 15, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 42, 42, 42, 42, 42,
+        50, 42, 42, 42, 42, 42, 42, 42,
+        42, 42, 42, 42, 42, 42, 42, 42,
+        42, 42, 42, 42, 42, 42, 42, 42,
+        42, 42, 42, 42, 42, 42, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 51,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 43, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 52, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 65537, 3, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 53,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 54, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 55, 26, 26,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 56, 56, 56, 56, 56,
+        50, 56, 56, 56, 57, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 1, 36,
+        1, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 65536, 2, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 65539, 5, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 58, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 59, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 56,
+        56, 56, 56, 56, 60, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 1, 33, 29, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 65540, 6, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 61, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 56,
+        56, 56, 56, 56, 60, 56, 56, 56,
+        57, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 1, 65541, 7, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0 };
+
+    if (start_token_ == end_)
+    {
+        unique_id_ = npos;
+        return 0;
+    }
+
+    std::size_t const* ptr_ = dfa_ + dfa_alphabet_;
+    Iterator curr_ = start_token_;
+    bool end_state_ = *ptr_ != 0;
+    std::size_t id_ = *(ptr_ + id_index);
+    std::size_t uid_ = *(ptr_ + unique_id_index);
+    Iterator end_token_ = start_token_;
+
+    while (curr_ != end_)
+    {
+        std::size_t const state_ =
+            ptr_[lookup_[static_cast<unsigned char>(*curr_++)]];
+
+        if (state_ == 0) break;
+
+        ptr_ = &dfa_[state_ * dfa_alphabet_];
+
+        if (*ptr_)
+        {
+            end_state_ = true;
+            id_ = *(ptr_ + id_index);
+            uid_ = *(ptr_ + unique_id_index);
+            end_token_ = curr_;
+        }
+    }
+
+    if (end_state_)
+    {
+        // return longest match
+        start_token_ = end_token_;
+    }
+    else
+    {
+        id_ = npos;
+        uid_ = npos;
+    }
+
+    unique_id_ = uid_;
+    return id_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// this defines a generic accessors for the information above
+struct lexer_conjure_static
+{
+    // version number and feature-set of compatible static lexer engine
+    enum
+    {
+        static_version = 65536,
+        supports_bol = false,
+        supports_eol = false
+    };
+
+    // return the number of lexer states
+    static std::size_t state_count()
+    {
+        return lexer_state_count_conjure_static; 
+    }
+
+    // return the name of the lexer state as given by 'idx'
+    static char const* state_name(std::size_t idx)
+    {
+        return lexer_state_names_conjure_static[idx]; 
+    }
+
+    // return the next matched token
+    template<typename Iterator>
+    static std::size_t next(std::size_t &start_state_, bool& bol_
+      , Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+    {
+        return next_token_conjure_static(start_state_, bol_, start_token_, end_, unique_id_);
+    }
+};
+
+}}}}}  // namespace boost::spirit::lex::lexertl::static_
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/conjure_static_lexer_generate.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/conjure_static_lexer_generate.cpp
new file mode 100644
index 00000000..1ba8fac0
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/conjure_static_lexer_generate.cpp
@@ -0,0 +1,43 @@
+//  Copyright (c) 2001-2011 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)
+
+// This small utility program generates the 2 static lexers, the static table 
+// driven and the static switch based lexer.
+
+#include <fstream>
+#include <iostream>
+
+#include "lexer_def.hpp"
+#include <boost/spirit/include/lex_generate_static_lexertl.hpp>
+
+int main()
+{
+    typedef std::string::const_iterator base_iterator_type;
+    typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+
+    lexer_type lexer;
+
+    // first generate the static switch based lexer 
+    std::ofstream out_static("conjure_static_switch_lexer.hpp");
+
+    bool result = boost::spirit::lex::lexertl::generate_static_switch(
+        lexer, out_static, "conjure_static_switch");
+    if (!result) {
+        std::cerr << "Failed to generate static switch based lexer\n";
+        return -1;
+    }
+
+    // now generate the static table based lexer 
+    std::ofstream out("conjure_static_lexer.hpp");
+    result = boost::spirit::lex::lexertl::generate_static(
+        lexer, out, "conjure_static");
+    if (!result) {
+        std::cerr << "Failed to generate static table based lexer\n";
+        return -1;
+    }
+
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/conjure_static_switch_lexer.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/conjure_static_switch_lexer.hpp
new file mode 100644
index 00000000..3b23016b
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/conjure_static_switch_lexer.hpp
@@ -0,0 +1,873 @@
+// Copyright (c) 2008-2009 Ben Hanson
+// Copyright (c) 2008-2011 Hartmut Kaiser
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Auto-generated by boost::lexer, do not edit
+
+#if !defined(BOOST_SPIRIT_LEXER_NEXT_TOKEN_CONJURE_STATIC_SWITCH_JUL_25_2011_07_03_08)
+#define BOOST_SPIRIT_LEXER_NEXT_TOKEN_CONJURE_STATIC_SWITCH_JUL_25_2011_07_03_08
+
+#include <boost/spirit/home/support/detail/lexer/char_traits.hpp>
+
+////////////////////////////////////////////////////////////////////////////////
+// the generated table of state names and the tokenizer have to be
+// defined in the boost::spirit::lex::lexertl::static_ namespace
+namespace boost { namespace spirit { namespace lex { namespace lexertl { namespace static_ {
+
+////////////////////////////////////////////////////////////////////////////////
+// this table defines the names of the lexer states
+char const* const lexer_state_names_conjure_static_switch[1] = 
+{
+    "INITIAL"
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// this variable defines the number of lexer states
+std::size_t const lexer_state_count_conjure_static_switch = 1;
+
+////////////////////////////////////////////////////////////////////////////////
+// this function returns the next matched token
+template<typename Iterator>
+std::size_t next_token_conjure_static_switch (std::size_t& /*start_state_*/, bool& /*bol_*/, 
+    Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+{
+    static std::size_t const npos = static_cast<std::size_t>(~0);
+
+    if (start_token_ == end_)
+    {
+        unique_id_ = npos;
+        return 0;
+    }
+
+    Iterator curr_ = start_token_;
+    bool end_state_ = false;
+    std::size_t id_ = npos;
+    std::size_t uid_ = npos;
+    Iterator end_token_ = start_token_;
+
+    char ch_ = 0;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9')) goto state0_1;
+
+    if (ch_ == 't') goto state0_2;
+
+    if (ch_ == 'f') goto state0_3;
+
+    if (ch_ == 'v') goto state0_4;
+
+    if (ch_ == 'i') goto state0_5;
+
+    if (ch_ == 'e') goto state0_6;
+
+    if (ch_ == 'w') goto state0_7;
+
+    if (ch_ == 'r') goto state0_8;
+
+    if (ch_ == '|') goto state0_9;
+
+    if (ch_ == '&') goto state0_10;
+
+    if (ch_ == '=') goto state0_11;
+
+    if (ch_ == '!') goto state0_12;
+
+    if (ch_ == '<') goto state0_13;
+
+    if (ch_ == '>') goto state0_14;
+
+    if (ch_ == '+') goto state0_15;
+
+    if (ch_ == '-') goto state0_16;
+
+    if (ch_ == '*') goto state0_17;
+
+    if (ch_ == '/') goto state0_18;
+
+    if (ch_ == '(') goto state0_19;
+
+    if (ch_ == ')') goto state0_20;
+
+    if (ch_ == '{') goto state0_21;
+
+    if (ch_ == '}') goto state0_22;
+
+    if (ch_ == ',') goto state0_23;
+
+    if (ch_ == ';') goto state0_24;
+
+    if ((ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'g' && ch_ <= 'h') || (ch_ >= 'j' && ch_ <= 'q') || ch_ == 's' || ch_ == 'u' || (ch_ >= 'x' && ch_ <= 'z')) goto state0_25;
+
+    if ((ch_ >= '\t' && ch_ <= '\n') || ch_ == '\r' || ch_ == ' ') goto state0_26;
+    goto end;
+
+state0_1:
+    end_state_ = true;
+    id_ = 35;
+    uid_ = 0;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9')) goto state0_1;
+    goto end;
+
+state0_2:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'q') || (ch_ >= 's' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'r') goto state0_27;
+    goto end;
+
+state0_3:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'b' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'a') goto state0_28;
+    goto end;
+
+state0_4:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'n') || (ch_ >= 'p' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'o') goto state0_29;
+    goto end;
+
+state0_5:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'e') || (ch_ >= 'g' && ch_ <= 'm') || (ch_ >= 'o' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'n') goto state0_30;
+
+    if (ch_ == 'f') goto state0_31;
+    goto end;
+
+state0_6:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'k') || (ch_ >= 'm' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'l') goto state0_32;
+    goto end;
+
+state0_7:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'g') || (ch_ >= 'i' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'h') goto state0_33;
+    goto end;
+
+state0_8:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'f' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'e') goto state0_34;
+    goto end;
+
+state0_9:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '|') goto state0_35;
+    goto end;
+
+state0_10:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '&') goto state0_36;
+    goto end;
+
+state0_11:
+    end_state_ = true;
+    id_ = 61;
+    uid_ = 26;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '=') goto state0_37;
+    goto end;
+
+state0_12:
+    end_state_ = true;
+    id_ = 262177;
+    uid_ = 20;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '=') goto state0_38;
+    goto end;
+
+state0_13:
+    end_state_ = true;
+    id_ = 131091;
+    uid_ = 12;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '=') goto state0_39;
+    goto end;
+
+state0_14:
+    end_state_ = true;
+    id_ = 131093;
+    uid_ = 14;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '=') goto state0_40;
+    goto end;
+
+state0_15:
+    end_state_ = true;
+    id_ = 393241;
+    uid_ = 16;
+    end_token_ = curr_;
+    goto end;
+
+state0_16:
+    end_state_ = true;
+    id_ = 393242;
+    uid_ = 17;
+    end_token_ = curr_;
+    goto end;
+
+state0_17:
+    end_state_ = true;
+    id_ = 131099;
+    uid_ = 18;
+    end_token_ = curr_;
+    goto end;
+
+state0_18:
+    end_state_ = true;
+    id_ = 131100;
+    uid_ = 19;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '*') goto state0_41;
+    goto end;
+
+state0_19:
+    end_state_ = true;
+    id_ = 40;
+    uid_ = 21;
+    end_token_ = curr_;
+    goto end;
+
+state0_20:
+    end_state_ = true;
+    id_ = 41;
+    uid_ = 22;
+    end_token_ = curr_;
+    goto end;
+
+state0_21:
+    end_state_ = true;
+    id_ = 123;
+    uid_ = 23;
+    end_token_ = curr_;
+    goto end;
+
+state0_22:
+    end_state_ = true;
+    id_ = 125;
+    uid_ = 24;
+    end_token_ = curr_;
+    goto end;
+
+state0_23:
+    end_state_ = true;
+    id_ = 44;
+    uid_ = 25;
+    end_token_ = curr_;
+    goto end;
+
+state0_24:
+    end_state_ = true;
+    id_ = 59;
+    uid_ = 27;
+    end_token_ = curr_;
+    goto end;
+
+state0_25:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_26:
+    end_state_ = true;
+    id_ = 34;
+    uid_ = 30;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '\t' && ch_ <= '\n') || ch_ == '\r' || ch_ == ' ') goto state0_26;
+    goto end;
+
+state0_27:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 't') || (ch_ >= 'v' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'u') goto state0_42;
+    goto end;
+
+state0_28:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'k') || (ch_ >= 'm' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'l') goto state0_43;
+    goto end;
+
+state0_29:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'h') || (ch_ >= 'j' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'i') goto state0_44;
+    goto end;
+
+state0_30:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 's') || (ch_ >= 'u' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 't') goto state0_45;
+    goto end;
+
+state0_31:
+    end_state_ = true;
+    id_ = 65538;
+    uid_ = 4;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_32:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'r') || (ch_ >= 't' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 's') goto state0_46;
+    goto end;
+
+state0_33:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'h') || (ch_ >= 'j' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'i') goto state0_47;
+    goto end;
+
+state0_34:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 's') || (ch_ >= 'u' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 't') goto state0_48;
+    goto end;
+
+state0_35:
+    end_state_ = true;
+    id_ = 131084;
+    uid_ = 8;
+    end_token_ = curr_;
+    goto end;
+
+state0_36:
+    end_state_ = true;
+    id_ = 131085;
+    uid_ = 9;
+    end_token_ = curr_;
+    goto end;
+
+state0_37:
+    end_state_ = true;
+    id_ = 131089;
+    uid_ = 10;
+    end_token_ = curr_;
+    goto end;
+
+state0_38:
+    end_state_ = true;
+    id_ = 131090;
+    uid_ = 11;
+    end_token_ = curr_;
+    goto end;
+
+state0_39:
+    end_state_ = true;
+    id_ = 131092;
+    uid_ = 13;
+    end_token_ = curr_;
+    goto end;
+
+state0_40:
+    end_state_ = true;
+    id_ = 131094;
+    uid_ = 15;
+    end_token_ = curr_;
+    goto end;
+
+state0_41:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ != '*') goto state0_41;
+
+    if (ch_ == '*') goto state0_49;
+    goto end;
+
+state0_42:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'f' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'e') goto state0_50;
+    goto end;
+
+state0_43:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'r') || (ch_ >= 't' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 's') goto state0_42;
+    goto end;
+
+state0_44:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'c') || (ch_ >= 'e' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'd') goto state0_51;
+    goto end;
+
+state0_45:
+    end_state_ = true;
+    id_ = 65537;
+    uid_ = 3;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_46:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'f' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'e') goto state0_52;
+    goto end;
+
+state0_47:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'k') || (ch_ >= 'm' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'l') goto state0_53;
+    goto end;
+
+state0_48:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 't') || (ch_ >= 'v' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'u') goto state0_54;
+    goto end;
+
+state0_49:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '*') goto state0_49;
+
+    if (ch_ != '*' && ch_ != '/') goto state0_55;
+
+    if (ch_ == '/') goto state0_56;
+    goto end;
+
+state0_50:
+    end_state_ = true;
+    id_ = 36;
+    uid_ = 1;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_51:
+    end_state_ = true;
+    id_ = 65536;
+    uid_ = 2;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_52:
+    end_state_ = true;
+    id_ = 65539;
+    uid_ = 5;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_53:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'f' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'e') goto state0_57;
+    goto end;
+
+state0_54:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'q') || (ch_ >= 's' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'r') goto state0_58;
+    goto end;
+
+state0_55:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ != '*') goto state0_55;
+
+    if (ch_ == '*') goto state0_59;
+    goto end;
+
+state0_56:
+    end_state_ = true;
+    id_ = 33;
+    uid_ = 29;
+    end_token_ = curr_;
+    goto end;
+
+state0_57:
+    end_state_ = true;
+    id_ = 65540;
+    uid_ = 6;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_58:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'm') || (ch_ >= 'o' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'n') goto state0_60;
+    goto end;
+
+state0_59:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ != '*' && ch_ != '/') goto state0_55;
+
+    if (ch_ == '/') goto state0_56;
+
+    if (ch_ == '*') goto state0_59;
+    goto end;
+
+state0_60:
+    end_state_ = true;
+    id_ = 65541;
+    uid_ = 7;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+
+end:
+    if (end_state_)
+    {
+        // return longest match
+        start_token_ = end_token_;
+    }
+    else
+    {
+        id_ = npos;
+        uid_ = npos;
+    }
+
+    unique_id_ = uid_;
+    return id_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// this defines a generic accessors for the information above
+struct lexer_conjure_static_switch
+{
+    // version number and feature-set of compatible static lexer engine
+    enum
+    {
+        static_version = 65536,
+        supports_bol = false,
+        supports_eol = false
+    };
+
+    // return the number of lexer states
+    static std::size_t state_count()
+    {
+        return lexer_state_count_conjure_static_switch; 
+    }
+
+    // return the name of the lexer state as given by 'idx'
+    static char const* state_name(std::size_t idx)
+    {
+        return lexer_state_names_conjure_static_switch[idx]; 
+    }
+
+    // return the next matched token
+    template<typename Iterator>
+    static std::size_t next(std::size_t &start_state_, bool& bol_
+      , Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+    {
+        return next_token_conjure_static_switch(start_state_, bol_, start_token_, end_, unique_id_);
+    }
+};
+
+}}}}}  // namespace boost::spirit::lex::lexertl::static_
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/error_handler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/error_handler.hpp
new file mode 100644
index 00000000..2b1ee5b2
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/error_handler.hpp
@@ -0,0 +1,105 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_CONJURE_ERROR_HANDLER_HPP
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The error handler
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename BaseIterator, typename Iterator>
+    struct error_handler
+    {
+        template <typename, typename, typename>
+        struct result { typedef void type; };
+
+        error_handler(BaseIterator first, BaseIterator last)
+          : first(first), last(last) {}
+
+        template <typename Message, typename What>
+        void operator()(
+            Message const& message,
+            What const& what,
+            Iterator err_pos) const
+        {
+            // retrieve underlying iterator from current token, err_pos points
+            // to the last validly matched token, so we use its end iterator 
+            // as the error position
+            BaseIterator err_pos_base = err_pos->matched().end();
+            std::cout << message << what << std::endl;
+            if (err_pos_base != BaseIterator())
+                dump_error_line(err_pos_base);
+        }
+        
+        void dump_error_line(BaseIterator err_pos_base) const
+        {
+            int line;
+            BaseIterator line_start = get_pos(err_pos_base, line);
+            if (err_pos_base != last)
+            {
+                std::cout << " line " << line << ':' << std::endl;
+                std::cout << get_line(line_start) << std::endl;
+                for (; line_start != err_pos_base; ++line_start)
+                    std::cout << ' ';
+                std::cout << '^' << std::endl;
+            }
+            else
+            {
+                std::cout << "Unexpected end of file.\n";
+            }
+            
+        }
+
+        BaseIterator get_pos(BaseIterator err_pos, int& line) const
+        {
+            line = 1;
+            BaseIterator i = first;
+            BaseIterator line_start = first;
+            while (i != err_pos)
+            {
+                bool eol = false;
+                if (i != err_pos && *i == '\r') // CR
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (i != err_pos && *i == '\n') // LF
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (eol)
+                    ++line;
+                else
+                    ++i;
+            }
+            return line_start;
+        }
+
+        std::string get_line(BaseIterator err_pos) const
+        {
+            BaseIterator i = err_pos;
+            // position i to the next EOL
+            while (i != last && (*i != '\r' && *i != '\n'))
+                ++i;
+            return std::string(err_pos, i);
+        }
+
+        BaseIterator first;
+        BaseIterator last;
+        std::vector<Iterator> iters;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/expression.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/expression.cpp
new file mode 100644
index 00000000..5b51ce36
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/expression.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "config.hpp"
+#include "lexer.hpp"
+#include "expression_def.hpp"
+
+typedef std::string::const_iterator base_iterator_type;
+typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+typedef lexer_type::iterator_type iterator_type;
+
+template struct client::parser::expression<iterator_type, lexer_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/expression.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/expression.hpp
new file mode 100644
index 00000000..a5d431ef
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/expression.hpp
@@ -0,0 +1,58 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_EXPRESSION_HPP)
+#define BOOST_SPIRIT_CONJURE_EXPRESSION_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+// #define BOOST_SPIRIT_QI_DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/spirit/include/qi.hpp>
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+
+namespace client { namespace parser
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The expression grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer>
+    struct expression : qi::grammar<Iterator, ast::expression()>
+    {
+        typedef error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+
+        expression(error_handler_type& error_handler, Lexer const& l);
+
+        Lexer const& lexer;
+
+        qi::rule<Iterator, ast::expression()> expr;
+        qi::rule<Iterator, ast::operand()> unary_expr, primary_expr;
+        qi::rule<Iterator, ast::function_call()> function_call;
+        qi::rule<Iterator, std::list<ast::expression>()> argument_list;
+        qi::rule<Iterator, std::string()> identifier;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/expression_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/expression_def.hpp
new file mode 100644
index 00000000..795051eb
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/expression_def.hpp
@@ -0,0 +1,94 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "expression.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/lex_plain_token.hpp>
+
+namespace client { namespace parser
+{
+    template <typename Iterator, typename Lexer>
+    expression<Iterator, Lexer>::expression(
+            error_handler<typename Lexer::base_iterator_type, Iterator>& error_handler
+          , Lexer const& l)
+      : expression::base_type(expr), lexer(l)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+        qi::tokenid_mask_type tokenid_mask;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef client::error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+        typedef function<error_handler_type> error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Main expression grammar
+        expr =
+                unary_expr
+            >>  *(tokenid_mask(token_ids::op_binary) > unary_expr)
+            ;
+
+        unary_expr =
+                primary_expr
+            |   (tokenid_mask(token_ids::op_unary) > unary_expr)
+            ;
+
+        primary_expr =
+                lexer.lit_uint
+            |   function_call
+            |   identifier
+            |   lexer.true_or_false
+            |   '(' > expr > ')'
+            ;
+
+        function_call =
+                (identifier >> '(')
+            >   argument_list
+            >   ')'
+            ;
+
+        argument_list = -(expr % ',');
+
+        identifier = lexer.identifier;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (expr)
+            (unary_expr)
+            (primary_expr)
+            (function_call)
+            (argument_list)
+            (identifier)
+        );
+
+        ///////////////////////////////////////////////////////////////////////
+        // Error handling: on error in expr, call error_handler.
+        on_error<fail>(expr,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        ///////////////////////////////////////////////////////////////////////
+        // Annotation: on success in primary_expr, call annotation.
+        on_success(primary_expr,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/function.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/function.cpp
new file mode 100644
index 00000000..98c8169b
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/function.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "config.hpp"
+#include "lexer.hpp"
+#include "function_def.hpp"
+
+typedef std::string::const_iterator base_iterator_type;
+typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+typedef lexer_type::iterator_type iterator_type;
+
+template struct client::parser::function<iterator_type, lexer_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/function.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/function.hpp
new file mode 100644
index 00000000..fc5263f1
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/function.hpp
@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_FUNCTION_HPP)
+#define BOOST_SPIRIT_CONJURE_FUNCTION_HPP
+
+#include "statement.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The function grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer>
+    struct function : qi::grammar<Iterator, ast::function()>
+    {
+        typedef error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+
+        function(error_handler_type& error_handler, Lexer const& l);
+
+        statement<Iterator, Lexer> body;
+
+        qi::rule<Iterator, ast::identifier()> identifier;
+        qi::rule<Iterator, std::list<ast::identifier>()> argument_list;
+        qi::rule<Iterator, ast::function()> start;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/function_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/function_def.hpp
new file mode 100644
index 00000000..72bab856
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/function_def.hpp
@@ -0,0 +1,64 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "function.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator, typename Lexer>
+    function<Iterator, Lexer>::function(
+            error_handler<typename Lexer::base_iterator_type, Iterator>& error_handler
+          , Lexer const& l)
+      : function::base_type(start), body(error_handler, l)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef client::error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+        typedef function<error_handler_type> error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        identifier = body.expr.identifier;
+        argument_list = -(identifier % ',');
+
+        start = (l.token("void") | l.token("int"))
+            >   identifier
+            >   '(' > argument_list > ')'
+            >   '{' > body > '}'
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (identifier)
+            (argument_list)
+            (start)
+        );
+
+        // Error handling: on error in start, call error_handler.
+        on_error<fail>(start,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in start, call annotation.
+        on_success(identifier,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/ids.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/ids.hpp
new file mode 100644
index 00000000..9446074c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/ids.hpp
@@ -0,0 +1,154 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_IDS_HPP)
+#define BOOST_SPIRIT_CONJURE_IDS_HPP
+
+namespace client
+{
+    struct op_type
+    {
+        enum type
+        {
+            binary = 0x20000,
+            unary = 0x40000,
+            assign = 0x80000
+        };
+    };
+
+    struct op
+    {
+        enum type
+        {
+            // binary
+            comma,
+            assign,
+            plus_assign,
+            minus_assign,
+            times_assign,
+            divide_assign,
+            mod_assign,
+            bit_and_assign,
+            bit_xor_assign,
+            bit_or_assign,
+            shift_left_assign,
+            shift_right_assign,
+            logical_or,
+            logical_and,
+            bit_or,
+            bit_xor,
+            bit_and,
+            equal,
+            not_equal,
+            less,
+            less_equal,
+            greater,
+            greater_equal,
+            shift_left,
+            shift_right,
+            plus,
+            minus,
+            times,
+            divide,
+            mod,
+
+            // unary
+            plus_plus,
+            minus_minus,
+            compl_,
+            not_,
+        };
+    };
+
+    template <int type, int op>
+    struct make_op
+    {
+        static int const value = type + op;
+    };
+
+    template <op::type op>
+    struct unary_op : make_op<op_type::unary, op> {};
+
+    template <op::type op>
+    struct binary_op
+        : make_op<op_type::binary, op> {};
+
+    template <op::type op>
+    struct assign_op
+        : make_op<op_type::assign, op> {};
+
+    template <op::type op>
+    struct binary_or_unary_op
+        : make_op<op_type::unary | op_type::binary, op> {};
+
+    struct token_ids
+    {
+        enum type
+        {
+            // pseudo tags
+            invalid             = -1,
+            op_binary           = op_type::binary,
+            op_unary            = op_type::unary,
+            op_assign           = op_type::assign,
+
+            // binary / unary operators with common tokens
+            // '+' and '-' can be binary or unary
+            // (the lexer cannot distinguish which)
+            plus                = binary_or_unary_op<op::plus>::value,
+            minus               = binary_or_unary_op<op::minus>::value,
+
+            // binary operators
+            comma               = binary_op<op::comma>::value,
+            assign              = assign_op<op::assign>::value,
+            plus_assign         = assign_op<op::plus_assign>::value,
+            minus_assign        = assign_op<op::minus_assign>::value,
+            times_assign        = assign_op<op::times_assign>::value,
+            divide_assign       = assign_op<op::divide_assign>::value,
+            mod_assign          = assign_op<op::mod_assign>::value,
+            bit_and_assign      = assign_op<op::bit_and_assign>::value,
+            bit_xor_assign      = assign_op<op::bit_xor_assign>::value,
+            bit_or_assign       = assign_op<op::bit_or_assign>::value,
+            shift_left_assign   = assign_op<op::shift_left_assign>::value,
+            shift_right_assign  = assign_op<op::shift_right_assign>::value,
+            logical_or          = binary_op<op::logical_or>::value,
+            logical_and         = binary_op<op::logical_and>::value,
+            bit_or              = binary_op<op::bit_or>::value,
+            bit_xor             = binary_op<op::bit_xor>::value,
+            bit_and             = binary_op<op::bit_and>::value,
+            equal               = binary_op<op::equal>::value,
+            not_equal           = binary_op<op::not_equal>::value,
+            less                = binary_op<op::less>::value,
+            less_equal          = binary_op<op::less_equal>::value,
+            greater             = binary_op<op::greater>::value,
+            greater_equal       = binary_op<op::greater_equal>::value,
+            shift_left          = binary_op<op::shift_left>::value,
+            shift_right         = binary_op<op::shift_right>::value,
+            times               = binary_op<op::times>::value,
+            divide              = binary_op<op::divide>::value,
+            mod                 = binary_op<op::mod>::value,
+
+            // unary operators with overlaps
+            // '++' and '--' can be prefix or postfix
+            // (the lexer cannot distinguish which)
+            plus_plus           = unary_op<op::plus_plus>::value,
+            minus_minus         = unary_op<op::minus_minus>::value,
+
+            // unary operators
+            compl_              = unary_op<op::compl_>::value,
+            not_                = unary_op<op::not_>::value,
+
+            // misc tags
+            identifier          = op::not_ + 1,
+            comment,
+            whitespace,
+            lit_uint,
+            true_or_false
+        };
+    };
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/lexer.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/lexer.cpp
new file mode 100644
index 00000000..7ce7ec0c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/lexer.cpp
@@ -0,0 +1,17 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "config.hpp"
+#include "lexer_def.hpp"
+
+typedef std::string::const_iterator base_iterator_type;
+template client::lexer::conjure_tokens<base_iterator_type>::conjure_tokens();
+template bool client::lexer::conjure_tokens<base_iterator_type>::add_keyword(
+    std::string const&);
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/lexer.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/lexer.hpp
new file mode 100644
index 00000000..c4945779
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/lexer.hpp
@@ -0,0 +1,128 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_LEXER_HPP)
+#define BOOST_SPIRIT_CONJURE_LEXER_HPP
+
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/lex_lexertl_position_token.hpp>
+
+#include "config.hpp"
+#include "ids.hpp"
+
+#if CONJURE_LEXER_STATIC_TABLES != 0
+#include <boost/spirit/include/lex_static_lexertl.hpp>
+#include "conjure_static_lexer.hpp"
+#elif CONJURE_LEXER_STATIC_SWITCH != 0
+#include <boost/spirit/include/lex_static_lexertl.hpp>
+#include "conjure_static_switch_lexer.hpp"
+#endif
+#include <boost/assert.hpp>
+
+namespace client { namespace lexer
+{
+    namespace lex = boost::spirit::lex;
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        namespace lex = boost::spirit::lex;
+
+        template <typename BaseIterator>
+        struct get_lexer_type
+        {
+            // Our token needs to be able to carry several token values:
+            // std::string, unsigned int, and bool
+            typedef boost::mpl::vector<std::string, unsigned int, bool>
+                token_value_types;
+
+            // Using the position_token class as the token type to be returned
+            // from the lexer iterators allows to retain positional information
+            // as every token instance stores an iterator pair pointing to the
+            // matched input sequence.
+            typedef lex::lexertl::position_token<
+                BaseIterator, token_value_types, boost::mpl::false_
+            > token_type;
+
+#if CONJURE_LEXER_DYNAMIC_TABLES != 0
+            // use the lexer based on runtime generated DFA tables
+            typedef lex::lexertl::actor_lexer<token_type> type;
+#elif CONJURE_LEXER_STATIC_TABLES != 0
+            // use the lexer based on pre-generated static DFA tables
+            typedef lex::lexertl::static_actor_lexer<
+                token_type
+              , boost::spirit::lex::lexertl::static_::lexer_conjure_static
+            > type;
+#elif CONJURE_LEXER_STATIC_SWITCH != 0
+            // use the lexer based on pre-generated static code
+            typedef lex::lexertl::static_actor_lexer<
+                token_type
+              , boost::spirit::lex::lexertl::static_::lexer_conjure_static_switch
+            > type;
+#else
+#error "Configuration problem: please select exactly one type of lexer to build"
+#endif
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename BaseIterator>
+    struct conjure_tokens
+      : lex::lexer<typename detail::get_lexer_type<BaseIterator>::type>
+    {
+    private:
+        // get the type of any qi::raw_token(...) and qi::token(...) constructs
+        typedef typename boost::spirit::result_of::terminal<
+            boost::spirit::tag::raw_token(token_ids::type)
+        >::type raw_token_spec;
+
+        typedef typename boost::spirit::result_of::terminal<
+            boost::spirit::tag::token(token_ids::type)
+        >::type token_spec;
+
+        typedef std::map<std::string, token_ids::type> keyword_map_type;
+
+    protected:
+        // add a keyword to the mapping table
+        bool add_keyword(std::string const& keyword);
+
+    public:
+        typedef BaseIterator base_iterator_type;
+
+        conjure_tokens();
+
+        // extract a raw_token(id) for the given registered keyword
+        raw_token_spec operator()(std::string const& kwd) const
+        {
+            namespace qi = boost::spirit::qi;
+            qi::raw_token_type raw_token;
+
+            typename keyword_map_type::const_iterator it = keywords_.find(kwd);
+            BOOST_ASSERT(it != keywords_.end());
+            return raw_token((it != keywords_.end()) ? (*it).second : token_ids::invalid);
+        }
+
+        // extract a token(id) for the given registered keyword
+        token_spec token(std::string const& kwd) const
+        {
+            namespace qi = boost::spirit::qi;
+            qi::token_type token;
+
+            typename keyword_map_type::const_iterator it = keywords_.find(kwd);
+            BOOST_ASSERT(it != keywords_.end());
+            return token((it != keywords_.end()) ? (*it).second : token_ids::invalid);
+        }
+
+        lex::token_def<std::string> identifier;
+        lex::token_def<unsigned int> lit_uint;
+        lex::token_def<bool> true_or_false;
+        keyword_map_type keywords_;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/lexer_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/lexer_def.hpp
new file mode 100644
index 00000000..cab990f7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/lexer_def.hpp
@@ -0,0 +1,74 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+
+#include "lexer.hpp"
+
+namespace client { namespace lexer
+{
+    template <typename BaseIterator>
+    conjure_tokens<BaseIterator>::conjure_tokens()
+      : identifier("[a-zA-Z_][a-zA-Z_0-9]*", token_ids::identifier)
+      , lit_uint("[0-9]+", token_ids::lit_uint)
+      , true_or_false("true|false", token_ids::true_or_false)
+    {
+        lex::_pass_type _pass;
+
+        this->self = lit_uint | true_or_false;
+
+        add_keyword("void");
+        add_keyword("int");
+        add_keyword("if");
+        add_keyword("else");
+        add_keyword("while");
+        add_keyword("return");
+
+        this->self.add
+                ("\\|\\|", token_ids::logical_or)
+                ("&&", token_ids::logical_and)
+                ("==", token_ids::equal)
+                ("!=", token_ids::not_equal)
+                ("<", token_ids::less)
+                ("<=", token_ids::less_equal)
+                (">", token_ids::greater)
+                (">=", token_ids::greater_equal)
+                ("\\+", token_ids::plus)
+                ("\\-", token_ids::minus)
+                ("\\*", token_ids::times)
+                ("\\/", token_ids::divide)
+                ("!", token_ids::not_)
+            ;
+
+        this->self += lex::char_('(') | ')' | '{' | '}' | ',' | '=' | ';';
+
+        this->self +=
+                identifier
+            |   lex::string("\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\/", token_ids::comment)
+                [
+                    lex::_pass = lex::pass_flags::pass_ignore
+                ]
+            |   lex::string("[ \t\n\r]+", token_ids::whitespace)
+                [
+                    lex::_pass = lex::pass_flags::pass_ignore
+                ]
+            ;
+    }
+
+    template <typename BaseIterator>
+    bool conjure_tokens<BaseIterator>::add_keyword(std::string const& keyword)
+    {
+        // add the token to the lexer
+        token_ids::type id = token_ids::type(this->get_next_id());
+        this->self.add(keyword, id);
+
+        // store the mapping for later retrieval
+        std::pair<typename keyword_map_type::iterator, bool> p =
+            keywords_.insert(typename keyword_map_type::value_type(keyword, id));
+
+        return p.second;
+    }
+}}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/main.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/main.cpp
new file mode 100644
index 00000000..3e4e83c9
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/main.cpp
@@ -0,0 +1,131 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Not a calculator anymore, right? :-)
+//
+//  [ JDG April 10, 2007 ]      spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ HK June 3, 2011 ]         Adding lexer
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "config.hpp"
+#include "function.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+#include "lexer.hpp"
+#include <boost/lexical_cast.hpp>
+#include <fstream>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    std::string source_code; // We will read the contents here.
+    in.unsetf(std::ios::skipws); // No white space skipping!
+    std::copy(
+        std::istream_iterator<char>(in),
+        std::istream_iterator<char>(),
+        std::back_inserter(source_code));
+
+    typedef std::string::const_iterator base_iterator_type;
+    typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+    typedef lexer_type::iterator_type iterator_type;
+
+    lexer_type lexer;                           // Our lexer
+
+    base_iterator_type first = source_code.begin();
+    base_iterator_type last = source_code.end();
+
+    iterator_type iter = lexer.begin(first, last);
+    iterator_type end = lexer.end();
+
+    client::vmachine vm;                        // Our virtual machine
+    client::ast::function_list ast;             // Our AST
+
+    client::error_handler<base_iterator_type, iterator_type>
+        error_handler(first, last);             // Our error handler
+    client::parser::function<iterator_type, lexer_type>
+        function(error_handler, lexer);         // Our parser
+    client::code_gen::compiler
+        compiler(error_handler);                // Our compiler
+
+    // note: we don't need a skipper
+    bool success = parse(iter, end, +function, ast);
+
+    std::cout << "-------------------------\n";
+
+    if (success && iter == end)
+    {
+        if (compiler(ast))
+        {
+            boost::shared_ptr<client::code_gen::function>
+                p  = compiler.find_function("main");
+            if (!p)
+                return 1;
+
+            int nargs = argc-2;
+            if (p->nargs() != nargs)
+            {
+                std::cerr << "Error: main function requires " << p->nargs() << " arguments." << std::endl;
+                std::cerr << nargs << " supplied." << std::endl;
+                return 1;
+            }
+
+            std::cout << "Success\n";
+            std::cout << "-------------------------\n";
+            std::cout << "Assembler----------------\n\n";
+            compiler.print_assembler();
+
+            // Push the arguments into our stack
+            for (int i = 0; i < nargs; ++i)
+                vm.get_stack()[i] = boost::lexical_cast<int>(argv[i+2]);
+
+            // Call the interpreter
+            int r = vm.execute(compiler.get_code());
+
+            std::cout << "-------------------------\n";
+            std::cout << "Result: " << r << std::endl;
+            std::cout << "-------------------------\n\n";
+        }
+        else
+        {
+            std::cout << "Compile failure\n";
+        }
+    }
+    else
+    {
+        error_handler.dump_error_line(first);
+        std::cout << "Parse failure\n";
+    }
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/statement.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/statement.cpp
new file mode 100644
index 00000000..ca85a61c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/statement.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "config.hpp"
+#include "lexer.hpp"
+#include "statement_def.hpp"
+
+typedef std::string::const_iterator base_iterator_type;
+typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+typedef lexer_type::iterator_type iterator_type;
+
+template struct client::parser::statement<iterator_type, lexer_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/statement.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/statement.hpp
new file mode 100644
index 00000000..208ca247
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/statement.hpp
@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_STATEMENT_HPP)
+#define BOOST_SPIRIT_CONJURE_STATEMENT_HPP
+
+#include "expression.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The statement grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer>
+    struct statement : qi::grammar<Iterator, ast::statement_list()>
+    {
+        typedef error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+
+        statement(error_handler_type& error_handler, Lexer const& l);
+
+        expression<Iterator, Lexer> expr;
+
+        qi::rule<Iterator, ast::statement_list()>
+            statement_list, compound_statement;
+
+        qi::rule<Iterator, ast::statement()> statement_;
+        qi::rule<Iterator, ast::variable_declaration()> variable_declaration;
+        qi::rule<Iterator, ast::assignment()> assignment;
+        qi::rule<Iterator, ast::if_statement()> if_statement;
+        qi::rule<Iterator, ast::while_statement()> while_statement;
+        qi::rule<Iterator, ast::return_statement()> return_statement;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/statement_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/statement_def.hpp
new file mode 100644
index 00000000..ab937085
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/statement_def.hpp
@@ -0,0 +1,123 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "statement.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator, typename Lexer>
+    statement<Iterator, Lexer>::statement(
+            error_handler<typename Lexer::base_iterator_type, Iterator>& error_handler
+          , Lexer const& l)
+      : statement::base_type(statement_list), expr(error_handler, l)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef client::error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+        typedef function<error_handler_type> error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        statement_list =
+            +statement_
+            ;
+
+        statement_ =
+                variable_declaration
+            |   assignment
+            |   compound_statement
+            |   if_statement
+            |   while_statement
+            |   return_statement
+            ;
+
+        variable_declaration =
+                l("int")
+            >   expr.identifier
+            >  -('=' > expr)
+            >   ';'
+            ;
+
+        assignment =
+                expr.identifier
+            >   '='
+            >   expr
+            >   ';'
+            ;
+
+        if_statement =
+                l("if")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            >
+               -(
+                    l("else")
+                >   statement_
+                )
+            ;
+
+        while_statement =
+                l("while")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            ;
+
+        compound_statement =
+            '{' >> -statement_list >> '}'
+            ;
+
+        return_statement =
+                l("return")
+            >  -expr
+            >   ';'
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (statement_list)
+            (statement_)
+            (variable_declaration)
+            (assignment)
+            (if_statement)
+            (while_statement)
+            (compound_statement)
+            (return_statement)
+        );
+
+        // Error handling: on error in statement_list, call error_handler.
+        on_error<fail>(statement_list,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in variable_declaration,
+        // assignment and return_statement, call annotation.
+        on_success(variable_declaration,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(assignment,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(return_statement,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/vm.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/vm.cpp
new file mode 100644
index 00000000..af68f523
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/vm.cpp
@@ -0,0 +1,160 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "config.hpp"
+#include "vm.hpp"
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4800) // forcing value to bool 'true' or 'false'
+                                // (performance warning)
+#endif
+
+namespace client
+{
+    int vmachine::execute(
+        std::vector<int> const& code
+      , std::vector<int>::const_iterator pc
+      , std::vector<int>::iterator frame_ptr
+    )
+    {
+        std::vector<int>::iterator stack_ptr = frame_ptr;
+
+        while (true)
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_not:
+                    stack_ptr[-1] = !bool(stack_ptr[-1]);
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_eq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] == stack_ptr[0]);
+                    break;
+
+                case op_neq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] != stack_ptr[0]);
+                    break;
+
+                case op_lt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] < stack_ptr[0]);
+                    break;
+
+                case op_lte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] <= stack_ptr[0]);
+                    break;
+
+                case op_gt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] > stack_ptr[0]);
+                    break;
+
+                case op_gte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] >= stack_ptr[0]);
+                    break;
+
+                case op_and:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) && bool(stack_ptr[0]);
+                    break;
+
+                case op_or:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) || bool(stack_ptr[0]);
+                    break;
+
+                case op_load:
+                    *stack_ptr++ = frame_ptr[*pc++];
+                    break;
+
+                case op_store:
+                    --stack_ptr;
+                    frame_ptr[*pc++] = stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+
+                case op_true:
+                    *stack_ptr++ = true;
+                    break;
+
+                case op_false:
+                    *stack_ptr++ = false;
+                    break;
+
+                case op_jump:
+                    pc += *pc;
+                    break;
+
+                case op_jump_if:
+                    if (!bool(stack_ptr[-1]))
+                        pc += *pc;
+                    else
+                        ++pc;
+                    --stack_ptr;
+                    break;
+
+                case op_stk_adj:
+                    stack_ptr += *pc++;
+                    break;
+
+                case op_call:
+                    {
+                        int nargs = *pc++;
+                        int jump = *pc++;
+
+                        // a function call is a recursive call to execute
+                        int r = execute(
+                            code
+                          , code.begin() + jump
+                          , stack_ptr - nargs
+                        );
+
+                        // cleanup after return from function
+                        stack_ptr[-nargs] = r;      //  get return value
+                        stack_ptr -= (nargs - 1);   //  the stack will now contain
+                                                    //  the return value
+                    }
+                    break;
+
+                case op_return:
+                    return stack_ptr[-1];
+            }
+        }
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/vm.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/vm.hpp
new file mode 100644
index 00000000..0362eaf8
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure2/vm.hpp
@@ -0,0 +1,82 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_VM_HPP)
+#define BOOST_SPIRIT_CONJURE_VM_HPP
+
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ///////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,         //  negate the top stack entry
+        op_add,         //  add top two stack entries
+        op_sub,         //  subtract top two stack entries
+        op_mul,         //  multiply top two stack entries
+        op_div,         //  divide top two stack entries
+
+        op_not,         //  boolean negate the top stack entry
+        op_eq,          //  compare the top two stack entries for ==
+        op_neq,         //  compare the top two stack entries for !=
+        op_lt,          //  compare the top two stack entries for <
+        op_lte,         //  compare the top two stack entries for <=
+        op_gt,          //  compare the top two stack entries for >
+        op_gte,         //  compare the top two stack entries for >=
+
+        op_and,         //  logical and top two stack entries
+        op_or,          //  logical or top two stack entries
+
+        op_load,        //  load a variable
+        op_store,       //  store a variable
+
+        op_int,         //  push constant integer into the stack
+        op_true,        //  push constant 0 into the stack
+        op_false,       //  push constant 1 into the stack
+
+        op_jump_if,     //  jump to a relative position in the code if top stack
+                        //  evaluates to false
+        op_jump,        //  jump to a relative position in the code
+
+        op_stk_adj,     //  adjust the stack (for args and locals)
+        op_call,        //  function call
+        op_return       //  return from function
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+        {
+        }
+
+        int execute(std::vector<int> const& code)
+        {
+            return execute(code, code.begin(), stack.begin());
+        }
+
+        std::vector<int> const& get_stack() const { return stack; };
+        std::vector<int>& get_stack() { return stack; };
+
+    private:
+
+        int execute(
+            std::vector<int> const& code            // the program code
+          , std::vector<int>::const_iterator pc     // program counter
+          , std::vector<int>::iterator frame_ptr    // start of arguments and locals
+        );
+
+        std::vector<int> stack;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/annotation.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/annotation.hpp
new file mode 100644
index 00000000..3b876431
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/annotation.hpp
@@ -0,0 +1,141 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_ANNOTATION_HPP)
+#define BOOST_SPIRIT_CONJURE_ANNOTATION_HPP
+
+#include <map>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/bool.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The annotation handler links the AST to a map of iterator positions
+    //  for the purpose of subsequent semantic error handling when the
+    //  program is being compiled.
+    ///////////////////////////////////////////////////////////////////////////////
+    struct set_annotation_id
+    {
+        typedef void result_type;
+
+        int id;
+        set_annotation_id(int id) : id(id) {}
+
+        void operator()(ast::function_call& x) const
+        {
+            x.function_name.id = id;
+        }
+
+        template <typename T>
+        void dispatch(T& x, boost::mpl::true_) const
+        {
+            x.id = id;
+        }
+
+        template <typename T>
+        void dispatch(T& x, boost::mpl::false_) const
+        {
+            // no-op
+        }
+
+        template <typename T>
+        void operator()(T& x) const
+        {
+            typename boost::is_base_of<ast::tagged, T> is_tagged;
+            dispatch(x, is_tagged);
+        }
+    };
+
+    struct get_annotation_id
+    {
+        typedef int result_type;
+
+        int operator()(ast::function_call& x) const
+        {
+            return x.function_name.id;
+        }
+
+        template <typename T>
+        int dispatch(T& x, boost::mpl::true_) const
+        {
+            return x.id;
+        }
+
+        template <typename T>
+        int dispatch(T& x, boost::mpl::false_) const
+        {
+            return -1;
+        }
+
+        template <typename T>
+        int operator()(T& x) const
+        {
+            typename boost::is_base_of<ast::tagged, T> is_tagged;
+            return dispatch(x, is_tagged);
+        }
+    };
+
+    template <typename Iterator>
+    struct annotation
+    {
+        template <typename, typename>
+        struct result { typedef void type; };
+
+        std::vector<Iterator>& iters;
+        annotation(std::vector<Iterator>& iters)
+          : iters(iters) {}
+
+        void operator()(ast::operand& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            boost::apply_visitor(set_annotation_id(id), ast);
+            ast.id = id;
+        }
+
+        void operator()(ast::primary_expr& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            boost::apply_visitor(set_annotation_id(id), ast);
+            ast.id = id;
+        }
+
+        void operator()(ast::variable_declaration& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+
+        void operator()(ast::assignment& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+
+        void operator()(ast::return_statement& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.id = id;
+        }
+
+        void operator()(ast::identifier& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.id = id;
+        }
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/ast.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/ast.hpp
new file mode 100644
index 00000000..a77cb0ed
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/ast.hpp
@@ -0,0 +1,240 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_AST_HPP)
+#define BOOST_SPIRIT_CONJURE_AST_HPP
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <boost/spirit/include/support_extended_variant.hpp>
+#include <boost/spirit/include/support_attributes.hpp>
+#include <boost/optional.hpp>
+#include <list>
+
+#include "ids.hpp"
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct tagged
+    {
+        int id; // Used to annotate the AST with the iterator position.
+                // This id is used as a key to a map<int, Iterator>
+                // (not really part of the AST.)
+    };
+
+    struct nil {};
+    struct unary_expr;
+    struct function_call;
+    struct expression;
+
+    struct identifier : tagged
+    {
+        identifier(std::string const& name = "") : name(name) {}
+        std::string name;
+    };
+
+    struct primary_expr :
+        tagged,
+        boost::spirit::extended_variant<
+            nil
+          , bool
+          , unsigned int
+          , identifier
+          , boost::recursive_wrapper<expression>
+        >
+    {
+        primary_expr() : base_type() {}
+        primary_expr(bool val) : base_type(val) {}
+        primary_expr(unsigned int val) : base_type(val) {}
+        primary_expr(identifier const& val) : base_type(val) {}
+        primary_expr(expression const& val) : base_type(val) {}
+        primary_expr(primary_expr const& rhs)
+            : base_type(rhs.get()) {}
+    };
+
+    struct operand :
+        tagged,
+        boost::spirit::extended_variant<
+            nil
+          , primary_expr
+          , boost::recursive_wrapper<unary_expr>
+          , boost::recursive_wrapper<function_call>
+        >
+    {
+        operand() : base_type() {}
+        operand(primary_expr const& val) : base_type(val) {}
+        operand(unary_expr const& val) : base_type(val) {}
+        operand(function_call const& val) : base_type(val) {}
+        operand(operand const& rhs)
+            : base_type(rhs.get()) {}
+    };
+
+    struct unary_expr : tagged
+    {
+        token_ids::type operator_;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        token_ids::type operator_;
+        operand operand_;
+    };
+
+    struct function_call
+    {
+        identifier function_name;
+        std::list<expression> args;
+    };
+
+    struct expression
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    struct assignment
+    {
+        identifier lhs;
+        token_ids::type operator_;
+        expression rhs;
+    };
+
+    struct variable_declaration
+    {
+        identifier lhs;
+        boost::optional<expression> rhs;
+    };
+
+    struct if_statement;
+    struct while_statement;
+    struct statement_list;
+    struct return_statement;
+
+    typedef boost::variant<
+            nil
+          , variable_declaration
+          , assignment
+          , boost::recursive_wrapper<if_statement>
+          , boost::recursive_wrapper<while_statement>
+          , boost::recursive_wrapper<return_statement>
+          , boost::recursive_wrapper<statement_list>
+          , boost::recursive_wrapper<expression>
+        >
+    statement;
+
+    struct statement_list : std::list<statement> {};
+
+    struct if_statement
+    {
+        expression condition;
+        statement then;
+        boost::optional<statement> else_;
+    };
+
+    struct while_statement
+    {
+        expression condition;
+        statement body;
+    };
+
+    struct return_statement : tagged
+    {
+        boost::optional<expression> expr;
+    };
+
+    struct function
+    {
+        std::string return_type;
+        identifier function_name;
+        std::list<identifier> args;
+        boost::optional<statement_list> body;
+    };
+
+    typedef std::list<function> function_list;
+
+    // print functions for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil)
+    {
+        out << "nil"; return out;
+    }
+
+    inline std::ostream& operator<<(std::ostream& out, identifier const& id)
+    {
+        out << id.name; return out;
+    }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::unary_expr,
+    (client::token_ids::type, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::operation,
+    (client::token_ids::type, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::function_call,
+    (client::ast::identifier, function_name)
+    (std::list<client::ast::expression>, args)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::expression,
+    (client::ast::operand, first)
+    (std::list<client::ast::operation>, rest)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::variable_declaration,
+    (client::ast::identifier, lhs)
+    (boost::optional<client::ast::expression>, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::assignment,
+    (client::ast::identifier, lhs)
+    (client::token_ids::type, operator_)
+    (client::ast::expression, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::if_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, then)
+    (boost::optional<client::ast::statement>, else_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::while_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, body)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::return_statement,
+    (boost::optional<client::ast::expression>, expr)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::function,
+    (std::string, return_type)
+    (client::ast::identifier, function_name)
+    (std::list<client::ast::identifier>, args)
+    (boost::optional<client::ast::statement_list>, body)
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/compiler.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/compiler.cpp
new file mode 100644
index 00000000..e36ad770
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/compiler.cpp
@@ -0,0 +1,1141 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "config.hpp"
+#include "compiler.hpp"
+#include "annotation.hpp"
+#include "vm.hpp"
+
+#include <boost/foreach.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/range/adaptor/transformed.hpp>
+#include <boost/assert.hpp>
+#include <set>
+
+namespace client { namespace code_gen
+{
+    value::value()
+      : v(0),
+        is_lvalue_(false),
+        builder(0)
+    {}
+
+    value::value(
+        llvm::Value* v,
+        bool is_lvalue_,
+        llvm::IRBuilder<>* builder)
+      : v(v),
+        is_lvalue_(is_lvalue_),
+        builder(builder)
+    {}
+
+    value::value(value const& rhs)
+      : v(rhs.v),
+        is_lvalue_(rhs.is_lvalue_),
+        builder(rhs.builder)
+    {}
+
+    bool value::is_lvalue() const
+    {
+        return is_lvalue_;
+    }
+
+    bool value::is_valid() const
+    {
+        return v != 0;
+    }
+
+    value::operator bool() const
+    {
+        return v != 0;
+    }
+
+    void value::name(char const* id)
+    {
+        v->setName(id);
+    }
+
+    void value::name(std::string const& id)
+    {
+        v->setName(id);
+    }
+
+    value::operator llvm::Value*() const
+    {
+        if (is_lvalue_)
+        {
+            BOOST_ASSERT(builder != 0);
+            return builder->CreateLoad(v, v->getName());
+        }
+        return v;
+    }
+
+    value& value::operator=(value const& rhs)
+    {
+        v = rhs.v;
+        is_lvalue_ = rhs.is_lvalue_;
+        builder = rhs.builder;
+        return *this;
+    }
+
+    value& value::assign(value const& rhs)
+    {
+        BOOST_ASSERT(is_lvalue());
+        BOOST_ASSERT(builder != 0);
+        builder->CreateStore(rhs, v);
+        return *this;
+    }
+
+    value operator-(value a)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateNeg(a, "neg_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator!(value a)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateNot(a, "not_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator+(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateAdd(a, b, "add_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator-(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateSub(a, b, "sub_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator*(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateMul(a, b, "mul_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator/(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateSDiv(a, b, "div_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator%(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateSRem(a, b, "mod_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator&(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateAnd(a, b, "and_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator|(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateOr(a, b, "or_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator^(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateXor(a, b, "xor_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator<<(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateShl(a, b, "shl_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator>>(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateLShr(a, b, "shr_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator==(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateICmpEQ(a, b, "eq_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator!=(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateICmpNE(a, b, "ne_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator<(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateICmpSLT(a, b, "slt_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator<=(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateICmpSLE(a, b, "sle_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator>(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateICmpSGT(a, b, "sgt_tmp"),
+            false, a.builder
+        );
+    }
+
+    value operator>=(value a, value b)
+    {
+        BOOST_ASSERT(a.builder != 0);
+        return value(
+            a.builder->CreateICmpSGE(a, b, "sge_tmp"),
+            false, a.builder
+        );
+    }
+
+    struct function::to_value
+    {
+        typedef value result_type;
+        llvm_compiler* c;
+
+        to_value(llvm_compiler* c = 0) : c(c) {}
+
+        value operator()(llvm::Value& v) const
+        {
+            return c->val(&v);
+        }
+    };
+
+    bool basic_block::has_terminator() const
+    {
+        return b->getTerminator() != 0;
+    }
+
+    bool basic_block::is_valid() const
+    {
+        return b != 0;
+    }
+
+    function::operator llvm::Function*() const
+    {
+        return f;
+    }
+
+    std::size_t function::arg_size() const
+    {
+        return f->arg_size();
+    }
+
+    void function::add(basic_block const& b)
+    {
+        f->getBasicBlockList().push_back(b);
+    }
+
+    void function::erase_from_parent()
+    {
+        f->eraseFromParent();
+    }
+
+    basic_block function::last_block()
+    {
+        return &f->getBasicBlockList().back();
+    }
+
+    bool function::empty() const
+    {
+        return f->empty();
+    }
+
+    std::string function::name() const
+    {
+        return f->getName();
+    }
+
+    function::arg_range function::args() const
+    {
+        BOOST_ASSERT(c != 0);
+        arg_val_iterator first(f->arg_begin(), to_value());
+        arg_val_iterator last(f->arg_end(), to_value());
+        return arg_range(first, last);
+    }
+
+    bool function::is_valid() const
+    {
+        return f != 0;
+    }
+
+    void function::verify() const
+    {
+        llvm::verifyFunction(*f);
+    }
+
+    value llvm_compiler::val(unsigned int x)
+    {
+        return value(
+            llvm::ConstantInt::get(context(), llvm::APInt(int_size, x)),
+            false, &llvm_builder);
+    }
+
+    value llvm_compiler::val(int x)
+    {
+        return value(
+            llvm::ConstantInt::get(context(), llvm::APInt(int_size, x)),
+            false, &llvm_builder);
+    }
+
+    value llvm_compiler::val(bool x)
+    {
+        return value(
+            llvm::ConstantInt::get(context(), llvm::APInt(1, x)),
+            false, &llvm_builder);
+    }
+
+    value llvm_compiler::val(llvm::Value* v)
+    {
+        return value(v, false, &llvm_builder);
+    }
+
+    namespace
+    {
+        //  Create an alloca instruction in the entry block of
+        //  the function. This is used for mutable variables etc.
+        llvm::AllocaInst*
+        make_entry_block_alloca(
+            llvm::Function* f,
+            char const* name,
+            llvm::LLVMContext& context)
+        {
+            llvm::IRBuilder<> builder(
+                &f->getEntryBlock(),
+                f->getEntryBlock().begin());
+
+            return builder.CreateAlloca(
+                llvm::Type::getIntNTy(context, int_size), 0, name);
+        }
+    }
+
+    value llvm_compiler::var(char const* name)
+    {
+        llvm::Function* f = llvm_builder.GetInsertBlock()->getParent();
+        llvm::IRBuilder<> builder(
+            &f->getEntryBlock(),
+            f->getEntryBlock().begin());
+
+        llvm::AllocaInst* alloca = builder.CreateAlloca(
+            llvm::Type::getIntNTy(context(), int_size), 0, name);
+
+        return value(alloca, true, &llvm_builder);
+    }
+
+    struct value::to_llvm_value
+    {
+        typedef llvm::Value* result_type;
+        llvm::Value* operator()(value const& x) const
+        {
+            return x;
+        }
+    };
+
+    template <typename C>
+    llvm::Value* llvm_compiler::call_impl(
+        function callee,
+        C const& args_)
+    {
+        // Sigh. LLVM requires CreateCall arguments to be random access.
+        // It would have been better if it can accept forward iterators.
+        // I guess it needs the arguments to be in contiguous memory.
+        // So, we have to put the args into a temporary std::vector.
+        std::vector<llvm::Value*> args(
+            args_.begin(), args_.end());
+
+        // Check the args for null values. We can't have null values.
+        // Return 0 if we find one to flag error.
+        BOOST_FOREACH(llvm::Value* arg, args)
+        {
+            if (arg == 0)
+                return 0;
+        }
+
+        return llvm_builder.CreateCall(
+            callee, args.begin(), args.end(), "call_tmp");
+    }
+
+    template <typename Container>
+    value llvm_compiler::call(
+        function callee,
+        Container const& args)
+    {
+        llvm::Value* call = call_impl(
+            callee,
+            args | boost::adaptors::transformed(value::to_llvm_value()));
+
+        if (call == 0)
+            return val();
+        return value(call, false, &llvm_builder);
+    }
+
+    function llvm_compiler::get_function(char const* name)
+    {
+        return function(vm.module()->getFunction(name), this);
+    }
+
+    function llvm_compiler::get_current_function()
+    {
+        // get the current function
+        return function(llvm_builder.GetInsertBlock()->getParent(), this);
+    }
+
+    function llvm_compiler::declare_function(
+        bool void_return
+      , std::string const& name
+      , std::size_t nargs)
+    {
+        llvm::Type const* int_type =
+            llvm::Type::getIntNTy(context(), int_size);
+        llvm::Type const* void_type = llvm::Type::getVoidTy(context());
+
+        std::vector<llvm::Type const*> ints(nargs, int_type);
+        llvm::Type const* return_type = void_return ? void_type : int_type;
+
+        llvm::FunctionType* function_type =
+            llvm::FunctionType::get(void_return ? void_type : int_type, ints, false);
+
+        return function(llvm::Function::Create(
+                function_type, llvm::Function::ExternalLinkage,
+                name, vm.module()), this);
+    }
+
+    basic_block llvm_compiler::make_basic_block(
+        char const* name
+      , function parent
+      , basic_block before)
+    {
+        return llvm::BasicBlock::Create(context(), name, parent, before);
+    }
+
+    value llvm_compiler::var(std::string const& name)
+    {
+        return var(name.c_str());
+    }
+
+    function llvm_compiler::get_function(std::string const& name)
+    {
+        return get_function(name.c_str());
+    }
+
+    basic_block llvm_compiler::get_insert_block()
+    {
+        return llvm_builder.GetInsertBlock();
+    }
+
+    void llvm_compiler::set_insert_point(basic_block b)
+    {
+        llvm_builder.SetInsertPoint(b);
+    }
+
+    void llvm_compiler::conditional_branch(
+        value cond, basic_block true_br, basic_block false_br)
+    {
+        llvm_builder.CreateCondBr(cond, true_br, false_br);
+    }
+
+    void llvm_compiler::branch(basic_block b)
+    {
+        llvm_builder.CreateBr(b);
+    }
+
+    void llvm_compiler::return_()
+    {
+        llvm_builder.CreateRetVoid();
+    }
+
+    void llvm_compiler::return_(value v)
+    {
+        llvm_builder.CreateRet(v);
+    }
+
+    void llvm_compiler::optimize_function(function f)
+    {
+        // Optimize the function.
+        fpm.run(*f);
+    }
+
+    void llvm_compiler::init_fpm()
+    {
+        // Set up the optimizer pipeline.  Start with registering info about how the
+        // target lays out data structures.
+        fpm.add(new llvm::TargetData(*vm.execution_engine()->getTargetData()));
+        // Provide basic AliasAnalysis support for GVN.
+        fpm.add(llvm::createBasicAliasAnalysisPass());
+        // Promote allocas to registers.
+        fpm.add(llvm::createPromoteMemoryToRegisterPass());
+        // Do simple "peephole" optimizations and bit-twiddling optzns.
+        fpm.add(llvm::createInstructionCombiningPass());
+        // Reassociate expressions.
+        fpm.add(llvm::createReassociatePass());
+        // Eliminate Common SubExpressions.
+        fpm.add(llvm::createGVNPass());
+        // Simplify the control flow graph (deleting unreachable blocks, etc).
+        fpm.add(llvm::createCFGSimplificationPass());
+
+        fpm.doInitialization();
+    }
+
+    value compiler::operator()(unsigned int x)
+    {
+        return val(x);
+    }
+
+    value compiler::operator()(bool x)
+    {
+        return val(x);
+    }
+
+    value compiler::operator()(ast::primary_expr const& x)
+    {
+        return boost::apply_visitor(*this, x.get());
+    }
+
+    value compiler::operator()(ast::identifier const& x)
+    {
+        // Look this variable up in the function.
+        if (locals.find(x.name) == locals.end())
+        {
+            error_handler(x.id, "Undeclared variable: " + x.name);
+            return val();
+        }
+        return locals[x.name];
+    }
+
+    value compiler::operator()(ast::unary_expr const& x)
+    {
+        value operand = boost::apply_visitor(*this, x.operand_);
+        if (!operand.is_valid())
+            return val();
+
+        switch (x.operator_)
+        {
+            case token_ids::compl_:     return operand ^ val(-1);
+            case token_ids::minus:      return -operand;
+            case token_ids::not_:       return !operand;
+            case token_ids::plus:       return operand;
+            case token_ids::plus_plus:
+            {
+                if (!operand.is_lvalue())
+                {
+                    error_handler(x.id, "++ needs an var");
+                    return val();
+                }
+
+                value r = operand + val(1);
+                operand.assign(r);
+                return operand;
+            }
+            case token_ids::minus_minus:
+            {
+                if (!operand.is_lvalue())
+                {
+                    error_handler(x.id, "-- needs an var");
+                    return val();
+                }
+
+                value r = operand - val(1);
+                operand.assign(r);
+                return operand;
+            }
+            default:
+                BOOST_ASSERT(0);
+                return val();
+        }
+    }
+
+    namespace
+    {
+        struct compile_args
+        {
+            compiler& c;
+            compile_args(compiler& c) : c(c) {}
+
+            typedef value result_type;
+            value operator()(ast::expression const& expr) const
+            {
+                return c(expr);
+            }
+        };
+    }
+
+    value compiler::operator()(ast::function_call const& x)
+    {
+        function callee = get_function(x.function_name.name);
+        if (!callee.is_valid())
+        {
+            error_handler(x.function_name.id,
+                "Function not found: " + x.function_name.name);
+            return val();
+        }
+
+        if (callee.arg_size() != x.args.size())
+        {
+            error_handler(x.function_name.id,
+                "Wrong number of arguments: " + x.function_name.name);
+            return val();
+        }
+
+        return call(callee,
+            x.args | boost::adaptors::transformed(compile_args(*this)));
+    }
+
+    namespace
+    {
+        int precedence[] = {
+            // precedence 1
+            1, // op_comma
+
+            // precedence 2
+            2, // op_assign
+            2, // op_plus_assign
+            2, // op_minus_assign
+            2, // op_times_assign
+            2, // op_divide_assign
+            2, // op_mod_assign
+            2, // op_bit_and_assign
+            2, // op_bit_xor_assign
+            2, // op_bitor_assign
+            2, // op_shift_left_assign
+            2, // op_shift_right_assign
+
+            // precedence 3
+            3, // op_logical_or
+
+            // precedence 4
+            4, // op_logical_and
+
+            // precedence 5
+            5, // op_bit_or
+
+            // precedence 6
+            6, // op_bit_xor
+
+            // precedence 7
+            7, // op_bit_and
+
+            // precedence 8
+            8, // op_equal
+            8, // op_not_equal
+
+            // precedence 9
+            9, // op_less
+            9, // op_less_equal
+            9, // op_greater
+            9, // op_greater_equal
+
+            // precedence 10
+            10, // op_shift_left
+            10, // op_shift_right
+
+            // precedence 11
+            11, // op_plus
+            11, // op_minus
+
+            // precedence 12
+            12, // op_times
+            12, // op_divide
+            12 // op_mod
+        };
+    }
+
+    inline int precedence_of(token_ids::type op)
+    {
+        return precedence[op & 0xFF];
+    }
+
+    value compiler::compile_binary_expression(
+        value lhs, value rhs, token_ids::type op)
+    {
+        switch (op)
+        {
+            case token_ids::plus:           return lhs + rhs;
+            case token_ids::minus:          return lhs - rhs;
+            case token_ids::times:          return lhs * rhs;
+            case token_ids::divide:         return lhs / rhs;
+            case token_ids::mod:            return lhs % rhs;
+
+            case token_ids::logical_or:
+            case token_ids::bit_or:         return lhs | rhs;
+
+            case token_ids::logical_and:
+            case token_ids::bit_and:        return lhs & rhs;
+
+            case token_ids::bit_xor:        return lhs ^ rhs;
+            case token_ids::shift_left:     return lhs << rhs;
+            case token_ids::shift_right:    return lhs >> rhs;
+
+            case token_ids::equal:          return lhs == rhs;
+            case token_ids::not_equal:      return lhs != rhs;
+            case token_ids::less:           return lhs < rhs;
+            case token_ids::less_equal:     return lhs <= rhs;
+            case token_ids::greater:        return lhs > rhs;
+            case token_ids::greater_equal:  return lhs >= rhs;
+
+            default: BOOST_ASSERT(0);       return val();
+        }
+    }
+
+    // The Shunting-yard algorithm
+    value compiler::compile_expression(
+        int min_precedence,
+        value lhs,
+        std::list<ast::operation>::const_iterator& rest_begin,
+        std::list<ast::operation>::const_iterator rest_end)
+    {
+        while ((rest_begin != rest_end) &&
+            (precedence_of(rest_begin->operator_) >= min_precedence))
+        {
+            token_ids::type op = rest_begin->operator_;
+            value rhs = boost::apply_visitor(*this, rest_begin->operand_);
+            if (!rhs.is_valid())
+                return val();
+            ++rest_begin;
+
+            while ((rest_begin != rest_end) &&
+                (precedence_of(rest_begin->operator_) > precedence_of(op)))
+            {
+                token_ids::type next_op = rest_begin->operator_;
+                rhs = compile_expression(
+                    precedence_of(next_op), rhs, rest_begin, rest_end);
+            }
+
+            lhs = compile_binary_expression(lhs, rhs, op);
+        }
+        return lhs;
+    }
+
+    value compiler::operator()(ast::expression const& x)
+    {
+        value lhs = boost::apply_visitor(*this, x.first);
+        if (!lhs.is_valid())
+            return val();
+        std::list<ast::operation>::const_iterator rest_begin = x.rest.begin();
+        return compile_expression(0, lhs, rest_begin, x.rest.end());
+    }
+
+    value compiler::operator()(ast::assignment const& x)
+    {
+        if (locals.find(x.lhs.name) == locals.end())
+        {
+            error_handler(x.lhs.id, "Undeclared variable: " + x.lhs.name);
+            return val();
+        }
+
+        value lhs = locals[x.lhs.name];
+        value rhs = (*this)(x.rhs);
+        if (!rhs.is_valid())
+            return val();
+
+        if (x.operator_ == token_ids::assign)
+        {
+            lhs.assign(rhs);
+            return lhs;
+        }
+
+        value result;
+        switch (x.operator_)
+        {
+            case token_ids::plus_assign:        result = lhs + rhs; break;
+            case token_ids::minus_assign:       result = lhs - rhs; break;
+            case token_ids::times_assign:       result = lhs * rhs; break;
+            case token_ids::divide_assign:      result = lhs / rhs; break;
+            case token_ids::mod_assign:         result = lhs % rhs; break;
+            case token_ids::bit_and_assign:     result = lhs & rhs; break;
+            case token_ids::bit_xor_assign:     result = lhs ^ rhs; break;
+            case token_ids::bit_or_assign:      result = lhs | rhs; break;
+            case token_ids::shift_left_assign:  result = lhs << rhs; break;
+            case token_ids::shift_right_assign: result = lhs >> rhs; break;
+            default: BOOST_ASSERT(0);           return val();
+        }
+
+        lhs.assign(result);
+        return lhs;
+    }
+
+    bool compiler::operator()(ast::variable_declaration const& x)
+    {
+        if (locals.find(x.lhs.name) != locals.end())
+        {
+            error_handler(x.lhs.id, "Duplicate variable: " + x.lhs.name);
+            return false;
+        }
+
+        value init;
+        std::string const& name = x.lhs.name;
+
+        if (x.rhs) // if there's an RHS initializer
+        {
+            init = (*this)(*x.rhs);
+            if (!init.is_valid()) // don't add the variable if the RHS fails
+                return false;
+        }
+
+        value var_ = var(name.c_str());
+        if (init.is_valid())
+            var_.assign(init);
+
+        // Remember this binding.
+        locals[name] = var_;
+        return true;
+    }
+
+    struct compiler::statement_compiler : compiler
+    {
+        typedef bool result_type;
+    };
+
+    compiler::statement_compiler& compiler::as_statement()
+    {
+        return *static_cast<statement_compiler*>(this);
+    }
+
+    bool compiler::operator()(ast::statement const& x)
+    {
+        if (boost::get<ast::nil>(&x) != 0) // empty statement
+            return true;
+        return boost::apply_visitor(as_statement(), x);
+    }
+
+    bool compiler::operator()(ast::statement_list const& x)
+    {
+        BOOST_FOREACH(ast::statement const& s, x)
+        {
+            if (!(*this)(s))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::if_statement const& x)
+    {
+        value condition = (*this)(x.condition);
+        if (!condition.is_valid())
+            return false;
+
+        function f = get_current_function();
+
+        // Create blocks for the then and else cases.  Insert the 'then' block at the
+        // end of the function.
+        basic_block then_block = make_basic_block("if.then", f);
+        basic_block else_block;
+        basic_block exit_block;
+
+        if (x.else_)
+        {
+            else_block = make_basic_block("if.else");
+            conditional_branch(condition, then_block, else_block);
+        }
+        else
+        {
+            exit_block = make_basic_block("if.end");
+            conditional_branch(condition, then_block, exit_block);
+        }
+
+        // Emit then value.
+        set_insert_point(then_block);
+        if (!(*this)(x.then))
+            return false;
+        if (!then_block.has_terminator())
+        {
+            if (!exit_block.is_valid())
+                exit_block = make_basic_block("if.end");
+            branch(exit_block);
+        }
+        // Codegen of 'then' can change the current block, update then_block
+        then_block = get_insert_block();
+
+        if (x.else_)
+        {
+            // Emit else block.
+            f.add(else_block);
+            set_insert_point(else_block);
+            if (!(*this)(*x.else_))
+                return false;
+            if (!else_block.has_terminator())
+            {
+                if (!exit_block.is_valid())
+                    exit_block = make_basic_block("if.end");
+                branch(exit_block);
+            }
+            // Codegen of 'else' can change the current block, update else_block
+            else_block = get_insert_block();
+        }
+
+        if (exit_block.is_valid())
+        {
+            // Emit exit block
+            f.add(exit_block);
+            set_insert_point(exit_block);
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::while_statement const& x)
+    {
+        function f = get_current_function();
+
+        basic_block cond_block = make_basic_block("while.cond", f);
+        basic_block body_block = make_basic_block("while.body");
+        basic_block exit_block = make_basic_block("while.end");
+
+        branch(cond_block);
+        set_insert_point(cond_block);
+        value condition = (*this)(x.condition);
+        if (!condition.is_valid())
+            return false;
+        conditional_branch(condition, body_block, exit_block);
+        f.add(body_block);
+        set_insert_point(body_block);
+
+        if (!(*this)(x.body))
+            return false;
+
+        if (!body_block.has_terminator())
+            branch(cond_block); // loop back
+
+        // Emit exit block
+        f.add(exit_block);
+        set_insert_point(exit_block);
+
+        return true;
+    }
+
+    bool compiler::operator()(ast::return_statement const& x)
+    {
+        if (void_return)
+        {
+            if (x.expr)
+            {
+                error_handler(
+                    x.id, "'void' function returning a value: ");
+                return false;
+            }
+        }
+        else
+        {
+            if (!x.expr)
+            {
+                error_handler(
+                    x.id, current_function_name
+                    + " function must return a value: ");
+                return false;
+            }
+        }
+
+        if (x.expr)
+        {
+            value return_val = (*this)(*x.expr);
+            if (!return_val.is_valid())
+                return false;
+            return_var.assign(return_val);
+        }
+
+        branch(return_block);
+        return true;
+    }
+
+    function compiler::function_decl(ast::function const& x)
+    {
+        void_return = x.return_type == "void";
+        current_function_name = x.function_name.name;
+
+        function f =
+            declare_function(
+                void_return
+              , current_function_name
+              , x.args.size());
+
+        // If function conflicted, the function already exixts. If it has a
+        // body, don't allow redefinition or reextern.
+        if (f.name() != current_function_name)
+        {
+            // Delete the one we just made and get the existing one.
+            f.erase_from_parent();
+            f = get_function(current_function_name);
+
+            // If function already has a body, reject this.
+            if (!f.empty())
+            {
+                error_handler(
+                    x.function_name.id,
+                    "Duplicate function: " + x.function_name.name);
+                return function();
+            }
+
+            // If function took a different number of args, reject.
+            if (f.arg_size() != x.args.size())
+            {
+                error_handler(
+                    x.function_name.id,
+                    "Redefinition of function with different # args: "
+                        + x.function_name.name);
+                return function();
+            }
+
+            // Set names for all arguments.
+            function::arg_range rng = f.args();
+            function::arg_range::const_iterator iter = rng.begin();
+            BOOST_FOREACH(ast::identifier const& arg, x.args)
+            {
+                iter->name(arg.name);
+                ++iter;
+            }
+        }
+        return f;
+    }
+
+    void compiler::function_allocas(ast::function const& x, function f)
+    {
+        // Create variables for each argument and register the
+        // argument in the symbol table so that references to it will succeed.
+        function::arg_range rng = f.args();
+        function::arg_range::const_iterator iter = rng.begin();
+        BOOST_FOREACH(ast::identifier const& arg, x.args)
+        {
+            // Create an arg_ for this variable.
+            value arg_ = var(arg.name);
+
+            // Store the initial value into the arg_.
+            arg_.assign(*iter);
+
+            // Add arguments to variable symbol table.
+            locals[arg.name] = arg_;
+            ++iter;
+        }
+
+        if (!void_return)
+        {
+            // Create an alloca for the return value
+            return_var = var("return.val");
+        }
+    }
+
+    bool compiler::operator()(ast::function const& x)
+    {
+        ///////////////////////////////////////////////////////////////////////
+        // the signature:
+        function f = function_decl(x);
+        if (!f.is_valid())
+            return false;
+
+        ///////////////////////////////////////////////////////////////////////
+        // the body:
+        if (x.body) // compile the body if this is not a prototype
+        {
+            // Create a new basic block to start insertion into.
+            basic_block block = make_basic_block("entry", f);
+            set_insert_point(block);
+
+            function_allocas(x, f);
+            return_block = make_basic_block("return");
+
+            if (!(*this)(*x.body))
+            {
+                // Error reading body, remove function.
+                f.erase_from_parent();
+                return false;
+            }
+
+            basic_block last_block = f.last_block();
+
+            // If the last block is unterminated, connect it to return_block
+            if (!last_block.has_terminator())
+            {
+                set_insert_point(last_block);
+                branch(return_block);
+            }
+
+            f.add(return_block);
+            set_insert_point(return_block);
+
+            if (void_return)
+                return_();
+            else
+                return_(return_var);
+
+            // Validate the generated code, checking for consistency.
+            f.verify();
+
+            // Optimize the function.
+            optimize_function(f);
+        }
+
+        return true;
+    }
+
+    bool compiler::operator()(ast::function_list const& x)
+    {
+        BOOST_FOREACH(ast::function const& f, x)
+        {
+            locals.clear(); // clear the variables
+            if (!(*this)(f))
+                return false;
+        }
+        return true;
+    }
+}}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/compiler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/compiler.hpp
new file mode 100644
index 00000000..ccca3644
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/compiler.hpp
@@ -0,0 +1,311 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_COMPILER_HPP)
+#define BOOST_SPIRIT_CONJURE_COMPILER_HPP
+
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include "vm.hpp"
+#include <map>
+
+#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+
+#include <llvm/DerivedTypes.h>
+#include <llvm/Constants.h>
+#include <llvm/LLVMContext.h>
+#include <llvm/Module.h>
+#include <llvm/PassManager.h>
+#include <llvm/Analysis/Verifier.h>
+#include <llvm/Analysis/Passes.h>
+#include <llvm/Transforms/Scalar.h>
+#include <llvm/Support/IRBuilder.h>
+
+namespace client { namespace code_gen
+{
+    unsigned const int_size = 32;
+    struct compiler;
+    struct llvm_compiler;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Value (light abstraction of an LLVM::Value)
+    ///////////////////////////////////////////////////////////////////////////
+    struct value
+    {
+        value();
+        value(value const& rhs);
+
+        value& operator=(value const& rhs);
+        bool is_lvalue() const;
+        bool is_valid() const;
+        operator bool() const;
+
+        value& assign(value const& rhs);
+
+        void name(char const* id);
+        void name(std::string const& id);
+
+        friend value operator-(value a);
+        friend value operator!(value a);
+        friend value operator+(value a, value b);
+        friend value operator-(value a, value b);
+        friend value operator*(value a, value b);
+        friend value operator/(value a, value b);
+        friend value operator%(value a, value b);
+
+        friend value operator&(value a, value b);
+        friend value operator|(value a, value b);
+        friend value operator^(value a, value b);
+        friend value operator<<(value a, value b);
+        friend value operator>>(value a, value b);
+
+        friend value operator==(value a, value b);
+        friend value operator!=(value a, value b);
+        friend value operator<(value a, value b);
+        friend value operator<=(value a, value b);
+        friend value operator>(value a, value b);
+        friend value operator>=(value a, value b);
+
+    private:
+
+        struct to_llvm_value;
+        friend struct to_llvm_value;
+        friend struct llvm_compiler;
+
+        value(
+            llvm::Value* v,
+            bool is_lvalue_,
+            llvm::IRBuilder<>* builder);
+
+        llvm::LLVMContext& context() const
+        { return llvm::getGlobalContext(); }
+
+        operator llvm::Value*() const;
+
+        llvm::Value* v;
+        bool is_lvalue_;
+        llvm::IRBuilder<>* builder;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Basic Block (light abstraction of an LLVM::BasicBlock)
+    ///////////////////////////////////////////////////////////////////////////
+    struct function;
+
+    struct basic_block
+    {
+        basic_block()
+          : b(0) {}
+
+        bool has_terminator() const;
+        bool is_valid() const;
+
+    private:
+
+        basic_block(llvm::BasicBlock* b)
+          : b(b) {}
+
+        operator llvm::BasicBlock*() const
+        { return b; }
+
+        friend struct llvm_compiler;
+        friend struct function;
+        llvm::BasicBlock* b;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Function (light abstraction of an LLVM::Function)
+    ///////////////////////////////////////////////////////////////////////////
+    struct llvm_compiler;
+
+    struct function
+    {
+    private:
+
+        struct to_value;
+        typedef llvm::Function::arg_iterator arg_iterator;
+        typedef boost::transform_iterator<
+            to_value, arg_iterator>
+        arg_val_iterator;
+
+    public:
+
+        typedef boost::iterator_range<arg_val_iterator> arg_range;
+
+        function()
+          : f(0), c(c) {}
+
+        std::string name() const;
+
+        std::size_t arg_size() const;
+        arg_range args() const;
+
+        void add(basic_block const& b);
+        void erase_from_parent();
+        basic_block last_block();
+        bool empty() const;
+
+        bool is_valid() const;
+        void verify() const;
+
+    private:
+
+        function(llvm::Function* f, llvm_compiler* c)
+          : f(f), c(c) {}
+
+        operator llvm::Function*() const;
+
+        friend struct llvm_compiler;
+        llvm::Function* f;
+        llvm_compiler* c;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The LLVM Compiler. Lower level compiler (does not deal with ASTs)
+    ///////////////////////////////////////////////////////////////////////////
+    struct llvm_compiler
+    {
+        llvm_compiler(vmachine& vm)
+          : llvm_builder(context())
+          , vm(vm)
+          , fpm(vm.module())
+        { init_fpm(); }
+
+        value val() { return value(); }
+        value val(unsigned int x);
+        value val(int x);
+        value val(bool x);
+
+        value var(char const* name);
+        value var(std::string const& name);
+
+        template <typename Container>
+        value call(function callee, Container const& args);
+
+        function get_function(char const* name);
+        function get_function(std::string const& name);
+        function get_current_function();
+
+        function declare_function(
+            bool void_return
+          , std::string const& name
+          , std::size_t nargs);
+
+        basic_block make_basic_block(
+            char const* name
+          , function parent = function()
+          , basic_block before = basic_block());
+
+        basic_block get_insert_block();
+        void set_insert_point(basic_block b);
+
+        void conditional_branch(
+            value cond, basic_block true_br, basic_block false_br);
+        void branch(basic_block b);
+
+        void return_();
+        void return_(value v);
+
+        void optimize_function(function f);
+
+    protected:
+
+        llvm::LLVMContext& context() const
+        { return llvm::getGlobalContext(); }
+
+        llvm::IRBuilder<>& builder()
+        { return llvm_builder; }
+
+    private:
+
+        friend struct function::to_value;
+
+        value val(llvm::Value* v);
+
+        template <typename C>
+        llvm::Value* call_impl(
+            function callee,
+            C const& args);
+
+        void init_fpm();
+        llvm::IRBuilder<> llvm_builder;
+        vmachine& vm;
+        llvm::FunctionPassManager fpm;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The main compiler. Generates code from our AST.
+    ///////////////////////////////////////////////////////////////////////////
+    struct compiler : llvm_compiler
+    {
+        typedef value result_type;
+
+        template <typename ErrorHandler>
+        compiler(vmachine& vm, ErrorHandler& error_handler_)
+          : llvm_compiler(vm)
+        {
+            using namespace boost::phoenix::arg_names;
+            namespace phx = boost::phoenix;
+            using boost::phoenix::function;
+
+            error_handler = function<ErrorHandler>(error_handler_)(
+                "Error! ", _2, phx::cref(error_handler_.iters)[_1]);
+        }
+
+        value operator()(ast::nil) { BOOST_ASSERT(0); return val(); }
+        value operator()(unsigned int x);
+        value operator()(bool x);
+        value operator()(ast::primary_expr const& x);
+        value operator()(ast::identifier const& x);
+        value operator()(ast::unary_expr const& x);
+        value operator()(ast::function_call const& x);
+        value operator()(ast::expression const& x);
+        value operator()(ast::assignment const& x);
+
+        bool operator()(ast::variable_declaration const& x);
+        bool operator()(ast::statement_list const& x);
+        bool operator()(ast::statement const& x);
+        bool operator()(ast::if_statement const& x);
+        bool operator()(ast::while_statement const& x);
+        bool operator()(ast::return_statement const& x);
+        bool operator()(ast::function const& x);
+        bool operator()(ast::function_list const& x);
+
+    private:
+
+        value compile_binary_expression(
+            value lhs, value rhs, token_ids::type op);
+
+        value compile_expression(
+            int min_precedence,
+            value lhs,
+            std::list<ast::operation>::const_iterator& rest_begin,
+            std::list<ast::operation>::const_iterator rest_end);
+
+        struct statement_compiler;
+        statement_compiler& as_statement();
+
+        function function_decl(ast::function const& x);
+        void function_allocas(ast::function const& x, function function);
+
+        boost::function<
+            void(int tag, std::string const& what)>
+        error_handler;
+
+        bool void_return;
+        std::string current_function_name;
+        std::map<std::string, value> locals;
+        basic_block return_block;
+        value return_var;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/config.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/config.hpp
new file mode 100644
index 00000000..70af0db0
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/config.hpp
@@ -0,0 +1,51 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_LEXER_CONFIG_HPP)
+#define BOOST_SPIRIT_CONJURE_LEXER_CONFIG_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+// The conjure lexer example can be built in 3 different variations:
+//
+//    - With a lexer using runtime generated DFA tables
+//    - With a lexer using pre-generated (static) DFA tables
+//    - With a lexer using a pre-generated custom switch based state machine
+//
+// Use one of the following preprocessor constants to define, which of those 
+// will be built:
+
+///////////////////////////////////////////////////////////////////////////////
+// Use the lexer based on runtime generated DFA tables
+// #define CONJURE_LEXER_DYNAMIC_TABLES 1
+
+///////////////////////////////////////////////////////////////////////////////
+// Use the lexer based on pre-generated static DFA tables
+// #define CONJURE_LEXER_STATIC_TABLES 1
+
+///////////////////////////////////////////////////////////////////////////////
+// Use the lexer based on runtime generated DFA tables
+// #define CONJURE_LEXER_STATIC_SWITCH 1
+
+///////////////////////////////////////////////////////////////////////////////
+// The default is to use the dynamic table driven lexer
+#if CONJURE_LEXER_DYNAMIC_TABLES == 0 && \
+    CONJURE_LEXER_STATIC_TABLES == 0 && \
+    CONJURE_LEXER_STATIC_SWITCH == 0
+
+#define CONJURE_LEXER_DYNAMIC_TABLES 1
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Make sure we have only one lexer type selected
+#if (CONJURE_LEXER_DYNAMIC_TABLES != 0 && CONJURE_LEXER_STATIC_TABLES != 0) || \
+    (CONJURE_LEXER_DYNAMIC_TABLES != 0 && CONJURE_LEXER_STATIC_SWITCH != 0) || \
+    (CONJURE_LEXER_STATIC_TABLES != 0 && CONJURE_LEXER_STATIC_SWITCH != 0)
+
+#error "Configuration problem: please select exactly one type of lexer to build"
+#endif
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/conjure_static_lexer.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/conjure_static_lexer.hpp
new file mode 100644
index 00000000..651d34d6
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/conjure_static_lexer.hpp
@@ -0,0 +1,483 @@
+// Copyright (c) 2008-2009 Ben Hanson
+// Copyright (c) 2008-2011 Hartmut Kaiser
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Auto-generated by boost::lexer, do not edit
+
+#if !defined(BOOST_SPIRIT_LEXER_NEXT_TOKEN_CONJURE_STATIC_JUL_25_2011_07_25_53)
+#define BOOST_SPIRIT_LEXER_NEXT_TOKEN_CONJURE_STATIC_JUL_25_2011_07_25_53
+
+#include <boost/spirit/home/support/detail/lexer/char_traits.hpp>
+
+////////////////////////////////////////////////////////////////////////////////
+// the generated table of state names and the tokenizer have to be
+// defined in the boost::spirit::lex::lexertl::static_ namespace
+namespace boost { namespace spirit { namespace lex { namespace lexertl { namespace static_ {
+
+////////////////////////////////////////////////////////////////////////////////
+// this table defines the names of the lexer states
+char const* const lexer_state_names_conjure_static[1] = 
+{
+    "INITIAL"
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// this variable defines the number of lexer states
+std::size_t const lexer_state_count_conjure_static = 1;
+
+////////////////////////////////////////////////////////////////////////////////
+// this function returns the next matched token
+template<typename Iterator>
+std::size_t next_token_conjure_static (std::size_t& /*start_state_*/, bool& /*bol_*/, 
+    Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+{
+    enum {end_state_index, id_index, unique_id_index, state_index, bol_index,
+        eol_index, dead_state_index, dfa_offset};
+
+    static std::size_t const npos = static_cast<std::size_t>(~0);
+    static std::size_t const lookup_[256] = {
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 7, 7, 41, 41, 7, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        7, 8, 41, 41, 41, 41, 9, 41,
+        10, 11, 12, 13, 14, 15, 41, 16,
+        17, 17, 17, 17, 17, 17, 17, 17,
+        17, 17, 41, 19, 20, 21, 22, 41,
+        41, 18, 18, 18, 18, 18, 18, 18,
+        18, 18, 18, 18, 18, 18, 18, 18,
+        18, 18, 18, 18, 18, 18, 18, 18,
+        18, 18, 18, 41, 41, 41, 41, 18,
+        41, 23, 18, 18, 24, 25, 26, 18,
+        27, 28, 18, 18, 29, 18, 30, 31,
+        18, 18, 32, 33, 34, 35, 36, 37,
+        18, 18, 18, 38, 39, 40, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41,
+        41, 41, 41, 41, 41, 41, 41, 41 };
+    static std::size_t const dfa_alphabet_ = 42;
+    static std::size_t const dfa_[2604] = {
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 27, 13, 11, 20, 21, 18, 16,
+        24, 17, 19, 2, 26, 25, 14, 12,
+        15, 26, 26, 7, 4, 26, 6, 26,
+        26, 26, 9, 26, 3, 26, 5, 8,
+        22, 10, 23, 0, 1, 35, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 2, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 28, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 29,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 30, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 32, 26,
+        26, 26, 31, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 33, 26, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 34, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 35, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 36, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 37,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 61, 26, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 38, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 262177, 20, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 39,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 131091, 12, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 40, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 131093,
+        14, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 41, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 393241, 16, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 393242, 17, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 131099, 18, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 131100,
+        19, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 42, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 40, 21, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 41, 22, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 123, 23, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 125,
+        24, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 44, 25, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 59, 27, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 34,
+        30, 0, 0, 0, 0, 27, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 43, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 44,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        45, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        46, 26, 26, 26, 0, 0, 0, 0,
+        1, 65538, 4, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 47, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        48, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        49, 26, 26, 26, 0, 0, 0, 0,
+        1, 131084, 8, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 131085, 9, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 131089, 10, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 1, 131090,
+        11, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        1, 131092, 13, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 1, 131094, 15, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 42, 42, 42, 42, 42,
+        50, 42, 42, 42, 42, 42, 42, 42,
+        42, 42, 42, 42, 42, 42, 42, 42,
+        42, 42, 42, 42, 42, 42, 42, 42,
+        42, 42, 42, 42, 42, 42, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 51,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 43, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 52, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 65537, 3, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 53,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 32, 28, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 54, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 32, 28, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 55, 26, 26,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 56, 56, 56, 56, 56,
+        50, 56, 56, 56, 57, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 1, 36,
+        1, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        1, 65536, 2, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 26, 26, 0, 0, 0, 0, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 0, 0,
+        0, 0, 1, 65539, 5, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0, 1, 32, 28, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 58, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 59, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 56,
+        56, 56, 56, 56, 60, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 1, 33, 29, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 65540, 6, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 26, 26, 0,
+        0, 0, 0, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 0, 0, 0, 0, 1, 32,
+        28, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 26,
+        26, 0, 0, 0, 0, 26, 26, 26,
+        26, 26, 26, 26, 61, 26, 26, 26,
+        26, 26, 26, 26, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 56,
+        56, 56, 56, 56, 60, 56, 56, 56,
+        57, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 56, 56, 56, 56, 56, 56,
+        56, 56, 1, 65541, 7, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 26, 26, 0, 0, 0,
+        0, 26, 26, 26, 26, 26, 26, 26,
+        26, 26, 26, 26, 26, 26, 26, 26,
+        0, 0, 0, 0 };
+
+    if (start_token_ == end_)
+    {
+        unique_id_ = npos;
+        return 0;
+    }
+
+    std::size_t const* ptr_ = dfa_ + dfa_alphabet_;
+    Iterator curr_ = start_token_;
+    bool end_state_ = *ptr_ != 0;
+    std::size_t id_ = *(ptr_ + id_index);
+    std::size_t uid_ = *(ptr_ + unique_id_index);
+    Iterator end_token_ = start_token_;
+
+    while (curr_ != end_)
+    {
+        std::size_t const state_ =
+            ptr_[lookup_[static_cast<unsigned char>(*curr_++)]];
+
+        if (state_ == 0) break;
+
+        ptr_ = &dfa_[state_ * dfa_alphabet_];
+
+        if (*ptr_)
+        {
+            end_state_ = true;
+            id_ = *(ptr_ + id_index);
+            uid_ = *(ptr_ + unique_id_index);
+            end_token_ = curr_;
+        }
+    }
+
+    if (end_state_)
+    {
+        // return longest match
+        start_token_ = end_token_;
+    }
+    else
+    {
+        id_ = npos;
+        uid_ = npos;
+    }
+
+    unique_id_ = uid_;
+    return id_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// this defines a generic accessors for the information above
+struct lexer_conjure_static
+{
+    // version number and feature-set of compatible static lexer engine
+    enum
+    {
+        static_version = 65536,
+        supports_bol = false,
+        supports_eol = false
+    };
+
+    // return the number of lexer states
+    static std::size_t state_count()
+    {
+        return lexer_state_count_conjure_static; 
+    }
+
+    // return the name of the lexer state as given by 'idx'
+    static char const* state_name(std::size_t idx)
+    {
+        return lexer_state_names_conjure_static[idx]; 
+    }
+
+    // return the next matched token
+    template<typename Iterator>
+    static std::size_t next(std::size_t &start_state_, bool& bol_
+      , Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+    {
+        return next_token_conjure_static(start_state_, bol_, start_token_, end_, unique_id_);
+    }
+};
+
+}}}}}  // namespace boost::spirit::lex::lexertl::static_
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/conjure_static_lexer_generate.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/conjure_static_lexer_generate.cpp
new file mode 100644
index 00000000..1ba8fac0
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/conjure_static_lexer_generate.cpp
@@ -0,0 +1,43 @@
+//  Copyright (c) 2001-2011 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)
+
+// This small utility program generates the 2 static lexers, the static table 
+// driven and the static switch based lexer.
+
+#include <fstream>
+#include <iostream>
+
+#include "lexer_def.hpp"
+#include <boost/spirit/include/lex_generate_static_lexertl.hpp>
+
+int main()
+{
+    typedef std::string::const_iterator base_iterator_type;
+    typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+
+    lexer_type lexer;
+
+    // first generate the static switch based lexer 
+    std::ofstream out_static("conjure_static_switch_lexer.hpp");
+
+    bool result = boost::spirit::lex::lexertl::generate_static_switch(
+        lexer, out_static, "conjure_static_switch");
+    if (!result) {
+        std::cerr << "Failed to generate static switch based lexer\n";
+        return -1;
+    }
+
+    // now generate the static table based lexer 
+    std::ofstream out("conjure_static_lexer.hpp");
+    result = boost::spirit::lex::lexertl::generate_static(
+        lexer, out, "conjure_static");
+    if (!result) {
+        std::cerr << "Failed to generate static table based lexer\n";
+        return -1;
+    }
+
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/conjure_static_switch_lexer.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/conjure_static_switch_lexer.hpp
new file mode 100644
index 00000000..0dcd1ac7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/conjure_static_switch_lexer.hpp
@@ -0,0 +1,873 @@
+// Copyright (c) 2008-2009 Ben Hanson
+// Copyright (c) 2008-2011 Hartmut Kaiser
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file licence_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Auto-generated by boost::lexer, do not edit
+
+#if !defined(BOOST_SPIRIT_LEXER_NEXT_TOKEN_CONJURE_STATIC_SWITCH_JUL_25_2011_07_25_53)
+#define BOOST_SPIRIT_LEXER_NEXT_TOKEN_CONJURE_STATIC_SWITCH_JUL_25_2011_07_25_53
+
+#include <boost/spirit/home/support/detail/lexer/char_traits.hpp>
+
+////////////////////////////////////////////////////////////////////////////////
+// the generated table of state names and the tokenizer have to be
+// defined in the boost::spirit::lex::lexertl::static_ namespace
+namespace boost { namespace spirit { namespace lex { namespace lexertl { namespace static_ {
+
+////////////////////////////////////////////////////////////////////////////////
+// this table defines the names of the lexer states
+char const* const lexer_state_names_conjure_static_switch[1] = 
+{
+    "INITIAL"
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// this variable defines the number of lexer states
+std::size_t const lexer_state_count_conjure_static_switch = 1;
+
+////////////////////////////////////////////////////////////////////////////////
+// this function returns the next matched token
+template<typename Iterator>
+std::size_t next_token_conjure_static_switch (std::size_t& /*start_state_*/, bool& /*bol_*/, 
+    Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+{
+    static std::size_t const npos = static_cast<std::size_t>(~0);
+
+    if (start_token_ == end_)
+    {
+        unique_id_ = npos;
+        return 0;
+    }
+
+    Iterator curr_ = start_token_;
+    bool end_state_ = false;
+    std::size_t id_ = npos;
+    std::size_t uid_ = npos;
+    Iterator end_token_ = start_token_;
+
+    char ch_ = 0;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9')) goto state0_1;
+
+    if (ch_ == 't') goto state0_2;
+
+    if (ch_ == 'f') goto state0_3;
+
+    if (ch_ == 'v') goto state0_4;
+
+    if (ch_ == 'i') goto state0_5;
+
+    if (ch_ == 'e') goto state0_6;
+
+    if (ch_ == 'w') goto state0_7;
+
+    if (ch_ == 'r') goto state0_8;
+
+    if (ch_ == '|') goto state0_9;
+
+    if (ch_ == '&') goto state0_10;
+
+    if (ch_ == '=') goto state0_11;
+
+    if (ch_ == '!') goto state0_12;
+
+    if (ch_ == '<') goto state0_13;
+
+    if (ch_ == '>') goto state0_14;
+
+    if (ch_ == '+') goto state0_15;
+
+    if (ch_ == '-') goto state0_16;
+
+    if (ch_ == '*') goto state0_17;
+
+    if (ch_ == '/') goto state0_18;
+
+    if (ch_ == '(') goto state0_19;
+
+    if (ch_ == ')') goto state0_20;
+
+    if (ch_ == '{') goto state0_21;
+
+    if (ch_ == '}') goto state0_22;
+
+    if (ch_ == ',') goto state0_23;
+
+    if (ch_ == ';') goto state0_24;
+
+    if ((ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'g' && ch_ <= 'h') || (ch_ >= 'j' && ch_ <= 'q') || ch_ == 's' || ch_ == 'u' || (ch_ >= 'x' && ch_ <= 'z')) goto state0_25;
+
+    if ((ch_ >= '\t' && ch_ <= '\n') || ch_ == '\r' || ch_ == ' ') goto state0_26;
+    goto end;
+
+state0_1:
+    end_state_ = true;
+    id_ = 35;
+    uid_ = 0;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9')) goto state0_1;
+    goto end;
+
+state0_2:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'q') || (ch_ >= 's' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'r') goto state0_27;
+    goto end;
+
+state0_3:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'b' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'a') goto state0_28;
+    goto end;
+
+state0_4:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'n') || (ch_ >= 'p' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'o') goto state0_29;
+    goto end;
+
+state0_5:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'e') || (ch_ >= 'g' && ch_ <= 'm') || (ch_ >= 'o' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'n') goto state0_30;
+
+    if (ch_ == 'f') goto state0_31;
+    goto end;
+
+state0_6:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'k') || (ch_ >= 'm' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'l') goto state0_32;
+    goto end;
+
+state0_7:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'g') || (ch_ >= 'i' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'h') goto state0_33;
+    goto end;
+
+state0_8:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'f' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'e') goto state0_34;
+    goto end;
+
+state0_9:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '|') goto state0_35;
+    goto end;
+
+state0_10:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '&') goto state0_36;
+    goto end;
+
+state0_11:
+    end_state_ = true;
+    id_ = 61;
+    uid_ = 26;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '=') goto state0_37;
+    goto end;
+
+state0_12:
+    end_state_ = true;
+    id_ = 262177;
+    uid_ = 20;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '=') goto state0_38;
+    goto end;
+
+state0_13:
+    end_state_ = true;
+    id_ = 131091;
+    uid_ = 12;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '=') goto state0_39;
+    goto end;
+
+state0_14:
+    end_state_ = true;
+    id_ = 131093;
+    uid_ = 14;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '=') goto state0_40;
+    goto end;
+
+state0_15:
+    end_state_ = true;
+    id_ = 393241;
+    uid_ = 16;
+    end_token_ = curr_;
+    goto end;
+
+state0_16:
+    end_state_ = true;
+    id_ = 393242;
+    uid_ = 17;
+    end_token_ = curr_;
+    goto end;
+
+state0_17:
+    end_state_ = true;
+    id_ = 131099;
+    uid_ = 18;
+    end_token_ = curr_;
+    goto end;
+
+state0_18:
+    end_state_ = true;
+    id_ = 131100;
+    uid_ = 19;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '*') goto state0_41;
+    goto end;
+
+state0_19:
+    end_state_ = true;
+    id_ = 40;
+    uid_ = 21;
+    end_token_ = curr_;
+    goto end;
+
+state0_20:
+    end_state_ = true;
+    id_ = 41;
+    uid_ = 22;
+    end_token_ = curr_;
+    goto end;
+
+state0_21:
+    end_state_ = true;
+    id_ = 123;
+    uid_ = 23;
+    end_token_ = curr_;
+    goto end;
+
+state0_22:
+    end_state_ = true;
+    id_ = 125;
+    uid_ = 24;
+    end_token_ = curr_;
+    goto end;
+
+state0_23:
+    end_state_ = true;
+    id_ = 44;
+    uid_ = 25;
+    end_token_ = curr_;
+    goto end;
+
+state0_24:
+    end_state_ = true;
+    id_ = 59;
+    uid_ = 27;
+    end_token_ = curr_;
+    goto end;
+
+state0_25:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_26:
+    end_state_ = true;
+    id_ = 34;
+    uid_ = 30;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '\t' && ch_ <= '\n') || ch_ == '\r' || ch_ == ' ') goto state0_26;
+    goto end;
+
+state0_27:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 't') || (ch_ >= 'v' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'u') goto state0_42;
+    goto end;
+
+state0_28:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'k') || (ch_ >= 'm' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'l') goto state0_43;
+    goto end;
+
+state0_29:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'h') || (ch_ >= 'j' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'i') goto state0_44;
+    goto end;
+
+state0_30:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 's') || (ch_ >= 'u' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 't') goto state0_45;
+    goto end;
+
+state0_31:
+    end_state_ = true;
+    id_ = 65538;
+    uid_ = 4;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_32:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'r') || (ch_ >= 't' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 's') goto state0_46;
+    goto end;
+
+state0_33:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'h') || (ch_ >= 'j' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'i') goto state0_47;
+    goto end;
+
+state0_34:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 's') || (ch_ >= 'u' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 't') goto state0_48;
+    goto end;
+
+state0_35:
+    end_state_ = true;
+    id_ = 131084;
+    uid_ = 8;
+    end_token_ = curr_;
+    goto end;
+
+state0_36:
+    end_state_ = true;
+    id_ = 131085;
+    uid_ = 9;
+    end_token_ = curr_;
+    goto end;
+
+state0_37:
+    end_state_ = true;
+    id_ = 131089;
+    uid_ = 10;
+    end_token_ = curr_;
+    goto end;
+
+state0_38:
+    end_state_ = true;
+    id_ = 131090;
+    uid_ = 11;
+    end_token_ = curr_;
+    goto end;
+
+state0_39:
+    end_state_ = true;
+    id_ = 131092;
+    uid_ = 13;
+    end_token_ = curr_;
+    goto end;
+
+state0_40:
+    end_state_ = true;
+    id_ = 131094;
+    uid_ = 15;
+    end_token_ = curr_;
+    goto end;
+
+state0_41:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ != '*') goto state0_41;
+
+    if (ch_ == '*') goto state0_49;
+    goto end;
+
+state0_42:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'f' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'e') goto state0_50;
+    goto end;
+
+state0_43:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'r') || (ch_ >= 't' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 's') goto state0_42;
+    goto end;
+
+state0_44:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'c') || (ch_ >= 'e' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'd') goto state0_51;
+    goto end;
+
+state0_45:
+    end_state_ = true;
+    id_ = 65537;
+    uid_ = 3;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_46:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'f' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'e') goto state0_52;
+    goto end;
+
+state0_47:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'k') || (ch_ >= 'm' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'l') goto state0_53;
+    goto end;
+
+state0_48:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 't') || (ch_ >= 'v' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'u') goto state0_54;
+    goto end;
+
+state0_49:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ == '*') goto state0_49;
+
+    if (ch_ != '*' && ch_ != '/') goto state0_55;
+
+    if (ch_ == '/') goto state0_56;
+    goto end;
+
+state0_50:
+    end_state_ = true;
+    id_ = 36;
+    uid_ = 1;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_51:
+    end_state_ = true;
+    id_ = 65536;
+    uid_ = 2;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_52:
+    end_state_ = true;
+    id_ = 65539;
+    uid_ = 5;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_53:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'd') || (ch_ >= 'f' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'e') goto state0_57;
+    goto end;
+
+state0_54:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'q') || (ch_ >= 's' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'r') goto state0_58;
+    goto end;
+
+state0_55:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ != '*') goto state0_55;
+
+    if (ch_ == '*') goto state0_59;
+    goto end;
+
+state0_56:
+    end_state_ = true;
+    id_ = 33;
+    uid_ = 29;
+    end_token_ = curr_;
+    goto end;
+
+state0_57:
+    end_state_ = true;
+    id_ = 65540;
+    uid_ = 6;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+    goto end;
+
+state0_58:
+    end_state_ = true;
+    id_ = 32;
+    uid_ = 28;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'm') || (ch_ >= 'o' && ch_ <= 'z')) goto state0_25;
+
+    if (ch_ == 'n') goto state0_60;
+    goto end;
+
+state0_59:
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if (ch_ != '*' && ch_ != '/') goto state0_55;
+
+    if (ch_ == '/') goto state0_56;
+
+    if (ch_ == '*') goto state0_59;
+    goto end;
+
+state0_60:
+    end_state_ = true;
+    id_ = 65541;
+    uid_ = 7;
+    end_token_ = curr_;
+
+    if (curr_ == end_) goto end;
+    ch_ = *curr_;
+    ++curr_;
+
+    if ((ch_ >= '0' && ch_ <= '9') || (ch_ >= 'A' && ch_ <= 'Z') || ch_ == '_' || (ch_ >= 'a' && ch_ <= 'z')) goto state0_25;
+
+end:
+    if (end_state_)
+    {
+        // return longest match
+        start_token_ = end_token_;
+    }
+    else
+    {
+        id_ = npos;
+        uid_ = npos;
+    }
+
+    unique_id_ = uid_;
+    return id_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// this defines a generic accessors for the information above
+struct lexer_conjure_static_switch
+{
+    // version number and feature-set of compatible static lexer engine
+    enum
+    {
+        static_version = 65536,
+        supports_bol = false,
+        supports_eol = false
+    };
+
+    // return the number of lexer states
+    static std::size_t state_count()
+    {
+        return lexer_state_count_conjure_static_switch; 
+    }
+
+    // return the name of the lexer state as given by 'idx'
+    static char const* state_name(std::size_t idx)
+    {
+        return lexer_state_names_conjure_static_switch[idx]; 
+    }
+
+    // return the next matched token
+    template<typename Iterator>
+    static std::size_t next(std::size_t &start_state_, bool& bol_
+      , Iterator &start_token_, Iterator const& end_, std::size_t& unique_id_)
+    {
+        return next_token_conjure_static_switch(start_state_, bol_, start_token_, end_, unique_id_);
+    }
+};
+
+}}}}}  // namespace boost::spirit::lex::lexertl::static_
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/error_handler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/error_handler.hpp
new file mode 100644
index 00000000..efda9a6a
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/error_handler.hpp
@@ -0,0 +1,99 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_CONJURE_ERROR_HANDLER_HPP
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The error handler
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename BaseIterator, typename Iterator>
+    struct error_handler
+    {
+        template <typename, typename, typename>
+        struct result { typedef void type; };
+
+        error_handler(BaseIterator first, BaseIterator last)
+          : first(first), last(last) {}
+
+        template <typename Message, typename What>
+        void operator()(
+            Message const& message,
+            What const& what,
+            Iterator err_pos) const
+        {
+            // retrieve underlying iterator from current token, err_pos points
+            // to the last validly matched token, so we use its end iterator 
+            // as the error position
+            BaseIterator err_pos_base = err_pos->matched().end();
+
+            int line;
+            BaseIterator line_start = get_pos(err_pos_base, line);
+            if (err_pos_base != last)
+            {
+                std::cout << message << what << " line " << line << ':' << std::endl;
+                std::cout << get_line(line_start) << std::endl;
+                for (; line_start != err_pos_base; ++line_start)
+                    std::cout << ' ';
+                std::cout << '^' << std::endl;
+            }
+            else
+            {
+                std::cout << "Unexpected end of file. ";
+                std::cout << message << what << " line " << line << std::endl;
+            }
+        }
+
+        BaseIterator get_pos(BaseIterator err_pos, int& line) const
+        {
+            line = 1;
+            BaseIterator i = first;
+            BaseIterator line_start = first;
+            while (i != err_pos)
+            {
+                bool eol = false;
+                if (i != err_pos && *i == '\r') // CR
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (i != err_pos && *i == '\n') // LF
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (eol)
+                    ++line;
+                else
+                    ++i;
+            }
+            return line_start;
+        }
+
+        std::string get_line(BaseIterator err_pos) const
+        {
+            BaseIterator i = err_pos;
+            // position i to the next EOL
+            while (i != last && (*i != '\r' && *i != '\n'))
+                ++i;
+            return std::string(err_pos, i);
+        }
+
+        BaseIterator first;
+        BaseIterator last;
+        std::vector<Iterator> iters;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/expression.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/expression.cpp
new file mode 100644
index 00000000..5b51ce36
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/expression.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "config.hpp"
+#include "lexer.hpp"
+#include "expression_def.hpp"
+
+typedef std::string::const_iterator base_iterator_type;
+typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+typedef lexer_type::iterator_type iterator_type;
+
+template struct client::parser::expression<iterator_type, lexer_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/expression.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/expression.hpp
new file mode 100644
index 00000000..eec9cd6a
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/expression.hpp
@@ -0,0 +1,59 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_EXPRESSION_HPP)
+#define BOOST_SPIRIT_CONJURE_EXPRESSION_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+// #define BOOST_SPIRIT_QI_DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/spirit/include/qi.hpp>
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+
+namespace client { namespace parser
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The expression grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer>
+    struct expression : qi::grammar<Iterator, ast::expression()>
+    {
+        typedef error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+
+        expression(error_handler_type& error_handler, Lexer const& l);
+
+        Lexer const& lexer;
+
+        qi::rule<Iterator, ast::expression()> expr;
+        qi::rule<Iterator, ast::operand()> unary_expr, postfix_expr;
+        qi::rule<Iterator, ast::function_call()> function_call;
+        qi::rule<Iterator, std::list<ast::expression>()> argument_list;
+        qi::rule<Iterator, std::string()> identifier;
+        qi::rule<Iterator, ast::primary_expr()> primary_expr;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/expression_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/expression_def.hpp
new file mode 100644
index 00000000..2d21323a
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/expression_def.hpp
@@ -0,0 +1,104 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "expression.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/lex_plain_token.hpp>
+
+namespace client { namespace parser
+{
+    template <typename Iterator, typename Lexer>
+    expression<Iterator, Lexer>::expression(
+            error_handler<typename Lexer::base_iterator_type, Iterator>& error_handler
+          , Lexer const& l)
+      : expression::base_type(expr), lexer(l)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+        qi::tokenid_mask_type tokenid_mask;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef client::error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+        typedef function<error_handler_type> error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Main expression grammar
+        expr =
+                unary_expr
+            >>  *(tokenid_mask(token_ids::op_binary) > unary_expr)
+            ;
+
+        unary_expr =
+                postfix_expr
+            |   (tokenid_mask(token_ids::op_unary) > unary_expr)
+            ;
+
+        postfix_expr =
+                function_call
+            |   primary_expr
+            ;
+
+        primary_expr =
+                lexer.lit_uint
+            |   lexer.true_or_false
+            |   identifier
+            |   '(' > expr > ')'
+            ;
+
+        function_call =
+                (identifier >> '(')
+            >   argument_list
+            >   ')'
+            ;
+
+        argument_list = -(expr % ',');
+
+        identifier = lexer.identifier;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (expr)
+            (unary_expr)
+            (postfix_expr)
+            (primary_expr)
+            (function_call)
+            (argument_list)
+            (identifier)
+        );
+
+        ///////////////////////////////////////////////////////////////////////
+        // Error handling: on error in expr, call error_handler.
+        on_error<fail>(expr,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        ///////////////////////////////////////////////////////////////////////
+        // Annotation: on success in unary_expr, postfix_expr,
+        // and primary_expr call annotation.
+        on_success(unary_expr,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(postfix_expr,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(primary_expr,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/function.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/function.cpp
new file mode 100644
index 00000000..98c8169b
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/function.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "config.hpp"
+#include "lexer.hpp"
+#include "function_def.hpp"
+
+typedef std::string::const_iterator base_iterator_type;
+typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+typedef lexer_type::iterator_type iterator_type;
+
+template struct client::parser::function<iterator_type, lexer_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/function.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/function.hpp
new file mode 100644
index 00000000..fc5263f1
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/function.hpp
@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_FUNCTION_HPP)
+#define BOOST_SPIRIT_CONJURE_FUNCTION_HPP
+
+#include "statement.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The function grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer>
+    struct function : qi::grammar<Iterator, ast::function()>
+    {
+        typedef error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+
+        function(error_handler_type& error_handler, Lexer const& l);
+
+        statement<Iterator, Lexer> body;
+
+        qi::rule<Iterator, ast::identifier()> identifier;
+        qi::rule<Iterator, std::list<ast::identifier>()> argument_list;
+        qi::rule<Iterator, ast::function()> start;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/function_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/function_def.hpp
new file mode 100644
index 00000000..95846264
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/function_def.hpp
@@ -0,0 +1,64 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "function.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator, typename Lexer>
+    function<Iterator, Lexer>::function(
+            error_handler<typename Lexer::base_iterator_type, Iterator>& error_handler
+          , Lexer const& l)
+      : function::base_type(start), body(error_handler, l)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef client::error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+        typedef function<error_handler_type> error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        identifier = body.expr.identifier;
+        argument_list = -(identifier % ',');
+
+        start = (l.token("void") | l.token("int"))
+            >   identifier
+            >   '(' > argument_list > ')'
+            >   (';' | '{' > body > '}')
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (identifier)
+            (argument_list)
+            (start)
+        );
+
+        // Error handling: on error in start, call error_handler.
+        on_error<fail>(start,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in start, call annotation.
+        on_success(identifier,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/ids.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/ids.hpp
new file mode 100644
index 00000000..c4d98acc
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/ids.hpp
@@ -0,0 +1,160 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_IDS_HPP)
+#define BOOST_SPIRIT_CONJURE_IDS_HPP
+
+namespace client
+{
+    struct op_type
+    {
+        enum type
+        {
+            binary = 0x20000,
+            unary = 0x40000,
+            postfix_unary = 0x80000,
+            assign = 0x100000
+        };
+    };
+
+    struct op
+    {
+        enum type
+        {
+            // binary
+            comma,
+            assign,
+            plus_assign,
+            minus_assign,
+            times_assign,
+            divide_assign,
+            mod_assign,
+            bit_and_assign,
+            bit_xor_assign,
+            bit_or_assign,
+            shift_left_assign,
+            shift_right_assign,
+            logical_or,
+            logical_and,
+            bit_or,
+            bit_xor,
+            bit_and,
+            equal,
+            not_equal,
+            less,
+            less_equal,
+            greater,
+            greater_equal,
+            shift_left,
+            shift_right,
+            plus,
+            minus,
+            times,
+            divide,
+            mod,
+
+            // unary
+            plus_plus,
+            minus_minus,
+            compl_,
+            not_,
+        };
+    };
+
+    template <int type, int op>
+    struct make_op
+    {
+        static int const value = type + op;
+    };
+
+    template <op::type op>
+    struct unary_op : make_op<op_type::unary, op> {};
+
+    template <op::type op>
+    struct binary_op
+        : make_op<op_type::binary, op> {};
+
+    template <op::type op>
+    struct assign_op
+        : make_op<op_type::assign, op> {};
+
+    template <op::type op>
+    struct binary_or_unary_op
+        : make_op<op_type::unary | op_type::binary, op> {};
+
+    struct token_ids
+    {
+        enum type
+        {
+            // pseudo tags
+            invalid             = -1,
+            op_binary           = op_type::binary,
+            op_unary            = op_type::unary,
+            op_assign           = op_type::assign,
+
+            // binary / unary operators with common tokens
+            // '+' and '-' can be binary or unary
+            // (the lexer cannot distinguish which)
+            plus                = binary_or_unary_op<op::plus>::value,
+            minus               = binary_or_unary_op<op::minus>::value,
+
+            // binary operators
+            comma               = binary_op<op::comma>::value,
+            assign              = assign_op<op::assign>::value,
+            plus_assign         = assign_op<op::plus_assign>::value,
+            minus_assign        = assign_op<op::minus_assign>::value,
+            times_assign        = assign_op<op::times_assign>::value,
+            divide_assign       = assign_op<op::divide_assign>::value,
+            mod_assign          = assign_op<op::mod_assign>::value,
+            bit_and_assign      = assign_op<op::bit_and_assign>::value,
+            bit_xor_assign      = assign_op<op::bit_xor_assign>::value,
+            bit_or_assign       = assign_op<op::bit_or_assign>::value,
+            shift_left_assign   = assign_op<op::shift_left_assign>::value,
+            shift_right_assign  = assign_op<op::shift_right_assign>::value,
+            logical_or          = binary_op<op::logical_or>::value,
+            logical_and         = binary_op<op::logical_and>::value,
+            bit_or              = binary_op<op::bit_or>::value,
+            bit_xor             = binary_op<op::bit_xor>::value,
+            bit_and             = binary_op<op::bit_and>::value,
+            equal               = binary_op<op::equal>::value,
+            not_equal           = binary_op<op::not_equal>::value,
+            less                = binary_op<op::less>::value,
+            less_equal          = binary_op<op::less_equal>::value,
+            greater             = binary_op<op::greater>::value,
+            greater_equal       = binary_op<op::greater_equal>::value,
+            shift_left          = binary_op<op::shift_left>::value,
+            shift_right         = binary_op<op::shift_right>::value,
+            times               = binary_op<op::times>::value,
+            divide              = binary_op<op::divide>::value,
+            mod                 = binary_op<op::mod>::value,
+
+            // unary operators with overlaps
+            // '++' and '--' can be prefix or postfix
+            // (the lexer cannot distinguish which)
+            plus_plus           = make_op<
+                    op_type::unary
+                |   op_type::postfix_unary, op::plus_plus>::value,
+
+            minus_minus         = make_op<
+                    op_type::unary
+                |   op_type::postfix_unary, op::minus_minus>::value,
+
+            // unary operators
+            compl_              = unary_op<op::compl_>::value,
+            not_                = unary_op<op::not_>::value,
+
+            // misc tags
+            identifier          = op::not_ + 1,
+            comment,
+            whitespace,
+            lit_uint,
+            true_or_false
+        };
+    };
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/lexer.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/lexer.cpp
new file mode 100644
index 00000000..d7125fed
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/lexer.cpp
@@ -0,0 +1,17 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "config.hpp"
+#include "lexer_def.hpp"
+
+typedef std::string::const_iterator base_iterator_type;
+template client::lexer::conjure_tokens<base_iterator_type>::conjure_tokens();
+template bool client::lexer::conjure_tokens<base_iterator_type>::add_(
+    std::string const&, int);
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/lexer.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/lexer.hpp
new file mode 100644
index 00000000..9624fe2f
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/lexer.hpp
@@ -0,0 +1,144 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_LEXER_HPP)
+#define BOOST_SPIRIT_CONJURE_LEXER_HPP
+
+#include <boost/spirit/include/lex_lexertl.hpp>
+#include <boost/spirit/include/lex_lexertl_position_token.hpp>
+
+#include "config.hpp"
+#include "ids.hpp"
+
+#if CONJURE_LEXER_STATIC_TABLES != 0
+#include <boost/spirit/include/lex_static_lexertl.hpp>
+#include "conjure_static_lexer.hpp"
+#elif CONJURE_LEXER_STATIC_SWITCH != 0
+#include <boost/spirit/include/lex_static_lexertl.hpp>
+#include "conjure_static_switch_lexer.hpp"
+#endif
+#include <boost/assert.hpp>
+
+namespace client { namespace lexer
+{
+    namespace lex = boost::spirit::lex;
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        namespace lex = boost::spirit::lex;
+
+        template <typename BaseIterator>
+        struct get_lexer_type
+        {
+            // Our token needs to be able to carry several token values:
+            // std::string, unsigned int, and bool
+            typedef boost::mpl::vector<std::string, unsigned int, bool>
+                token_value_types;
+
+            // Using the position_token class as the token type to be returned
+            // from the lexer iterators allows to retain positional information
+            // as every token instance stores an iterator pair pointing to the
+            // matched input sequence.
+            typedef lex::lexertl::position_token<
+                BaseIterator, token_value_types, boost::mpl::false_
+            > token_type;
+
+#if CONJURE_LEXER_DYNAMIC_TABLES != 0
+            // use the lexer based on runtime generated DFA tables
+            typedef lex::lexertl::actor_lexer<token_type> type;
+#elif CONJURE_LEXER_STATIC_TABLES != 0
+            // use the lexer based on pre-generated static DFA tables
+            typedef lex::lexertl::static_actor_lexer<
+                token_type
+              , boost::spirit::lex::lexertl::static_::lexer_conjure_static
+            > type;
+#elif CONJURE_LEXER_STATIC_SWITCH != 0
+            // use the lexer based on pre-generated static code
+            typedef lex::lexertl::static_actor_lexer<
+                token_type
+              , boost::spirit::lex::lexertl::static_::lexer_conjure_static_switch
+            > type;
+#else
+#error "Configuration problem: please select exactly one type of lexer to build"
+#endif
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename BaseIterator>
+    struct conjure_tokens
+      : lex::lexer<typename detail::get_lexer_type<BaseIterator>::type>
+    {
+    private:
+        // get the type of any qi::raw_token(...) and qi::token(...) constructs
+        typedef typename boost::spirit::result_of::terminal<
+            boost::spirit::tag::raw_token(token_ids::type)
+        >::type raw_token_spec;
+
+        typedef typename boost::spirit::result_of::terminal<
+            boost::spirit::tag::token(token_ids::type)
+        >::type token_spec;
+
+        typedef std::map<std::string, token_ids::type> keyword_map_type;
+
+    protected:
+        // add a keyword to the mapping table
+        bool add_(std::string const& keyword, int id = token_ids::invalid);
+
+        struct keyword_adder
+        {
+            conjure_tokens& l;
+            keyword_adder(conjure_tokens& l) : l(l) {}
+            keyword_adder& operator()(
+                std::string const& keyword, int id = token_ids::invalid)
+            {
+                l.add_(keyword, id);
+                return *this;
+            }
+        };
+
+        friend struct keyword_adder;
+        keyword_adder add;
+
+    public:
+        typedef BaseIterator base_iterator_type;
+
+        conjure_tokens();
+
+        // extract a raw_token(id) for the given registered keyword
+        raw_token_spec operator()(std::string const& kwd) const
+        {
+            namespace qi = boost::spirit::qi;
+            qi::raw_token_type raw_token;
+
+            typename keyword_map_type::const_iterator it = keywords_.find(kwd);
+            BOOST_ASSERT(it != keywords_.end());
+            return raw_token((it != keywords_.end()) ? (*it).second : token_ids::invalid);
+        }
+
+        // extract a token(id) for the given registered keyword
+        token_spec token(std::string const& kwd) const
+        {
+            namespace qi = boost::spirit::qi;
+            qi::token_type token;
+
+            typename keyword_map_type::const_iterator it = keywords_.find(kwd);
+            BOOST_ASSERT(it != keywords_.end());
+            return token((it != keywords_.end()) ? (*it).second : token_ids::invalid);
+        }
+
+        lex::token_def<std::string> identifier;
+        lex::token_def<unsigned int> lit_uint;
+        lex::token_def<bool> true_or_false;
+        keyword_map_type keywords_;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/lexer_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/lexer_def.hpp
new file mode 100644
index 00000000..29239768
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/lexer_def.hpp
@@ -0,0 +1,100 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+
+#include "lexer.hpp"
+
+namespace client { namespace lexer
+{
+    template <typename BaseIterator>
+    conjure_tokens<BaseIterator>::conjure_tokens()
+      : identifier("[a-zA-Z_][a-zA-Z_0-9]*", token_ids::identifier)
+      , lit_uint("[0-9]+", token_ids::lit_uint)
+      , true_or_false("true|false", token_ids::true_or_false)
+      , add(*this)
+    {
+        lex::_pass_type _pass;
+
+        this->self = lit_uint | true_or_false;
+
+        this->add
+                ("void")
+                ("int")
+                ("if")
+                ("else")
+                ("while")
+                ("return")
+                ("=",       token_ids::assign)
+                ("\\+=",    token_ids::plus_assign)
+                ("\\-=",    token_ids::minus_assign)
+                ("\\*=",    token_ids::times_assign)
+                ("\\/=",    token_ids::divide_assign)
+                ("%=",      token_ids::mod_assign)
+                ("\\&=",    token_ids::bit_and_assign)
+                ("\\^=",    token_ids::bit_xor_assign)
+                ("\\|=",    token_ids::bit_or_assign)
+                ("<<=",     token_ids::shift_left_assign)
+                (">>=",     token_ids::shift_right_assign)
+                ("\\|\\|",  token_ids::logical_or)
+                ("&&",      token_ids::logical_and)
+                ("\\|",     token_ids::bit_or)
+                ("\\^",     token_ids::bit_xor)
+                ("&",       token_ids::bit_and)
+                ("<<",      token_ids::shift_left)
+                (">>",      token_ids::shift_right)
+                ("==",      token_ids::equal)
+                ("!=",      token_ids::not_equal)
+                ("<",       token_ids::less)
+                ("<=",      token_ids::less_equal)
+                (">",       token_ids::greater)
+                (">=",      token_ids::greater_equal)
+                ("\\+",     token_ids::plus)
+                ("\\-",     token_ids::minus)
+                ("\\*",     token_ids::times)
+                ("\\/",     token_ids::divide)
+                ("%",       token_ids::mod)
+                ("\\+\\+",  token_ids::plus_plus)
+                ("\\-\\-",  token_ids::minus_minus)
+                ("~",       token_ids::compl_)
+                ("!",       token_ids::not_)
+            ;
+
+        this->self += lex::char_('(') | ')' | '{' | '}' | ',' | ';';
+
+        this->self +=
+                identifier
+            |   lex::string("(\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\/)|(\\/\\/[^\r\n]*)", token_ids::comment)
+                [
+                    lex::_pass = lex::pass_flags::pass_ignore
+                ]
+            |   lex::string("[ \t\n\r]+", token_ids::whitespace)
+                [
+                    lex::_pass = lex::pass_flags::pass_ignore
+                ]
+            ;
+    }
+
+    template <typename BaseIterator>
+    bool conjure_tokens<BaseIterator>::add_(
+        std::string const& keyword, int id_)
+    {
+        // add the token to the lexer
+        token_ids::type id;
+        if (id_ == token_ids::invalid)
+            id = token_ids::type(this->get_next_id());
+        else
+            id = token_ids::type(id_);
+
+        this->self.add(keyword, id);
+        // store the mapping for later retrieval
+        std::pair<typename keyword_map_type::iterator, bool> p =
+            keywords_.insert(typename keyword_map_type::value_type(keyword, id));
+
+        return p.second;
+    }
+}}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/main.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/main.cpp
new file mode 100644
index 00000000..9788e56f
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/main.cpp
@@ -0,0 +1,156 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Not a calculator anymore, right? :-)
+//
+//  [ JDG April 10, 2007 ]      spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ HK June 3, 2011 ]         Adding lexer
+//  [ JDG July 18, 2011 ]       Switching to LLVM backend
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "config.hpp"
+#include "function.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+#include "lexer.hpp"
+#include <boost/lexical_cast.hpp>
+#include <fstream>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    std::string source_code; // We will read the contents here.
+    in.unsetf(std::ios::skipws); // No white space skipping!
+    std::copy(
+        std::istream_iterator<char>(in),
+        std::istream_iterator<char>(),
+        std::back_inserter(source_code));
+
+    typedef std::string::const_iterator base_iterator_type;
+    typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+    typedef lexer_type::iterator_type iterator_type;
+
+    lexer_type lexer;                           // Our lexer
+
+    base_iterator_type first = source_code.begin();
+    base_iterator_type last = source_code.end();
+
+    iterator_type iter = lexer.begin(first, last);
+    iterator_type end = lexer.end();
+
+    client::vmachine vm;                        // Our virtual machine
+    client::ast::function_list ast;             // Our AST
+
+    client::error_handler<base_iterator_type, iterator_type>
+        error_handler(first, last);             // Our error handler
+    client::parser::function<iterator_type, lexer_type>
+        function(error_handler, lexer);         // Our parser
+    client::code_gen::compiler
+        compiler(vm, error_handler);            // Our compiler
+
+    // note: we don't need a skipper
+    bool success = parse(iter, end, +function, ast);
+
+    std::cout << "-------------------------\n";
+
+    if (success && iter == end)
+    {
+        if (compiler(ast))
+        {
+            // JIT the main function
+            client::function main_function = vm.get_function("main");
+            if (!main_function)
+            {
+                std::cerr << "function main not found" << std::endl;
+                return 1;
+            }
+
+            int nargs = argc-2;
+            if (main_function.arity() != nargs)
+            {
+                std::cerr << "Error: main function requires "
+                    << main_function.arity() << " arguments." << std::endl;
+                std::cerr << nargs << " supplied." << std::endl;
+                return 1;
+            }
+
+            std::cout << "Success\n";
+            std::cout << "-------------------------\n";
+            std::cout << "Assembler----------------\n\n";
+            vm.print_assembler();
+
+            // Call the main function
+            int r;
+            char** args = argv + 2;
+            switch (nargs)
+            {
+                case 0: r = main_function(); break;
+
+                case 1: r = main_function(
+                    boost::lexical_cast<int>(args[0]));
+                    break;
+
+                case 2: r = main_function(
+                    boost::lexical_cast<int>(args[0]),
+                    boost::lexical_cast<int>(args[1]));
+                    break;
+
+                case 3: r = main_function(
+                    boost::lexical_cast<int>(args[0]),
+                    boost::lexical_cast<int>(args[1]),
+                    boost::lexical_cast<int>(args[2]));
+                    break;
+
+                default:
+                    std::cerr << "Function calls with more " <<
+                        "than 3 arguments not supported" << std::endl;
+                    return 1;
+            }
+
+            std::cout << "-------------------------\n";
+            std::cout << "Result: " << r << std::endl;
+            std::cout << "-------------------------\n\n";
+        }
+        else
+        {
+            std::cout << "Compile failure\n";
+        }
+    }
+    else
+    {
+        std::cout << "Parse failure\n";
+    }
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/statement.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/statement.cpp
new file mode 100644
index 00000000..ca85a61c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/statement.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "config.hpp"
+#include "lexer.hpp"
+#include "statement_def.hpp"
+
+typedef std::string::const_iterator base_iterator_type;
+typedef client::lexer::conjure_tokens<base_iterator_type> lexer_type;
+typedef lexer_type::iterator_type iterator_type;
+
+template struct client::parser::statement<iterator_type, lexer_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/statement.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/statement.hpp
new file mode 100644
index 00000000..208ca247
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/statement.hpp
@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_STATEMENT_HPP)
+#define BOOST_SPIRIT_CONJURE_STATEMENT_HPP
+
+#include "expression.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The statement grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Lexer>
+    struct statement : qi::grammar<Iterator, ast::statement_list()>
+    {
+        typedef error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+
+        statement(error_handler_type& error_handler, Lexer const& l);
+
+        expression<Iterator, Lexer> expr;
+
+        qi::rule<Iterator, ast::statement_list()>
+            statement_list, compound_statement;
+
+        qi::rule<Iterator, ast::statement()> statement_;
+        qi::rule<Iterator, ast::variable_declaration()> variable_declaration;
+        qi::rule<Iterator, ast::assignment()> assignment;
+        qi::rule<Iterator, ast::if_statement()> if_statement;
+        qi::rule<Iterator, ast::while_statement()> while_statement;
+        qi::rule<Iterator, ast::return_statement()> return_statement;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/statement_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/statement_def.hpp
new file mode 100644
index 00000000..4712aa5f
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/statement_def.hpp
@@ -0,0 +1,126 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "statement.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator, typename Lexer>
+    statement<Iterator, Lexer>::statement(
+            error_handler<typename Lexer::base_iterator_type, Iterator>& error_handler
+          , Lexer const& l)
+      : statement::base_type(statement_list), expr(error_handler, l)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+        qi::tokenid_mask_type tokenid_mask;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef client::error_handler<typename Lexer::base_iterator_type, Iterator>
+            error_handler_type;
+        typedef function<error_handler_type> error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        statement_list =
+            +statement_
+            ;
+
+        statement_ =
+                variable_declaration
+            |   assignment
+            |   compound_statement
+            |   if_statement
+            |   while_statement
+            |   return_statement
+            |   expr
+            |   ';'
+            ;
+
+        variable_declaration =
+                l("int")
+            >   expr.identifier
+            >  -(l("=") > expr)
+            >   ';'
+            ;
+
+        assignment =
+                expr.identifier
+            >   tokenid_mask(token_ids::op_assign)
+            >   expr
+            >   ';'
+            ;
+
+        if_statement =
+                l("if")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            >
+               -(
+                    l("else")
+                >   statement_
+                )
+            ;
+
+        while_statement =
+                l("while")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            ;
+
+        compound_statement =
+            '{' >> -statement_list >> '}'
+            ;
+
+        return_statement =
+                l("return")
+            >  -expr
+            >   ';'
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (statement_list)
+            (statement_)
+            (variable_declaration)
+            (assignment)
+            (if_statement)
+            (while_statement)
+            (compound_statement)
+            (return_statement)
+        );
+
+        // Error handling: on error in statement_list, call error_handler.
+        on_error<fail>(statement_list,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in variable_declaration,
+        // assignment and return_statement, call annotation.
+        on_success(variable_declaration,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(assignment,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(return_statement,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/vm.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/vm.cpp
new file mode 100644
index 00000000..5434046f
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/vm.cpp
@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "config.hpp"
+#include "vm.hpp"
+#include <iostream>
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4800) // forcing value to bool 'true' or 'false'
+                                // (performance warning)
+#endif
+
+namespace client
+{
+    vmachine::vmachine()
+    {
+        llvm::InitializeNativeTarget();
+        llvm::LLVMContext& context = llvm::getGlobalContext();
+
+        // Make the module, which holds all the code.
+        module_ = new llvm::Module("Conjure JIT", context);
+
+        // Create the JIT.  This takes ownership of the module.
+        std::string error;
+        execution_engine_ =
+            llvm::EngineBuilder(module_).setErrorStr(&error).create();
+
+        BOOST_ASSERT(execution_engine_ != 0);
+        if (!execution_engine_)
+        {
+            std::cerr <<
+                "Could not create ExecutionEngine: " <<
+                error << std::endl;
+
+            exit(1);
+        }
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/vm.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/vm.hpp
new file mode 100644
index 00000000..68698920
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure3/vm.hpp
@@ -0,0 +1,121 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONJURE_VM_HPP)
+#define BOOST_SPIRIT_CONJURE_VM_HPP
+
+#include <llvm/ExecutionEngine/ExecutionEngine.h>
+#include <llvm/ExecutionEngine/JIT.h>
+#include <llvm/LLVMContext.h>
+#include <llvm/Module.h>
+#include <llvm/Target/TargetData.h>
+#include <llvm/Target/TargetSelect.h>
+
+#include <boost/assert.hpp>
+
+namespace client
+{
+    class vmachine;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  A light wrapper to a function pointer returning int and accepting
+    //  from 0 to 3 arguments, where arity is determined at runtime.
+    ///////////////////////////////////////////////////////////////////////////
+    class function
+    {
+    public:
+
+        typedef int result_type;
+
+        int operator()() const
+        {
+            BOOST_ASSERT(fptr != 0);
+            BOOST_ASSERT(arity() == 0);
+            int (*fp)() = (int(*)())(intptr_t)fptr;
+            return fp();
+        }
+
+        int operator()(int _1) const
+        {
+            BOOST_ASSERT(fptr != 0);
+            BOOST_ASSERT(arity() == 1);
+            int (*fp)(int) = (int(*)(int))(intptr_t)fptr;
+            return fp(_1);
+        }
+
+        int operator()(int _1, int _2) const
+        {
+            BOOST_ASSERT(fptr != 0);
+            BOOST_ASSERT(arity() == 2);
+            int (*fp)(int, int) = (int(*)(int, int))(intptr_t)fptr;
+            return fp(_1, _2);
+        }
+
+        int operator()(int _1, int _2, int _3) const
+        {
+            BOOST_ASSERT(fptr != 0);
+            BOOST_ASSERT(arity() == 3);
+            int (*fp)(int, int, int) = (int(*)(int, int, int))(intptr_t)fptr;
+            return fp(_1, _2, _3);
+        }
+
+        unsigned arity() const { return arity_; }
+        bool operator!() const { return fptr == 0; }
+
+    private:
+
+        friend class vmachine;
+        function(void* fptr, unsigned arity_)
+            : fptr(fptr), arity_(arity_) {}
+
+        void* fptr;
+        unsigned arity_;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine (light wrapper over LLVM JIT)
+    ///////////////////////////////////////////////////////////////////////////
+    class vmachine
+    {
+    public:
+
+        vmachine();
+
+        llvm::Module* module() const
+        {
+            return module_;
+        }
+
+        llvm::ExecutionEngine* execution_engine() const
+        {
+            return execution_engine_;
+        }
+
+        void print_assembler() const
+        {
+            module_->dump();
+        }
+
+        function get_function(char const* name)
+        {
+            llvm::Function* callee = module_->getFunction(name);
+            if (callee == 0)
+                return function(0, 0);
+
+            // JIT the function
+            void *fptr = execution_engine_->getPointerToFunction(callee);
+            return function(fptr, callee->arg_size());
+        }
+
+    private:
+
+        llvm::Module* module_;
+        llvm::ExecutionEngine* execution_engine_;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/error.cnj b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/error.cnj
new file mode 100644
index 00000000..2c7c0a94
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/error.cnj
@@ -0,0 +1,16 @@
+/* conjure program with syntax error */
+
+int foo(n)
+{
+    int a = 2;
+    if (n @ 3) /* we don't have @ operator in conjure */
+    {
+        a = 3
+    }
+    return a;
+}
+
+int main()
+{
+    return foo(10);
+}
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/factorial.cnj b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/factorial.cnj
new file mode 100644
index 00000000..5ea05731
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/factorial.cnj
@@ -0,0 +1,15 @@
+/* The factorial */
+
+int factorial(n)
+{
+    if (n <= 0)
+        return 1;
+    else
+        return n * factorial(n-1);
+}
+
+int main(n)
+{
+    return factorial(n);
+}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/operators.cnj b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/operators.cnj
new file mode 100644
index 00000000..8f8aad56
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/operators.cnj
@@ -0,0 +1,137 @@
+/* More operators tests */
+/* Conjure >=3 only!!! */
+
+// assign ops
+
+int aplus(x, y)
+{
+    int t = x;
+    t += y;
+    return t;
+}
+
+int aminus(x, y)
+{
+    int t = x;
+    t -= y;
+    return t;
+}
+
+int ashl(x, y)
+{
+    int t = x;
+    t <<= y;
+    return t;
+}
+
+int adiv(x, y)
+{
+    int t = x;
+    t /= y;
+    return t;
+}
+
+int amult(x, y)
+{
+    int t = x;
+    t *= y;
+    return t;
+}
+
+int amod(x, y)
+{
+    int t = x;
+    t %= y;
+    return t;
+}
+
+int aor(x, y)
+{
+    int t = x;
+    t |= y;
+    return t;
+}
+
+int aand(x, y)
+{
+    int t = x;
+    t &= y;
+    return t;
+}
+
+int axor(x, y)
+{
+    int t = x;
+    t ^= y;
+    return t;
+}
+
+int ashr(x, y)
+{
+    int t = x;
+    t >>= y;
+    return t;
+}
+
+// binary ops
+
+int plus(x, y)      { return x + y; }
+int minus(x, y)     { return x - y; }
+int shl(x, y)       { return x << y; }
+int div(x, y)       { return x / y; }
+int mult(x, y)      { return x * y; }
+int mod(x, y)       { return x % y; }
+int or(x, y)        { return x | y; }
+int and(x, y)       { return x & y; }
+int xor(x, y)       { return x ^ y; }
+int shr(x, y)       { return x >> y; }
+
+int assign()
+{
+    int a = aplus(2, 3);    // 5
+    int b = ashl(a, 2);     // 20
+    int c = aminus(b, 2);   // 18
+    int d = adiv(c, 2);     // 9
+    int e = amult(d, c);    // 162
+    int f = amod(e, 10);    // 2
+    int g = aor(f, 45);     // 47
+    int h = aand(g, 48);    // 32
+    int j = axor(h, h);     // 0
+    int k = aor(j, 65535);  // 65535
+    int l = ashr(k, 3);     // 8191
+    return l;
+}
+
+int binary()
+{
+    int a = plus(2, 3);     // 5
+    int b = shl(a, 2);      // 20
+    int c = minus(b, 2);    // 18
+    int d = div(c, 2);      // 9
+    int e = mult(d, c);     // 162
+    int f = mod(e, 10);     // 2
+    int g = or(f, 45);      // 47
+    int h = and(g, 48);     // 32
+    int j = xor(h, h);      // 0
+    int k = or(j, 65535);   // 65535
+    int l = shr(k, 3);      // 8191
+    return l;
+}
+
+int zero() { return 0; }
+
+int unary()
+{
+    int i = ~zero();    // -1
+    int j = -i;         // 1
+    ++j;                // 2
+    ++++j;              // 4
+    --j;                // 3
+    return j;
+}
+
+int main()
+{
+    return assign() + binary() + unary(); // 16385
+}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/pow2.cnj b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/pow2.cnj
new file mode 100644
index 00000000..4d22fd70
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/pow2.cnj
@@ -0,0 +1,19 @@
+/* My first conjure program */
+
+int pow2(n)
+{
+    int a = 2;
+    int i = 1;
+    while (i < n)
+    {
+        a = a * 2;
+        i = i + 1;
+    }
+    return a;
+}
+
+int main()
+{
+    return pow2(10);
+}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/precedence.cnj b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/precedence.cnj
new file mode 100644
index 00000000..eb91b92e
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/conjure_samples/precedence.cnj
@@ -0,0 +1,8 @@
+/* testing the shunting yard operator precedence algorithm */
+
+int main()
+{
+    return 1 + 2 + 3 + 5 * 4 * 6 + 5; /* answer is 131 */
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/annotation.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/annotation.hpp
new file mode 100644
index 00000000..9e7e814e
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/annotation.hpp
@@ -0,0 +1,95 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_MINIC_ANNOTATION_HPP)
+#define BOOST_SPIRIT_MINIC_ANNOTATION_HPP
+
+#include <map>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/mpl/bool.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The annotation handler links the AST to a map of iterator positions
+    //  for the purpose of subsequent semantic error handling when the
+    //  program is being compiled.
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct annotation
+    {
+        template <typename, typename>
+        struct result { typedef void type; };
+
+        std::vector<Iterator>& iters;
+        annotation(std::vector<Iterator>& iters)
+          : iters(iters) {}
+
+        struct set_id
+        {
+            typedef void result_type;
+
+            int id;
+            set_id(int id) : id(id) {}
+
+            void operator()(ast::function_call& x) const
+            {
+                x.function_name.id = id;
+            }
+
+            void operator()(ast::identifier& x) const
+            {
+                x.id = id;
+            }
+
+            template <typename T>
+            void operator()(T& x) const
+            {
+                // no-op
+            }
+        };
+
+        void operator()(ast::operand& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            boost::apply_visitor(set_id(id), ast);
+        }
+
+        void operator()(ast::variable_declaration& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+
+        void operator()(ast::assignment& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.lhs.id = id;
+        }
+
+        void operator()(ast::return_statement& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.id = id;
+        }
+
+        void operator()(ast::identifier& ast, Iterator pos) const
+        {
+            int id = iters.size();
+            iters.push_back(pos);
+            ast.id = id;
+        }
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/ast.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/ast.hpp
new file mode 100644
index 00000000..fc755064
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/ast.hpp
@@ -0,0 +1,225 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_MINIC_AST_HPP)
+#define BOOST_SPIRIT_MINIC_AST_HPP
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <boost/optional.hpp>
+#include <list>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct tagged
+    {
+        int id; // Used to annotate the AST with the iterator position.
+                // This id is used as a key to a map<int, Iterator>
+                // (not really part of the AST.)
+    };
+
+    struct nil {};
+    struct unary;
+    struct function_call;
+    struct expression;
+
+    struct identifier : tagged
+    {
+        identifier(std::string const& name = "") : name(name) {}
+        std::string name;
+    };
+
+    typedef boost::variant<
+            nil
+          , bool
+          , unsigned int
+          , identifier
+          , boost::recursive_wrapper<unary>
+          , boost::recursive_wrapper<function_call>
+          , boost::recursive_wrapper<expression>
+        >
+    operand;
+
+    enum optoken
+    {
+        op_plus,
+        op_minus,
+        op_times,
+        op_divide,
+        op_positive,
+        op_negative,
+        op_not,
+        op_equal,
+        op_not_equal,
+        op_less,
+        op_less_equal,
+        op_greater,
+        op_greater_equal,
+        op_and,
+        op_or
+    };
+
+    struct unary
+    {
+        optoken operator_;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        optoken operator_;
+        operand operand_;
+    };
+
+    struct function_call
+    {
+        identifier function_name;
+        std::list<expression> args;
+    };
+
+    struct expression
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    struct assignment
+    {
+        identifier lhs;
+        expression rhs;
+    };
+
+    struct variable_declaration
+    {
+        identifier lhs;
+        boost::optional<expression> rhs;
+    };
+
+    struct if_statement;
+    struct while_statement;
+    struct statement_list;
+    struct return_statement;
+
+    typedef boost::variant<
+            variable_declaration
+          , assignment
+          , boost::recursive_wrapper<if_statement>
+          , boost::recursive_wrapper<while_statement>
+          , boost::recursive_wrapper<return_statement>
+          , boost::recursive_wrapper<statement_list>
+        >
+    statement;
+
+    struct statement_list : std::list<statement> {};
+
+    struct if_statement
+    {
+        expression condition;
+        statement then;
+        boost::optional<statement> else_;
+    };
+
+    struct while_statement
+    {
+        expression condition;
+        statement body;
+    };
+
+    struct return_statement : tagged
+    {
+        boost::optional<expression> expr;
+    };
+
+    struct function
+    {
+        std::string return_type;
+        identifier function_name;
+        std::list<identifier> args;
+        statement_list body;
+    };
+
+    typedef std::list<function> function_list;
+
+    // print functions for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil)
+    {
+        out << "nil"; return out;
+    }
+
+    inline std::ostream& operator<<(std::ostream& out, identifier const& id)
+    {
+        out << id.name; return out;
+    }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::unary,
+    (client::ast::optoken, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::operation,
+    (client::ast::optoken, operator_)
+    (client::ast::operand, operand_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::function_call,
+    (client::ast::identifier, function_name)
+    (std::list<client::ast::expression>, args)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::expression,
+    (client::ast::operand, first)
+    (std::list<client::ast::operation>, rest)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::variable_declaration,
+    (client::ast::identifier, lhs)
+    (boost::optional<client::ast::expression>, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::assignment,
+    (client::ast::identifier, lhs)
+    (client::ast::expression, rhs)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::if_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, then)
+    (boost::optional<client::ast::statement>, else_)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::while_statement,
+    (client::ast::expression, condition)
+    (client::ast::statement, body)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::return_statement,
+    (boost::optional<client::ast::expression>, expr)
+)
+
+BOOST_FUSION_ADAPT_STRUCT(
+    client::ast::function,
+    (std::string, return_type)
+    (client::ast::identifier, function_name)
+    (std::list<client::ast::identifier>, args)
+    (client::ast::statement_list, body)
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/compiler.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/compiler.cpp
new file mode 100644
index 00000000..5a17ee07
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/compiler.cpp
@@ -0,0 +1,538 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "compiler.hpp"
+#include "vm.hpp"
+#include <boost/foreach.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/assert.hpp>
+#include <boost/lexical_cast.hpp>
+#include <set>
+
+namespace client { namespace code_gen
+{
+    void function::op(int a)
+    {
+        code.push_back(a);
+        size_ += 1;
+    }
+
+    void function::op(int a, int b)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        size_ += 2;
+    }
+
+    void function::op(int a, int b, int c)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        code.push_back(c);
+        size_ += 3;
+    }
+
+    int const* function::find_var(std::string const& name) const
+    {
+        std::map<std::string, int>::const_iterator i = variables.find(name);
+        if (i == variables.end())
+            return 0;
+        return &i->second;
+    }
+
+    void function::add_var(std::string const& name)
+    {
+        std::size_t n = variables.size();
+        variables[name] = n;
+    }
+
+    void function::link_to(std::string const& name, std::size_t address)
+    {
+        function_calls[address] = name;
+    }
+
+    void function::print_assembler() const
+    {
+        std::vector<int>::const_iterator pc = code.begin() + address;
+
+        std::vector<std::string> locals(variables.size());
+        typedef std::pair<std::string, int> pair;
+        BOOST_FOREACH(pair const& p, variables)
+        {
+            locals[p.second] = p.first;
+            std::cout << "      local       "
+                << p.first << ", @" << p.second << std::endl;
+        }
+
+        std::map<std::size_t, std::string> lines;
+        std::set<std::size_t> jumps;
+
+        while (pc != (code.begin() + address + size_))
+        {
+            std::string line;
+            std::size_t address = pc - code.begin();
+
+            switch (*pc++)
+            {
+                case op_neg:
+                    line += "      op_neg";
+                    break;
+
+                case op_not:
+                    line += "      op_not";
+                    break;
+
+                case op_add:
+                    line += "      op_add";
+                    break;
+
+                case op_sub:
+                    line += "      op_sub";
+                    break;
+
+                case op_mul:
+                    line += "      op_mul";
+                    break;
+
+                case op_div:
+                    line += "      op_div";
+                    break;
+
+                case op_eq:
+                    line += "      op_eq";
+                    break;
+
+                case op_neq:
+                    line += "      op_neq";
+                    break;
+
+                case op_lt:
+                    line += "      op_lt";
+                    break;
+
+                case op_lte:
+                    line += "      op_lte";
+                    break;
+
+                case op_gt:
+                    line += "      op_gt";
+                    break;
+
+                case op_gte:
+                    line += "      op_gte";
+                    break;
+
+                case op_and:
+                    line += "      op_and";
+                    break;
+
+                case op_or:
+                    line += "      op_or";
+                    break;
+
+                case op_load:
+                    line += "      op_load     ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_store:
+                    line += "      op_store    ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_int:
+                    line += "      op_int      ";
+                    line += boost::lexical_cast<std::string>(*pc++);
+                    break;
+
+                case op_true:
+                    line += "      op_true";
+                    break;
+
+                case op_false:
+                    line += "      op_false";
+                    break;
+
+                case op_jump:
+                    {
+                        line += "      op_jump     ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += boost::lexical_cast<std::string>(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_jump_if:
+                    {
+                        line += "      op_jump_if  ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += boost::lexical_cast<std::string>(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_call:
+                    {
+                        line += "      op_call     ";
+                        int nargs = *pc++;
+                        std::size_t jump = *pc++;
+                        line += boost::lexical_cast<std::string>(nargs) + ", ";
+                        BOOST_ASSERT(function_calls.find(jump) != function_calls.end());
+                        line += function_calls.find(jump)->second;
+                    }
+                    break;
+
+                case op_stk_adj:
+                    line += "      op_stk_adj  ";
+                    line += boost::lexical_cast<std::string>(*pc++);
+                    break;
+
+
+                case op_return:
+                    line += "      op_return";
+                    break;
+            }
+            lines[address] = line;
+        }
+
+        std::cout << "start:" << std::endl;
+        typedef std::pair<std::size_t, std::string> line_info;
+        BOOST_FOREACH(line_info const& l, lines)
+        {
+            std::size_t pos = l.first;
+            if (jumps.find(pos) != jumps.end())
+                std::cout << pos << ':' << std::endl;
+            std::cout << l.second << std::endl;
+        }
+
+        std::cout << "end:" << std::endl << std::endl;
+    }
+
+    bool compiler::operator()(unsigned int x)
+    {
+        BOOST_ASSERT(current != 0);
+        current->op(op_int, x);
+        return true;
+    }
+
+    bool compiler::operator()(bool x)
+    {
+        BOOST_ASSERT(current != 0);
+        current->op(x ? op_true : op_false);
+        return true;
+    }
+
+    bool compiler::operator()(ast::identifier const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        int const* p = current->find_var(x.name);
+        if (p == 0)
+        {
+            error_handler(x.id, "Undeclared variable: " + x.name);
+            return false;
+        }
+        current->op(op_load, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::operation const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case ast::op_plus: current->op(op_add); break;
+            case ast::op_minus: current->op(op_sub); break;
+            case ast::op_times: current->op(op_mul); break;
+            case ast::op_divide: current->op(op_div); break;
+
+            case ast::op_equal: current->op(op_eq); break;
+            case ast::op_not_equal: current->op(op_neq); break;
+            case ast::op_less: current->op(op_lt); break;
+            case ast::op_less_equal: current->op(op_lte); break;
+            case ast::op_greater: current->op(op_gt); break;
+            case ast::op_greater_equal: current->op(op_gte); break;
+
+            case ast::op_and: current->op(op_and); break;
+            case ast::op_or: current->op(op_or); break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::unary const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case ast::op_negative: current->op(op_neg); break;
+            case ast::op_not: current->op(op_not); break;
+            case ast::op_positive: break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::function_call const& x)
+    {
+        BOOST_ASSERT(current != 0);
+
+        if (functions.find(x.function_name.name) == functions.end())
+        {
+            error_handler(x.function_name.id, "Function not found: " + x.function_name.name);
+            return false;
+        }
+
+        boost::shared_ptr<code_gen::function> p = functions[x.function_name.name];
+
+        if (p->nargs() != x.args.size())
+        {
+            error_handler(x.function_name.id, "Wrong number of arguments: " + x.function_name.name);
+            return false;
+        }
+
+        BOOST_FOREACH(ast::expression const& expr, x.args)
+        {
+            if (!(*this)(expr))
+                return false;
+        }
+
+        current->op(
+            op_call,
+            p->nargs(),
+            p->get_address());
+        current->link_to(x.function_name.name, p->get_address());
+
+        return true;
+    }
+
+    bool compiler::operator()(ast::expression const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!boost::apply_visitor(*this, x.first))
+            return false;
+        BOOST_FOREACH(ast::operation const& oper, x.rest)
+        {
+            if (!(*this)(oper))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::assignment const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!(*this)(x.rhs))
+            return false;
+        int const* p = current->find_var(x.lhs.name);
+        if (p == 0)
+        {
+            error_handler(x.lhs.id, "Undeclared variable: " + x.lhs.name);
+            return false;
+        }
+        current->op(op_store, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable_declaration const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        int const* p = current->find_var(x.lhs.name);
+        if (p != 0)
+        {
+            error_handler(x.lhs.id, "Duplicate variable: " + x.lhs.name);
+            return false;
+        }
+        if (x.rhs) // if there's an RHS initializer
+        {
+            bool r = (*this)(*x.rhs);
+            if (r) // don't add the variable if the RHS fails
+            {
+                current->add_var(x.lhs.name);
+                current->op(op_store, *current->find_var(x.lhs.name));
+            }
+            return r;
+        }
+        else
+        {
+            current->add_var(x.lhs.name);
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::statement const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        return boost::apply_visitor(*this, x);
+    }
+
+    bool compiler::operator()(ast::statement_list const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        BOOST_FOREACH(ast::statement const& s, x)
+        {
+            if (!(*this)(s))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::if_statement const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        if (!(*this)(x.condition))
+            return false;
+        current->op(op_jump_if, 0);                 // we shall fill this (0) in later
+        std::size_t skip = current->size()-1;       // mark its position
+        if (!(*this)(x.then))
+            return false;
+        (*current)[skip] = current->size()-skip;    // now we know where to jump to (after the if branch)
+
+        if (x.else_)                                // We got an else
+        {
+            (*current)[skip] += 2;                  // adjust for the "else" jump
+            current->op(op_jump, 0);                // we shall fill this (0) in later
+            std::size_t exit = current->size()-1;   // mark its position
+            if (!(*this)(*x.else_))
+                return false;
+            (*current)[exit] = current->size()-exit;// now we know where to jump to (after the else branch)
+        }
+
+        return true;
+    }
+
+    bool compiler::operator()(ast::while_statement const& x)
+    {
+        BOOST_ASSERT(current != 0);
+        std::size_t loop = current->size();         // mark our position
+        if (!(*this)(x.condition))
+            return false;
+        current->op(op_jump_if, 0);                 // we shall fill this (0) in later
+        std::size_t exit = current->size()-1;       // mark its position
+        if (!(*this)(x.body))
+            return false;
+        current->op(op_jump,
+            int(loop-1) - int(current->size()));    // loop back
+        (*current)[exit] = current->size()-exit;    // now we know where to jump to (to exit the loop)
+        return true;
+    }
+
+    bool compiler::operator()(ast::return_statement const& x)
+    {
+        if (void_return)
+        {
+            if (x.expr)
+            {
+                error_handler(x.id, "'void' function returning a value: ");
+                return false;
+            }
+        }
+        else
+        {
+            if (!x.expr)
+            {
+                error_handler(x.id, current_function_name + " function must return a value: ");
+                return false;
+            }
+        }
+
+        if (x.expr)
+        {
+            if (!(*this)(*x.expr))
+                return false;
+        }
+        current->op(op_return);
+        return true;
+    }
+
+    bool compiler::operator()(ast::function const& x)
+    {
+        void_return = x.return_type == "void";
+        if (functions.find(x.function_name.name) != functions.end())
+        {
+            error_handler(x.function_name.id, "Duplicate function: " + x.function_name.name);
+            return false;
+        }
+        boost::shared_ptr<code_gen::function>& p = functions[x.function_name.name];
+        p.reset(new code_gen::function(code, x.args.size()));
+        current = p.get();
+        current_function_name = x.function_name.name;
+
+        // op_stk_adj 0 for now. we'll know how many variables
+        // we'll have later and add them
+        current->op(op_stk_adj, 0);
+        BOOST_FOREACH(ast::identifier const& arg, x.args)
+        {
+            current->add_var(arg.name);
+        }
+
+        if (!(*this)(x.body))
+            return false;
+        (*current)[1] = current->nvars();   // now store the actual number of variables
+                                            // this includes the arguments
+        return true;
+    }
+
+    bool compiler::operator()(ast::function_list const& x)
+    {
+        // Jump to the main function
+        code.push_back(op_jump);
+        code.push_back(0); // we will fill this in later when we finish compiling
+                           // and we know where the main function is
+
+        BOOST_FOREACH(ast::function const& f, x)
+        {
+            if (!(*this)(f))
+            {
+                code.clear();
+                return false;
+            }
+        }
+        // find the main function
+        boost::shared_ptr<code_gen::function> p =
+            find_function("main");
+
+        if (!p) // main function not found
+        {
+            std::cerr << "Error: main function not defined" << std::endl;
+            return false;
+        }
+        code[1] = p->get_address()-1; // jump to this (main function) address
+
+        return true;
+    }
+
+    void compiler::print_assembler() const
+    {
+        typedef std::pair<std::string, boost::shared_ptr<code_gen::function> > pair;
+        BOOST_FOREACH(pair const& p, functions)
+        {
+            std::cout << ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" << std::endl;
+            std::cout << p.second->get_address() << ": function " << p.first << std::endl;
+            p.second->print_assembler();
+        }
+    }
+
+    boost::shared_ptr<code_gen::function>
+    compiler::find_function(std::string const& name) const
+    {
+        function_table::const_iterator i = functions.find(name);
+        if (i == functions.end())
+            return boost::shared_ptr<code_gen::function>();
+        else
+            return i->second;
+    }
+}}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/compiler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/compiler.hpp
new file mode 100644
index 00000000..8a3eea72
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/compiler.hpp
@@ -0,0 +1,118 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_MINIC_COMPILER_HPP)
+#define BOOST_SPIRIT_MINIC_COMPILER_HPP
+
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+#include <map>
+#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_function.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+namespace client { namespace code_gen
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Function
+    ///////////////////////////////////////////////////////////////////////////
+    struct function
+    {
+        function(std::vector<int>& code, int nargs)
+          : code(code), address(code.size()), size_(0), nargs_(nargs) {}
+
+        void op(int a);
+        void op(int a, int b);
+        void op(int a, int b, int c);
+
+        int& operator[](std::size_t i) { return code[address+i]; }
+        int const& operator[](std::size_t i) const { return code[address+i]; }
+        std::size_t size() const { return size_; }
+        std::size_t get_address() const { return address; }
+
+        int nargs() const { return nargs_; }
+        int nvars() const { return variables.size(); }
+        int const* find_var(std::string const& name) const;
+        void add_var(std::string const& name);
+        void link_to(std::string const& name, std::size_t address);
+
+        void print_assembler() const;
+
+    private:
+
+        std::map<std::string, int> variables;
+        std::map<std::size_t, std::string> function_calls;
+        std::vector<int>& code;
+        std::size_t address;
+        std::size_t size_;
+        std::size_t nargs_;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ///////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef bool result_type;
+
+        template <typename ErrorHandler>
+        compiler(ErrorHandler& error_handler_)
+          : current(0)
+        {
+            using namespace boost::phoenix::arg_names;
+            namespace phx = boost::phoenix;
+            using boost::phoenix::function;
+
+            error_handler = function<ErrorHandler>(error_handler_)(
+                "Error! ", _2, phx::cref(error_handler_.iters)[_1]);
+        }
+
+        bool operator()(ast::nil) { BOOST_ASSERT(0); return false; }
+        bool operator()(unsigned int x);
+        bool operator()(bool x);
+        bool operator()(ast::identifier const& x);
+        bool operator()(ast::operation const& x);
+        bool operator()(ast::unary const& x);
+        bool operator()(ast::function_call const& x);
+        bool operator()(ast::expression const& x);
+        bool operator()(ast::assignment const& x);
+        bool operator()(ast::variable_declaration const& x);
+        bool operator()(ast::statement_list const& x);
+        bool operator()(ast::statement const& x);
+        bool operator()(ast::if_statement const& x);
+        bool operator()(ast::while_statement const& x);
+        bool operator()(ast::return_statement const& x);
+        bool operator()(ast::function const& x);
+        bool operator()(ast::function_list const& x);
+
+        void print_assembler() const;
+
+        boost::shared_ptr<code_gen::function>
+        find_function(std::string const& name) const;
+
+        std::vector<int>& get_code() { return code; }
+        std::vector<int> const& get_code() const { return code; }
+
+    private:
+
+        typedef std::map<std::string, boost::shared_ptr<code_gen::function> > function_table;
+
+        std::vector<int> code;
+        code_gen::function* current;
+        std::string current_function_name;
+        function_table functions;
+        bool void_return;
+
+        boost::function<
+            void(int tag, std::string const& what)>
+        error_handler;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/error_handler.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/error_handler.hpp
new file mode 100644
index 00000000..4ba833c6
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/error_handler.hpp
@@ -0,0 +1,93 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_MINIC_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_MINIC_ERROR_HANDLER_HPP
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The error handler
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct error_handler
+    {
+        template <typename, typename, typename>
+        struct result { typedef void type; };
+
+        error_handler(Iterator first, Iterator last)
+          : first(first), last(last) {}
+
+        template <typename Message, typename What>
+        void operator()(
+            Message const& message,
+            What const& what,
+            Iterator err_pos) const
+        {
+            int line;
+            Iterator line_start = get_pos(err_pos, line);
+            if (err_pos != last)
+            {
+                std::cout << message << what << " line " << line << ':' << std::endl;
+                std::cout << get_line(line_start) << std::endl;
+                for (; line_start != err_pos; ++line_start)
+                    std::cout << ' ';
+                std::cout << '^' << std::endl;
+            }
+            else
+            {
+                std::cout << "Unexpected end of file. ";
+                std::cout << message << what << " line " << line << std::endl;
+            }
+        }
+
+        Iterator get_pos(Iterator err_pos, int& line) const
+        {
+            line = 1;
+            Iterator i = first;
+            Iterator line_start = first;
+            while (i != err_pos)
+            {
+                bool eol = false;
+                if (i != err_pos && *i == '\r') // CR
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (i != err_pos && *i == '\n') // LF
+                {
+                    eol = true;
+                    line_start = ++i;
+                }
+                if (eol)
+                    ++line;
+                else
+                    ++i;
+            }
+            return line_start;
+        }
+
+        std::string get_line(Iterator err_pos) const
+        {
+            Iterator i = err_pos;
+            // position i to the next EOL
+            while (i != last && (*i != '\r' && *i != '\n'))
+                ++i;
+            return std::string(err_pos, i);
+        }
+
+        Iterator first;
+        Iterator last;
+        std::vector<Iterator> iters;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/expression.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/expression.cpp
new file mode 100644
index 00000000..32f44adc
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/expression.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "expression_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::expression<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/expression.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/expression.hpp
new file mode 100644
index 00000000..60edceec
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/expression.hpp
@@ -0,0 +1,79 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_MINIC_EXPRESSION_HPP)
+#define BOOST_SPIRIT_MINIC_EXPRESSION_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+// Spirit v2.5 allows you to suppress automatic generation
+// of predefined terminals to speed up complation. With
+// BOOST_SPIRIT_NO_PREDEFINED_TERMINALS defined, you are
+// responsible in creating instances of the terminals that
+// you need (e.g. see qi::uint_type uint_ below).
+#define BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+// #define BOOST_SPIRIT_QI_DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/spirit/include/qi.hpp>
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include "skipper.hpp"
+#include <vector>
+
+namespace client { namespace parser
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The expression grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct expression : qi::grammar<Iterator, ast::expression(), skipper<Iterator> >
+    {
+        expression(error_handler<Iterator>& error_handler);
+
+        qi::rule<Iterator, ast::expression(), skipper<Iterator> >
+            expr, equality_expr, relational_expr,
+            logical_or_expr, logical_and_expr,
+            additive_expr, multiplicative_expr
+            ;
+
+        qi::rule<Iterator, ast::operand(), skipper<Iterator> >
+            unary_expr, primary_expr
+            ;
+
+        qi::rule<Iterator, ast::function_call(), skipper<Iterator> >
+            function_call
+            ;
+
+        qi::rule<Iterator, std::list<ast::expression>(), skipper<Iterator> >
+            argument_list
+            ;
+
+        qi::rule<Iterator, std::string(), skipper<Iterator> >
+            identifier
+            ;
+
+        qi::symbols<char, ast::optoken>
+            logical_or_op, logical_and_op,
+            equality_op, relational_op,
+            additive_op, multiplicative_op, unary_op
+            ;
+
+        qi::symbols<char>
+            keywords
+            ;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/expression_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/expression_def.hpp
new file mode 100644
index 00000000..f6f7c5d6
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/expression_def.hpp
@@ -0,0 +1,181 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "expression.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+#include <boost/spirit/include/phoenix_function.hpp>
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    expression<Iterator>::expression(error_handler<Iterator>& error_handler)
+      : expression::base_type(expr)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::char_type char_;
+        qi::uint_type uint_;
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+        qi::bool_type bool_;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Tokens
+        logical_or_op.add
+            ("||", ast::op_or)
+            ;
+
+        logical_and_op.add
+            ("&&", ast::op_and)
+            ;
+
+        equality_op.add
+            ("==", ast::op_equal)
+            ("!=", ast::op_not_equal)
+            ;
+
+        relational_op.add
+            ("<", ast::op_less)
+            ("<=", ast::op_less_equal)
+            (">", ast::op_greater)
+            (">=", ast::op_greater_equal)
+            ;
+
+        additive_op.add
+            ("+", ast::op_plus)
+            ("-", ast::op_minus)
+            ;
+
+        multiplicative_op.add
+            ("*", ast::op_times)
+            ("/", ast::op_divide)
+            ;
+
+        unary_op.add
+            ("+", ast::op_positive)
+            ("-", ast::op_negative)
+            ("!", ast::op_not)
+            ;
+
+        keywords.add
+            ("true")
+            ("false")
+            ("if")
+            ("else")
+            ("while")
+            ("int")
+            ("void")
+            ("return")
+            ;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Main expression grammar
+        expr =
+            logical_or_expr.alias()
+            ;
+
+        logical_or_expr =
+                logical_and_expr
+            >> *(logical_or_op > logical_and_expr)
+            ;
+
+        logical_and_expr =
+                equality_expr
+            >> *(logical_and_op > equality_expr)
+            ;
+
+        equality_expr =
+                relational_expr
+            >> *(equality_op > relational_expr)
+            ;
+
+        relational_expr =
+                additive_expr
+            >> *(relational_op > additive_expr)
+            ;
+
+        additive_expr =
+                multiplicative_expr
+            >> *(additive_op > multiplicative_expr)
+            ;
+
+        multiplicative_expr =
+                unary_expr
+            >> *(multiplicative_op > unary_expr)
+            ;
+
+        unary_expr =
+                primary_expr
+            |   (unary_op > unary_expr)
+            ;
+
+        primary_expr =
+                uint_
+            |   function_call
+            |   identifier
+            |   bool_
+            |   '(' > expr > ')'
+            ;
+
+        function_call =
+                (identifier >> '(')
+            >   argument_list
+            >   ')'
+            ;
+
+        argument_list = -(expr % ',');
+
+        identifier =
+                !lexeme[keywords >> !(alnum | '_')]
+            >>  raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        ///////////////////////////////////////////////////////////////////////
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (expr)
+            (logical_or_expr)
+            (logical_and_expr)
+            (equality_expr)
+            (relational_expr)
+            (additive_expr)
+            (multiplicative_expr)
+            (unary_expr)
+            (primary_expr)
+            (function_call)
+            (argument_list)
+            (identifier)
+        );
+
+        ///////////////////////////////////////////////////////////////////////
+        // Error handling: on error in expr, call error_handler.
+        on_error<fail>(expr,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        ///////////////////////////////////////////////////////////////////////
+        // Annotation: on success in primary_expr, call annotation.
+        on_success(primary_expr,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/function.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/function.cpp
new file mode 100644
index 00000000..ababd4ad
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/function.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "function_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::function<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/function.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/function.hpp
new file mode 100644
index 00000000..cef1c82d
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/function.hpp
@@ -0,0 +1,32 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_MINIC_FUNCTION_HPP)
+#define BOOST_SPIRIT_MINIC_FUNCTION_HPP
+
+#include "statement.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The function grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct function : qi::grammar<Iterator, ast::function(), skipper<Iterator> >
+    {
+        function(error_handler<Iterator>& error_handler);
+
+        statement<Iterator> body;
+        qi::rule<Iterator, std::string(), skipper<Iterator> > name;
+        qi::rule<Iterator, ast::identifier(), skipper<Iterator> > identifier;
+        qi::rule<Iterator, std::list<ast::identifier>(), skipper<Iterator> > argument_list;
+        qi::rule<Iterator, ast::function(), skipper<Iterator> > start;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/function_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/function_def.hpp
new file mode 100644
index 00000000..bd2c7d02
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/function_def.hpp
@@ -0,0 +1,71 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "function.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    function<Iterator>::function(error_handler<Iterator>& error_handler)
+      : function::base_type(start), body(error_handler)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+        qi::string_type string;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        name =
+                !body.expr.keywords
+            >>  raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        identifier = name;
+        argument_list = -(identifier % ',');
+
+        start =
+                lexeme[(string("void") | string("int"))
+                    >> !(alnum | '_')]  // make sure we have whole words
+            >   identifier
+            >   '(' > argument_list > ')'
+            >   '{' > body > '}'
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (identifier)
+            (argument_list)
+            (start)
+        );
+
+        // Error handling: on error in start, call error_handler.
+        on_error<fail>(start,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in start, call annotation.
+        on_success(identifier,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/main.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/main.cpp
new file mode 100644
index 00000000..27d4bee0
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/main.cpp
@@ -0,0 +1,121 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Not a calculator anymore, right? :-)
+//
+//  [ JDG April 10, 2007 ]      spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "function.hpp"
+#include "skipper.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+#include <boost/lexical_cast.hpp>
+#include <fstream>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    std::string source_code; // We will read the contents here.
+    in.unsetf(std::ios::skipws); // No white space skipping!
+    std::copy(
+        std::istream_iterator<char>(in),
+        std::istream_iterator<char>(),
+        std::back_inserter(source_code));
+
+    typedef std::string::const_iterator iterator_type;
+    iterator_type iter = source_code.begin();
+    iterator_type end = source_code.end();
+
+    client::vmachine vm;                        // Our virtual machine
+    client::ast::function_list ast;             // Our AST
+
+    client::error_handler<iterator_type>
+        error_handler(iter, end);               // Our error handler
+    client::parser::function<iterator_type>
+        function(error_handler);                // Our parser
+    client::parser::skipper<iterator_type>
+        skipper;                                // Our skipper
+    client::code_gen::compiler
+        compiler(error_handler);                // Our compiler
+
+
+    bool success = phrase_parse(iter, end, +function, skipper, ast);
+
+    std::cout << "-------------------------\n";
+
+    if (success && iter == end)
+    {
+        if (compiler(ast))
+        {
+            boost::shared_ptr<client::code_gen::function>
+                p  = compiler.find_function("main");
+            if (!p)
+                return 1;
+
+            int nargs = argc-2;
+            if (p->nargs() != nargs)
+            {
+                std::cerr << "Error: main function requires " << p->nargs() << " arguments." << std::endl;
+                std::cerr << nargs << "supplied." << std::endl;
+                return 1;
+            }
+
+            std::cout << "Success\n";
+            std::cout << "-------------------------\n";
+            std::cout << "Assembler----------------\n\n";
+            compiler.print_assembler();
+
+            // Push the arguments into our stack
+            for (int i = 0; i < nargs; ++i)
+                vm.get_stack()[i] = boost::lexical_cast<int>(argv[i+2]);
+
+            // Call the interpreter
+            int r = vm.execute(compiler.get_code());
+
+            std::cout << "-------------------------\n";
+            std::cout << "Result: " << r << std::endl;
+            std::cout << "-------------------------\n\n";
+        }
+        else
+        {
+            std::cout << "Compile failure\n";
+        }
+    }
+    else
+    {
+        std::cout << "Parse failure\n";
+    }
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/skipper.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/skipper.hpp
new file mode 100644
index 00000000..041fb9b0
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/skipper.hpp
@@ -0,0 +1,40 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_MINIC_SKIPPER_HPP)
+#define BOOST_SPIRIT_MINIC_SKIPPER_HPP
+
+#include <boost/spirit/include/qi.hpp>
+
+namespace client { namespace parser
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The skipper grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct skipper : qi::grammar<Iterator>
+    {
+        skipper() : skipper::base_type(start)
+        {
+            qi::char_type char_;
+            ascii::space_type space;
+
+            start =
+                    space                               // tab/space/cr/lf
+                |   "/*" >> *(char_ - "*/") >> "*/"     // C-style comments
+                ;
+        }
+
+        qi::rule<Iterator> start;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/statement.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/statement.cpp
new file mode 100644
index 00000000..54bc9ac3
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/statement.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include "statement_def.hpp"
+
+typedef std::string::const_iterator iterator_type;
+template struct client::parser::statement<iterator_type>;
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/statement.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/statement.hpp
new file mode 100644
index 00000000..366f8741
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/statement.hpp
@@ -0,0 +1,38 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_MINIC_STATEMENT_HPP)
+#define BOOST_SPIRIT_MINIC_STATEMENT_HPP
+
+#include "expression.hpp"
+
+namespace client { namespace parser
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The statement grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct statement : qi::grammar<Iterator, ast::statement_list(), skipper<Iterator> >
+    {
+        statement(error_handler<Iterator>& error_handler);
+
+        expression<Iterator> expr;
+        qi::rule<Iterator, ast::statement_list(), skipper<Iterator> >
+            statement_list, compound_statement;
+
+        qi::rule<Iterator, ast::statement(), skipper<Iterator> > statement_;
+        qi::rule<Iterator, ast::variable_declaration(), skipper<Iterator> > variable_declaration;
+        qi::rule<Iterator, ast::assignment(), skipper<Iterator> > assignment;
+        qi::rule<Iterator, ast::if_statement(), skipper<Iterator> > if_statement;
+        qi::rule<Iterator, ast::while_statement(), skipper<Iterator> > while_statement;
+        qi::rule<Iterator, ast::return_statement(), skipper<Iterator> > return_statement;
+        qi::rule<Iterator, std::string(), skipper<Iterator> > identifier;
+    };
+}}
+
+#endif
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/statement_def.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/statement_def.hpp
new file mode 100644
index 00000000..f99b665a
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/statement_def.hpp
@@ -0,0 +1,124 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "statement.hpp"
+#include "error_handler.hpp"
+#include "annotation.hpp"
+
+namespace client { namespace parser
+{
+    template <typename Iterator>
+    statement<Iterator>::statement(error_handler<Iterator>& error_handler)
+      : statement::base_type(statement_list), expr(error_handler)
+    {
+        qi::_1_type _1;
+        qi::_2_type _2;
+        qi::_3_type _3;
+        qi::_4_type _4;
+
+        qi::_val_type _val;
+        qi::raw_type raw;
+        qi::lexeme_type lexeme;
+        qi::alpha_type alpha;
+        qi::alnum_type alnum;
+        qi::lit_type lit;
+
+        using qi::on_error;
+        using qi::on_success;
+        using qi::fail;
+        using boost::phoenix::function;
+
+        typedef function<client::error_handler<Iterator> > error_handler_function;
+        typedef function<client::annotation<Iterator> > annotation_function;
+
+        statement_list =
+            +statement_
+            ;
+
+        statement_ =
+                variable_declaration
+            |   assignment
+            |   compound_statement
+            |   if_statement
+            |   while_statement
+            |   return_statement
+            ;
+
+        identifier =
+                !expr.keywords
+            >>  raw[lexeme[(alpha | '_') >> *(alnum | '_')]]
+            ;
+
+        variable_declaration =
+                lexeme["int" >> !(alnum | '_')] // make sure we have whole words
+            >   identifier
+            >   -('=' > expr)
+            >   ';'
+            ;
+
+        assignment =
+                identifier
+            >   '='
+            >   expr
+            >   ';'
+            ;
+
+        if_statement =
+                lit("if")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            >
+               -(
+                    lexeme["else" >> !(alnum | '_')] // make sure we have whole words
+                >   statement_
+                )
+            ;
+
+        while_statement =
+                lit("while")
+            >   '('
+            >   expr
+            >   ')'
+            >   statement_
+            ;
+
+        compound_statement =
+            '{' >> -statement_list >> '}'
+            ;
+
+        return_statement =
+                lexeme["return" >> !(alnum | '_')] // make sure we have whole words
+            >  -expr
+            >   ';'
+            ;
+
+        // Debugging and error handling and reporting support.
+        BOOST_SPIRIT_DEBUG_NODES(
+            (statement_list)
+            (identifier)
+            (variable_declaration)
+            (assignment)
+        );
+
+        // Error handling: on error in statement_list, call error_handler.
+        on_error<fail>(statement_list,
+            error_handler_function(error_handler)(
+                "Error! Expecting ", _4, _3));
+
+        // Annotation: on success in variable_declaration,
+        // assignment and return_statement, call annotation.
+        on_success(variable_declaration,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(assignment,
+            annotation_function(error_handler.iters)(_val, _1));
+        on_success(return_statement,
+            annotation_function(error_handler.iters)(_val, _1));
+    }
+}}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/vm.cpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/vm.cpp
new file mode 100644
index 00000000..8740bf9c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/vm.cpp
@@ -0,0 +1,159 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#include "vm.hpp"
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4800) // forcing value to bool 'true' or 'false'
+                                // (performance warning)
+#endif
+
+namespace client
+{
+    int vmachine::execute(
+        std::vector<int> const& code
+      , std::vector<int>::const_iterator pc
+      , std::vector<int>::iterator frame_ptr
+    )
+    {
+        std::vector<int>::iterator stack_ptr = frame_ptr;
+
+        while (true)
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_not:
+                    stack_ptr[-1] = !bool(stack_ptr[-1]);
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_eq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] == stack_ptr[0]);
+                    break;
+
+                case op_neq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] != stack_ptr[0]);
+                    break;
+
+                case op_lt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] < stack_ptr[0]);
+                    break;
+
+                case op_lte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] <= stack_ptr[0]);
+                    break;
+
+                case op_gt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] > stack_ptr[0]);
+                    break;
+
+                case op_gte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] >= stack_ptr[0]);
+                    break;
+
+                case op_and:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) && bool(stack_ptr[0]);
+                    break;
+
+                case op_or:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) || bool(stack_ptr[0]);
+                    break;
+
+                case op_load:
+                    *stack_ptr++ = frame_ptr[*pc++];
+                    break;
+
+                case op_store:
+                    --stack_ptr;
+                    frame_ptr[*pc++] = stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+
+                case op_true:
+                    *stack_ptr++ = true;
+                    break;
+
+                case op_false:
+                    *stack_ptr++ = false;
+                    break;
+
+                case op_jump:
+                    pc += *pc;
+                    break;
+
+                case op_jump_if:
+                    if (!bool(stack_ptr[-1]))
+                        pc += *pc;
+                    else
+                        ++pc;
+                    --stack_ptr;
+                    break;
+
+                case op_stk_adj:
+                    stack_ptr += *pc++;
+                    break;
+
+                case op_call:
+                    {
+                        int nargs = *pc++;
+                        int jump = *pc++;
+
+                        // a function call is a recursive call to execute
+                        int r = execute(
+                            code
+                          , code.begin() + jump
+                          , stack_ptr - nargs
+                        );
+
+                        // cleanup after return from function
+                        stack_ptr[-nargs] = r;      //  get return value
+                        stack_ptr -= (nargs - 1);   //  the stack will now contain
+                                                    //  the return value
+                    }
+                    break;
+
+                case op_return:
+                    return stack_ptr[-1];
+            }
+        }
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/vm.hpp b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/vm.hpp
new file mode 100644
index 00000000..eb4cc294
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c/vm.hpp
@@ -0,0 +1,82 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_MINIC_VM_HPP)
+#define BOOST_SPIRIT_MINIC_VM_HPP
+
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ///////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,         //  negate the top stack entry
+        op_add,         //  add top two stack entries
+        op_sub,         //  subtract top two stack entries
+        op_mul,         //  multiply top two stack entries
+        op_div,         //  divide top two stack entries
+
+        op_not,         //  boolean negate the top stack entry
+        op_eq,          //  compare the top two stack entries for ==
+        op_neq,         //  compare the top two stack entries for !=
+        op_lt,          //  compare the top two stack entries for <
+        op_lte,         //  compare the top two stack entries for <=
+        op_gt,          //  compare the top two stack entries for >
+        op_gte,         //  compare the top two stack entries for >=
+
+        op_and,         //  logical and top two stack entries
+        op_or,          //  logical or top two stack entries
+
+        op_load,        //  load a variable
+        op_store,       //  store a variable
+
+        op_int,         //  push constant integer into the stack
+        op_true,        //  push constant 0 into the stack
+        op_false,       //  push constant 1 into the stack
+
+        op_jump_if,     //  jump to a relative position in the code if top stack
+                        //  evaluates to false
+        op_jump,        //  jump to a relative position in the code
+
+        op_stk_adj,     //  adjust the stack (for args and locals)
+        op_call,        //  function call
+        op_return       //  return from function
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+        {
+        }
+
+        int execute(std::vector<int> const& code)
+        {
+            return execute(code, code.begin(), stack.begin());
+        }
+
+        std::vector<int> const& get_stack() const { return stack; };
+        std::vector<int>& get_stack() { return stack; };
+
+    private:
+
+        int execute(
+            std::vector<int> const& code            // the program code
+          , std::vector<int>::const_iterator pc     // program counter
+          , std::vector<int>::iterator frame_ptr    // start of arguments and locals
+        );
+
+        std::vector<int> stack;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c_samples/1.mini b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c_samples/1.mini
new file mode 100644
index 00000000..bd22c869
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c_samples/1.mini
@@ -0,0 +1,19 @@
+/* My first mini program */
+
+int pow2(n)
+{
+    int a = 2;
+    int i = 1;
+    while (i < n)
+    {
+        a = a * 2;
+        i = i + 1;
+    }
+    return a;
+}
+
+int main()
+{
+    return pow2(10);
+}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c_samples/2.mini b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c_samples/2.mini
new file mode 100644
index 00000000..5ea05731
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c_samples/2.mini
@@ -0,0 +1,15 @@
+/* The factorial */
+
+int factorial(n)
+{
+    if (n <= 0)
+        return 1;
+    else
+        return n * factorial(n-1);
+}
+
+int main(n)
+{
+    return factorial(n);
+}
+
diff --git a/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c_samples/3.mini b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c_samples/3.mini
new file mode 100644
index 00000000..5c407d6e
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/compiler_tutorial/mini_c_samples/3.mini
@@ -0,0 +1,17 @@
+/* mini program with syntax error */
+
+int foo(n)
+{
+    int a = 2;
+    if (n @ 3) /* we don't have @ operator in mini_c */
+    {
+        a = 3
+    }
+    return a;
+}
+
+int main()
+{
+    return foo(10);
+}
+
diff --git a/src/boost/libs/spirit/example/qi/complex_number.cpp b/src/boost/libs/spirit/example/qi/complex_number.cpp
new file mode 100644
index 00000000..a4400e0c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/complex_number.cpp
@@ -0,0 +1,101 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A complex number micro parser.
+//
+//  [ JDG May 10, 2002 ]    spirit1
+//  [ JDG May 9, 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 <iostream>
+#include <string>
+#include <complex>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our complex number parser/compiler
+///////////////////////////////////////////////////////////////////////////////
+//[tutorial_complex_number
+namespace client
+{
+    template <typename Iterator>
+    bool parse_complex(Iterator first, Iterator last, std::complex<double>& c)
+    {
+        using boost::spirit::qi::double_;
+        using boost::spirit::qi::_1;
+        using boost::spirit::qi::phrase_parse;
+        using boost::spirit::ascii::space;
+        using boost::phoenix::ref;
+
+        double rN = 0.0;
+        double iN = 0.0;
+        bool r = phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                    '(' >> double_[ref(rN) = _1]
+                        >> -(',' >> double_[ref(iN) = _1]) >> ')'
+                |   double_[ref(rN) = _1]
+            ),
+            //  End grammar
+
+            space);
+
+        if (!r || first != last) // fail if we did not get a full match
+            return false;
+        c = std::complex<double>(rN, iN);
+        return r;
+    }
+}
+//]
+
+////////////////////////////////////////////////////////////////////////////
+//  Main program
+////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA complex number micro parser for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a complex number of the form r or (r) or (r,i) \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::complex<double> c;
+        if (client::parse_complex(str.begin(), str.end(), c))
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "got: " << c << 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;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/custom_string.cpp b/src/boost/libs/spirit/example/qi/custom_string.cpp
new file mode 100644
index 00000000..e5e78221
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/custom_string.cpp
@@ -0,0 +1,113 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example demonstrates the steps needed to integrate a custom container
+//  type to be usable with Spirit.Qi. It shows how to utilize the QString data
+//  type as a Qi attribute.
+
+//  Note: you need to have Qt4 installed on your system and you have to make 
+//        sure your compiler finds the includes and your linker finds the 
+//        proper libraries.
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+
+#include <Qt/qstring.h>
+
+namespace boost { namespace spirit { namespace traits
+{
+    // Make Qi recognize QString as a container
+    template <> struct is_container<QString> : mpl::true_ {};
+
+    // Expose the container's (QString's) value_type
+    template <> struct container_value<QString> : mpl::identity<QChar> {};
+
+    // Define how to insert a new element at the end of the container (QString)
+    template <>
+    struct push_back_container<QString, QChar>
+    {
+        static bool call(QString& c, QChar const& val)
+        {
+            c.append(val);
+            return true;
+        }
+    };
+    
+    // Test if a QString is empty (required for debug)
+    template <>
+    struct is_empty_container<QString>
+    {
+        static bool call(QString const& c)
+        {
+            return c.isEmpty();
+        }
+    };
+
+    // Define how to stream a QString (required for debug)
+    template <typename Out, typename Enable>
+    struct print_attribute_debug<Out, QString, Enable>
+    {
+        static void call(Out& out, QString const& val)
+        {
+            out << val.toStdString();
+        }
+    };
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace client
+{
+    template <typename Iterator>
+    bool parse_qstring(Iterator first, Iterator last, QString& t)
+    {
+        using boost::spirit::qi::char_;
+        using boost::spirit::ascii::space;
+        using boost::spirit::qi::phrase_parse;
+
+        bool r = phrase_parse(first, last, +char_, space, t);
+        if (!r || first != last) // fail if we did not get a full match
+            return false;
+
+        return r;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tParsing into a QString from Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a complex number of the form r or (r) or (r,i) \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;
+
+        QString t;
+        if (client::parse_qstring(str.begin(), str.end(), t))
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "got: " << t.toStdString() << 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;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/display_attribute_type.cpp b/src/boost/libs/spirit/example/qi/display_attribute_type.cpp
new file mode 100644
index 00000000..11f086b5
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/display_attribute_type.cpp
@@ -0,0 +1,22 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example implements a simple utility allowing to print the attribute 
+//  type as it is exposed by an arbitrary Qi parser expression. Just insert 
+//  your expression below, compile and run this example to see what Qi is 
+//  seeing!
+
+#include "display_attribute_type.hpp"
+
+namespace qi = boost::spirit::qi;
+
+int main()
+{
+    tools::display_attribute_of_parser(
+        std::cerr,                // put the required output stream here
+        qi::int_ >> qi::double_   // put your parser expression here
+    );
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/qi/display_attribute_type.hpp b/src/boost/libs/spirit/example/qi/display_attribute_type.hpp
new file mode 100644
index 00000000..84c2245d
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/display_attribute_type.hpp
@@ -0,0 +1,59 @@
+//  Copyright (c) 2001-2010 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)
+
+//  This example implements a simple utility allowing to print the attribute 
+//  type as it is exposed by an arbitrary Qi parser expression. Just insert 
+//  your expression below, compile and run this example to see what Qi is 
+//  seeing!
+
+#if !defined (DISPLAY_ATTRIBUTE_OF_PARSER_JAN_2010_30_0722PM)
+#define DISPLAY_ATTRIBUTE_OF_PARSER_JAN_2010_30_0722PM
+
+#include <iostream>
+#include <boost/spirit/include/qi.hpp>
+
+namespace tools
+{
+    namespace spirit = boost::spirit;
+
+    template <typename Expr, typename Iterator = spirit::unused_type>
+    struct attribute_of_parser
+    {
+        typedef typename spirit::result_of::compile<
+            spirit::qi::domain, Expr
+        >::type parser_expression_type;
+
+        typedef typename spirit::traits::attribute_of<
+            parser_expression_type, spirit::unused_type, Iterator
+        >::type type;
+    };
+
+    template <typename T>
+    void display_attribute_of_parser(T const &) 
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(spirit::qi::domain, T);
+
+        typedef typename attribute_of_parser<T>::type type;
+        std::cout << typeid(type).name() << std::endl;
+    }
+
+    template <typename T>
+    void display_attribute_of_parser(std::ostream& os, T const &) 
+    {
+        // Report invalid expression error as early as possible.
+        // If you got an error_invalid_expression error message here,
+        // then the expression (expr) is not a valid spirit qi expression.
+        BOOST_SPIRIT_ASSERT_MATCH(spirit::qi::domain, T);
+
+        typedef typename attribute_of_parser<T>::type type;
+        os << typeid(type).name() << std::endl;
+    }
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/qi/employee.cpp b/src/boost/libs/spirit/example/qi/employee.cpp
new file mode 100644
index 00000000..c303ff8b
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/employee.cpp
@@ -0,0 +1,151 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A parser for arbitrary tuples. This example presents a parser
+//  for an employee structure.
+//
+//  [ JDG May 9, 2007 ]
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#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_object.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+
+#include <iostream>
+#include <string>
+#include <complex>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our employee struct
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_employee_struct
+    struct employee
+    {
+        int age;
+        std::string surname;
+        std::string forename;
+        double salary;
+    };
+    //]
+}
+
+// We need to tell fusion about our employee struct
+// to make it a first-class fusion citizen. This has to
+// be in global scope.
+
+//[tutorial_employee_adapt_struct
+BOOST_FUSION_ADAPT_STRUCT(
+    client::employee,
+    (int, age)
+    (std::string, surname)
+    (std::string, forename)
+    (double, salary)
+)
+//]
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our employee parser
+    ///////////////////////////////////////////////////////////////////////////////
+    //[tutorial_employee_parser
+    template <typename Iterator>
+    struct employee_parser : qi::grammar<Iterator, employee(), ascii::space_type>
+    {
+        employee_parser() : employee_parser::base_type(start)
+        {
+            using qi::int_;
+            using qi::lit;
+            using qi::double_;
+            using qi::lexeme;
+            using ascii::char_;
+
+            quoted_string %= lexeme['"' >> +(char_ - '"') >> '"'];
+
+            start %=
+                lit("employee")
+                >> '{'
+                >>  int_ >> ','
+                >>  quoted_string >> ','
+                >>  quoted_string >> ','
+                >>  double_
+                >>  '}'
+                ;
+        }
+
+        qi::rule<Iterator, std::string(), ascii::space_type> quoted_string;
+        qi::rule<Iterator, employee(), ascii::space_type> start;
+    };
+    //]
+}
+
+////////////////////////////////////////////////////////////////////////////
+//  Main program
+////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tAn employee parser for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout
+        << "Give me an employee of the form :"
+        << "employee{age, \"surname\", \"forename\", salary } \n";
+    std::cout << "Type [q or Q] to quit\n\n";
+
+    using boost::spirit::ascii::space;
+    typedef std::string::const_iterator iterator_type;
+    typedef client::employee_parser<iterator_type> employee_parser;
+
+    employee_parser g; // Our grammar
+    std::string str;
+    while (getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        client::employee emp;
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = phrase_parse(iter, end, g, space, emp);
+
+        if (r && iter == end)
+        {
+            std::cout << boost::fusion::tuple_open('[');
+            std::cout << boost::fusion::tuple_close(']');
+            std::cout << boost::fusion::tuple_delimiter(", ");
+
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "got: " << boost::fusion::as_vector(emp) << 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;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/expect.cpp b/src/boost/libs/spirit/example/qi/expect.cpp
new file mode 100644
index 00000000..ecbc24aa
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/expect.cpp
@@ -0,0 +1,112 @@
+/*=============================================================================
+Copyright (c) 2016 Frank Hein, maxence business consulting gmbh
+
+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)
+==============================================================================*/
+
+#include <iostream>
+#include <map>
+
+#include <boost/spirit/home/qi.hpp>
+#include <boost/spirit/home/qi/nonterminal/grammar.hpp>
+#include <boost/spirit/include/phoenix.hpp>
+#include <boost/foreach.hpp>
+
+namespace qi = boost::spirit::qi;
+
+typedef std::string::const_iterator iterator_type;
+typedef std::string result_type;
+
+template<typename Parser>
+void parse(const std::string message, const std::string& input, const std::string& rule, const Parser& parser) {
+    iterator_type iter = input.begin(), end = input.end();
+
+    std::vector<result_type> parsed_result;
+
+    std::cout << "-------------------------\n";
+    std::cout << message << "\n";
+    std::cout << "Rule: " << rule << std::endl;
+    std::cout << "Parsing: \"" << input << "\"\n";
+
+    bool result = qi::phrase_parse(iter, end, parser, qi::space, parsed_result);
+    if (result)
+    {
+        std::cout << "Parser succeeded.\n";
+        std::cout << "Parsed " << parsed_result.size() << " elements:";
+        BOOST_FOREACH(result_type const& str, parsed_result)
+        {
+            std::cout << "[" << str << "]";
+        }
+        std::cout << std::endl;
+    }
+    else
+    {
+        std::cout << "Parser failed" << std::endl;
+    }
+    if (iter == end) {
+        std::cout << "EOI reached." << std::endl;
+    }
+    else {
+        std::cout << "EOI not reached. Unparsed: \"" << std::string(iter, end) << "\"" << std::endl;
+    }
+    std::cout << "-------------------------\n";
+
+}
+
+namespace grammars {
+    namespace phx = boost::phoenix;
+
+    template <typename Iterator>
+    struct ident : qi::grammar < Iterator, std::string(), qi::space_type>
+    {
+        ident();
+
+        qi::rule <iterator_type, std::string(), qi::space_type>
+            id, id_list, qualified_id;
+    };
+
+    template <typename Iterator>
+    ident<Iterator>::ident() : ident::base_type(id_list) {
+
+        using qi::on_error;
+        using qi::fail;
+        using qi::expect;
+
+        id = (qi::alpha | qi::char_('_')) >> *(qi::alnum | qi::char_('_'));
+
+        id_list = expect[id >> qi::lit(';')];
+
+        on_error<fail>(id_list,
+            phx::ref(std::cout)
+            << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl
+            << "Error! Expecting "
+            << qi::_4
+            << " here: "
+            << phx::construct<std::string>(qi::_3, qi::_2) << std::endl
+            << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl
+            );
+    }
+}
+
+int main() {
+
+    grammars::ident<iterator_type> id;
+
+    parse("expect directive, fail on first"
+        , "1234; id2;"
+        , "qi::expect[ id  >> qi::lit(';') ]"
+        , id);
+
+    parse("expect directive, fail on second"
+        , "id1, id2"
+        , "qi::expect[ id  >> qi::lit(';') ]"
+        , id);
+
+    parse("expect directive, success"
+        , "id1;"
+        , "qi::expect[ id  >> qi::lit(';') ]"
+        , id);
+
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/qi/german_floating_point.cpp b/src/boost/libs/spirit/example/qi/german_floating_point.cpp
new file mode 100644
index 00000000..c091ca92
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/german_floating_point.cpp
@@ -0,0 +1,48 @@
+//  Copyright (c) 2001-2011 Hartmut Kaiser
+//  Copyright (c) 2011 Michael Caisse
+// 
+//  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)
+
+#include <boost/spirit/include/qi.hpp>
+
+namespace qi = boost::spirit::qi;
+
+template <typename T>
+struct german_real_policies : qi::real_policies<T>
+{
+    template <typename Iterator>
+    static bool parse_dot(Iterator& first, Iterator const& last)
+    {
+        if (first == last || *first != ',')
+            return false;
+        ++first;
+        return true;
+    }
+};
+
+qi::real_parser<double, german_real_policies<double> > const german_double;
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::string input("123,456");
+    std::string::iterator begin = input.begin();
+    std::string::iterator end = input.end();
+
+    double value = 0;
+    if (!qi::parse(begin, end, german_double, value))
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------------- \n";
+    }
+    else
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing succeeded, got: " << value << "\n";
+        std::cout << "---------------------------------\n";
+    }
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/qi/iter_pos.hpp b/src/boost/libs/spirit/example/qi/iter_pos.hpp
new file mode 100644
index 00000000..b6259fd7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/iter_pos.hpp
@@ -0,0 +1,83 @@
+//  Copyright (c) 2001-2010 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)
+
+#if !defined(ITER_POS_NOV_20_2009_1245PM)
+#define ITER_POS_NOV_20_2009_1245PM
+
+#include <boost/spirit/include/qi_parse.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// definition the place holder 
+namespace custom_parser 
+{ 
+    BOOST_SPIRIT_TERMINAL(iter_pos)
+} 
+
+///////////////////////////////////////////////////////////////////////////////
+// implementation the enabler
+namespace boost { namespace spirit 
+{ 
+    // We want custom_parser::iter_pos to be usable as a terminal only, 
+    // and only for parser expressions (qi::domain).
+    template <>
+    struct use_terminal<qi::domain, custom_parser::tag::iter_pos> 
+      : mpl::true_ 
+    {}; 
+}}
+
+///////////////////////////////////////////////////////////////////////////////
+// implementation of the parser
+namespace custom_parser 
+{ 
+    struct iter_pos_parser 
+      : boost::spirit::qi::primitive_parser<iter_pos_parser>
+    {
+        // Define the attribute type exposed by this parser component
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef Iterator type;
+        };
+
+        // This function is called during the actual parsing process
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context&, Skipper const& skipper, Attribute& attr) const
+        {
+            boost::spirit::qi::skip_over(first, last, skipper);
+            boost::spirit::traits::assign_to(first, attr);
+            return true;
+        }
+
+        // This function is called during error handling to create
+        // a human readable string for the error context.
+        template <typename Context>
+        boost::spirit::info what(Context&) const
+        {
+            return boost::spirit::info("iter_pos");
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// instantiation of the parser
+namespace boost { namespace spirit { namespace qi
+{
+    // This is the factory function object invoked in order to create 
+    // an instance of our iter_pos_parser.
+    template <typename Modifiers>
+    struct make_primitive<custom_parser::tag::iter_pos, Modifiers>
+    {
+        typedef custom_parser::iter_pos_parser result_type;
+
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+}}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/qi/iter_pos_parser.cpp b/src/boost/libs/spirit/example/qi/iter_pos_parser.cpp
new file mode 100644
index 00000000..92ff4b00
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/iter_pos_parser.cpp
@@ -0,0 +1,51 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The purpose of this example is to show how a simple custom primitive parser
+//  component can be written. We develop a custom parser exposing the current 
+//  iterator position as its attribute.
+//
+//  For more information see: http://spirit.sourceforge.net/home/?page_id=567
+
+#include <boost/spirit/include/qi_parse_attr.hpp>
+#include <boost/spirit/include/qi_char.hpp>
+#include <boost/spirit/include/qi_operator.hpp>
+
+#include <string>
+#include "iter_pos.hpp"
+
+namespace qi = boost::spirit::qi;
+
+int main()
+{
+    using custom_parser::iter_pos;
+
+    std::string prefix, suffix;           // attributes receiving the
+    std::string::iterator position;       // parsed values
+
+    std::string input("prefix1234567");
+    std::string::iterator first = input.begin();
+    bool result = 
+        qi::parse(first, input.end()
+          , +qi::alpha >> iter_pos >> +qi::digit
+          , prefix, position, suffix);
+
+    if (result) 
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "prefix is: " << prefix << "\n";
+        std::cout << "suffix is: " << suffix << "\n";
+        std::cout << "position is: " << std::distance(input.begin(), position) << "\n";
+        std::cout << "-------------------------------- \n";
+    }
+    else 
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------------- \n";
+    }
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/qi/key_value_sequence.cpp b/src/boost/libs/spirit/example/qi/key_value_sequence.cpp
new file mode 100644
index 00000000..3e75786d
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/key_value_sequence.cpp
@@ -0,0 +1,78 @@
+//  Copyright (c) 2001-2010 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)
+
+// The purpose of this example is to show how to parse arbitrary key/value 
+// pairs delimited by some separator into a std::map. Parsing the URL query 
+// format is the example we use to demonstrate how this can be done 
+// (i.e. things like: key1=value1;key2=value2;...;keyN=valueN).
+//
+// For a more elaborate explanation see here: http://spirit.sourceforge.net/home/?p=371
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+
+#include <iostream>
+#include <map>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+
+    typedef std::map<std::string, std::string> pairs_type;
+
+    template <typename Iterator>
+    struct key_value_sequence 
+      : qi::grammar<Iterator, pairs_type()>
+    {
+        key_value_sequence()
+          : key_value_sequence::base_type(query)
+        {
+            query =  pair >> *((qi::lit(';') | '&') >> pair);
+            pair  =  key >> -('=' >> value);
+            key   =  qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9");
+            value = +qi::char_("a-zA-Z_0-9");
+        }
+
+        qi::rule<Iterator, pairs_type()> query;
+        qi::rule<Iterator, std::pair<std::string, std::string>()> pair;
+        qi::rule<Iterator, std::string()> key, value;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    namespace qi = boost::spirit::qi;
+
+    std::string input("key1=value1;key2;key3=value3");
+    std::string::iterator begin = input.begin();
+    std::string::iterator end = input.end();
+
+    client::key_value_sequence<std::string::iterator> p;
+    client::pairs_type m;
+
+    if (!qi::parse(begin, end, p, m))
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------------- \n";
+    }
+    else
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing succeeded, found entries:\n";
+        client::pairs_type::iterator end = m.end();
+        for (client::pairs_type::iterator it = m.begin(); it != end; ++it)
+        {
+            std::cout << (*it).first;
+            if (!(*it).second.empty())
+                std::cout << "=" << (*it).second;
+            std::cout << std::endl;
+        }
+        std::cout << "---------------------------------\n";
+    }
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/qi/key_value_sequence_empty_value.cpp b/src/boost/libs/spirit/example/qi/key_value_sequence_empty_value.cpp
new file mode 100644
index 00000000..8cb8e20d
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/key_value_sequence_empty_value.cpp
@@ -0,0 +1,83 @@
+//  Copyright (c) 2001-2010 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)
+
+// The purpose of this example is to show how to parse arbitrary key/value 
+// pairs delimited by some separator into a std::vector. The difference to 
+// the example 'key_value_sequence.cpp' is that we preserve the order of the
+// elements in the parsed sequence as well as possibly existing duplicates.
+// In addition to the example 'key_value_sequence_ordered.cpp' we allow for 
+// empty values, i.e. the grammar allows to distinguish between 'key=;' and
+// 'key;", where the first stores an empty string as the value, while the 
+// second does not initialize the optional holding the value.
+//
+// For a more elaborate explanation see here: http://spirit.sourceforge.net/home/?p=371
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+
+#include <iostream>
+#include <map>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+
+    typedef std::pair<std::string, boost::optional<std::string> > pair_type;
+    typedef std::vector<pair_type> pairs_type;
+
+    template <typename Iterator>
+    struct key_value_sequence_empty_value
+      : qi::grammar<Iterator, pairs_type()>
+    {
+        key_value_sequence_empty_value()
+          : key_value_sequence_empty_value::base_type(query)
+        {
+            query =  pair >> *((qi::lit(';') | '&') >> pair);
+            pair  =  key >> -('=' >> -value);
+            key   =  qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9");
+            value = +qi::char_("a-zA-Z_0-9");
+        }
+
+        qi::rule<Iterator, pairs_type()> query;
+        qi::rule<Iterator, pair_type()> pair;
+        qi::rule<Iterator, std::string()> key, value;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    namespace qi = boost::spirit::qi;
+
+    std::string input("key1=value1;key2;key3=value3;key4=");
+    std::string::iterator begin = input.begin();
+    std::string::iterator end = input.end();
+
+    client::key_value_sequence_empty_value<std::string::iterator> p;
+    client::pairs_type m;
+
+    if (!qi::parse(begin, end, p, m))
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------------- \n";
+    }
+    else
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing succeeded, found entries:\n";
+        client::pairs_type::iterator end = m.end();
+        for (client::pairs_type::iterator it = m.begin(); it != end; ++it)
+        {
+            std::cout << (*it).first;
+            if ((*it).second)
+                std::cout << "=" << boost::get<std::string>((*it).second);
+            std::cout << std::endl;
+        }
+        std::cout << "---------------------------------\n";
+    }
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/qi/key_value_sequence_ordered.cpp b/src/boost/libs/spirit/example/qi/key_value_sequence_ordered.cpp
new file mode 100644
index 00000000..21689239
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/key_value_sequence_ordered.cpp
@@ -0,0 +1,78 @@
+//  Copyright (c) 2001-2010 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)
+
+// The purpose of this example is to show how to parse arbitrary key/value 
+// pairs delimited by some separator into a std::vector. The difference to 
+// the example 'key_value_sequence.cpp' is that we preserve the order of the
+// elements in the parsed seqeunce as well as possibly existing duplicates.
+//
+// For a more elaborate explanation see here: http://spirit.sourceforge.net/home/?p=371
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+
+#include <iostream>
+#include <map>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+
+    typedef std::vector<std::pair<std::string, std::string> > pairs_type;
+
+    template <typename Iterator>
+    struct key_value_sequence_ordered 
+      : qi::grammar<Iterator, pairs_type()>
+    {
+        key_value_sequence_ordered()
+          : key_value_sequence_ordered::base_type(query)
+        {
+            query =  pair >> *((qi::lit(';') | '&') >> pair);
+            pair  =  key >> -('=' >> value);
+            key   =  qi::char_("a-zA-Z_") >> *qi::char_("a-zA-Z_0-9");
+            value = +qi::char_("a-zA-Z_0-9");
+        }
+
+        qi::rule<Iterator, pairs_type()> query;
+        qi::rule<Iterator, std::pair<std::string, std::string>()> pair;
+        qi::rule<Iterator, std::string()> key, value;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    namespace qi = boost::spirit::qi;
+
+    std::string input("key2=value2;key1;key3=value3");
+    std::string::iterator begin = input.begin();
+    std::string::iterator end = input.end();
+
+    client::key_value_sequence_ordered<std::string::iterator> p;
+    client::pairs_type v;
+
+    if (!qi::parse(begin, end, p, v))
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------------- \n";
+    }
+    else
+    {
+        std::cout << "-------------------------------- \n";
+        std::cout << "Parsing succeeded, found entries:\n";
+        client::pairs_type::iterator end = v.end();
+        for (client::pairs_type::iterator it = v.begin(); it != end; ++it)
+        {
+            std::cout << (*it).first;
+            if (!(*it).second.empty())
+                std::cout << "=" << (*it).second;
+            std::cout << std::endl;
+        }
+        std::cout << "---------------------------------\n";
+    }
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/qi/mini_xml1.cpp b/src/boost/libs/spirit/example/qi/mini_xml1.cpp
new file mode 100644
index 00000000..1a27eda4
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/mini_xml1.cpp
@@ -0,0 +1,242 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A mini XML-like parser
+//
+//  [ JDG March 25, 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_fusion.hpp>
+#include <boost/spirit/include/phoenix_stl.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/foreach.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    namespace fusion = boost::fusion;
+    namespace phoenix = boost::phoenix;
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our mini XML tree representation
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_xml1_structures
+    struct mini_xml;
+
+    typedef
+        boost::variant<
+            boost::recursive_wrapper<mini_xml>
+          , std::string
+        >
+    mini_xml_node;
+
+    struct mini_xml
+    {
+        std::string name;                           // tag name
+        std::vector<mini_xml_node> children;        // children
+    };
+    //]
+}
+
+// We need to tell fusion about our mini_xml struct
+// to make it a first-class fusion citizen
+//[tutorial_xml1_adapt_structures
+BOOST_FUSION_ADAPT_STRUCT(
+    client::mini_xml,
+    (std::string, name)
+    (std::vector<client::mini_xml_node>, children)
+)
+//]
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Print out the mini xml tree
+    ///////////////////////////////////////////////////////////////////////////
+    int const tabsize = 4;
+
+    void tab(int indent)
+    {
+        for (int i = 0; i < indent; ++i)
+            std::cout << ' ';
+    }
+
+    struct mini_xml_printer
+    {
+        mini_xml_printer(int indent = 0)
+          : indent(indent)
+        {
+        }
+
+        void operator()(mini_xml const& xml) const;
+
+        int indent;
+    };
+
+    struct mini_xml_node_printer : boost::static_visitor<>
+    {
+        mini_xml_node_printer(int indent = 0)
+          : indent(indent)
+        {
+        }
+
+        void operator()(mini_xml const& xml) const
+        {
+            mini_xml_printer(indent+tabsize)(xml);
+        }
+
+        void operator()(std::string const& text) const
+        {
+            tab(indent+tabsize);
+            std::cout << "text: \"" << text << '"' << std::endl;
+        }
+
+        int indent;
+    };
+
+    void mini_xml_printer::operator()(mini_xml const& xml) const
+    {
+        tab(indent);
+        std::cout << "tag: " << xml.name << std::endl;
+        tab(indent);
+        std::cout << '{' << std::endl;
+
+        BOOST_FOREACH(mini_xml_node const& node, xml.children)
+        {
+            boost::apply_visitor(mini_xml_node_printer(indent), node);
+        }
+
+        tab(indent);
+        std::cout << '}' << std::endl;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our mini XML grammar definition
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_xml1_grammar
+    template <typename Iterator>
+    struct mini_xml_grammar : qi::grammar<Iterator, mini_xml(), ascii::space_type>
+    {
+        mini_xml_grammar() : mini_xml_grammar::base_type(xml)
+        {
+            using qi::lit;
+            using qi::lexeme;
+            using ascii::char_;
+            using ascii::string;
+            using namespace qi::labels;
+
+            using phoenix::at_c;
+            using phoenix::push_back;
+
+            text = lexeme[+(char_ - '<')        [_val += _1]];
+            node = (xml | text)                 [_val = _1];
+
+            start_tag =
+                    '<'
+                >>  !lit('/')
+                >>  lexeme[+(char_ - '>')       [_val += _1]]
+                >>  '>'
+            ;
+
+            end_tag =
+                    "</"
+                >>  lit(_r1)
+                >>  '>'
+            ;
+
+            xml =
+                    start_tag                   [at_c<0>(_val) = _1]
+                >>  *node                       [push_back(at_c<1>(_val), _1)]
+                >>  end_tag(at_c<0>(_val))
+            ;
+        }
+
+        qi::rule<Iterator, mini_xml(), ascii::space_type> xml;
+        qi::rule<Iterator, mini_xml_node(), ascii::space_type> node;
+        qi::rule<Iterator, std::string(), ascii::space_type> text;
+        qi::rule<Iterator, std::string(), ascii::space_type> start_tag;
+        qi::rule<Iterator, void(std::string), ascii::space_type> end_tag;
+    };
+    //]
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    std::string storage; // We will read the contents here.
+    in.unsetf(std::ios::skipws); // No white space skipping!
+    std::copy(
+        std::istream_iterator<char>(in),
+        std::istream_iterator<char>(),
+        std::back_inserter(storage));
+
+    typedef client::mini_xml_grammar<std::string::const_iterator> mini_xml_grammar;
+    mini_xml_grammar xml; // Our grammar
+    client::mini_xml ast; // Our tree
+
+    using boost::spirit::ascii::space;
+    std::string::const_iterator iter = storage.begin();
+    std::string::const_iterator end = storage.end();
+    bool r = phrase_parse(iter, end, xml, space, ast);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+        client::mini_xml_printer printer;
+        printer(ast);
+        return 0;
+    }
+    else
+    {
+        std::string::const_iterator some = iter + std::min(30, int(end - iter));
+        std::string context(iter, (some>end)?end:some);
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \"" << context << "...\"\n";
+        std::cout << "-------------------------\n";
+        return 1;
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/mini_xml2.cpp b/src/boost/libs/spirit/example/qi/mini_xml2.cpp
new file mode 100644
index 00000000..6d56374b
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/mini_xml2.cpp
@@ -0,0 +1,237 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A mini XML-like parser
+//
+//  [ JDG March 25, 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_fusion.hpp>
+#include <boost/spirit/include/phoenix_stl.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/foreach.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    namespace fusion = boost::fusion;
+    namespace phoenix = boost::phoenix;
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our mini XML tree representation
+    ///////////////////////////////////////////////////////////////////////////
+    struct mini_xml;
+
+    typedef
+        boost::variant<
+            boost::recursive_wrapper<mini_xml>
+          , std::string
+        >
+    mini_xml_node;
+
+    struct mini_xml
+    {
+        std::string name;                           // tag name
+        std::vector<mini_xml_node> children;        // children
+    };
+}
+
+// We need to tell fusion about our mini_xml struct
+// to make it a first-class fusion citizen
+BOOST_FUSION_ADAPT_STRUCT(
+    client::mini_xml,
+    (std::string, name)
+    (std::vector<client::mini_xml_node>, children)
+)
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Print out the mini xml tree
+    ///////////////////////////////////////////////////////////////////////////
+    int const tabsize = 4;
+
+    void tab(int indent)
+    {
+        for (int i = 0; i < indent; ++i)
+            std::cout << ' ';
+    }
+
+    struct mini_xml_printer
+    {
+        mini_xml_printer(int indent = 0)
+          : indent(indent)
+        {
+        }
+
+        void operator()(mini_xml const& xml) const;
+
+        int indent;
+    };
+
+    struct mini_xml_node_printer : boost::static_visitor<>
+    {
+        mini_xml_node_printer(int indent = 0)
+          : indent(indent)
+        {
+        }
+
+        void operator()(mini_xml const& xml) const
+        {
+            mini_xml_printer(indent+tabsize)(xml);
+        }
+
+        void operator()(std::string const& text) const
+        {
+            tab(indent+tabsize);
+            std::cout << "text: \"" << text << '"' << std::endl;
+        }
+
+        int indent;
+    };
+
+    void mini_xml_printer::operator()(mini_xml const& xml) const
+    {
+        tab(indent);
+        std::cout << "tag: " << xml.name << std::endl;
+        tab(indent);
+        std::cout << '{' << std::endl;
+
+        BOOST_FOREACH(mini_xml_node const& node, xml.children)
+        {
+            boost::apply_visitor(mini_xml_node_printer(indent), node);
+        }
+
+        tab(indent);
+        std::cout << '}' << std::endl;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our mini XML grammar definition
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_xml2_grammar
+    template <typename Iterator>
+    struct mini_xml_grammar
+      : qi::grammar<Iterator, mini_xml(), qi::locals<std::string>, ascii::space_type>
+    {
+        mini_xml_grammar()
+          : mini_xml_grammar::base_type(xml)
+        {
+            using qi::lit;
+            using qi::lexeme;
+            using ascii::char_;
+            using ascii::string;
+            using namespace qi::labels;
+
+            text %= lexeme[+(char_ - '<')];
+            node %= xml | text;
+
+            start_tag %=
+                    '<'
+                >>  !lit('/')
+                >>  lexeme[+(char_ - '>')]
+                >>  '>'
+            ;
+
+            end_tag =
+                    "</"
+                >>  lit(_r1)
+                >>  '>'
+            ;
+
+            xml %=
+                    start_tag[_a = _1]
+                >>  *node
+                >>  end_tag(_a)
+            ;
+        }
+
+        qi::rule<Iterator, mini_xml(), qi::locals<std::string>, ascii::space_type> xml;
+        qi::rule<Iterator, mini_xml_node(), ascii::space_type> node;
+        qi::rule<Iterator, std::string(), ascii::space_type> text;
+        qi::rule<Iterator, std::string(), ascii::space_type> start_tag;
+        qi::rule<Iterator, void(std::string), ascii::space_type> end_tag;
+    };
+    //]
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    std::string storage; // We will read the contents here.
+    in.unsetf(std::ios::skipws); // No white space skipping!
+    std::copy(
+        std::istream_iterator<char>(in),
+        std::istream_iterator<char>(),
+        std::back_inserter(storage));
+
+    typedef client::mini_xml_grammar<std::string::const_iterator> mini_xml_grammar;
+    mini_xml_grammar xml; // Our grammar
+    client::mini_xml ast; // Our tree
+
+    using boost::spirit::ascii::space;
+    std::string::const_iterator iter = storage.begin();
+    std::string::const_iterator end = storage.end();
+    bool r = phrase_parse(iter, end, xml, space, ast);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+        client::mini_xml_printer printer;
+        printer(ast);
+        return 0;
+    }
+    else
+    {
+        std::string::const_iterator some = iter + std::min(30, int(end - iter));
+        std::string context(iter, (some>end)?end:some);
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \"" << context << "...\"\n";
+        std::cout << "-------------------------\n";
+        return 1;
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/mini_xml3.cpp b/src/boost/libs/spirit/example/qi/mini_xml3.cpp
new file mode 100644
index 00000000..d8926c1a
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/mini_xml3.cpp
@@ -0,0 +1,258 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A mini XML-like parser
+//
+//  [ JDG March 25, 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_fusion.hpp>
+#include <boost/spirit/include/phoenix_stl.hpp>
+#include <boost/spirit/include/phoenix_object.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/foreach.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    namespace fusion = boost::fusion;
+    namespace phoenix = boost::phoenix;
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our mini XML tree representation
+    ///////////////////////////////////////////////////////////////////////////
+    struct mini_xml;
+
+    typedef
+        boost::variant<
+            boost::recursive_wrapper<mini_xml>
+          , std::string
+        >
+    mini_xml_node;
+
+    struct mini_xml
+    {
+        std::string name;                           // tag name
+        std::vector<mini_xml_node> children;        // children
+    };
+}
+
+// We need to tell fusion about our mini_xml struct
+// to make it a first-class fusion citizen
+BOOST_FUSION_ADAPT_STRUCT(
+    client::mini_xml,
+    (std::string, name)
+    (std::vector<client::mini_xml_node>, children)
+)
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Print out the mini xml tree
+    ///////////////////////////////////////////////////////////////////////////
+    int const tabsize = 4;
+
+    void tab(int indent)
+    {
+        for (int i = 0; i < indent; ++i)
+            std::cout << ' ';
+    }
+
+    struct mini_xml_printer
+    {
+        mini_xml_printer(int indent = 0)
+          : indent(indent)
+        {
+        }
+
+        void operator()(mini_xml const& xml) const;
+
+        int indent;
+    };
+
+    struct mini_xml_node_printer : boost::static_visitor<>
+    {
+        mini_xml_node_printer(int indent = 0)
+          : indent(indent)
+        {
+        }
+
+        void operator()(mini_xml const& xml) const
+        {
+            mini_xml_printer(indent+tabsize)(xml);
+        }
+
+        void operator()(std::string const& text) const
+        {
+            tab(indent+tabsize);
+            std::cout << "text: \"" << text << '"' << std::endl;
+        }
+
+        int indent;
+    };
+
+    void mini_xml_printer::operator()(mini_xml const& xml) const
+    {
+        tab(indent);
+        std::cout << "tag: " << xml.name << std::endl;
+        tab(indent);
+        std::cout << '{' << std::endl;
+
+        BOOST_FOREACH(mini_xml_node const& node, xml.children)
+        {
+            boost::apply_visitor(mini_xml_node_printer(indent), node);
+        }
+
+        tab(indent);
+        std::cout << '}' << std::endl;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our mini XML grammar definition
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_xml3_grammar
+    template <typename Iterator>
+    struct mini_xml_grammar
+      : qi::grammar<Iterator, mini_xml(), qi::locals<std::string>, ascii::space_type>
+    {
+        mini_xml_grammar()
+          : mini_xml_grammar::base_type(xml, "xml")
+        {
+            using qi::lit;
+            using qi::lexeme;
+            using qi::on_error;
+            using qi::fail;
+            using ascii::char_;
+            using ascii::string;
+            using namespace qi::labels;
+
+            using phoenix::construct;
+            using phoenix::val;
+
+            text %= lexeme[+(char_ - '<')];
+            node %= xml | text;
+
+            start_tag %=
+                    '<'
+                >>  !lit('/')
+                >   lexeme[+(char_ - '>')]
+                >   '>'
+            ;
+
+            end_tag =
+                    "</"
+                >   lit(_r1)
+                >   '>'
+            ;
+
+            xml %=
+                    start_tag[_a = _1]
+                >   *node
+                >   end_tag(_a)
+            ;
+
+            xml.name("xml");
+            node.name("node");
+            text.name("text");
+            start_tag.name("start_tag");
+            end_tag.name("end_tag");
+
+            on_error<fail>
+            (
+                xml
+              , std::cout
+                    << val("Error! Expecting ")
+                    << _4                               // what failed?
+                    << val(" here: \"")
+                    << construct<std::string>(_3, _2)   // iterators to error-pos, end
+                    << val("\"")
+                    << std::endl
+            );
+        }
+
+        qi::rule<Iterator, mini_xml(), qi::locals<std::string>, ascii::space_type> xml;
+        qi::rule<Iterator, mini_xml_node(), ascii::space_type> node;
+        qi::rule<Iterator, std::string(), ascii::space_type> text;
+        qi::rule<Iterator, std::string(), ascii::space_type> start_tag;
+        qi::rule<Iterator, void(std::string), ascii::space_type> end_tag;
+    };
+    //]
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    std::string storage; // We will read the contents here.
+    in.unsetf(std::ios::skipws); // No white space skipping!
+    std::copy(
+        std::istream_iterator<char>(in),
+        std::istream_iterator<char>(),
+        std::back_inserter(storage));
+
+    typedef client::mini_xml_grammar<std::string::const_iterator> mini_xml_grammar;
+    mini_xml_grammar xml; // Our grammar
+    client::mini_xml ast; // Our tree
+
+    using boost::spirit::ascii::space;
+    std::string::const_iterator iter = storage.begin();
+    std::string::const_iterator end = storage.end();
+    bool r = phrase_parse(iter, end, xml, space, ast);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+        client::mini_xml_printer printer;
+        printer(ast);
+        return 0;
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------\n";
+        return 1;
+    }
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/mini_xml_samples/1.toyxml b/src/boost/libs/spirit/example/qi/mini_xml_samples/1.toyxml
new file mode 100644
index 00000000..54181ed4
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/mini_xml_samples/1.toyxml
@@ -0,0 +1 @@
+<foo></foo>
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/qi/mini_xml_samples/2.toyxml b/src/boost/libs/spirit/example/qi/mini_xml_samples/2.toyxml
new file mode 100644
index 00000000..266e4b1f
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/mini_xml_samples/2.toyxml
@@ -0,0 +1 @@
+<foo><bar></bar></foo>
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/qi/mini_xml_samples/3.toyxml b/src/boost/libs/spirit/example/qi/mini_xml_samples/3.toyxml
new file mode 100644
index 00000000..9d89cf7b
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/mini_xml_samples/3.toyxml
@@ -0,0 +1,5 @@
+<foo>
+    <bar>bar 1</bar>
+    <bar>bar 2</bar>
+    <bar>bar 3</bar>
+</foo>
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/qi/mini_xml_samples/4.toyxml b/src/boost/libs/spirit/example/qi/mini_xml_samples/4.toyxml
new file mode 100644
index 00000000..0f220f1e
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/mini_xml_samples/4.toyxml
@@ -0,0 +1 @@
+<foo><bar></foo></bar>
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/qi/nabialek.cpp b/src/boost/libs/spirit/example/qi/nabialek.cpp
new file mode 100644
index 00000000..4795578c
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/nabialek.cpp
@@ -0,0 +1,98 @@
+/*=============================================================================
+    Copyright (c) 2003 Sam Nabialek
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  The Nabialek trick.
+//
+//  [ Sam Nabialek; Somewhere, sometime in 2003... ]    spirit1
+//  [ JDG November 17, 2009 ]                           spirit2
+//  [ JDG January 10, 2010 ]                            Updated to use rule pointers
+//                                                      for efficiency.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <iostream>
+#include <string>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our nabialek_trick grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    struct nabialek_trick : qi::grammar<
+        Iterator, ascii::space_type, qi::locals<qi::rule<Iterator, ascii::space_type>*> >
+    {
+        nabialek_trick() : nabialek_trick::base_type(start)
+        {
+            using ascii::alnum;
+            using qi::lexeme;
+            using qi::lazy;
+            using qi::_a;
+            using qi::_1;
+
+            id = lexeme[*(ascii::alnum | '_')];
+            one = id;
+            two = id >> ',' >> id;
+
+            keyword.add
+                ("one", &one)
+                ("two", &two)
+                ;
+
+            start = *(keyword[_a = _1] >> lazy(*_a));
+        }
+
+        qi::rule<Iterator, ascii::space_type> id, one, two;
+        qi::rule<Iterator, ascii::space_type, qi::locals<qi::rule<Iterator, ascii::space_type>*> > start;
+        qi::symbols<char, qi::rule<Iterator, ascii::space_type>*> keyword;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    using boost::spirit::ascii::space;
+    typedef std::string::const_iterator iterator_type;
+    typedef client::nabialek_trick<iterator_type> nabialek_trick;
+
+    nabialek_trick g; // Our grammar
+
+    std::string str = "one only\none again\ntwo first,second";
+    std::string::const_iterator iter = str.begin();
+    std::string::const_iterator end = str.end();
+    bool r = phrase_parse(iter, end, g, space);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::string rest(iter, end);
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \": " << rest << "\"\n";
+        std::cout << "-------------------------\n";
+    }
+
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/num_list1.cpp b/src/boost/libs/spirit/example/qi/num_list1.cpp
new file mode 100644
index 00000000..dc2e696d
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/num_list1.cpp
@@ -0,0 +1,90 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 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.
+//  No actions.
+//
+//  [ JDG May 10, 2002 ]    spirit1
+//  [ JDG March 24, 2007 ]  spirit2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list parser
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_numlist1
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last)
+    {
+        using qi::double_;
+        using qi::phrase_parse;
+        using ascii::space;
+
+        bool r = phrase_parse(
+            first,                          /*< start iterator >*/
+            last,                           /*< end iterator >*/
+            double_ >> *(',' >> double_),   /*< the parser >*/
+            space                           /*< the skip-parser >*/
+        );
+        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 << "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;
+
+        if (client::parse_numbers(str.begin(), str.end()))
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << str << " Parses OK: " << std::endl;
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/num_list2.cpp b/src/boost/libs/spirit/example/qi/num_list2.cpp
new file mode 100644
index 00000000..9fb854e7
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/num_list2.cpp
@@ -0,0 +1,109 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 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>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+    namespace phoenix = boost::phoenix;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list compiler
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_numlist2
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
+    {
+        using qi::double_;
+        using qi::phrase_parse;
+        using qi::_1;
+        using ascii::space;
+        using phoenix::push_back;
+
+        bool r = phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                double_[push_back(phoenix::ref(v), _1)]
+                    >> *(',' >> double_[push_back(phoenix::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 (client::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;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/num_list3.cpp b/src/boost/libs/spirit/example/qi/num_list3.cpp
new file mode 100644
index 00000000..3ba09ffb
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/num_list3.cpp
@@ -0,0 +1,108 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 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>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+    namespace phoenix = boost::phoenix;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our number list compiler
+    ///////////////////////////////////////////////////////////////////////////////
+    //[tutorial_numlist3
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
+    {
+        using qi::double_;
+        using qi::phrase_parse;
+        using qi::_1;
+        using ascii::space;
+        using phoenix::push_back;
+
+        bool r = phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                double_[push_back(phoenix::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 (client::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;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/num_list4.cpp b/src/boost/libs/spirit/example/qi/num_list4.cpp
new file mode 100644
index 00000000..552dd8d1
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/num_list4.cpp
@@ -0,0 +1,106 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 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>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list compiler
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_numlist4
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
+    {
+        using qi::double_;
+        using qi::phrase_parse;
+        using qi::_1;
+        using ascii::space;
+
+        bool r = phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                double_ % ','
+            )
+            ,
+            //  End grammar
+
+            space, v);
+
+        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 (client::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;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/parse_date.cpp b/src/boost/libs/spirit/example/qi/parse_date.cpp
new file mode 100644
index 00000000..82b5092d
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/parse_date.cpp
@@ -0,0 +1,125 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 Hartmut Kaiser
+    Copyright (c) 2001-2010 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 example is not meant to be a sophisticated date parser. It's sole 
+// purpose is to demonstrate the intrinsic attribute transformation 
+// capabilities of a rule. 
+// 
+// Note how the rule exposes a fusion sequence, but gets passed an instance of
+// a boost::gregorian::date as the attribute. In order to make these types 
+// compatible for the rule we define a specialization of the customization 
+// point called 'transform_attribute'.
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/fusion/include/vector.hpp>
+#include <boost/date_time.hpp>
+
+// define custom transformation
+namespace boost { namespace spirit { namespace traits
+{
+    // This specialization of the customization point transform_attribute 
+    // allows to pass a boost::gregorian::date to a rule which is expecting
+    // a fusion sequence consisting out of three integers as its attribute.
+    template<>
+    struct transform_attribute<
+        boost::gregorian::date, fusion::vector<int, int, int>, qi::domain>
+    {
+        typedef fusion::vector<int, int, int> date_parts;
+
+        // The embedded typedef 'type' exposes the attribute as it will be 
+        // passed to the right hand side of the rule. 
+        typedef date_parts type;
+
+        // The function pre() is called for down-stream conversion of the
+        // attribute supplied to the rule to the attribute expected by the
+        // right hand side.
+        // The supplied attribute might have been pre-initialized by parsers
+        // (i.e. semantic actions) higher up the parser hierarchy (in the 
+        // grammar), in which case we would need to properly initialize the 
+        // returned value from the argument. In this example this is not
+        // required, so we just create a new instance of a date_parts.
+        static date_parts pre(boost::gregorian::date) 
+        { 
+            return date_parts(); 
+        }
+
+        // The function post() is called for up-stream conversion of the 
+        // results returned from parsing the right hand side of the rule.
+        // We need to initialize the attribute supplied to the rule (referenced 
+        // by the first argument) with the values taken from the parsing 
+        // results (referenced by the second argument).
+        static void post(boost::gregorian::date& d, date_parts const& v)
+        {
+            d = boost::gregorian::date(fusion::at_c<0>(v), fusion::at_c<1>(v)
+              , fusion::at_c<2>(v));
+        }
+
+        // The function fail() is called whenever the parsing of the right hand
+        // side of the rule fails. We don't need to do anything here.
+        static void fail(boost::gregorian::date&) {}
+    };
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+
+    template <typename Iterator>
+    bool parse_date(Iterator& first, Iterator last, boost::gregorian::date& d)
+    {
+        typedef boost::fusion::vector<int, int, int> date_parts;
+        qi::rule<Iterator, date_parts(), qi::space_type> date =
+            qi::int_ >> '-' >> qi::int_ >> '-' >> qi::int_;
+
+        return phrase_parse(first, last, date, qi::space, d);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA date parser for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a date of the form : year-month-day\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;
+
+        boost::gregorian::date d;
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = client::parse_date(iter, end, d);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "got: " << d << 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;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/porting_guide_classic.cpp b/src/boost/libs/spirit/example/qi/porting_guide_classic.cpp
new file mode 100644
index 00000000..b12f0f22
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/porting_guide_classic.cpp
@@ -0,0 +1,108 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    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)
+=============================================================================*/
+//[porting_guide_classic_includes
+#include <boost/spirit/include/classic.hpp>
+#include <boost/spirit/include/phoenix1.hpp>
+#include <iostream>
+#include <string>
+//]
+
+//[porting_guide_classic_namespace
+using namespace boost::spirit::classic;
+//]
+
+//[porting_guide_classic_grammar
+struct roman : public grammar<roman>
+{
+    template <typename ScannerT>
+    struct definition
+    {
+        definition(roman const& self)
+        {
+            hundreds.add
+                ("C"  , 100)("CC"  , 200)("CCC"  , 300)("CD" , 400)("D" , 500)
+                ("DC" , 600)("DCC" , 700)("DCCC" , 800)("CM" , 900) ;
+
+            tens.add
+                ("X"  , 10)("XX"  , 20)("XXX"  , 30)("XL" , 40)("L" , 50)
+                ("LX" , 60)("LXX" , 70)("LXXX" , 80)("XC" , 90) ;
+
+            ones.add
+                ("I"  , 1)("II"  , 2)("III"  , 3)("IV" , 4)("V" , 5)
+                ("VI" , 6)("VII" , 7)("VIII" , 8)("IX" , 9) ;
+
+            first = eps_p         [phoenix::var(self.r) = phoenix::val(0)]
+                >>  (  +ch_p('M') [phoenix::var(self.r) += phoenix::val(1000)]
+                    ||  hundreds  [phoenix::var(self.r) += phoenix::_1]
+                    ||  tens      [phoenix::var(self.r) += phoenix::_1]
+                    ||  ones      [phoenix::var(self.r) += phoenix::_1] 
+                    ) ;
+        }
+
+        rule<ScannerT> first;
+        symbols<unsigned> hundreds;
+        symbols<unsigned> tens;
+        symbols<unsigned> ones;
+
+        rule<ScannerT> const& start() const { return first; }
+    };
+
+    roman(unsigned& r_) : r(r_) {}
+    unsigned& r;
+};
+//]
+
+int main()
+{
+    {
+        //[porting_guide_classic_parse
+        std::string input("1,1");
+        parse_info<std::string::iterator> pi = parse(input.begin(), input.end(), int_p);
+
+        if (pi.hit) 
+            std::cout << "successful match!\n";
+
+        if (pi.full) 
+            std::cout << "full match!\n";
+        else
+            std::cout << "stopped at: " << std::string(pi.stop, input.end()) << "\n";
+
+        std::cout << "matched length: " << pi.length << "\n";
+        //]
+    }
+
+    {
+        //[porting_guide_classic_phrase_parse
+        std::string input(" 1, 1");
+        parse_info<std::string::iterator> pi = parse(input.begin(), input.end(), int_p, space_p);
+
+        if (pi.hit) 
+            std::cout << "successful match!\n";
+
+        if (pi.full) 
+            std::cout << "full match!\n";
+        else
+            std::cout << "stopped at: " << std::string(pi.stop, input.end()) << "\n";
+
+        std::cout << "matched length: " << pi.length << "\n";
+        //]
+    }
+
+    {
+        //[porting_guide_classic_use_grammar
+        std::string input("MMIX");        // MMIX == 2009
+        unsigned value = 0;
+        roman r(value);
+        parse_info<std::string::iterator> pi = parse(input.begin(), input.end(), r);
+        if (pi.hit) 
+            std::cout << "successfully matched: " << value << "\n";
+        //]
+    }
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/qi/porting_guide_qi.cpp b/src/boost/libs/spirit/example/qi/porting_guide_qi.cpp
new file mode 100644
index 00000000..d1ec0335
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/porting_guide_qi.cpp
@@ -0,0 +1,106 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    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)
+=============================================================================*/
+//[porting_guide_qi_includes
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <iostream>
+#include <string>
+#include <algorithm>
+//]
+
+//[porting_guide_qi_namespace
+using namespace boost::spirit;
+//]
+
+//[porting_guide_qi_grammar
+template <typename Iterator>
+struct roman : qi::grammar<Iterator, unsigned()>
+{
+    roman() : roman::base_type(first)
+    {
+        hundreds.add
+            ("C"  , 100)("CC"  , 200)("CCC"  , 300)("CD" , 400)("D" , 500)
+            ("DC" , 600)("DCC" , 700)("DCCC" , 800)("CM" , 900) ;
+
+        tens.add
+            ("X"  , 10)("XX"  , 20)("XXX"  , 30)("XL" , 40)("L" , 50)
+            ("LX" , 60)("LXX" , 70)("LXXX" , 80)("XC" , 90) ;
+
+        ones.add
+            ("I"  , 1)("II"  , 2)("III"  , 3)("IV" , 4)("V" , 5)
+            ("VI" , 6)("VII" , 7)("VIII" , 8)("IX" , 9) ;
+
+        // qi::_val refers to the attribute of the rule on the left hand side 
+        first = eps          [qi::_val = 0] 
+            >>  (  +lit('M') [qi::_val += 1000]
+                ||  hundreds [qi::_val += qi::_1]
+                ||  tens     [qi::_val += qi::_1]
+                ||  ones     [qi::_val += qi::_1]
+                ) ;
+    }
+
+    qi::rule<Iterator, unsigned()> first;
+    qi::symbols<char, unsigned> hundreds;
+    qi::symbols<char, unsigned> tens;
+    qi::symbols<char, unsigned> ones;
+};
+//]
+
+int main()
+{
+    {
+        //[porting_guide_qi_parse
+        std::string input("1,1");
+        std::string::iterator it = input.begin();
+        bool result = qi::parse(it, input.end(), qi::int_);
+
+        if (result) 
+            std::cout << "successful match!\n";
+
+        if (it == input.end()) 
+            std::cout << "full match!\n";
+        else
+            std::cout << "stopped at: " << std::string(it, input.end()) << "\n";
+
+        // seldomly needed: use std::distance to calculate the length of the match
+        std::cout << "matched length: " << std::distance(input.begin(), it) << "\n";
+        //]
+    }
+
+    {
+        //[porting_guide_qi_phrase_parse
+        std::string input(" 1, 1");
+        std::string::iterator it = input.begin();
+        bool result = qi::phrase_parse(it, input.end(), qi::int_, ascii::space);
+
+        if (result) 
+            std::cout << "successful match!\n";
+
+        if (it == input.end()) 
+            std::cout << "full match!\n";
+        else
+            std::cout << "stopped at: " << std::string(it, input.end()) << "\n";
+
+        // seldomly needed: use std::distance to calculate the length of the match
+        std::cout << "matched length: " << std::distance(input.begin(), it) << "\n";
+        //]
+    }
+
+    {
+        //[porting_guide_qi_use_grammar
+        std::string input("MMIX");        // MMIX == 2009
+        std::string::iterator it = input.begin();
+        unsigned value = 0;
+        roman<std::string::iterator> r;
+        if (qi::parse(it, input.end(), r, value)) 
+            std::cout << "successfully matched: " << value << "\n";
+        //]
+    }
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/qi/reference.cpp b/src/boost/libs/spirit/example/qi/reference.cpp
new file mode 100644
index 00000000..4cd8a147
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/reference.cpp
@@ -0,0 +1,1481 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    http://spirit.sourceforge.net/
+
+    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 code is not supposed to be executed, so the asserts are for
+// demonstration purposes only
+// boostinspect:naassert_macro
+
+//[reference_includes
+#include <boost/spirit/include/support_utree.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/assert.hpp>
+#include <boost/predef/other/endian.h>
+#include <iostream>
+#include <string>
+#include <cstdlib>
+//]
+
+//[reference_test
+template <typename P>
+void test_parser(
+    char const* input, P const& p, bool full_match = true)
+{
+    using boost::spirit::qi::parse;
+
+    char const* f(input);
+    char const* l(f + strlen(f));
+    if (parse(f, l, p) && (!full_match || (f == l)))
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+
+template <typename P>
+void test_phrase_parser(
+    char const* input, P const& p, bool full_match = true)
+{
+    using boost::spirit::qi::phrase_parse;
+    using boost::spirit::qi::ascii::space;
+
+    char const* f(input);
+    char const* l(f + strlen(f));
+    if (phrase_parse(f, l, p, space) && (!full_match || (f == l)))
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+//]
+
+//[reference_test_attr
+template <typename P, typename T>
+void test_parser_attr(
+    char const* input, P const& p, T& attr, bool full_match = true)
+{
+    using boost::spirit::qi::parse;
+
+    char const* f(input);
+    char const* l(f + strlen(f));
+    if (parse(f, l, p, attr) && (!full_match || (f == l)))
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+
+template <typename P, typename T>
+void test_phrase_parser_attr(
+    char const* input, P const& p, T& attr, bool full_match = true)
+{
+    using boost::spirit::qi::phrase_parse;
+    using boost::spirit::qi::ascii::space;
+
+    char const* f(input);
+    char const* l(f + strlen(f));
+    if (phrase_parse(f, l, p, space, attr) && (!full_match || (f == l)))
+        std::cout << "ok" << std::endl;
+    else
+        std::cout << "fail" << std::endl;
+}
+//]
+
+//[reference_print_info
+struct printer
+{
+    typedef boost::spirit::utf8_string string;
+
+    void element(string const& tag, string const& value, int depth) const
+    {
+        for (int i = 0; i < (depth*4); ++i) // indent to depth
+            std::cout << ' ';
+
+        std::cout << "tag: " << tag;
+        if (value != "")
+            std::cout << ", value: " << value;
+        std::cout << std::endl;
+    }
+};
+
+void print_info(boost::spirit::info const& what)
+{
+    using boost::spirit::basic_info_walker;
+
+    printer pr;
+    basic_info_walker<printer> walker(pr, what.tag, 0);
+    boost::apply_visitor(walker, what.value);
+}
+//]
+
+//[reference_test_real_policy
+///////////////////////////////////////////////////////////////////////////////
+//  These policies can be used to parse thousand separated
+//  numbers with at most 2 decimal digits after the decimal
+//  point. e.g. 123,456,789.01
+///////////////////////////////////////////////////////////////////////////////
+template <typename T>
+struct ts_real_policies : boost::spirit::qi::ureal_policies<T>
+{
+    //  2 decimal places Max
+    template <typename Iterator, typename Attribute>
+    static bool
+    parse_frac_n(Iterator& first, Iterator const& last, Attribute& attr,
+                 int& frac_digits)
+    {
+        Iterator savef = first;
+        bool r = boost::spirit::qi::
+            extract_uint<T, 10, 1, 2, true>::call(first, last, attr);
+        if (r) {
+            // Optimization note: don't compute frac_digits if T is
+            // an unused_type. This should be optimized away by the compiler.
+            if (!boost::is_same<T, boost::spirit::unused_type>::value)
+                frac_digits = static_cast<int>(std::distance(savef, first));
+        }
+        return r;
+    }
+
+    //  No exponent
+    template <typename Iterator>
+    static bool
+    parse_exp(Iterator&, Iterator const&)
+    {
+        return false;
+    }
+
+    //  No exponent
+    template <typename Iterator, typename Attribute>
+    static bool
+    parse_exp_n(Iterator&, Iterator const&, Attribute&)
+    {
+        return false;
+    }
+
+    //  Thousands separated numbers
+    template <typename Iterator, typename Accumulator>
+    static bool
+    parse_n(Iterator& first, Iterator const& last, Accumulator& result)
+    {
+        using boost::spirit::qi::uint_parser;
+        namespace qi = boost::spirit::qi;
+
+        uint_parser<unsigned, 10, 1, 3> uint3;
+        uint_parser<unsigned, 10, 3, 3> uint3_3;
+
+        if (parse(first, last, uint3, result))
+        {
+            Accumulator n;
+            Iterator iter = first;
+
+            while (qi::parse(iter, last, ',') && qi::parse(iter, last, uint3_3, n))
+            {
+                result = result * 1000 + n;
+                first = iter;
+            }
+
+            return true;
+        }
+        return false;
+    }
+};
+//]
+
+//[reference_test_bool_policy
+///////////////////////////////////////////////////////////////////////////////
+//  These policies can be used to parse "eurt" (i.e. "true" spelled backwards)
+//  as `false`
+///////////////////////////////////////////////////////////////////////////////
+struct backwards_bool_policies : boost::spirit::qi::bool_policies<>
+{
+    // we want to interpret a 'true' spelled backwards as 'false'
+    template <typename Iterator, typename Attribute>
+    static bool
+    parse_false(Iterator& first, Iterator const& last, Attribute& attr)
+    {
+        namespace qi = boost::spirit::qi;
+        if (qi::detail::string_parse("eurt", first, last, qi::unused))
+        {
+            namespace traits = boost::spirit::traits;
+            traits::assign_to(false, attr);    // result is false
+            return true;
+        }
+        return false;
+    }
+};
+//]
+
+//[reference_qi_complex
+// a simple complex number representation z = a + bi
+struct complex
+{
+    complex (double a = 0.0, double b = 0.0)
+      : a(a), b(b)
+    {}
+
+    double a;
+    double b;
+};
+//]
+
+//[reference_qi_stream_complex
+// define streaming operator for the type complex
+std::istream&
+operator>> (std::istream& is, complex& z)
+{
+    char lbrace = '\0', comma = '\0', rbrace = '\0';
+    is >> lbrace >> z.a >> comma >> z.b >> rbrace;
+    if (lbrace != '{' || comma != ',' || rbrace != '}')
+        is.setstate(std::ios_base::failbit);
+    return is;
+}
+//]
+
+//[reference_qi_auto_complex
+/*`The following construct is required to allow the `complex` data structure
+   to be utilized as a __fusion__ sequence. This is required as we will
+   emit output for this data structure with a __qi__ sequence:
+   `'{' >> qi::double_ >> ',' >> qi::double_ >> '}'`.
+*/
+BOOST_FUSION_ADAPT_STRUCT(
+    complex,
+    (double, a)
+    (double, b)
+)
+
+/*`We add a specialization for the create_parser customization point
+   defining a custom output format for the complex type. Generally, any
+   specialization for create_parser is expected to return the proto
+   expression to be used to match input for the type the customization
+   point has been specialized for.
+ */
+/*`We need to utilize `proto::deep_copy` as the expression contains literals
+   (the `'{'`, `','`, and `'}'`) which normally get embedded in the proto
+   expression by reference only. The deep copy converts the proto tree to
+   hold this by value. The deep copy operation can be left out for simpler
+   proto expressions (not containing references to temporaries). Alternatively
+   you could use the `proto::make_expr` facility to build the required
+   proto expression.
+*/
+namespace boost { namespace spirit { namespace traits
+{
+    template <>
+    struct create_parser<complex>
+    {
+        typedef proto::result_of::deep_copy<
+            BOOST_TYPEOF('{' >> qi::double_ >> ',' >> qi::double_ >> '}')
+        >::type type;
+
+        static type call()
+        {
+            return proto::deep_copy(
+                '{' >> qi::double_ >> ',' >> qi::double_ >> '}');
+        }
+    };
+}}}
+//]
+
+//[reference_qi_auxiliary_attr_cast_data1
+// this is just a test structure we want to use in place of an int
+struct int_data
+{
+    int i;
+};
+
+
+// we provide a custom attribute transformation to allow its use as an int
+namespace boost { namespace spirit { namespace traits
+{
+    // in this case we just expose the embedded 'int' as the attribute instance
+    // to use, allowing to leave the function 'post()' empty
+    template <>
+    struct transform_attribute<int_data, int, qi::domain>
+    {
+        typedef int& type;
+        static int& pre(int_data& d) { return d.i; }
+        static void post(int_data& val, int const& attr) {}
+        static void fail(int_data&) {}
+    };
+}}}
+//]
+
+namespace client
+{
+    using boost::spirit::qi::grammar;
+    using boost::spirit::qi::rule;
+    using boost::spirit::ascii::space_type;
+
+//[reference_grammar_definition
+/*`Basic grammar usage:
+ */
+    struct num_list : grammar<char const*, space_type>
+    {
+        num_list() : base_type(start)
+        {
+            using boost::spirit::int_;
+            num = int_;
+            start = num >> *(',' >> num);
+        }
+
+        rule<char const*, space_type> start, num;
+    };
+//]
+}
+
+int
+main()
+{
+    {
+        //[reference_using_declarations_lit_char
+        using boost::spirit::qi::lit;
+        using boost::spirit::ascii::char_;
+        //]
+
+        //[reference_char_literals
+        test_parser("x", 'x');                      // plain literal
+        test_parser("x", lit('x'));                 // explicit literal
+        test_parser("x", char_('x'));               // ascii::char_
+        //]
+
+        //[reference_char_range
+        char ch;
+        test_parser_attr("5", char_('0','9'), ch);  // ascii::char_ range
+        std::cout << ch << std::endl;               // prints '5'
+        //]
+
+        //[reference_char_set
+        test_parser_attr("5", char_("0-9"), ch);    // ascii::char_ set
+        std::cout << ch << std::endl;               // prints '5'
+        //]
+
+        //[reference_char_phoenix
+        namespace phx = boost::phoenix;
+        test_parser("x", phx::val('x'));            // direct
+        test_parser("5",
+            char_(phx::val('0'),phx::val('9')));    // ascii::char_ range
+        //]
+    }
+
+    {
+        //[reference_using_declarations_lit_string
+        using boost::spirit::qi::lit;
+        using boost::spirit::ascii::string;
+        //]
+
+        //[reference_string_literals
+        test_parser("boost", "boost");          // plain literal
+        test_parser("boost", lit("boost"));     // explicit literal
+        test_parser("boost", string("boost"));  // ascii::string
+        //]
+    }
+
+    {
+        using boost::spirit::qi::lit;
+        using boost::spirit::ascii::string;
+
+        //[reference_string_std_string
+        std::string s("boost");
+        test_parser("boost", s);            // direct
+        test_parser("boost", lit(s));       // explicit
+        test_parser("boost", string(s));    // ascii::string
+        //]
+    }
+
+    {
+        using boost::spirit::qi::lit;
+        using boost::spirit::ascii::string;
+
+        //[reference_string_phoenix
+        namespace phx = boost::phoenix;
+        test_parser("boost", phx::val("boost"));            // direct
+        test_parser("boost", lit(phx::val("boost")));       // explicit
+        test_parser("boost", string(phx::val("boost")));    // ascii::string
+        //]
+    }
+
+    {
+        //[reference_using_declarations_symbols
+        using boost::spirit::qi::symbols;
+        //]
+
+        //[reference_symbols_with_data
+        symbols<char, int> sym;
+
+        sym.add
+            ("Apple", 1)
+            ("Banana", 2)
+            ("Orange", 3)
+        ;
+
+        int i;
+        test_parser_attr("Banana", sym, i);
+        std::cout << i << std::endl;
+        //]
+    }
+
+    {
+        //[reference_using_declarations_lexeme
+        using boost::spirit::qi::lexeme;
+        using boost::spirit::qi::lit;
+        using boost::spirit::ascii::digit;
+        //]
+
+        //[reference_lexeme
+        /*`The use of lexeme here will prevent skipping in between the
+            digits and the sign making inputs such as `"1 2 345"` erroneous.*/
+        test_phrase_parser("12345", lexeme[ -(lit('+') | '-') >> +digit ]);
+        //]
+    }
+
+    // as
+    {
+        //[reference_using_declarations_as
+        using boost::spirit::utree;
+        using boost::spirit::utree_type;
+        using boost::spirit::utf8_symbol_type;
+        using boost::spirit::qi::as;
+        using boost::spirit::qi::as_string;
+        using boost::spirit::qi::char_;
+        //]
+
+        //[reference_as
+        /*`To properly handle string concatenation with __utree__, we
+           make use of `as_string[]`. We also use `as<T>` to explicitly create
+           a __utree__ symbol node.*/
+        utree ut;
+
+        typedef as<utf8_symbol_type> as_symbol_type;
+        as_symbol_type const as_symbol = as_symbol_type();
+
+        test_parser_attr("foo", as_string[*char_], ut);
+        std::cout << ut << std::endl; // will output >"foo"<
+        BOOST_ASSERT(ut.which() == utree_type::string_type);
+        ut.clear();
+
+        test_parser_attr("foo", as<std::string>()[*char_], ut);
+        std::cout << ut << std::endl; // will output >"foo"<
+        BOOST_ASSERT(ut.which() == utree_type::string_type);
+        ut.clear();
+
+        test_parser_attr("foo", as_symbol[*char_], ut);
+        std::cout << ut << std::endl; // will output >foo<
+        BOOST_ASSERT(ut.which() == utree_type::symbol_type);
+        ut.clear();
+
+        test_parser_attr("foo", as<utf8_symbol_type>()[*char_], ut);
+        std::cout << ut << std::endl; // will output >foo<
+        BOOST_ASSERT(ut.which() == utree_type::symbol_type);
+        //]
+    }
+
+    {
+        //[reference_using_declarations_no_skip
+        using boost::spirit::qi::no_skip;
+        using boost::spirit::qi::char_;
+        //]
+
+        //[reference_no_skip
+        /*`The use of no_skip here will prevent skipping of whitespace in front
+           and in between the characters of the string `'  abc  '`.*/
+
+        std::string str;
+        test_phrase_parser_attr("'  abc  '",
+            '\'' >> no_skip[+~char_('\'')] >> '\'', str);
+        std::cout << str << std::endl;    // will output: >  abc  <
+        //]
+    }
+
+    {
+        //[reference_using_declarations_hold
+        using boost::spirit::qi::hold;
+        using boost::spirit::qi::int_;
+        using boost::spirit::qi::attr;
+        //]
+
+        //[reference_hold
+        /*`The use of `hold[]` here will make sure the changes to the attribute
+           caused by the (failing) first alternative will not be visible after
+           the whole parsing succeeded. */
+
+        std::vector<int> v;
+        test_phrase_parser_attr("123",
+              hold[int_ >> ':' >> int_] | int_ >> attr(0), v);
+        std::cout << v[0] << "," << v[1] << std::endl;    // will output: >123,0<
+        //]
+    }
+
+    {
+        //[reference_using_declarations_no_case
+        using boost::spirit::ascii::no_case;
+        using boost::spirit::ascii::char_;
+        using boost::spirit::ascii::alnum;
+        using boost::spirit::qi::symbols;
+        //]
+
+        //[reference_no_case
+        test_parser("X", no_case[char_('x')]);
+        test_parser("6", no_case[alnum]);
+        //]
+
+        //[reference_symbols_with_no_case
+        symbols<char, int> sym;
+
+        sym.add
+            ("apple", 1)    // symbol strings are added in lowercase...
+            ("banana", 2)
+            ("orange", 3)
+        ;
+
+        int i;
+        // ...because sym is used for case-insensitive parsing
+        test_parser_attr("Apple", no_case[ sym ], i);
+        std::cout << i << std::endl;
+        test_parser_attr("ORANGE", no_case[ sym ], i);
+        std::cout << i << std::endl;
+        //]
+    }
+
+    {
+        //[reference_using_declarations_omit
+        using boost::spirit::qi::omit;
+        using boost::spirit::qi::int_;
+        using boost::spirit::ascii::char_;
+        //]
+
+        //[reference_omit
+        /*`This parser ignores the first two characters
+            and extracts the succeeding `int`:*/
+        int i;
+        test_parser_attr("xx345", omit[char_ >> char_] >> int_, i);
+        std::cout << i << std::endl; // should print 345
+        //]
+    }
+
+    {
+        //[reference_using_declarations_matches
+        using boost::spirit::qi::matches;
+        using boost::spirit::qi::int_;
+        //]
+
+        //[reference_matches
+        /*`This parser tries to match an `int` and returns `true` a its
+           attribute as it succeeded matching: */
+        bool result = false;
+        test_parser_attr("345", matches[int_], result);
+        std::cout << std::boolalpha << result << std::endl; // should print: true
+
+        /*`This parser tries to match an `int` as well and returns `false` as
+           its attribute as it fails matching: */
+        result = true;
+        test_parser_attr("abc", matches[int_], result);
+        std::cout << std::boolalpha << result << std::endl; // should print: false
+        //]
+    }
+
+    {
+        //[reference_using_declarations_raw
+        using boost::spirit::qi::raw;
+        using boost::spirit::ascii::alpha;
+        using boost::spirit::ascii::alnum;
+        //]
+
+        //[reference_raw
+        //`This parser matches and extracts C++ identifiers:
+        std::string id;
+        test_parser_attr("James007", raw[(alpha | '_') >> *(alnum | '_')], id);
+        std::cout << id << std::endl; // should print James007
+        //]
+    }
+
+    {
+        //[reference_using_declarations_repeat
+        using boost::spirit::qi::repeat;
+        using boost::spirit::qi::lit;
+        using boost::spirit::qi::uint_parser;
+        using boost::spirit::qi::_1;
+        using boost::spirit::ascii::char_;
+        namespace phx = boost::phoenix;
+        //]
+
+        //[reference_repeat
+        //`A parser for a file name with a maximum of 255 characters:
+        test_parser("batman.jpeg", repeat(1, 255)[char_("a-zA-Z_./")]);
+
+        /*`A parser for a specific bitmap file format which has exactly 4096 RGB color information.
+            (for the purpose of this example, we will be testing only 3 RGB color information.)
+         */
+        uint_parser<unsigned, 16, 6, 6> rgb;
+        std::vector<unsigned> colors;
+        test_parser_attr("ffffff0000003f3f3f", repeat(3)[rgb], colors);
+        std::cout
+            << std::hex
+            << colors[0] << ','
+            << colors[1] << ','
+            << colors[2] << std::endl;
+
+        /*`A 256 bit binary string (1..256 1s or 0s). (For the purpose of this example,
+            we will be testing only 16 bits.)
+         */
+        test_parser("1011101011110010", repeat(16)[lit('1') | '0']);
+        //]
+
+        std::cout << std::dec; // reset to decimal
+
+        //[reference_repeat_pascal
+        /*`This trivial example cannot be practically defined in traditional EBNF.
+            Although some EBNF variants allow more powerful repetition constructs other
+            than the Kleene Star, we are still limited to parsing fixed strings.
+            The nature of EBNF forces the repetition factor to be a constant.
+            On the other hand, Spirit allows the repetition factor to be variable at
+            run time. We could write a grammar that accepts the input string above.
+            Example using phoenix:
+         */
+        std::string str;
+        int n;
+        test_parser_attr("\x0bHello World",
+            char_[phx::ref(n) = _1] >> repeat(phx::ref(n))[char_], str);
+        std::cout << n << ',' << str << std::endl;  // will print "11,Hello World"
+        //]
+    }
+
+    {
+        //[reference_using_declarations_skip
+        using boost::spirit::qi::skip;
+        using boost::spirit::qi::int_;
+        using boost::spirit::ascii::space;
+        //]
+
+        //[reference_skip
+        /*`Explicitly specify a skip parser. This parser parses comma
+            delimited numbers, ignoring spaces.*/
+        test_parser("1, 2, 3, 4, 5", skip(space)[int_ >> *(',' >> int_)]);
+        //]
+    }
+
+    // attr()
+    {
+        //[reference_using_declarations_attr
+        namespace phx = boost::phoenix;
+        using boost::spirit::qi::attr;
+        //]
+
+        //[reference_attr
+        std::string str;
+        test_parser_attr("", attr("boost"), str);
+        std::cout << str << std::endl;            // will print 'boost'
+
+        double d;
+        test_parser_attr("", attr(1.0), d);
+        std::cout << d << std::endl;              // will print '1.0'
+        //]
+
+        //[reference_attr_phoenix
+        d = 0.0;
+        double d1 = 1.2;
+        test_parser_attr("", attr(phx::ref(d1)), d);
+        std::cout << d << std::endl;              // will print '1.2'
+        //]
+    }
+
+    // attr_cast
+    {
+        //[reference_qi_using_declarations_attr_cast
+        using boost::spirit::qi::int_;
+        //]
+
+        //[reference_qi_attr_cast1
+        int_data d = { 0 };
+        test_parser_attr("1", boost::spirit::qi::attr_cast(int_), d);
+        std::cout << d.i << std::endl;
+        //]
+    }
+
+    // eol
+    {
+        //[reference_using_declarations_eol
+        using boost::spirit::qi::eol;
+        //]
+
+        //[reference_eol
+        test_parser("\n", eol);
+        //]
+    }
+
+    // eoi
+    {
+        //[reference_using_declarations_eoi
+        using boost::spirit::qi::eoi;
+        //]
+
+        //[reference_eoi
+        test_parser("", eoi);
+        //]
+    }
+
+    // eps
+    {
+        //[reference_using_declarations_eps
+        using boost::spirit::qi::eps;
+        using boost::spirit::qi::int_;
+        using boost::spirit::qi::_1;
+        namespace phx = boost::phoenix;
+        //]
+
+        //[reference_eps
+        //`Basic `eps`:
+        test_parser("", eps); // always matches
+        //]
+
+        //[reference_eps_if
+        /*`This example simulates the "classic" `if_p` parser. Here, `int_` will be
+            tried only if the condition, `c`, is true.
+         */
+        bool c = true; // a flag
+        test_parser("1234", eps(phx::ref(c) == true) >> int_);
+        //]
+
+        //[reference_eps_while
+        /*`This example simulates the "classic" `while_p` parser. Here, the kleene loop
+            will exit once the condition, `c`, becomes true. Notice that the condition, `c`,
+            is turned to `false` when we get to parse `4`.
+         */
+        test_phrase_parser("1 2 3 4",
+            *(eps(phx::ref(c) == true) >> int_[phx::ref(c) = (_1 == 4)]));
+        //]
+    }
+
+    // lazy
+    {
+        //[reference_using_declarations_lazy
+        using boost::spirit::qi::lazy;
+        using boost::spirit::ascii::string;
+        using boost::phoenix::val;
+        //]
+
+        //[reference_lazy
+        /*` Here, the phoenix::val expression creates a function
+            that returns its argument when invoked. The lazy expression
+            defers the invocation of this function at parse time. Then,
+            this parser (string parser) is called into action. All this
+            takes place at parse time.
+         */
+        test_parser("Hello", lazy(val(string("Hello"))));
+
+        //` The above is equivalent to:
+        test_parser("Hello", string("Hello"));
+        //]
+    }
+
+    // char class
+    {
+        //[reference_using_declarations_char_class
+        using boost::spirit::ascii::alnum;
+        using boost::spirit::ascii::blank;
+        using boost::spirit::ascii::digit;
+        using boost::spirit::ascii::lower;
+        //]
+
+        //[reference_char_class
+        test_parser("1", alnum);
+        test_parser(" ", blank);
+        test_parser("1", digit);
+        test_parser("a", lower);
+        //]
+    }
+
+    // uint
+    {
+        //[reference_using_declarations_uint
+        using boost::phoenix::val;
+        using boost::spirit::qi::lit;
+        using boost::spirit::qi::uint_;
+        using boost::spirit::qi::uint_parser;
+        //]
+
+        //[reference_uint
+        // unsigned int
+        test_parser("12345", uint_);
+        test_parser("12345", uint_(12345));
+        test_parser("12345", uint_(val(12345)));
+
+        // literals
+        test_parser("12345", lit(12345));
+        test_parser("12345", lit(val(12345)));
+        //]
+
+        //[reference_thousand_separated
+        //`Thousand separated number parser:
+        uint_parser<unsigned, 10, 1, 3> uint3_p;        //  1..3 digits
+        uint_parser<unsigned, 10, 3, 3> uint3_3_p;      //  exactly 3 digits
+        test_parser("12,345,678", uint3_p >> *(',' >> uint3_3_p));
+        //]
+    }
+
+    // int
+    {
+        //[reference_using_declarations_int
+        using boost::phoenix::val;
+        using boost::spirit::qi::lit;
+        using boost::spirit::qi::int_;
+        //]
+
+        //[reference_int
+        // signed int
+        test_parser("+12345", int_);
+        test_parser("-12345", int_);
+        test_parser("+12345", int_(12345));
+        test_parser("-12345", int_(-12345));
+        test_parser("+12345", int_(val(12345)));
+        test_parser("-12345", int_(val(-12345)));
+
+        // literals
+        test_parser("+12345", lit(12345));
+        test_parser("-12345", lit(-12345));
+        test_parser("+12345", lit(val(12345)));
+        test_parser("-12345", lit(val(-12345)));
+        //]
+    }
+
+    // real
+    {
+        //[reference_using_declarations_real
+        using boost::phoenix::val;
+        using boost::spirit::qi::double_;
+        using boost::spirit::qi::real_parser;
+        using boost::spirit::qi::lit;
+        //]
+
+        //[reference_real
+        // double
+        test_parser("+12345e6", double_);
+        test_parser("-12345e6", double_);
+        test_parser("+12345e6", double_(12345e6));
+        test_parser("-12345e6", double_(-123456e6));
+        test_parser("+12345e6", double_(val(12345e6)));
+        test_parser("-12345e6", double_(val(-123456e6)));
+
+        // literals
+        test_parser("+12345e6", lit(12345e6));
+        test_parser("-12345e6", lit(-123456e6));
+        test_parser("+12345e6", lit(val(12345e6)));
+        test_parser("-12345e6", lit(val(-123456e6)));
+        //]
+
+        //[reference_custom_real
+        real_parser<double, ts_real_policies<double> > ts_real;
+        test_parser("123,456,789.01", ts_real);
+        test_parser("123,456,789.01", ts_real(123456789.01));
+        //]
+    }
+
+    // bool_
+    {
+        //[reference_using_declarations_bool
+        using boost::phoenix::val;
+        using boost::spirit::qi::bool_;
+        using boost::spirit::qi::bool_parser;
+        using boost::spirit::qi::lit;
+        //]
+
+        //[reference_bool
+        // bool
+        test_parser("true", bool_);
+        test_parser("false", bool_);
+        test_parser("true", bool_(true));
+        test_parser("false", bool_(false));
+        test_parser("true", bool_(val(true)));
+        test_parser("false", bool_(val(false)));
+
+        // literals
+        test_parser("true", lit(true));
+        test_parser("false", lit(false));
+        test_parser("true", lit(val(true)));
+        test_parser("false", lit(val(false)));
+        //]
+
+        //[reference_custom_bool
+        bool_parser<bool, backwards_bool_policies> backwards_bool;
+        test_parser("true", backwards_bool);
+        test_parser("eurt", backwards_bool);
+        test_parser("true", backwards_bool(true));
+        test_parser("eurt", backwards_bool(false));
+        //]
+    }
+
+    // sequence
+    {
+        //[reference_using_declarations_sequence
+        using boost::spirit::ascii::char_;
+        using boost::spirit::qi::_1;
+        using boost::spirit::qi::_2;
+        namespace bf = boost::fusion;
+        //]
+
+        //[reference_sequence
+        //`Simple usage:
+        test_parser("xy", char_ >> char_);
+
+        //`Extracting the attribute tuple (using __fusion__):
+        bf::vector<char, char> attr;
+        test_parser_attr("xy", char_ >> char_, attr);
+        std::cout << bf::at_c<0>(attr) << ',' << bf::at_c<1>(attr) << std::endl;
+
+        //`Extracting the attribute vector (using __stl__):
+        std::vector<char> vec;
+        test_parser_attr("xy", char_ >> char_, vec);
+        std::cout << vec[0] << ',' << vec[1] << std::endl;
+
+        //`Extracting the attributes using __qi_semantic_actions__ (using __phoenix__):
+        test_parser("xy", (char_ >> char_)[std::cout << _1 << ',' << _2 << std::endl]);
+        //]
+    }
+
+    // sequential_or
+    {
+        //[reference_using_declarations_sequential_or
+        using boost::spirit::qi::int_;
+        //]
+
+        //[reference_sequential_or
+        //`Correctly parsing a number with optional fractional digits:
+        test_parser("123.456", int_ || ('.' >> int_));  // full
+        test_parser("123", int_ || ('.' >> int_));      // just the whole number
+        test_parser(".456", int_ || ('.' >> int_));     // just the fraction
+
+        /*`A naive but incorrect solution would try to do this using optionals (e.g.):
+
+                int_ >> -('.' >> int_)  // will not match ".456"
+                -int_ >> ('.' >> int_)  // will not match "123"
+                -int_ >> -('.' >> int_) // will match empty strings! Ooops.
+         */
+        //]
+    }
+
+    // alternative
+    {
+        //[reference_using_declarations_alternative
+        using boost::spirit::ascii::string;
+        using boost::spirit::qi::int_;
+        using boost::spirit::qi::_1;
+        using boost::variant;
+        //]
+
+        //[reference_alternative
+        //`Simple usage:
+        test_parser("Hello", string("Hello") | int_);
+        test_parser("123", string("Hello") | int_);
+
+        //`Extracting the attribute variant (using __boost_variant__):
+        variant<std::string, int> attr;
+        test_parser_attr("Hello", string("Hello") | int_, attr);
+
+        /*`This should print `"Hello"`. Note: There are better ways to extract the value
+            from the variant. See __boost_variant__ visitation. This code is solely
+            for demonstration.
+         */
+        if (boost::get<int>(&attr))
+            std::cout << boost::get<int>(attr) << std::endl;
+        else
+            std::cout << boost::get<std::string>(attr) << std::endl;
+
+        /*`Extracting the attributes using __qi_semantic_actions__ with __phoenix__
+            (this should print `123`):
+         */
+        test_parser("123", (string("Hello") | int_)[std::cout << _1 << std::endl]);
+        //]
+
+    }
+
+    // permutation
+    {
+        //[reference_using_declarations_permutation
+        using boost::spirit::ascii::char_;
+        //]
+
+        //[reference_permutation
+        //`Parse a string containing DNA codes (ACTG)
+        test_parser("ACTGGCTAGACT", *(char_('A') ^ 'C' ^ 'T' ^ 'G'));
+        //]
+    }
+
+    // expect
+    {
+        //[reference_using_declarations_expect
+        using boost::spirit::ascii::char_;
+        using boost::spirit::qi::expectation_failure;
+        //]
+
+        //[reference_expect
+        /*`The code below uses an expectation operator to throw an __qi_expectation_failure__
+            with a deliberate parsing error when `"o"` is expected and `"i"` is what is
+            found in the input. The `catch` block prints the information related to the
+            error. Note: This is low level code that demonstrates the /bare-metal/. Typically,
+            you use an __qi_error_handler__ to deal with the error.
+         */
+        try
+        {
+            test_parser("xi", char_('x') > char_('o')); // should throw an exception
+        }
+        catch (expectation_failure<char const*> const& x)
+        {
+            std::cout << "expected: "; print_info(x.what_);
+            std::cout << "got: \"" << std::string(x.first, x.last) << '"' << std::endl;
+        }
+        /*`The code above will print:[teletype]
+
+                expected: tag: literal-char, value: o
+                got: "i"``[c++]``
+         */
+        //]
+    }
+
+    // expectd
+    {
+        //[reference_using_declarations_expectd
+        using boost::spirit::ascii::char_;
+        using boost::spirit::qi::expect;
+        using boost::spirit::qi::expectation_failure;
+        //]
+
+        //[reference_expectd
+        /*`The code below uses an expectation operator to throw an __qi_expectation_failure__
+            with a deliberate parsing error when `"o"` is expected and `"x"` is what is
+            found in the input. The `catch` block prints the information related to the
+            error. Note: This is low level code that demonstrates the /bare-metal/. Typically,
+            you use an __qi_error_handler__ to deal with the error.
+         */
+        try
+        {
+            test_parser("xi", expect[char_('o')]); // should throw an exception
+        }
+        catch (expectation_failure<char const*> const& x)
+        {
+            std::cout << "expected: "; print_info(x.what_);
+            std::cout << "got: \"" << std::string(x.first, x.last) << '"' << std::endl;
+        }
+        /*`The code above will print:[teletype]
+
+                expected: tag: literal-char, value: o
+                got: "x"``[c++]``
+         */
+        //]
+    }
+	
+    // and-predicate
+    {
+        //[reference_and_predicate
+        //`Some using declarations:
+        using boost::spirit::lit;
+
+        /*`Basic look-ahead example: make sure that the last character is a
+            semicolon, but don't consume it, just peek at the next character:
+         */
+        test_phrase_parser("Hello ;", lit("Hello") >> &lit(';'), false);
+        //]
+    }
+
+    // not-predicate
+    {
+        //[reference_not_predicate
+        //`Some using declarations:
+        using boost::spirit::ascii::char_;
+        using boost::spirit::ascii::alpha;
+        using boost::spirit::qi::lit;
+        using boost::spirit::qi::symbols;
+
+        /*`Here's an alternative to the `*(r - x) >> x` idiom using the
+            not-predicate instead. This parses a list of characters terminated
+            by a ';':
+         */
+        test_parser("abcdef;", *(!lit(';') >> char_) >> ';');
+
+        /*`The following parser ensures that we match distinct keywords
+            (stored in a symbol table). To do this, we make sure that the
+            keyword does not follow an alpha or an underscore:
+         */
+        symbols<char, int> keywords;
+        keywords = "begin", "end", "for";
+
+        // This should fail:
+        test_parser("beginner", keywords >> !(alpha | '_'));
+
+        // This is ok:
+        test_parser("end ", keywords >> !(alpha | '_'), false);
+
+        // This is ok:
+        test_parser("for()", keywords >> !(alpha | '_'), false);
+        //]
+    }
+
+    // difference
+    {
+        //[reference_difference
+        //`Some using declarations:
+        using boost::spirit::ascii::char_;
+
+        /*`Parse a C/C++ style comment:
+         */
+        test_parser("/*A Comment*/", "/*" >> *(char_ - "*/") >> "*/");
+        //]
+    }
+
+    // kleene
+    {
+        //[reference_kleene
+        //`Some using declarations:
+        using boost::spirit::qi::int_;
+
+        /*`Parse a comma separated list of numbers and put them in a vector:
+         */
+        std::vector<int> attr;
+        test_phrase_parser_attr(
+            "111, 222, 333, 444, 555", int_ >> *(',' >> int_), attr);
+        std::cout
+            << attr[0] << ',' << attr[1] << ',' << attr[2] << ','
+            << attr[3] << ',' << attr[4]
+            << std::endl;
+        //]
+    }
+
+    // plus
+    {
+        //[reference_plus
+        //`Some using declarations:
+        using boost::spirit::ascii::alpha;
+        using boost::spirit::qi::lexeme;
+
+        /*`Parse one or more strings containing one or more alphabetic
+            characters and put them in a vector:
+         */
+        std::vector<std::string> attr;
+        test_phrase_parser_attr("yaba daba doo", +lexeme[+alpha], attr);
+        std::cout << attr[0] << ',' << attr[1] << ',' << attr[2] << std::endl;
+        //]
+    }
+
+    // optional
+    {
+        //[reference_optional
+        //`Some using declarations:
+        using boost::spirit::ascii::char_;
+        using boost::spirit::qi::lexeme;
+        using boost::spirit::qi::int_;
+        using boost::fusion::vector;
+        using boost::fusion::at_c;
+        using boost::optional;
+
+        /*`Parse a person info with name (in quotes) optional age [footnote
+            James Bond is shy about his age :-)] and optional sex, all
+            separated by comma.
+         */
+        vector<std::string, optional<int>, optional<char> > attr;
+
+        test_phrase_parser_attr(
+            "\"James Bond\", M"
+          , lexeme['"' >> +(char_ - '"') >> '"']    // name
+                >> -(',' >> int_)                   // optional age
+                >> -(',' >> char_)                  // optional sex
+          , attr);
+
+        // Should print: James Bond,M
+        std::cout << at_c<0>(attr);                 // print name
+        if (at_c<1>(attr))                          // print optional age
+            std::cout << ',' << *at_c<1>(attr);
+        if (at_c<2>(attr))                          // print optional sex
+            std::cout << ',' << *at_c<2>(attr);
+        std::cout << std::endl;
+        //]
+    }
+
+    // list
+    {
+        //[reference_list
+        //`Some using declarations:
+        using boost::spirit::qi::int_;
+
+        /*`Parse a comma separated list of numbers and put them in a vector:
+         */
+        std::vector<int> attr;
+        test_phrase_parser_attr(
+            "111, 222, 333, 444, 555", int_ % ',', attr);
+        std::cout
+            << attr[0] << ',' << attr[1] << ',' << attr[2] << ','
+            << attr[3] << ',' << attr[4]
+            << std::endl;
+        //]
+    }
+
+    // stream
+    {
+        //[reference_qi_stream
+        //`Using declarations and variables:
+        using boost::spirit::qi::stream;
+        using boost::spirit::qi::stream_parser;
+
+        /*`Parse a simple string using the operator>>(istream&, std::string&);
+         */
+        std::string str;
+        test_parser_attr("abc", stream, str);
+        std::cout << str << std::endl;                  // prints: abc
+
+        /*`Parse our complex type using the operator>>(istream&, complex&);
+         */
+        complex c;
+        test_parser_attr("{1.0,2.5}", stream_parser<char, complex>(), c);
+        std::cout << c.a << "," << c.b << std::endl;    // prints: 1.0,2.5
+        //]
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // auto module
+    {
+        //[reference_qi_using_declarations_auto
+        using boost::spirit::qi::auto_;
+        //]
+
+        //[reference_qi_auto
+        /*`Parse a simple integer using the generated parser component `int_`:
+         */
+        int i = 0;
+        test_parser_attr("123", auto_, i);
+        std::cout << i << std::endl;                    // prints: 123
+
+        /*`Parse an instance of the `complex` data type as defined above using
+           the parser as generated by the defined customization point:
+         */
+        complex c;
+        test_parser_attr("{1.2,2.4}", auto_, c);
+        std::cout << c.a << "," << c.b << std::endl;    // prints: 1.2,2.4
+        //]
+    }
+
+    // native binary
+    {
+        //[reference_qi_native_binary
+        //`Using declarations and variables:
+        using boost::spirit::qi::byte_;
+        using boost::spirit::qi::word;
+        using boost::spirit::qi::dword;
+        using boost::spirit::qi::qword;
+
+        boost::uint8_t uc;
+        boost::uint16_t us;
+        boost::uint32_t ui;
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        boost::uint64_t ul;
+//<-
+#endif
+
+#if BOOST_ENDIAN_LITTLE_BYTE
+//->
+        //`Basic usage of the native binary parsers for little endian platforms:
+        test_parser_attr("\x01", byte_, uc); assert(uc == 0x01);
+        test_parser_attr("\x01\x02", word, us); assert(us == 0x0201);
+        test_parser_attr("\x01\x02\x03\x04", dword, ui); assert(ui == 0x04030201);
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        test_parser_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul);
+        assert(ul == 0x0807060504030201LL);
+
+//<-
+#endif
+//->
+        test_parser("\x01", byte_(0x01));
+        test_parser("\x01\x02", word(0x0201));
+        test_parser("\x01\x02\x03\x04", dword(0x04030201));
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        test_parser("\x01\x02\x03\x04\x05\x06\x07\x08",
+            qword(0x0807060504030201LL));
+//<-
+#endif
+#else
+//->
+        //`Basic usage of the native binary parsers for big endian platforms:
+        test_parser_attr("\x01", byte_, uc); assert(uc == 0x01);
+        test_parser_attr("\x01\x02", word, us); assert(us ==  0x0102);
+        test_parser_attr("\x01\x02\x03\x04", dword, ui); assert(ui == 0x01020304);
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        test_parser_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul);
+        assert(0x0102030405060708LL);
+
+//<-
+#endif
+//->
+        test_parser("\x01", byte_(0x01));
+        test_parser("\x01\x02", word(0x0102));
+        test_parser("\x01\x02\x03\x04", dword(0x01020304));
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        test_parser("\x01\x02\x03\x04\x05\x06\x07\x08",
+            qword(0x0102030405060708LL));
+//<-
+#endif
+#endif
+//->
+        //]
+    }
+
+    // little binary
+    {
+        //[reference_qi_little_binary
+        //`Using declarations and variables:
+        using boost::spirit::qi::little_word;
+        using boost::spirit::qi::little_dword;
+        using boost::spirit::qi::little_qword;
+
+        boost::uint16_t us;
+        boost::uint32_t ui;
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        boost::uint64_t ul;
+//<-
+#endif
+
+//->
+        //`Basic usage of the little endian binary parsers:
+        test_parser_attr("\x01\x02", little_word, us); assert(us == 0x0201);
+        test_parser_attr("\x01\x02\x03\x04", little_dword, ui); assert(ui == 0x04030201);
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        test_parser_attr("\x01\x02\x03\x04\x05\x06\x07\x08", little_qword, ul);
+        assert(ul == 0x0807060504030201LL);
+
+//<-
+#endif
+//->
+        test_parser("\x01\x02", little_word(0x0201));
+        test_parser("\x01\x02\x03\x04", little_dword(0x04030201));
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        test_parser("\x01\x02\x03\x04\x05\x06\x07\x08",
+            little_qword(0x0807060504030201LL));
+//<-
+#endif
+//->
+        //]
+    }
+
+    // big binary
+    {
+        //[reference_qi_big_binary
+        //`Using declarations and variables:
+        using boost::spirit::qi::big_word;
+        using boost::spirit::qi::big_dword;
+        using boost::spirit::qi::big_qword;
+
+        boost::uint16_t us;
+        boost::uint32_t ui;
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        boost::uint64_t ul;
+//<-
+#endif
+
+//->
+        //`Basic usage of the big endian binary parsers:
+        test_parser_attr("\x01\x02", big_word, us); assert(us ==  0x0102);
+        test_parser_attr("\x01\x02\x03\x04", big_dword, ui); assert(ui == 0x01020304);
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        test_parser_attr("\x01\x02\x03\x04\x05\x06\x07\x08", big_qword, ul);
+        assert(0x0102030405060708LL);
+
+//<-
+#endif
+//->
+        test_parser("\x01\x02", big_word(0x0102));
+        test_parser("\x01\x02\x03\x04", big_dword(0x01020304));
+//<-
+#ifdef BOOST_HAS_LONG_LONG
+//->
+        test_parser("\x01\x02\x03\x04\x05\x06\x07\x08",
+            big_qword(0x0102030405060708LL));
+//<-
+#endif
+//->
+        //]
+    }
+
+    // rule
+    {
+        //[reference_rule
+        //`Some using declarations:
+        using boost::spirit::qi::rule;
+        using boost::spirit::qi::int_;
+        using boost::spirit::qi::locals;
+        using boost::spirit::qi::_1;
+        using boost::spirit::qi::_a;
+        using boost::spirit::ascii::alpha;
+        using boost::spirit::ascii::char_;
+        using boost::spirit::ascii::space_type;
+
+        /*`Basic rule:
+         */
+        rule<char const*> r;
+        r = int_;
+        test_parser("123", r);
+
+        /*`Rule with synthesized attribute:
+         */
+        rule<char const*, int()> ra;
+        ra = int_;
+        int i;
+        test_parser_attr("123", ra, i);
+        assert(i ==  123);
+
+        /*`Rule with skipper and synthesized attribute:
+         */
+        rule<char const*, std::vector<int>(), space_type> rs;
+        rs = *int_;
+        std::vector<int> v;
+        test_phrase_parser_attr("123 456 789", rs, v);
+        assert(v[0] ==  123);
+        assert(v[1] ==  456);
+        assert(v[2] ==  789);
+
+        /*`Rule with one local variable:
+         */
+        rule<char const*, locals<char> > rl;
+        rl = alpha[_a = _1] >> char_(_a); // get two identical characters
+        test_parser("aa", rl); // pass
+        test_parser("ax", rl); // fail
+        //]
+    }
+
+    // grammar
+    {
+        using client::num_list;
+
+        //[reference_grammar_using
+        //`Some using declarations:
+        using boost::spirit::ascii::space_type;
+        using boost::spirit::int_;
+        using boost::spirit::qi::grammar;
+        using boost::spirit::qi::rule;
+        //]
+
+        //[reference_grammar
+        //`How to use the example grammar:
+        num_list nlist;
+        test_phrase_parser("123, 456, 789", nlist);
+        //]
+    }
+
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/qi/reorder_struct.cpp b/src/boost/libs/spirit/example/qi/reorder_struct.cpp
new file mode 100644
index 00000000..5f5a50b1
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/reorder_struct.cpp
@@ -0,0 +1,130 @@
+//  Copyright (c) 2001-2010 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)
+
+//  The main purpose of this example is to show how a single fusion sequence
+//  can be filled from a parsed input of the elements in different sequences
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/mpl/print.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/fusion/include/struct.hpp>
+#include <boost/fusion/include/nview.hpp>
+#include <boost/foreach.hpp>
+
+namespace fusion = boost::fusion;
+namespace qi = boost::spirit::qi;
+
+///////////////////////////////////////////////////////////////////////////////
+namespace client
+{
+    //  Our employee struct
+    struct employee
+    {
+        std::string surname;
+        std::string forename;
+        int age;
+        double salary;
+        std::string department;
+    };
+
+    // define iterator type
+    typedef std::string::const_iterator iterator_type;
+
+    // This is the output routine taking a format description and the data to
+    // print
+    template <typename Parser, typename Sequence>
+    bool parse(std::string const& input, Parser const& p, Sequence& s)
+    {
+        iterator_type begin = input.begin();
+        return qi::parse(begin, input.end(), p, s);
+    }
+}
+
+// We need to tell fusion about our employee struct to make it a first-class 
+// fusion citizen. This has to be in global scope. Note that we don't need to 
+// list the members of our struct in the same sequence a they are defined
+BOOST_FUSION_ADAPT_STRUCT(
+    client::employee,
+    (int, age)
+    (std::string, surname)
+    (std::string, forename)
+    (std::string, department)
+    (double, salary)
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// that's the different types we need to reorder the attributes
+typedef fusion::result_of::as_nview<client::employee, 2, 0>::type name_and_age;
+typedef fusion::result_of::as_nview<client::employee, 1, 2, 4>::type names_and_salary;
+typedef fusion::result_of::as_nview<client::employee, 2, 0, 3>::type name_age_and_department;
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::string str;
+
+    // some employees
+    client::employee john;
+    client::employee mary;
+    client::employee tom;
+
+    // print data about employees in different formats
+    {
+        // parse forename and age only
+        name_and_age johnview(fusion::as_nview<2, 0>(john));
+        bool r = client::parse(
+            "John, 25",
+            *(qi::char_ - ',') >> ", " >> qi::int_, 
+            johnview);
+        if (r) {
+            std::cout << "Parsed: " << john.forename << ", " << john.age 
+                      << std::endl;
+        }
+
+        // parse surname, forename, and salary
+        names_and_salary maryview(fusion::as_nview<1, 2, 4>(mary));
+        r = client::parse(
+            "Higgins, Mary: 2200.36",
+            *(qi::char_ - ',') >> ", " >> *(qi::char_ - ':') >> ": " >> qi::double_, 
+            maryview);
+        if (r) {
+            std::cout << "Parsed: " << mary.forename << ", " << mary.surname 
+                      << ", " << mary.salary << std::endl;
+        }
+
+        // parse forename, age, and department
+        name_age_and_department tomview(fusion::as_nview<2, 0, 3>(tom));
+        client::parse(
+            "Tom: 48 (Boss)",
+            *(qi::char_ - ':') >> ": " >> qi::int_ >> " (" >> *(qi::char_ - ')') >> ')', 
+            tomview);
+        if (r) {
+            std::cout << "Parsed: " << tom.forename << ", " << tom.age
+                      << ", " << tom.department << std::endl;
+        }
+    }
+
+    // now parse a list of several employees and print them all
+    std::vector<client::employee> employees;
+
+    // parse surname, forename, and salary for all employees
+    {
+        qi::rule<client::iterator_type, names_and_salary()> r =
+            *(qi::char_ - ',') >> ", " >> *(qi::char_ - ',') >> ", " >> qi::double_;
+
+        bool result = client::parse(
+            "John, Smith, 2000.50\n" "Mary, Higgins, 2200.36\n" "Tom, Taylor, 3200.00\n",
+            r % qi::eol, employees);
+
+        std::cout << "Parsed: " << std::endl;
+        BOOST_FOREACH(client::employee const& e, employees) 
+        {
+            std::cout << e.forename << ", " << e.surname << ", " << e.salary 
+                      << std::endl;
+        }
+    }
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/qi/roman.cpp b/src/boost/libs/spirit/example/qi/roman.cpp
new file mode 100644
index 00000000..e98c2a8a
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/roman.cpp
@@ -0,0 +1,188 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Roman Numerals Parser (demonstrating the symbol table). This is
+//  discussed in the "Symbols" chapter in the Spirit User's Guide.
+//
+//  [ JDG August 22, 2002 ] spirit1
+//  [ JDG March 13, 2007 ]  spirit2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Parse roman hundreds (100..900) numerals using the symbol table.
+    //  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_ : qi::symbols<char, unsigned>
+    {
+        hundreds_()
+        {
+            add
+                ("C"    , 100)
+                ("CC"   , 200)
+                ("CCC"  , 300)
+                ("CD"   , 400)
+                ("D"    , 500)
+                ("DC"   , 600)
+                ("DCC"  , 700)
+                ("DCCC" , 800)
+                ("CM"   , 900)
+            ;
+        }
+
+    } hundreds;
+    //]
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Parse roman tens (10..90) numerals using the symbol table.
+    ///////////////////////////////////////////////////////////////////////////////
+    //[tutorial_roman_tens
+    struct tens_ : qi::symbols<char, unsigned>
+    {
+        tens_()
+        {
+            add
+                ("X"    , 10)
+                ("XX"   , 20)
+                ("XXX"  , 30)
+                ("XL"   , 40)
+                ("L"    , 50)
+                ("LX"   , 60)
+                ("LXX"  , 70)
+                ("LXXX" , 80)
+                ("XC"   , 90)
+            ;
+        }
+
+    } tens;
+    //]
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Parse roman ones (1..9) numerals using the symbol table.
+    ///////////////////////////////////////////////////////////////////////////////
+    //[tutorial_roman_ones
+    struct ones_ : qi::symbols<char, unsigned>
+    {
+        ones_()
+        {
+            add
+                ("I"    , 1)
+                ("II"   , 2)
+                ("III"  , 3)
+                ("IV"   , 4)
+                ("V"    , 5)
+                ("VI"   , 6)
+                ("VII"  , 7)
+                ("VIII" , 8)
+                ("IX"   , 9)
+            ;
+        }
+
+    } ones;
+    //]
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  roman (numerals) grammar
+    //
+    //      Note the use of the || operator. The expression
+    //      a || b reads match a or b and in sequence. Try
+    //      defining the roman numerals grammar in YACC or
+    //      PCCTS. Spirit rules! :-)
+    ///////////////////////////////////////////////////////////////////////////////
+    //[tutorial_roman_grammar
+    template <typename Iterator>
+    struct roman : qi::grammar<Iterator, unsigned()>
+    {
+        roman() : roman::base_type(start)
+        {
+            using qi::eps;
+            using qi::lit;
+            using qi::_val;
+            using qi::_1;
+            using ascii::char_;
+
+            start = eps             [_val = 0] >>
+                (
+                    +lit('M')       [_val += 1000]
+                    ||  hundreds    [_val += _1]
+                    ||  tens        [_val += _1]
+                    ||  ones        [_val += _1]
+                )
+            ;
+        }
+
+        qi::rule<Iterator, unsigned()> start;
+    };
+    //]
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tRoman Numerals Parser\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type a Roman Numeral ...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::roman<iterator_type> roman;
+
+    roman roman_parser; // Our grammar
+
+    std::string str;
+    unsigned result;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        //[tutorial_roman_grammar_parse
+        bool r = parse(iter, end, roman_parser, result);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "result = " << result << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \": " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+        //]
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/sum.cpp b/src/boost/libs/spirit/example/qi/sum.cpp
new file mode 100644
index 00000000..33310aa5
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/sum.cpp
@@ -0,0 +1,106 @@
+/*=============================================================================
+    Copyright (c) 2002-2010 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A parser for summing a comma-separated list of numbers using phoenix.
+//
+//  [ JDG June 28, 2002 ]   spirit1
+//  [ JDG March 24, 2007 ]  spirit2
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#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>
+//]
+
+namespace client
+{
+    //[tutorial_adder_using
+    namespace qi = boost::spirit::qi;
+    namespace ascii = boost::spirit::ascii;
+    namespace phoenix = boost::phoenix;
+
+    using qi::double_;
+    using qi::_1;
+    using ascii::space;
+    using phoenix::ref;
+    //]
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our adder
+    ///////////////////////////////////////////////////////////////////////////
+
+    //[tutorial_adder
+    template <typename Iterator>
+    bool adder(Iterator first, Iterator last, double& n)
+    {
+        bool r = qi::phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                double_[ref(n) = _1] >> *(',' >> double_[ref(n) += _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 parser for summing a list of numbers...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a comma separated list of numbers.\n";
+    std::cout << "The numbers are added using Phoenix.\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;
+
+        double n;
+        if (client::adder(str.begin(), str.end(), n))
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << str << " Parses OK: " << std::endl;
+
+            std::cout << "sum = " << n;
+            std::cout << "\n-------------------------\n";
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/typeof.cpp b/src/boost/libs/spirit/example/qi/typeof.cpp
new file mode 100644
index 00000000..90e8fb0e
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/typeof.cpp
@@ -0,0 +1,65 @@
+/*=============================================================================
+    Copyright (c) 2001-2010 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)
+=============================================================================*/
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/qi_copy.hpp>
+#include <boost/spirit/include/support_auto.hpp>
+#include <iostream>
+#include <string>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+
+int
+main()
+{
+    using boost::spirit::ascii::space;
+    using boost::spirit::ascii::char_;
+    using boost::spirit::qi::parse;
+    typedef std::string::const_iterator iterator_type;
+
+///////////////////////////////////////////////////////////////////////////////
+// this works for non-c++11 compilers
+#ifdef BOOST_NO_CXX11_AUTO_DECLARATIONS
+
+    BOOST_SPIRIT_AUTO(qi, comment, "/*" >> *(char_ - "*/") >> "*/");
+
+///////////////////////////////////////////////////////////////////////////////
+// but this is better for c++11 compilers with auto
+#else
+
+    using boost::spirit::qi::copy;
+
+    auto comment = copy("/*" >> *(char_ - "*/") >> "*/");
+
+#endif
+
+    std::string str = "/*This is a comment*/";
+    std::string::const_iterator iter = str.begin();
+    std::string::const_iterator end = str.end();
+    bool r = parse(iter, end, comment);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::string rest(iter, end);
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \": " << rest << "\"\n";
+        std::cout << "-------------------------\n";
+    }
+
+    return 0;
+}
+
+
diff --git a/src/boost/libs/spirit/example/qi/unescaped_string.cpp b/src/boost/libs/spirit/example/qi/unescaped_string.cpp
new file mode 100644
index 00000000..4a0d6002
--- /dev/null
+++ b/src/boost/libs/spirit/example/qi/unescaped_string.cpp
@@ -0,0 +1,72 @@
+//  Copyright (c) 2010 Jeroen Habraken
+// 
+//  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)
+
+#include <boost/spirit/include/qi.hpp>
+
+#include <iostream>
+#include <ostream>
+#include <string>
+
+namespace client
+{
+    namespace qi = boost::spirit::qi;
+
+    template <typename InputIterator>
+    struct unescaped_string
+        : qi::grammar<InputIterator, std::string(char const*)>
+    {
+        unescaped_string()
+            : unescaped_string::base_type(unesc_str)
+        {
+            unesc_char.add("\\a", '\a')("\\b", '\b')("\\f", '\f')("\\n", '\n')
+                          ("\\r", '\r')("\\t", '\t')("\\v", '\v')("\\\\", '\\')
+                          ("\\\'", '\'')("\\\"", '\"')
+                ;
+
+            unesc_str = qi::lit(qi::_r1)
+                    >> *(unesc_char | qi::alnum | "\\x" >> qi::hex)
+                    >>  qi::lit(qi::_r1)
+                ;
+        }
+
+        qi::rule<InputIterator, std::string(char const*)> unesc_str;
+        qi::symbols<char const, char const> unesc_char;
+    };
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    namespace qi = boost::spirit::qi;
+    
+    typedef std::string::const_iterator iterator_type;
+
+    std::string parsed;
+
+    std::string str("'''string\\x20to\\x20unescape\\x3a\\x20\\n\\r\\t\\\"\\'\\x41'''");
+    char const* quote = "'''";
+
+    iterator_type iter = str.begin();
+    iterator_type end = str.end();
+
+    client::unescaped_string<iterator_type> p;
+    if (!qi::parse(iter, end, p(quote), parsed))
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------\n";
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsed: " << parsed << "\n";
+        std::cout << "-------------------------\n";
+    }
+ 
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/support/Jamfile b/src/boost/libs/spirit/example/support/Jamfile
new file mode 100644
index 00000000..273e341b
--- /dev/null
+++ b/src/boost/libs/spirit/example/support/Jamfile
@@ -0,0 +1,16 @@
+#==============================================================================
+#   Copyright (c) 2001-2011 Joel de Guzman
+#   Copyright (c) 2001-2011 Hartmut Kaiser
+#   Copyright (C) 2011      Bryce Lelbach
+#
+#   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)
+#==============================================================================
+project spirit-support-example
+    : requirements <toolset>gcc:<c++-template-depth>300
+    :
+    :
+    ;
+
+exe multi_pass : multi_pass.cpp ;
+exe parse_sexpr : utree/parse_sexpr.cpp ;
diff --git a/src/boost/libs/spirit/example/support/multi_pass.cpp b/src/boost/libs/spirit/example/support/multi_pass.cpp
new file mode 100644
index 00000000..27e529c7
--- /dev/null
+++ b/src/boost/libs/spirit/example/support/multi_pass.cpp
@@ -0,0 +1,50 @@
+//  Copyright (c) 2001-2010 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)
+
+#include <iostream>
+#include <fstream>
+#include <vector>
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/support_multi_pass.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+//[tutorial_multi_pass
+int main()
+{
+    namespace spirit = boost::spirit;
+    using spirit::ascii::space;
+    using spirit::ascii::char_;
+    using spirit::qi::double_;
+    using spirit::qi::eol;
+
+    std::ifstream in("multi_pass.txt");    // we get our input from this file
+    if (!in.is_open()) {
+        std::cout << "Could not open input file: 'multi_pass.txt'" << std::endl;
+        return -1;
+    }
+
+    typedef std::istreambuf_iterator<char> base_iterator_type;
+    spirit::multi_pass<base_iterator_type> first = 
+        spirit::make_default_multi_pass(base_iterator_type(in));
+
+    std::vector<double> v;
+    bool result = spirit::qi::phrase_parse(first
+      , spirit::make_default_multi_pass(base_iterator_type())
+      , double_ >> *(',' >> double_)              // recognize list of doubles
+      , space | '#' >> *(char_ - eol) >> eol      // comment skipper
+      , v);                                       // data read from file
+
+    if (!result) {
+        std::cout << "Failed parsing input file!" << std::endl;
+        return -2;
+    }
+
+    std::cout << "Successfully parsed input file!" << std::endl;
+    return 0;
+}
+//]
diff --git a/src/boost/libs/spirit/example/support/multi_pass.txt b/src/boost/libs/spirit/example/support/multi_pass.txt
new file mode 100644
index 00000000..54368f38
--- /dev/null
+++ b/src/boost/libs/spirit/example/support/multi_pass.txt
@@ -0,0 +1,6 @@
+#  Copyright (c) 2001-2009 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)
+
+1.0,2.0,3.0
diff --git a/src/boost/libs/spirit/example/support/utree/error_handler.hpp b/src/boost/libs/spirit/example/support/utree/error_handler.hpp
new file mode 100644
index 00000000..6f5ba1bc
--- /dev/null
+++ b/src/boost/libs/spirit/example/support/utree/error_handler.hpp
@@ -0,0 +1,112 @@
+/*==============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2010-2011 Bryce Lelbach
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#if !defined(BOOST_SPIRIT_UTREE_EXAMPLE_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_UTREE_EXAMPLE_ERROR_HANDLER_HPP
+
+#include <string>
+#include <sstream>
+
+#include <boost/config.hpp>
+#include <boost/spirit/home/support/info.hpp>
+#include <boost/spirit/include/support_line_pos_iterator.hpp>
+
+namespace sexpr
+{
+
+using boost::spirit::info;
+ 
+template <typename Out>
+struct print_info
+{
+    typedef boost::spirit::utf8_string string;
+
+    print_info(Out& out) : out(out), first(true) {}
+
+    void element(string const& tag, string const& value, int) const
+    {
+        if (!first) {
+            out << ' ';
+            first = false;
+        }        
+
+        if (value == "")
+            out << tag;
+        else
+            out << "\"" << value << '"';
+    }
+
+    Out& out;
+    mutable bool first;
+};
+
+struct expected_component : std::exception
+{
+    std::string msg;
+
+    expected_component(std::string const& source, std::size_t line
+                     , info const& w)
+    {
+        using boost::spirit::basic_info_walker;
+
+        std::ostringstream oss;
+        oss << "(exception \"" << source << "\" ";
+      
+        if (line == -1)
+          oss << -1;
+        else
+          oss << line;
+
+        oss << " '(expected_component (";
+
+        print_info<std::ostringstream> pr(oss);
+        basic_info_walker<print_info<std::ostringstream> >
+        walker(pr, w.tag, 0);
+
+        boost::apply_visitor(walker, w.value);
+
+        oss << ")))";
+
+        msg = oss.str();
+    }
+
+    virtual ~expected_component() BOOST_NOEXCEPT_OR_NOTHROW {}
+
+    virtual char const* what() const BOOST_NOEXCEPT_OR_NOTHROW
+    {
+        return msg.c_str();
+    }
+};
+
+template <typename Iterator>
+struct error_handler
+{
+    template <typename, typename, typename, typename>
+    struct result
+    {
+        typedef void type;
+    };
+
+    std::string source;
+
+    error_handler(std::string const& source_ = "<string>") : source(source_) {}
+
+    void operator()(Iterator first, Iterator last, Iterator err_pos
+                  , info const& what) const
+    {
+        using boost::spirit::get_line;
+        Iterator eol = err_pos;
+        std::size_t line = get_line(err_pos);
+        throw expected_component(source, line, what);
+    }
+};
+
+} // sexpr
+
+#endif // BOOST_SPIRIT_UTREE_EXAMPLE_ERROR_HANDLER_HPP
+
diff --git a/src/boost/libs/spirit/example/support/utree/parse_sexpr.cpp b/src/boost/libs/spirit/example/support/utree/parse_sexpr.cpp
new file mode 100644
index 00000000..72d49ea5
--- /dev/null
+++ b/src/boost/libs/spirit/example/support/utree/parse_sexpr.cpp
@@ -0,0 +1,62 @@
+/*==============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2001-2011 Joel de Guzman 
+    Copyright (c) 2010-2011 Bryce Lelbach
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/spirit/include/support_istream_iterator.hpp>
+#include <boost/spirit/include/support_line_pos_iterator.hpp>
+#include <boost/spirit/include/qi_parse.hpp>
+
+#include "sexpr_parser.hpp"
+
+int
+main()
+{
+    using boost::spirit::qi::phrase_parse;
+
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "sexpr parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression... or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef sexpr::parser<iterator_type> parser;
+    typedef sexpr::whitespace<iterator_type> space;
+
+    parser p; 
+    space ws;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        std::string::const_iterator iter = str.begin();
+        std::string::const_iterator end = str.end();
+        bool r = phrase_parse(iter, end, p, ws);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \": " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
+
diff --git a/src/boost/libs/spirit/example/support/utree/sexpr_generator.hpp b/src/boost/libs/spirit/example/support/utree/sexpr_generator.hpp
new file mode 100644
index 00000000..5dc56223
--- /dev/null
+++ b/src/boost/libs/spirit/example/support/utree/sexpr_generator.hpp
@@ -0,0 +1,128 @@
+/*==============================================================================
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    Copyright (c) 2010-2011 Bryce Lelbach
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#if !defined(BOOST_SPIRIT_UTREE_EXAMPLE_SEXPR_GENERATOR_HPP)
+#define BOOST_SPIRIT_UTREE_EXAMPLE_SEXPR_GENERATOR_HPP
+
+#include <boost/spirit/include/support_utree.hpp>
+#include <boost/spirit/include/karma.hpp>
+
+namespace boost {
+namespace spirit {
+namespace traits { 
+
+template<>
+struct transform_attribute<utree::nil_type, unused_type, karma::domain> {
+  typedef unused_type type;
+
+  static unused_type pre (utree::nil_type&) { return unused_type(); }
+};
+
+} // traits
+} // spirit
+} // boost
+
+namespace sexpr
+{
+
+namespace karma = boost::spirit::karma;
+namespace standard = boost::spirit::standard;
+
+using boost::spirit::utree;
+using boost::spirit::utf8_symbol_range_type;
+using boost::spirit::utf8_string_range_type;
+using boost::spirit::binary_range_type;
+
+struct bool_output_policies : karma::bool_policies<>
+{
+    template <typename CharEncoding, typename Tag, typename Iterator>
+    static bool generate_true(Iterator& sink, bool)
+    {
+        return string_inserter<CharEncoding, Tag>::call(sink, "#t");
+    }
+
+    template <typename CharEncoding, typename Tag, typename Iterator>
+    static bool generate_false(Iterator& sink, bool)
+    {
+        return string_inserter<CharEncoding, Tag>::call(sink, "#f");
+    }
+};
+
+template <typename Iterator>
+struct generator : karma::grammar<Iterator, utree()>
+{
+    typedef boost::iterator_range<utree::const_iterator> utree_list;
+
+    karma::rule<Iterator, utree()>
+        start, ref_;
+
+    karma::rule<Iterator, utree_list()>
+        list;
+
+    karma::rule<Iterator, utf8_symbol_range_type()>
+        symbol;
+
+    karma::rule<Iterator, utree::nil_type()>
+        nil_;
+
+    karma::rule<Iterator, utf8_string_range_type()>
+        utf8;
+
+    karma::rule<Iterator, binary_range_type()>
+        binary;
+
+    generator() : generator::base_type(start)
+    {
+        using standard::char_;
+        using standard::string;
+        using karma::bool_generator;
+        using karma::uint_generator;
+        using karma::double_;
+        using karma::int_;
+        using karma::lit;
+        using karma::right_align;
+
+        uint_generator<unsigned char, 16> hex2;
+        bool_generator<bool, bool_output_policies> boolean;
+
+        start = nil_
+              | double_
+              | int_
+              | boolean
+              | utf8
+              | symbol
+              | binary
+              | list
+              | ref_;
+  
+        ref_ = start;
+
+        list = '(' << -(start % ' ') << ')';
+
+        utf8 = '"' << *(&char_('"') << "\\\"" | char_) << '"';
+
+        symbol = string;
+
+        binary = '#' << *right_align(2, '0')[hex2] << '#';
+
+        nil_ = karma::attr_cast(lit("nil"));
+
+        start.name("sexpr");
+        ref_.name("ref");
+        list.name("list");
+        utf8.name("string");
+        symbol.name("symbol");
+        binary.name("binary");
+        nil_.name("nil");
+    }
+};
+
+} // sexpr
+
+#endif // BOOST_SPIRIT_UTREE_EXAMPLE_SEXPR_GENERATOR_HPP
+
diff --git a/src/boost/libs/spirit/example/support/utree/sexpr_parser.hpp b/src/boost/libs/spirit/example/support/utree/sexpr_parser.hpp
new file mode 100644
index 00000000..15dfdfbd
--- /dev/null
+++ b/src/boost/libs/spirit/example/support/utree/sexpr_parser.hpp
@@ -0,0 +1,250 @@
+/*==============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2010-2011 Bryce Lelbach
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#if !defined(BOOST_SPIRIT_UTREE_EXAMPLE_SEXPR_PARSER_HPP)
+#define BOOST_SPIRIT_UTREE_EXAMPLE_SEXPR_PARSER_HPP
+
+#include "utf8_parser.hpp"
+#include "error_handler.hpp"
+
+namespace boost {
+namespace spirit {
+namespace traits { 
+
+template<>
+struct transform_attribute<utree::nil_type, unused_type, qi::domain> {
+  typedef unused_type type;
+
+  static unused_type pre (utree::nil_type&) { return unused_type(); }
+  static void post (utree::nil_type&, unused_type) { }
+  static void fail (utree::nil_type&) { }
+};
+
+} // traits
+} // spirit
+} // boost
+
+namespace sexpr
+{
+
+namespace qi = boost::spirit::qi;
+namespace px = boost::phoenix;
+namespace standard = boost::spirit::standard;
+
+using boost::spirit::utree;
+using boost::spirit::utf8_symbol_type;
+using boost::spirit::utf8_string_type;
+using boost::spirit::binary_string_type;
+
+struct bool_input_policies
+{
+    template <typename Iterator, typename Attribute>
+    static bool
+    parse_true(Iterator& first, Iterator const& last, Attribute& attr)
+    {
+        using boost::spirit::qi::detail::string_parse;
+        using boost::spirit::qi::bool_policies;
+        using boost::spirit::qi::unused;
+        using boost::spirit::traits::assign_to;
+        if (string_parse("#t", first, last, unused))
+        {
+            assign_to(true, attr);    // result is true
+            return true;
+        }
+        return bool_policies<bool>::parse_true(first, last, attr);
+    }
+
+    template <typename Iterator, typename Attribute>
+    static bool
+    parse_false(Iterator& first, Iterator const& last, Attribute& attr)
+    {
+        using boost::spirit::qi::detail::string_parse;
+        using boost::spirit::qi::bool_policies;
+        using boost::spirit::qi::unused;
+        using boost::spirit::traits::assign_to;
+        if (string_parse("#f", first, last, unused))
+        {
+            assign_to(false, attr);   // result is false
+            return true;
+        }
+        return bool_policies<bool>::parse_false(first, last, attr);
+    }
+};
+
+struct save_line_pos
+{
+    template <typename, typename>
+    struct result
+    {
+        typedef void type;
+    };
+
+    template <typename Range>
+    void operator()(utree& ast, Range const& rng) const
+    {
+        using boost::spirit::get_line;
+        std::size_t n = get_line(rng.begin());
+        if (n != -1)
+        {
+            BOOST_ASSERT(n <= (std::numeric_limits<short>::max)());
+            ast.tag(n);
+        }
+        else
+            ast.tag(-1);
+    }
+};
+
+template <typename Iterator, typename F>
+struct tagger : qi::grammar<Iterator, void(utree&, char)>
+{
+    qi::rule<Iterator, void(utree&, char)>
+        start;
+  
+    qi::rule<Iterator, void(utree&)>
+        epsilon;
+
+    px::function<F>
+        f;
+
+    tagger(F f_ = F()) : tagger::base_type(start), f(f_)
+    {
+        using qi::omit;
+        using qi::raw;
+        using qi::eps;
+        using qi::lit;
+        using qi::_1;
+        using qi::_r1;
+        using qi::_r2;
+
+        start   = omit[raw[lit(_r2)] [f(_r1, _1)]];
+
+        epsilon = omit[raw[eps]      [f(_r1, _1)]];
+    }
+};
+
+template <typename Iterator>
+struct whitespace : qi::grammar<Iterator> {
+    qi::rule<Iterator>
+        start;
+
+    whitespace() : whitespace::base_type(start)
+    {
+        using standard::space;
+        using standard::char_;
+        using qi::eol;
+
+        start = space | (';' >> *(char_ - eol) >> eol);
+    }
+};
+
+} // sexpr
+
+//[utree_sexpr_parser
+namespace sexpr
+{
+
+template <typename Iterator, typename ErrorHandler = error_handler<Iterator> >
+struct parser : qi::grammar<Iterator, utree(), whitespace<Iterator> >
+{
+    qi::rule<Iterator, utree(), whitespace<Iterator> >
+        start, element, list;
+
+    qi::rule<Iterator, utree()>
+        atom;
+
+    qi::rule<Iterator, int()>
+        integer;
+
+    qi::rule<Iterator, utf8_symbol_type()>
+        symbol;
+ 
+    qi::rule<Iterator, utree::nil_type()>
+        nil_;
+
+    qi::rule<Iterator, binary_string_type()>
+        binary;
+
+    utf8::parser<Iterator>
+        string;
+
+    px::function<ErrorHandler> const
+        error;
+  
+    tagger<Iterator, save_line_pos>
+        pos;
+
+    parser(std::string const& source_file = "<string>"):
+        parser::base_type(start), error(ErrorHandler(source_file))
+    {
+        using standard::char_;
+        using qi::unused_type;
+        using qi::lexeme;
+        using qi::hex;
+        using qi::oct;
+        using qi::no_case;
+        using qi::real_parser;
+        using qi::strict_real_policies;
+        using qi::uint_parser;
+        using qi::bool_parser;
+        using qi::on_error;
+        using qi::fail;
+        using qi::int_;
+        using qi::lit;
+        using qi::_val;
+        using qi::_1;
+        using qi::_2;
+        using qi::_3;
+        using qi::_4;
+
+        real_parser<double, strict_real_policies<double> > strict_double;
+        uint_parser<unsigned char, 16, 2, 2> hex2;
+        bool_parser<bool, sexpr::bool_input_policies> boolean;
+ 
+        start = element.alias();
+
+        element = atom | list;
+
+        list = pos(_val, '(') > *element > ')';
+
+        atom = nil_ 
+             | strict_double
+             | integer
+             | boolean
+             | string
+             | symbol
+             | binary;
+
+        nil_ = qi::attr_cast(lit("nil")); 
+
+        integer = lexeme[ no_case["#x"] >  hex]
+                | lexeme[ no_case["#o"] >> oct]
+                | lexeme[-no_case["#d"] >> int_];
+
+        std::string exclude = std::string(" ();\"\x01-\x1f\x7f") + '\0';
+        symbol = lexeme[+(~char_(exclude))];
+
+        binary = lexeme['#' > *hex2 > '#'];
+
+        start.name("sexpr");
+        element.name("element");
+        list.name("list");
+        atom.name("atom");
+        nil_.name("nil");
+        integer.name("integer");
+        symbol.name("symbol");
+        binary.name("binary");
+ 
+        on_error<fail>(start, error(_1, _2, _3, _4));
+    }
+};
+
+} // sexpr
+//]
+
+#endif // BOOST_SPIRIT_UTREE_EXAMPLE_SEXPR_PARSER_HPP
+
diff --git a/src/boost/libs/spirit/example/support/utree/utf8_parser.hpp b/src/boost/libs/spirit/example/support/utree/utf8_parser.hpp
new file mode 100644
index 00000000..b06046ae
--- /dev/null
+++ b/src/boost/libs/spirit/example/support/utree/utf8_parser.hpp
@@ -0,0 +1,138 @@
+/*==============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2010-2011 Bryce Lelbach
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#if !defined(BOOST_SPIRIT_UTREE_EXAMPLE_UTF8_PARSER_HPP)
+#define BOOST_SPIRIT_UTREE_EXAMPLE_UTF8_PARSER_HPP
+
+#include <string>
+
+#include <boost/cstdint.hpp>
+
+#include <boost/regex/pending/unicode_iterator.hpp>
+
+#include <boost/spirit/include/qi.hpp>
+#include <boost/spirit/include/phoenix_core.hpp>
+#include <boost/spirit/include/phoenix_container.hpp>
+#include <boost/spirit/include/phoenix_statement.hpp>
+#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/spirit/include/support_utree.hpp>
+
+namespace utf8
+{
+
+namespace qi = boost::spirit::qi;
+namespace px = boost::phoenix;
+namespace standard = boost::spirit::standard;
+
+using boost::spirit::utree;
+using boost::spirit::utf8_symbol_type;
+using boost::spirit::utf8_string_type;
+using boost::spirit::binary_string_type;
+
+typedef boost::uint32_t uchar;
+
+struct push_string
+{
+    template <typename, typename>
+    struct result
+    {
+        typedef void type;
+    };
+
+    void operator()(std::string& s, uchar code_point) const
+    {
+        typedef std::back_insert_iterator<std::string> insert_iter;
+        insert_iter out_iter(s);
+        boost::utf8_output_iterator<insert_iter> s_iter(out_iter);
+        *s_iter++ = code_point;
+    }
+};
+
+struct push_escaped_string
+{
+    template <typename, typename>
+    struct result
+    {
+        typedef void type;
+    };
+
+    void operator()(std::string& s, uchar c) const
+    {
+        switch (c) {
+            case 'b':
+                s += '\b';
+                break;
+            case 't':
+                s += '\t';
+                break;
+            case 'n':
+                s += '\n';
+                break;
+            case 'f':
+                s += '\f';
+                break;
+            case 'r':
+                s += '\r';
+                break;
+            case '"':
+                s += '"';
+                break;
+            case '\\':
+                s += '\\';
+                break;
+        }
+    }
+};
+
+template <typename Iterator>
+struct parser : qi::grammar<Iterator, std::string()>
+{
+    qi::rule<Iterator, void(std::string&)>
+        escaped;
+
+    qi::rule<Iterator, std::string()>
+        start;
+  
+    px::function<push_string>
+        push_str;
+
+    px::function<push_escaped_string>
+        push_esc;
+
+    parser() : parser::base_type (start)
+    {
+        using standard::char_;
+        using qi::uint_parser;
+        using qi::_val;
+        using qi::_r1;
+        using qi::_1;
+
+        uint_parser<uchar, 16, 4, 4> hex4;
+        uint_parser<uchar, 16, 8, 8> hex8;
+
+        escaped
+          = '\\'
+          > (   ('u' > hex4)                 [push_str(_r1, _1)]
+            |   ('U' > hex8)                 [push_str(_r1, _1)]
+            |   char_("btnfr\\\"'")          [push_esc(_r1, _1)]
+            );
+
+        start
+          = '"'
+          > *(escaped(_val) | (~char_('"'))  [_val += _1])
+          > '"';
+
+        escaped.name("escaped_string");
+        start.name("string");
+    }
+};
+
+} // utf8
+
+#endif // BOOST_SPIRIT_UTREE_EXAMPLE_UTF8_PARSER_HPP
+
diff --git a/src/boost/libs/spirit/example/x3/Jamfile b/src/boost/libs/spirit/example/x3/Jamfile
new file mode 100644
index 00000000..1e8bb8f3
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/Jamfile
@@ -0,0 +1,65 @@
+#==============================================================================
+#   Copyright (c) 2001-2014 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)
+#==============================================================================
+project spirit-x3-example
+    : requirements
+        <include>.
+        <c++-template-depth>512
+        <toolset>gcc:<cxxflags>-std=c++1y
+        <toolset>clang:<cxxflags>-std=c++1y
+        <toolset>darwin:<cxxflags>-std=c++1y
+    :
+    :
+    ;
+
+exe x3_num_list1 : num_list/num_list1.cpp ;
+exe x3_num_list2 : num_list/num_list2.cpp ;
+exe x3_num_list3 : num_list/num_list3.cpp ;
+exe x3_num_list4 : num_list/num_list4.cpp ;
+
+exe x3_actions : actions.cpp ;
+exe x3_complex_number : complex_number.cpp ;
+exe x3_sum : sum.cpp ;
+exe x3_roman : roman.cpp ;
+exe x3_employee : employee.cpp ;
+
+exe x3_rexpr : rexpr/rexpr_min/rexpr.cpp ;
+
+build-project rexpr/rexpr_full ;
+
+exe x3_calc1 : calc/calc1.cpp ;
+exe x3_calc2 : calc/calc2.cpp ;
+exe x3_calc4 : calc/calc4.cpp ;
+exe x3_calc4b : calc/calc4b.cpp ;
+exe x3_calc5 : calc/calc5.cpp ;
+exe x3_calc6 : calc/calc6.cpp ;
+
+exe x3_calc7 :
+    calc/calc7/vm.cpp
+    calc/calc7/compiler.cpp
+    calc/calc7/expression.cpp
+    calc/calc7/main.cpp
+;
+
+exe x3_calc8 :
+    /boost//filesystem
+    calc/calc8/vm.cpp
+    calc/calc8/compiler.cpp
+    calc/calc8/expression.cpp
+    calc/calc8/statement.cpp
+    calc/calc8/main.cpp
+;
+
+exe x3_calc9 :
+    /boost//filesystem
+    calc/calc9/vm.cpp
+    calc/calc9/compiler.cpp
+    calc/calc9/expression.cpp
+    calc/calc9/statement.cpp
+    calc/calc9/main.cpp
+;
+
+exe x3_tuple : attributes/tuple.cpp ;
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/actions.cpp b/src/boost/libs/spirit/example/x3/actions.cpp
new file mode 100644
index 00000000..7a80fe83
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/actions.cpp
@@ -0,0 +1,52 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include <iostream>
+
+// Presented are various ways to attach semantic actions
+//  * Using plain function pointer
+//  * Using simple function object
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    using x3::_attr;
+
+    struct print_action
+    {
+        template <typename Context>
+        void operator()(Context const& ctx) const
+        {
+            std::cout << _attr(ctx) << std::endl;
+        }
+    };
+}
+
+int main()
+{
+    using boost::spirit::x3::int_;
+    using boost::spirit::x3::parse;
+    using client::print_action;
+
+    { // example using function object
+
+        char const *first = "{43}", *last = first + std::strlen(first);
+        parse(first, last, '{' >> int_[print_action()] >> '}');
+    }
+
+    { // example using C++14 lambda
+
+        using boost::spirit::x3::_attr;
+        char const *first = "{44}", *last = first + std::strlen(first);
+        auto f = [](auto& ctx){ std::cout << _attr(ctx) << std::endl; };
+        parse(first, last, '{' >> int_[f] >> '}');
+    }
+
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/annotation.cpp b/src/boost/libs/spirit/example/x3/annotation.cpp
new file mode 100644
index 00000000..12dacfbb
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/annotation.cpp
@@ -0,0 +1,246 @@
+/*=============================================================================
+    Copyright (c) 2002-2018 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Based on the employee parser (see employee.cpp), this example shows how
+//  to annotate the AST with the iterator positions for access to the source
+//  code when post processing. This example also shows how to "inject" client
+//  data, using the "with" directive, that the handlers can access.
+//
+//  [ JDG May 9, 2007 ]
+//  [ JDG May 13, 2015 ]    spirit X3
+//  [ JDG Feb 22, 2018 ]    Parser annotations for spirit X3
+//
+//    I would like to thank Rainbowverse, llc (https://primeorbial.com/)
+//    for sponsoring this work and donating it to the community.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our AST (employee and person structs)
+    ///////////////////////////////////////////////////////////////////////////
+    namespace x3 = boost::spirit::x3;
+
+    struct person : x3::position_tagged
+    {
+        person(
+            std::string const& first_name = ""
+          , std::string const& last_name = ""
+        )
+          : first_name(first_name)
+          , last_name(last_name)
+        {}
+
+        std::string first_name, last_name;
+    };
+
+    struct employee : x3::position_tagged
+    {
+        int age;
+        person who;
+        double salary;
+    };
+
+    using boost::fusion::operator<<;
+}}
+
+// We need to tell fusion about our employee struct
+// to make it a first-class fusion citizen. This has to
+// be in global scope.
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::person,
+    first_name, last_name
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::employee,
+    age, who, salary
+)
+
+namespace client
+{
+    namespace parser
+    {
+        namespace x3 = boost::spirit::x3;
+        namespace ascii = boost::spirit::x3::ascii;
+
+        ///////////////////////////////////////////////////////////////////////
+        //  Our annotation handler
+        ///////////////////////////////////////////////////////////////////////
+
+        // tag used to get the position cache from the context
+        struct position_cache_tag;
+
+        struct annotate_position
+        {
+            template <typename T, typename Iterator, typename Context>
+            inline void on_success(Iterator const& first, Iterator const& last
+            , T& ast, Context const& context)
+            {
+                auto& position_cache = x3::get<position_cache_tag>(context).get();
+                position_cache.annotate(ast, first, last);
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        //  Our employee parser
+        ///////////////////////////////////////////////////////////////////////
+
+        using x3::int_;
+        using x3::double_;
+        using x3::lexeme;
+        using ascii::char_;
+
+        struct quoted_string_class;
+        struct person_class;
+        struct employee_class;
+
+        x3::rule<quoted_string_class, std::string> const quoted_string = "quoted_string";
+        x3::rule<person_class, ast::person> const person = "person";
+        x3::rule<employee_class, ast::employee> const employee = "employee";
+
+        auto const quoted_string_def = lexeme['"' >> +(char_ - '"') >> '"'];
+        auto const person_def = quoted_string >> ',' >> quoted_string;
+
+        auto const employee_def =
+                '{'
+            >>  int_ >> ','
+            >>  person >> ','
+            >>  double_
+            >>  '}'
+            ;
+
+        auto const employees = employee >> *(',' >> employee);
+
+        BOOST_SPIRIT_DEFINE(quoted_string, person, employee);
+
+        struct quoted_string_class {};
+        struct person_class : annotate_position {};
+        struct employee_class : annotate_position {};
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Our main parse entry point
+///////////////////////////////////////////////////////////////////////////////
+
+using iterator_type = std::string::const_iterator;
+using position_cache = boost::spirit::x3::position_cache<std::vector<iterator_type>>;
+
+std::vector<client::ast::employee>
+parse(std::string const& input, position_cache& positions)
+{
+    using boost::spirit::x3::ascii::space;
+
+    std::vector<client::ast::employee> ast;
+    iterator_type iter = input.begin();
+    iterator_type const end = input.end();
+
+    using boost::spirit::x3::with;
+
+    // Our parser
+    using client::parser::employees;
+    using client::parser::position_cache_tag;
+
+    auto const parser =
+        // we pass our position_cache to the parser so we can access
+        // it later in our on_sucess handlers
+        with<position_cache_tag>(std::ref(positions))
+        [
+            employees
+        ];
+
+    bool r = phrase_parse(iter, end, parser, space, ast);
+
+    if (r && iter == end)
+    {
+        std::cout << boost::fusion::tuple_open('[');
+        std::cout << boost::fusion::tuple_close(']');
+        std::cout << boost::fusion::tuple_delimiter(", ");
+
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+
+        for (auto const& emp : ast)
+        {
+            std::cout << "got: " << emp << std::endl;
+        }
+        std::cout << "\n-------------------------\n";
+
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------\n";
+        ast.clear();
+    }
+    return ast;
+}
+
+// Sample input:
+
+std::string input = R"(
+{
+    23,
+    "Amanda",
+    "Stefanski",
+    1000.99
+},
+{
+    35,
+    "Angie",
+    "Chilcote",
+    2000.99
+},
+{
+    43,
+    "Dannie",
+    "Dillinger",
+    3000.99
+},
+{
+    22,
+    "Dorene",
+    "Dole",
+    2500.99
+},
+{
+    38,
+    "Rossana",
+    "Rafferty",
+    5000.99
+}
+)";
+
+int
+main()
+{
+    position_cache positions{input.begin(), input.end()};
+    auto ast = parse(input, positions);
+
+    // Get the source of the 2nd employee and print it
+    auto pos = positions.position_of(ast[1]); // zero based of course!
+    std::cout << "Here's the 2nd employee:" << std::endl;
+    std::cout << std::string(pos.begin(), pos.end()) << std::endl;
+    std::cout << "-------------------------\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/attributes/tuple.cpp b/src/boost/libs/spirit/example/x3/attributes/tuple.cpp
new file mode 100644
index 00000000..979127a7
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/attributes/tuple.cpp
@@ -0,0 +1,51 @@
+
+/*=============================================================================
+    Copyright (c) 2019 Tom Tan
+
+    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)
+=============================================================================*/
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include <boost/fusion/adapted/std_tuple.hpp>
+
+#include <iostream>
+#include <tuple>
+#include <string>
+
+//
+// X3 does not support more than one attribute anymore in the parse function,
+// this example show how to wrap multiple attributes into one leveraging std::tuple.
+//
+
+std::tuple<uint32_t, uint32_t, uint32_t> parse_message_prefix_revision(const std::string &s)
+{
+
+  namespace x3 = boost::spirit::x3;
+
+  auto const uint_3_digits = x3::uint_parser<std::uint32_t, 10, 3, 3>{};
+  auto const uint_4_digits = x3::uint_parser<std::uint32_t, 10, 4, 4>{};
+
+  auto iter = s.cbegin();
+  auto end_iter = s.cend();
+
+  std::tuple<uint32_t, uint32_t, uint32_t> length_id_revision;
+
+  x3::parse(iter, end_iter,
+            uint_4_digits >> uint_4_digits >> uint_3_digits,
+            length_id_revision);
+
+  return length_id_revision;
+}
+
+int main()
+{
+  std::string s = "00200060001";
+
+  std::cout << "parsing " << s << '\n';
+  auto [len, id, rev] = parse_message_prefix_revision(s);
+  std::cout << "length = " << len << '\n'
+            << "id = " << id << '\n'
+            << "revision =" << rev;
+}
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/calc/calc1.cpp b/src/boost/libs/spirit/example/x3/calc/calc1.cpp
new file mode 100644
index 00000000..0a8e0c96
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc1.cpp
@@ -0,0 +1,123 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Plain calculator example demonstrating the grammar. The parser is a
+//  syntax checker only and does not do any semantic evaluation.
+//
+//  [ JDG May 10, 2002 ]        spirit 1
+//  [ JDG March 4, 2007 ]       spirit 2
+//  [ JDG February 21, 2011 ]   spirit 2.5
+//  [ JDG June 6, 2014 ]        spirit x3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+#include <iostream>
+#include <string>
+#include <list>
+#include <numeric>
+
+namespace x3 = boost::spirit::x3;
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace calculator_grammar
+    {
+        using x3::uint_;
+        using x3::char_;
+
+        x3::rule<class expression> const expression("expression");
+        x3::rule<class term> const term("term");
+        x3::rule<class factor> const factor("factor");
+
+        auto const expression_def =
+            term
+            >> *(   ('+' >> term)
+                |   ('-' >> term)
+                )
+            ;
+
+        auto const term_def =
+            factor
+            >> *(   ('*' >> factor)
+                |   ('/' >> factor)
+                )
+            ;
+
+        auto const factor_def =
+                uint_
+            |   '(' >> expression >> ')'
+            |   ('-' >> factor)
+            |   ('+' >> factor)
+            ;
+
+        BOOST_SPIRIT_DEFINE(
+            expression
+          , term
+          , factor
+        );
+
+        auto calculator = expression;
+    }
+
+    using calculator_grammar::calculator;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        auto& calc = client::calculator;    // Our grammar
+
+        iterator_type iter = str.begin();
+        iterator_type end = str.end();
+        boost::spirit::x3::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \"" << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc2.cpp b/src/boost/libs/spirit/example/x3/calc/calc2.cpp
new file mode 100644
index 00000000..6c0a2444
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc2.cpp
@@ -0,0 +1,139 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating the grammar and semantic actions
+//  using lambda functions. The parser prints code suitable for a stack
+//  based virtual machine.
+//
+//  [ JDG May 10, 2002 ]        spirit 1
+//  [ JDG March 4, 2007 ]       spirit 2
+//  [ JDG February 21, 2011 ]   spirit 2.5
+//  [ JDG June 6, 2014 ]        spirit x3 (from qi calc2, but using lambda functions)
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+#include <iostream>
+#include <string>
+#include <list>
+#include <numeric>
+
+namespace x3 = boost::spirit::x3;
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Semantic actions
+    ////////////////////////////////////////////////////////1///////////////////////
+    namespace
+    {
+        using x3::_attr;
+
+        auto do_int     = [](auto& ctx) { std::cout << "push " << _attr(ctx) << std::endl; };
+        auto do_add     = []{ std::cout << "add\n"; };
+        auto do_subt    = []{ std::cout << "subtract\n"; };
+        auto do_mult    = []{ std::cout << "mult\n"; };
+        auto do_div     = []{ std::cout << "divide\n"; };
+        auto do_neg     = []{ std::cout << "negate\n"; };
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace calculator_grammar
+    {
+        using x3::uint_;
+        using x3::char_;
+
+        x3::rule<class expression> const expression("expression");
+        x3::rule<class term> const term("term");
+        x3::rule<class factor> const factor("factor");
+
+        auto const expression_def =
+            term
+            >> *(   ('+' >> term            [do_add])
+                |   ('-' >> term            [do_subt])
+                )
+            ;
+
+        auto const term_def =
+            factor
+            >> *(   ('*' >> factor          [do_mult])
+                |   ('/' >> factor          [do_div])
+                )
+            ;
+
+        auto const factor_def =
+                uint_                       [do_int]
+            |   '(' >> expression >> ')'
+            |   ('-' >> factor              [do_neg])
+            |   ('+' >> factor)
+            ;
+
+        BOOST_SPIRIT_DEFINE(
+            expression
+          , term
+          , factor
+        );
+
+        auto calculator = expression;
+    }
+
+    using calculator_grammar::calculator;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        auto& calc = client::calculator;    // Our grammar
+
+        iterator_type iter = str.begin();
+        iterator_type end = str.end();
+        boost::spirit::x3::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \"" << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc4.cpp b/src/boost/libs/spirit/example/x3/calc/calc4.cpp
new file mode 100644
index 00000000..289e2cd9
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc4.cpp
@@ -0,0 +1,273 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST. The AST,
+//  once created, is traversed, 1) To print its contents and
+//  2) To evaluate the result.
+//
+//  [ JDG April 28, 2008 ]      For BoostCon 2008
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG January 9, 2013 ]     Spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+#include <iostream>
+#include <string>
+#include <list>
+#include <numeric>
+
+namespace x3 = boost::spirit::x3;
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct nil {};
+    struct signed_;
+    struct program;
+
+    struct operand : x3::variant<
+            nil
+          , unsigned int
+          , x3::forward_ast<signed_>
+          , x3::forward_ast<program>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct program
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::signed_,
+    sign, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::operation,
+    operator_, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::program,
+    first, rest
+)
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST Printer
+    ///////////////////////////////////////////////////////////////////////////
+    struct printer
+    {
+        typedef void result_type;
+
+        void operator()(nil) const {}
+        void operator()(unsigned int n) const { std::cout << n; }
+
+        void operator()(operation const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': std::cout << " add"; break;
+                case '-': std::cout << " subt"; break;
+                case '*': std::cout << " mult"; break;
+                case '/': std::cout << " div"; break;
+            }
+        }
+
+        void operator()(signed_ const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': std::cout << " neg"; break;
+                case '+': std::cout << " pos"; break;
+            }
+        }
+
+        void operator()(program const& x) const
+        {
+            boost::apply_visitor(*this, x.first);
+            for (operation const& oper: x.rest)
+            {
+                std::cout << ' ';
+                (*this)(oper);
+            }
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST evaluator
+    ///////////////////////////////////////////////////////////////////////////
+    struct eval
+    {
+        typedef int result_type;
+
+        int operator()(nil) const { BOOST_ASSERT(0); return 0; }
+        int operator()(unsigned int n) const { return n; }
+
+        int operator()(int lhs, operation const& x) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': return lhs + rhs;
+                case '-': return lhs - rhs;
+                case '*': return lhs * rhs;
+                case '/': return lhs / rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(signed_ const& x) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': return -rhs;
+                case '+': return +rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(program const& x) const
+        {
+            return std::accumulate(
+                x.rest.begin(), x.rest.end()
+              , boost::apply_visitor(*this, x.first)
+              , *this);
+        }
+    };
+}}
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace calculator_grammar
+    {
+        using x3::uint_;
+        using x3::char_;
+
+        x3::rule<class expression, ast::program> const expression("expression");
+        x3::rule<class term, ast::program> const term("term");
+        x3::rule<class factor, ast::operand> const factor("factor");
+
+        auto const expression_def =
+            term
+            >> *(   (char_('+') >> term)
+                |   (char_('-') >> term)
+                )
+            ;
+
+        auto const term_def =
+            factor
+            >> *(   (char_('*') >> factor)
+                |   (char_('/') >> factor)
+                )
+            ;
+
+        auto const factor_def =
+                uint_
+            |   '(' >> expression >> ')'
+            |   (char_('-') >> factor)
+            |   (char_('+') >> factor)
+            ;
+
+        BOOST_SPIRIT_DEFINE(
+            expression
+          , term
+          , factor
+        );
+
+        auto calculator = expression;
+    }
+
+    using calculator_grammar::calculator;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::ast::program ast_program;
+    typedef client::ast::printer ast_print;
+    typedef client::ast::eval ast_eval;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        auto& calc = client::calculator;    // Our grammar
+        ast_program program;                // Our program (AST)
+        ast_print print;                    // Prints the program
+        ast_eval eval;                      // Evaluates the program
+
+        iterator_type iter = str.begin();
+        iterator_type end = str.end();
+        boost::spirit::x3::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space, program);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            print(program);
+            std::cout << "\nResult: " << eval(program) << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \"" << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc4b.cpp b/src/boost/libs/spirit/example/x3/calc/calc4b.cpp
new file mode 100644
index 00000000..176359ab
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc4b.cpp
@@ -0,0 +1,273 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST. The AST,
+//  once created, is traversed, 1) To print its contents and
+//  2) To evaluate the result.
+//
+//  [ JDG April 28, 2008 ]      For BoostCon 2008
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG January 9, 2013 ]     Spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+#include <iostream>
+#include <string>
+#include <list>
+#include <numeric>
+
+namespace x3 = boost::spirit::x3;
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct nil {};
+    struct signed_;
+    struct program;
+
+    struct operand : x3::variant<
+            nil
+          , unsigned int
+          , x3::forward_ast<signed_>
+          , x3::forward_ast<program>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct program
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::signed_,
+    sign, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::operation,
+    operator_, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::program,
+    first, rest
+)
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST Printer
+    ///////////////////////////////////////////////////////////////////////////
+    struct printer
+    {
+        typedef void result_type;
+
+        void operator()(nil) const {}
+        void operator()(unsigned int n) const { std::cout << n; }
+
+        void operator()(operation const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': std::cout << " add"; break;
+                case '-': std::cout << " subt"; break;
+                case '*': std::cout << " mult"; break;
+                case '/': std::cout << " div"; break;
+            }
+        }
+
+        void operator()(signed_ const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': std::cout << " neg"; break;
+                case '+': std::cout << " pos"; break;
+            }
+        }
+
+        void operator()(program const& x) const
+        {
+            boost::apply_visitor(*this, x.first);
+            for (operation const& oper: x.rest)
+            {
+                std::cout << ' ';
+                (*this)(oper);
+            }
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST evaluator
+    ///////////////////////////////////////////////////////////////////////////
+    struct eval
+    {
+        typedef int result_type;
+
+        int operator()(nil) const { BOOST_ASSERT(0); return 0; }
+        int operator()(unsigned int n) const { return n; }
+
+        int operator()(int lhs, operation const& x) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': return lhs + rhs;
+                case '-': return lhs - rhs;
+                case '*': return lhs * rhs;
+                case '/': return lhs / rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(signed_ const& x) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': return -rhs;
+                case '+': return +rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(program const& x) const
+        {
+            return std::accumulate(
+                x.rest.begin(), x.rest.end()
+              , boost::apply_visitor(*this, x.first)
+              , *this);
+        }
+    };
+}}
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace calculator_grammar
+    {
+        using x3::uint_;
+        using x3::char_;
+
+        x3::rule<class expression, ast::program> const expression("expression");
+        x3::rule<class term, ast::program> const term("term");
+        x3::rule<class factor, ast::operand> const factor("factor");
+
+        auto const expression_def =
+                term
+                >> *(   (char_('+') >> term)
+                    |   (char_('-') >> term)
+                    )
+                ;
+
+        auto const term_def =
+                factor
+                >> *(   (char_('*') >> factor)
+                    |   (char_('/') >> factor)
+                    )
+                ;
+
+        auto const factor_def =
+                    uint_
+                |   '(' >> expression >> ')'
+                |   (char_('-') >> factor)
+                |   (char_('+') >> factor)
+                ;
+
+        BOOST_SPIRIT_DEFINE(expression, term, factor);
+        
+        auto calculator = expression;
+    }
+
+    using calculator_grammar::calculator;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::ast::program ast_program;
+    typedef client::ast::printer ast_print;
+    typedef client::ast::eval ast_eval;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        auto& calc = client::calculator;    // Our grammar
+        ast_program program;                // Our program (AST)
+        ast_print print;                    // Prints the program
+        ast_eval eval;                      // Evaluates the program
+
+        iterator_type iter = str.begin();
+        iterator_type end = str.end();
+        boost::spirit::x3::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space, program);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            print(program);
+            std::cout << "\nResult: " << eval(program) << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \"" << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc4c/calc4c.cpp b/src/boost/libs/spirit/example/x3/calc/calc4c/calc4c.cpp
new file mode 100644
index 00000000..91d396b5
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc4c/calc4c.cpp
@@ -0,0 +1,77 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 Joel de Guzman
+    Copyright (c) 2013-2014 Agustin Berge
+
+    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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST. The AST,
+//  once created, is traversed, 1) To print its contents and
+//  2) To evaluate the result.
+//
+//  [ JDG April 28, 2008 ]      For BoostCon 2008
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG January 9, 2013 ]     Spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "grammar.hpp"
+
+#include <iostream>
+#include <string>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::ast::program ast_program;
+    typedef client::ast::printer ast_print;
+    typedef client::ast::eval ast_eval;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        auto& calc = client::calculator;    // Our grammar
+        ast_program program;                // Our program (AST)
+        ast_print print;                    // Prints the program
+        ast_eval eval;                      // Evaluates the program
+
+        iterator_type iter = str.begin();
+        iterator_type end = str.end();
+        boost::spirit::x3::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space, program);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            print(program);
+            std::cout << "\nResult: " << eval(program) << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \"" << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc4c/grammar.cpp b/src/boost/libs/spirit/example/x3/calc/calc4c/grammar.cpp
new file mode 100644
index 00000000..8d1526b2
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc4c/grammar.cpp
@@ -0,0 +1,68 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 Joel de Guzman
+    Copyright (c) 2013-2014 Agustin Berge
+
+    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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST. The AST,
+//  once created, is traversed, 1) To print its contents and
+//  2) To evaluate the result.
+//
+//  [ JDG April 28, 2008 ]      For BoostCon 2008
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG January 9, 2013 ]     Spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "grammar.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace calculator_grammar
+    {
+        using x3::uint_;
+        using x3::char_;
+
+        x3::rule<class expression, ast::program> const expression("expression");
+        x3::rule<class term, ast::program> const term("term");
+        x3::rule<class factor, ast::operand> const factor("factor");
+
+        auto const expression_def =
+            term
+            >> *(   (char_('+') >> term)
+                |   (char_('-') >> term)
+                )
+            ;
+
+        auto const term_def =
+            factor
+            >> *(   (char_('*') >> factor)
+                |   (char_('/') >> factor)
+                )
+            ;
+
+        auto const factor_def =
+                uint_
+            |   '(' >> expression >> ')'
+            |   (char_('-') >> factor)
+            |   (char_('+') >> factor)
+            ;
+
+        BOOST_SPIRIT_DEFINE(
+            expression
+          , term
+          , factor
+        );
+
+        parser_type calculator()
+        {
+            return expression;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/calc/calc4c/grammar.hpp b/src/boost/libs/spirit/example/x3/calc/calc4c/grammar.hpp
new file mode 100644
index 00000000..89d867c6
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc4c/grammar.hpp
@@ -0,0 +1,192 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 Joel de Guzman
+    Copyright (c) 2013-2014 Agustin Berge
+
+    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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Calculator example demonstrating generation of AST. The AST,
+//  once created, is traversed, 1) To print its contents and
+//  2) To evaluate the result.
+//
+//  [ JDG April 28, 2008 ]      For BoostCon 2008
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG January 9, 2013 ]     Spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/variant/recursive_variant.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+#include <list>
+#include <numeric>
+
+namespace x3 = boost::spirit::x3;
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct nil {};
+    struct signed_;
+    struct program;
+
+    typedef x3::variant<
+            nil
+          , unsigned int
+          , x3::forward_ast<signed_>
+          , x3::forward_ast<program>
+        >
+    operand;
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct program
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::signed_,
+    sign, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::operation,
+    operator_, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::program,
+    first, rest
+)
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST Printer
+    ///////////////////////////////////////////////////////////////////////////
+    struct printer
+    {
+        typedef void result_type;
+
+        void operator()(nil) const {}
+        void operator()(unsigned int n) const { std::cout << n; }
+
+        void operator()(operation const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': std::cout << " add"; break;
+                case '-': std::cout << " subt"; break;
+                case '*': std::cout << " mult"; break;
+                case '/': std::cout << " div"; break;
+            }
+        }
+
+        void operator()(signed_ const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': std::cout << " neg"; break;
+                case '+': std::cout << " pos"; break;
+            }
+        }
+
+        void operator()(program const& x) const
+        {
+            boost::apply_visitor(*this, x.first);
+            for (operation const& oper: x.rest)
+            {
+                std::cout << ' ';
+                (*this)(oper);
+            }
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST evaluator
+    ///////////////////////////////////////////////////////////////////////////
+    struct eval
+    {
+        typedef int result_type;
+
+        int operator()(nil) const { BOOST_ASSERT(0); return 0; }
+        int operator()(unsigned int n) const { return n; }
+
+        int operator()(int lhs, operation const& x) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': return lhs + rhs;
+                case '-': return lhs - rhs;
+                case '*': return lhs * rhs;
+                case '/': return lhs / rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(signed_ const& x) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': return -rhs;
+                case '+': return +rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(program const& x) const
+        {
+            return std::accumulate( x.rest.begin(), x.rest.end()
+                                    , boost::apply_visitor(*this, x.first)
+                                    , *this);
+        }
+    };
+}}
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace calculator_grammar
+    {
+        using parser_type =
+            x3::any_parser<
+                std::string::const_iterator
+              , ast::program
+              , decltype(x3::make_context<x3::skipper_tag>(x3::ascii::space))
+            >;
+
+        parser_type calculator();
+    }
+    
+    auto const calculator = calculator_grammar::calculator();
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc5.cpp b/src/boost/libs/spirit/example/x3/calc/calc5.cpp
new file mode 100644
index 00000000..f6cd6a63
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc5.cpp
@@ -0,0 +1,301 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Same as Calc4, this time, we'll incorporate debugging support,
+//  plus error handling and reporting.
+//
+//  [ JDG April 28, 2008 ]      For BoostCon 2008
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG April 9, 2014 ]       Spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+//#define BOOST_SPIRIT_X3_DEBUG
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+#include <iostream>
+#include <string>
+#include <list>
+#include <numeric>
+
+namespace x3 = boost::spirit::x3;
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct nil {};
+    struct signed_;
+    struct program;
+
+    struct operand : x3::variant<
+            nil
+          , unsigned int
+          , x3::forward_ast<signed_>
+          , x3::forward_ast<program>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct program
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    // print function for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil) { out << "nil"; return out; }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::signed_,
+    sign, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::operation,
+    operator_, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::program,
+    first, rest
+)
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST Printer
+    ///////////////////////////////////////////////////////////////////////////
+    struct printer
+    {
+        typedef void result_type;
+
+        void operator()(nil) const {}
+        void operator()(unsigned int n) const { std::cout << n; }
+
+        void operator()(operation const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': std::cout << " add"; break;
+                case '-': std::cout << " subt"; break;
+                case '*': std::cout << " mult"; break;
+                case '/': std::cout << " div"; break;
+            }
+        }
+
+        void operator()(signed_ const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': std::cout << " neg"; break;
+                case '+': std::cout << " pos"; break;
+            }
+        }
+
+        void operator()(program const& x) const
+        {
+            boost::apply_visitor(*this, x.first);
+            for (operation const& oper : x.rest)
+            {
+                std::cout << ' ';
+                (*this)(oper);
+            }
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST evaluator
+    ///////////////////////////////////////////////////////////////////////////
+    struct eval
+    {
+        typedef int result_type;
+
+        int operator()(nil) const { BOOST_ASSERT(0); return 0; }
+        int operator()(unsigned int n) const { return n; }
+
+        int operator()(operation const& x, int lhs) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': return lhs + rhs;
+                case '-': return lhs - rhs;
+                case '*': return lhs * rhs;
+                case '/': return lhs / rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(signed_ const& x) const
+        {
+            int rhs = boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': return -rhs;
+                case '+': return +rhs;
+            }
+            BOOST_ASSERT(0);
+            return 0;
+        }
+
+        int operator()(program const& x) const
+        {
+            int state = boost::apply_visitor(*this, x.first);
+            for (operation const& oper : x.rest)
+            {
+                state = (*this)(oper, state);
+            }
+            return state;
+        }
+    };
+}}
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace calculator_grammar
+    {
+        using x3::uint_;
+        using x3::char_;
+
+        struct expression_class;
+        struct term_class;
+        struct factor_class;
+
+        x3::rule<expression_class, ast::program> const expression("expression");
+        x3::rule<term_class, ast::program> const term("term");
+        x3::rule<factor_class, ast::operand> const factor("factor");
+
+        auto const expression_def =
+            term
+            >> *(   (char_('+') > term)
+                |   (char_('-') > term)
+                )
+            ;
+
+        auto const term_def =
+            factor
+            >> *(   (char_('*') > factor)
+                |   (char_('/') > factor)
+                )
+            ;
+
+        auto const factor_def =
+                uint_
+            |   '(' > expression > ')'
+            |   (char_('-') > factor)
+            |   (char_('+') > factor)
+            ;
+
+        BOOST_SPIRIT_DEFINE(
+            expression
+          , term
+          , factor
+        );
+
+        struct expression_class
+        {
+            //  Our error handler
+            template <typename Iterator, typename Exception, typename Context>
+            x3::error_handler_result
+            on_error(Iterator&, Iterator const& last, Exception const& x, Context const& context)
+            {
+                std::cout
+                    << "Error! Expecting: "
+                    << x.which()
+                    << " here: \""
+                    << std::string(x.where(), last)
+                    << "\""
+                    << std::endl
+                    ;
+                return x3::error_handler_result::fail;
+            }
+        };
+
+        auto calculator = expression;
+    }
+
+    using calculator_grammar::calculator;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::ast::program ast_program;
+    typedef client::ast::printer ast_print;
+    typedef client::ast::eval ast_eval;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        auto& calc = client::calculator;    // Our grammar
+        ast_program program;                // Our program (AST)
+        ast_print print;                    // Prints the program
+        ast_eval eval;                      // Evaluates the program
+
+        iterator_type iter = str.begin();
+        iterator_type end = str.end();
+        boost::spirit::x3::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space, program);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            print(program);
+            std::cout << "\nResult: " << eval(program) << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc6.cpp b/src/boost/libs/spirit/example/x3/calc/calc6.cpp
new file mode 100644
index 00000000..f9554aa6
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc6.cpp
@@ -0,0 +1,341 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Yet another calculator example! This time, we will compile to a simple
+//  virtual machine. This is actually one of the very first Spirit example
+//  circa 2000. Now, it's ported to Spirit2 (and X3).
+//
+//  [ JDG Sometime 2000 ]       pre-boost
+//  [ JDG September 18, 2002 ]  spirit1
+//  [ JDG April 8, 2007 ]       spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG April 9, 2014 ]       Spirit X3 (from qi calc6)
+//
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment this if you want to enable debugging
+//#define BOOST_SPIRIT_X3_DEBUG
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4345)
+#endif
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+#include <iostream>
+#include <string>
+#include <list>
+#include <numeric>
+
+namespace x3 = boost::spirit::x3;
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct nil {};
+    struct signed_;
+    struct expression;
+
+    struct operand : x3::variant<
+            nil
+          , unsigned int
+          , x3::forward_ast<signed_>
+          , x3::forward_ast<expression>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct expression
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    // print function for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil) { out << "nil"; return out; }
+}}
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::signed_,
+    sign, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::operation,
+    operator_, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::expression,
+    first, rest
+)
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ///////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,     //  negate the top stack entry
+        op_add,     //  add top two stack entries
+        op_sub,     //  subtract top two stack entries
+        op_mul,     //  multiply top two stack entries
+        op_div,     //  divide top two stack entries
+        op_int,     //  push constant integer into the stack
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+          , stack_ptr(stack.begin())
+        {
+        }
+
+        int top() const { return stack_ptr[-1]; };
+        void execute(std::vector<int> const& code);
+
+    private:
+
+        std::vector<int> stack;
+        std::vector<int>::iterator stack_ptr;
+    };
+
+    void vmachine::execute(std::vector<int> const& code)
+    {
+        std::vector<int>::const_iterator pc = code.begin();
+        stack_ptr = stack.begin();
+
+        while (pc != code.end())
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+            }
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ///////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef void result_type;
+
+        std::vector<int>& code;
+        compiler(std::vector<int>& code)
+          : code(code) {}
+
+        void operator()(ast::nil) const { BOOST_ASSERT(0); }
+        void operator()(unsigned int n) const
+        {
+            code.push_back(op_int);
+            code.push_back(n);
+        }
+
+        void operator()(ast::operation const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.operator_)
+            {
+                case '+': code.push_back(op_add); break;
+                case '-': code.push_back(op_sub); break;
+                case '*': code.push_back(op_mul); break;
+                case '/': code.push_back(op_div); break;
+                default: BOOST_ASSERT(0); break;
+            }
+        }
+
+        void operator()(ast::signed_ const& x) const
+        {
+            boost::apply_visitor(*this, x.operand_);
+            switch (x.sign)
+            {
+                case '-': code.push_back(op_neg); break;
+                case '+': break;
+                default: BOOST_ASSERT(0); break;
+            }
+        }
+
+        void operator()(ast::expression const& x) const
+        {
+            boost::apply_visitor(*this, x.first);
+            for (ast::operation const& oper : x.rest)
+            {
+                (*this)(oper);
+            }
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  The calculator grammar
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace calculator_grammar
+    {
+        using x3::uint_;
+        using x3::char_;
+
+        struct expression_class;
+        struct term_class;
+        struct factor_class;
+
+        x3::rule<expression_class, ast::expression> const expression("expression");
+        x3::rule<term_class, ast::expression> const term("term");
+        x3::rule<factor_class, ast::operand> const factor("factor");
+
+        auto const expression_def =
+            term
+            >> *(   (char_('+') > term)
+                |   (char_('-') > term)
+                )
+            ;
+
+        auto const term_def =
+            factor
+            >> *(   (char_('*') > factor)
+                |   (char_('/') > factor)
+                )
+            ;
+
+        auto const factor_def =
+                uint_
+            |   '(' > expression > ')'
+            |   (char_('-') > factor)
+            |   (char_('+') > factor)
+            ;
+
+        BOOST_SPIRIT_DEFINE(
+            expression
+          , term
+          , factor
+        );
+
+        struct expression_class
+        {
+            //  Our error handler
+            template <typename Iterator, typename Exception, typename Context>
+            x3::error_handler_result
+            on_error(Iterator&, Iterator const& last, Exception const& x, Context const& context)
+            {
+                std::cout
+                    << "Error! Expecting: "
+                    << x.which()
+                    << " here: \""
+                    << std::string(x.where(), last)
+                    << "\""
+                    << std::endl
+                    ;
+                return x3::error_handler_result::fail;
+            }
+        };
+
+        auto calculator = expression;
+    }
+
+    using calculator_grammar::calculator;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::ast::expression ast_expression;
+    typedef client::compiler compiler;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        client::vmachine mach;              // Our virtual machine
+        std::vector<int> code;              // Our VM code
+        auto& calc = client::calculator;    // Our grammar
+        ast_expression expression;          // Our program (AST)
+        compiler compile(code);             // Compiles the program
+
+        iterator_type iter = str.begin();
+        iterator_type const end = str.end();
+        boost::spirit::x3::ascii::space_type space;
+        bool r = phrase_parse(iter, end, calc, space, expression);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            compile(expression);
+            mach.execute(code);
+            std::cout << "\nResult: " << mach.top() << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/ast.hpp b/src/boost/libs/spirit/example/x3/calc/calc7/ast.hpp
new file mode 100644
index 00000000..600350ec
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/ast.hpp
@@ -0,0 +1,63 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC7_AST_HPP)
+#define BOOST_SPIRIT_X3_CALC7_AST_HPP
+
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <list>
+
+namespace client { namespace ast
+{
+    namespace x3 = boost::spirit::x3;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    struct nil {};
+    struct signed_;
+    struct expression;
+
+    struct operand : x3::variant<
+            nil
+          , unsigned int
+          , x3::forward_ast<signed_>
+          , x3::forward_ast<expression>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct expression
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    // print function for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil)
+    {
+        out << "nil";
+        return out;
+    }
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/ast_adapted.hpp b/src/boost/libs/spirit/example/x3/calc/calc7/ast_adapted.hpp
new file mode 100644
index 00000000..bd56cfc7
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/ast_adapted.hpp
@@ -0,0 +1,25 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC7_AST_ADAPTED_HPP)
+#define BOOST_SPIRIT_X3_CALC7_AST_ADAPTED_HPP
+
+#include "ast.hpp"
+#include <boost/fusion/include/adapt_struct.hpp>
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::signed_,
+    sign, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::operation,
+    operator_, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::expression,
+    first, rest
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/compiler.cpp b/src/boost/libs/spirit/example/x3/calc/calc7/compiler.cpp
new file mode 100644
index 00000000..8f6d6f09
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/compiler.cpp
@@ -0,0 +1,55 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "compiler.hpp"
+#include "vm.hpp"
+
+namespace client
+{
+    void compiler::operator()(ast::nil) const
+    {
+        BOOST_ASSERT(0);
+    }
+
+    void compiler::operator()(unsigned int n) const
+    {
+        code.push_back(op_int);
+        code.push_back(n);
+    }
+
+    void compiler::operator()(ast::operation const& x) const
+    {
+        boost::apply_visitor(*this, x.operand_);
+        switch (x.operator_)
+        {
+            case '+': code.push_back(op_add); break;
+            case '-': code.push_back(op_sub); break;
+            case '*': code.push_back(op_mul); break;
+            case '/': code.push_back(op_div); break;
+            default: BOOST_ASSERT(0); break;
+        }
+    }
+
+    void compiler::operator()(ast::signed_ const& x) const
+    {
+        boost::apply_visitor(*this, x.operand_);
+        switch (x.sign)
+        {
+            case '-': code.push_back(op_neg); break;
+            case '+': break;
+            default: BOOST_ASSERT(0); break;
+        }
+    }
+
+    void compiler::operator()(ast::expression const& x) const
+    {
+        boost::apply_visitor(*this, x.first);
+        for (ast::operation const& oper : x.rest)
+        {
+            (*this)(oper);
+        }
+    }
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/compiler.hpp b/src/boost/libs/spirit/example/x3/calc/calc7/compiler.hpp
new file mode 100644
index 00000000..3cf0ed84
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/compiler.hpp
@@ -0,0 +1,33 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC7_COMPILER_HPP)
+#define BOOST_SPIRIT_X3_CALC7_COMPILER_HPP
+
+#include "ast.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ///////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef void result_type;
+
+        std::vector<int>& code;
+        compiler(std::vector<int>& code)
+          : code(code) {}
+
+        void operator()(ast::nil) const;
+        void operator()(unsigned int n) const;
+        void operator()(ast::operation const& x) const;
+        void operator()(ast::signed_ const& x) const;
+        void operator()(ast::expression const& x) const;
+    };
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/error_handler.hpp b/src/boost/libs/spirit/example/x3/calc/calc7/error_handler.hpp
new file mode 100644
index 00000000..9517220d
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/error_handler.hpp
@@ -0,0 +1,40 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC7_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_X3_CALC7_ERROR_HANDLER_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include <iostream>
+
+namespace client { namespace calculator_grammar
+{
+    ////////////////////////////////////////////////////////////////////////////
+    //  Our error handler
+    ////////////////////////////////////////////////////////////////////////////
+    namespace x3 = boost::spirit::x3;
+
+    struct error_handler
+    {
+        //  Our error handler
+        template <typename Iterator, typename Exception, typename Context>
+        x3::error_handler_result
+        on_error(Iterator&, Iterator const& last, Exception const& x, Context const& context)
+        {
+            std::cout
+                << "Error! Expecting: "
+                << x.which()
+                << " here: \""
+                << std::string(x.where(), last)
+                << "\""
+                << std::endl
+                ;
+            return x3::error_handler_result::fail;
+        }
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/expression.cpp b/src/boost/libs/spirit/example/x3/calc/calc7/expression.cpp
new file mode 100644
index 00000000..3dcb694e
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/expression.cpp
@@ -0,0 +1,15 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "expression_def.hpp"
+
+namespace client { namespace calculator_grammar
+{
+    typedef std::string::const_iterator iterator_type;
+    typedef x3::phrase_parse_context<x3::ascii::space_type>::type context_type;
+
+    BOOST_SPIRIT_INSTANTIATE(expression_type, iterator_type, context_type);
+}}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/expression.hpp b/src/boost/libs/spirit/example/x3/calc/calc7/expression.hpp
new file mode 100644
index 00000000..93568eaf
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/expression.hpp
@@ -0,0 +1,26 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC7_EXPRESSION_HPP)
+#define BOOST_SPIRIT_X3_CALC7_EXPRESSION_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace calculator_grammar
+    {
+        struct expression_class;
+        typedef x3::rule<expression_class, ast::expression> expression_type;
+        BOOST_SPIRIT_DECLARE(expression_type);
+    }
+    
+    calculator_grammar::expression_type expression();
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/expression_def.hpp b/src/boost/libs/spirit/example/x3/calc/calc7/expression_def.hpp
new file mode 100644
index 00000000..dc73c288
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/expression_def.hpp
@@ -0,0 +1,71 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC7_EXPRESSION_DEF_HPP)
+#define BOOST_SPIRIT_X3_CALC7_EXPRESSION_DEF_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include "ast.hpp"
+#include "ast_adapted.hpp"
+#include "expression.hpp"
+#include "error_handler.hpp"
+
+namespace client { namespace calculator_grammar
+{
+    using x3::uint_;
+    using x3::char_;
+
+    struct expression_class;
+    struct term_class;
+    struct factor_class;
+
+    typedef x3::rule<expression_class, ast::expression> expression_type;
+    typedef x3::rule<term_class, ast::expression> term_type;
+    typedef x3::rule<factor_class, ast::operand> factor_type;
+
+    expression_type const expression = "expression";
+    term_type const term = "term";
+    factor_type const factor = "factor";
+
+    auto const expression_def =
+        term
+        >> *(   (char_('+') > term)
+            |   (char_('-') > term)
+            )
+        ;
+
+    auto const term_def =
+        factor
+        >> *(   (char_('*') > factor)
+            |   (char_('/') > factor)
+            )
+        ;
+
+    auto const factor_def =
+            uint_
+        |   '(' > expression > ')'
+        |   (char_('-') > factor)
+        |   (char_('+') > factor)
+        ;
+
+    BOOST_SPIRIT_DEFINE(
+        expression
+      , term
+      , factor
+    );
+
+    struct expression_class : error_handler {};
+}}
+
+namespace client
+{
+    calculator_grammar::expression_type expression()
+    {
+        return calculator_grammar::expression;
+    }
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/main.cpp b/src/boost/libs/spirit/example/x3/calc/calc7/main.cpp
new file mode 100644
index 00000000..5f71230d
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/main.cpp
@@ -0,0 +1,81 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Same as calc6, but this version also shows off grammar modularization.
+//  Here you will see how expressions is built as a modular grammars.
+//
+//  [ JDG Sometime 2000 ]       pre-boost
+//  [ JDG September 18, 2002 ]  spirit1
+//  [ JDG April 8, 2007 ]       spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG April 9, 2014 ]       Spirit X3 (from qi calc6)
+//  [ JDG May 2, 2014 ]         Modular grammar using BOOST_SPIRIT_DEFINE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "ast.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+#include "expression.hpp"
+#include "error_handler.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Expression parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type an expression...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    typedef client::ast::expression ast_expression;
+    typedef client::compiler compiler;
+
+    std::string str;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        using boost::spirit::x3::ascii::space;
+
+        client::vmachine mach;                          // Our virtual machine
+        std::vector<int> code;                          // Our VM code
+        auto calc = client::expression();               // grammar
+
+        ast_expression ast;                             // Our program (AST)
+        compiler compile(code);                         // Compiles the program
+
+        iterator_type iter = str.begin();
+        iterator_type const end = str.end();
+        bool r = phrase_parse(iter, end, calc, space, ast);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            compile(ast);
+            mach.execute(code);
+            std::cout << "\nResult: " << mach.top() << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/vm.cpp b/src/boost/libs/spirit/example/x3/calc/calc7/vm.cpp
new file mode 100644
index 00000000..323d7217
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/vm.cpp
@@ -0,0 +1,50 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "vm.hpp"
+
+namespace client
+{
+    void vmachine::execute(std::vector<int> const& code)
+    {
+        std::vector<int>::const_iterator pc = code.begin();
+        stack_ptr = stack.begin();
+
+        while (pc != code.end())
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+            }
+        }
+    }
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc7/vm.hpp b/src/boost/libs/spirit/example/x3/calc/calc7/vm.hpp
new file mode 100644
index 00000000..2836efd3
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc7/vm.hpp
@@ -0,0 +1,48 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC7_VM_HPP)
+#define BOOST_SPIRIT_X3_CALC7_VM_HPP
+
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ///////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,     //  negate the top stack entry
+        op_add,     //  add top two stack entries
+        op_sub,     //  subtract top two stack entries
+        op_mul,     //  multiply top two stack entries
+        op_div,     //  divide top two stack entries
+        op_int,     //  push constant integer into the stack
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+          , stack_ptr(stack.begin())
+        {
+        }
+
+        int top() const { return stack_ptr[-1]; };
+        void execute(std::vector<int> const& code);
+
+    private:
+
+        std::vector<int> stack;
+        std::vector<int>::iterator stack_ptr;
+    };
+
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/ast.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/ast.hpp
new file mode 100644
index 00000000..aacde561
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/ast.hpp
@@ -0,0 +1,98 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_AST_HPP)
+#define BOOST_SPIRIT_X3_CALC8_AST_HPP
+
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <list>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    namespace x3 = boost::spirit::x3;
+
+    struct nil {};
+    struct signed_;
+    struct expression;
+
+    struct variable : x3::position_tagged
+    {
+        variable(std::string const& name = "") : name(name) {}
+        std::string name;
+    };
+
+    struct operand :
+        x3::variant<
+            nil
+          , unsigned int
+          , variable
+          , x3::forward_ast<signed_>
+          , x3::forward_ast<expression>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+
+    struct signed_
+    {
+        char sign;
+        operand operand_;
+    };
+
+    struct operation : x3::position_tagged
+    {
+        char operator_;
+        operand operand_;
+    };
+
+    struct expression : x3::position_tagged
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    struct assignment : x3::position_tagged
+    {
+        variable lhs;
+        expression rhs;
+    };
+
+    struct variable_declaration
+    {
+        assignment assign;
+    };
+
+    struct statement :
+        x3::variant<
+            variable_declaration
+          , assignment>
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+
+    typedef std::list<statement> statement_list;
+
+    // print functions for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil)
+    {
+        out << "nil";
+        return out;
+    }
+
+    inline std::ostream& operator<<(std::ostream& out, variable const& var)
+    {
+        out << var.name; return out;
+    }
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/ast_adapted.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/ast_adapted.hpp
new file mode 100644
index 00000000..ca776109
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/ast_adapted.hpp
@@ -0,0 +1,33 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_AST_ADAPTED_HPP)
+#define BOOST_SPIRIT_X3_CALC8_AST_ADAPTED_HPP
+
+#include "ast.hpp"
+#include <boost/fusion/include/adapt_struct.hpp>
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::signed_,
+    sign, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::operation,
+    operator_, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::expression,
+    first, rest
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::variable_declaration,
+    assign
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::assignment,
+    lhs, rhs
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/common.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/common.hpp
new file mode 100644
index 00000000..0a559573
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/common.hpp
@@ -0,0 +1,28 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_COMMON_HPP)
+#define BOOST_SPIRIT_X3_CALC8_COMMON_HPP
+
+#include <boost/spirit/home/x3.hpp>
+
+namespace client { namespace parser
+{
+    using x3::raw;
+    using x3::lexeme;
+    using x3::alpha;
+    using x3::alnum;
+
+    struct identifier_class;
+    typedef x3::rule<identifier_class, std::string> identifier_type;
+    identifier_type const identifier = "identifier";
+
+    auto const identifier_def = raw[lexeme[(alpha | '_') >> *(alnum | '_')]];
+
+    BOOST_SPIRIT_DEFINE(identifier);
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/compiler.cpp b/src/boost/libs/spirit/example/x3/calc/calc8/compiler.cpp
new file mode 100644
index 00000000..6410a981
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/compiler.cpp
@@ -0,0 +1,217 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "compiler.hpp"
+#include "vm.hpp"
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/assert.hpp>
+#include <iostream>
+
+namespace client { namespace code_gen
+{
+    void program::op(int a)
+    {
+        code.push_back(a);
+    }
+
+    void program::op(int a, int b)
+    {
+        code.push_back(a);
+        code.push_back(b);
+    }
+
+    void program::op(int a, int b, int c)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        code.push_back(c);
+    }
+
+    int const* program::find_var(std::string const& name) const
+    {
+        auto i = variables.find(name);
+        if (i == variables.end())
+            return 0;
+        return &i->second;
+    }
+
+    void program::add_var(std::string const& name)
+    {
+        std::size_t n = variables.size();
+        variables[name] = int(n);
+    }
+
+    void program::print_variables(std::vector<int> const& stack) const
+    {
+        for (auto const& p : variables)
+        {
+            std::cout << "    " << p.first << ": " << stack[p.second] << std::endl;
+        }
+    }
+
+    void program::print_assembler() const
+    {
+        auto pc = code.begin();
+
+        std::vector<std::string> locals(variables.size());
+        typedef std::pair<std::string, int> pair;
+        for (pair const& p : variables)
+        {
+            locals[p.second] = p.first;
+            std::cout << "local       "
+                << p.first << ", @" << p.second << std::endl;
+        }
+
+        while (pc != code.end())
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    std::cout << "op_neg" << std::endl;
+                    break;
+
+                case op_add:
+                    std::cout << "op_add" << std::endl;
+                    break;
+
+                case op_sub:
+                    std::cout << "op_sub" << std::endl;
+                    break;
+
+                case op_mul:
+                    std::cout << "op_mul" << std::endl;
+                    break;
+
+                case op_div:
+                    std::cout << "op_div" << std::endl;
+                    break;
+
+                case op_load:
+                    std::cout << "op_load     " << locals[*pc++] << std::endl;
+                    break;
+
+                case op_store:
+                    std::cout << "op_store    " << locals[*pc++] << std::endl;
+                    break;
+
+                case op_int:
+                    std::cout << "op_int      " << *pc++ << std::endl;
+                    break;
+
+                case op_stk_adj:
+                    std::cout << "op_stk_adj  " << *pc++ << std::endl;
+                    break;
+            }
+        }
+    }
+
+    bool compiler::operator()(unsigned int x) const
+    {
+        program.op(op_int, x);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable const& x) const
+    {
+        int const* p = program.find_var(x.name);
+        if (p == 0)
+        {
+            error_handler(x, "Undeclared variable: " + x.name);
+            return false;
+        }
+        program.op(op_load, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::operation const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case '+': program.op(op_add); break;
+            case '-': program.op(op_sub); break;
+            case '*': program.op(op_mul); break;
+            case '/': program.op(op_div); break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::signed_ const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.sign)
+        {
+            case '-': program.op(op_neg); break;
+            case '+': break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::expression const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.first))
+            return false;
+        for (ast::operation const& oper : x.rest)
+        {
+            if (!(*this)(oper))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::assignment const& x) const
+    {
+        if (!(*this)(x.rhs))
+            return false;
+        int const* p = program.find_var(x.lhs.name);
+        if (p == 0)
+        {
+            error_handler(x.lhs, "Undeclared variable: " + x.lhs.name);
+            return false;
+        }
+        program.op(op_store, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable_declaration const& x) const
+    {
+        int const* p = program.find_var(x.assign.lhs.name);
+        if (p != 0)
+        {
+            error_handler(x.assign.lhs, "Duplicate variable: " + x.assign.lhs.name);
+            return false;
+        }
+        bool r = (*this)(x.assign.rhs);
+        if (r) // don't add the variable if the RHS fails
+        {
+            program.add_var(x.assign.lhs.name);
+            program.op(op_store, *program.find_var(x.assign.lhs.name));
+        }
+        return r;
+    }
+
+    bool compiler::operator()(ast::statement_list const& x) const
+    {
+        program.clear();
+
+        // op_stk_adj 0 for now. we'll know how many variables we'll have later
+        program.op(op_stk_adj, 0);
+        for (ast::statement const& s : x)
+        {
+            if (!boost::apply_visitor(*this, s))
+            {
+                program.clear();
+                return false;
+            }
+        }
+        program[1] = int(program.nvars()); // now store the actual number of variables
+        return true;
+    }
+}}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/compiler.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/compiler.hpp
new file mode 100644
index 00000000..509298c9
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/compiler.hpp
@@ -0,0 +1,80 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_COMPILER_HPP)
+#define BOOST_SPIRIT_X3_CALC8_COMPILER_HPP
+
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+#include <map>
+
+namespace client { namespace code_gen
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Program
+    ///////////////////////////////////////////////////////////////////////////
+    struct program
+    {
+        void op(int a);
+        void op(int a, int b);
+        void op(int a, int b, int c);
+
+        int& operator[](std::size_t i) { return code[i]; }
+        int operator[](std::size_t i) const { return code[i]; }
+        void clear() { code.clear(); variables.clear(); }
+        std::vector<int> const& operator()() const { return code; }
+
+        std::size_t nvars() const { return variables.size(); }
+        int const* find_var(std::string const& name) const;
+        void add_var(std::string const& name);
+
+        void print_variables(std::vector<int> const& stack) const;
+        void print_assembler() const;
+
+    private:
+
+        std::map<std::string, int> variables;
+        std::vector<int> code;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ////////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef bool result_type;
+        typedef std::function<
+            void(x3::position_tagged, std::string const&)>
+        error_handler_type;
+
+        template <typename ErrorHandler>
+        compiler(
+            client::code_gen::program& program
+          , ErrorHandler const& error_handler)
+          : program(program)
+          , error_handler(
+                [&](x3::position_tagged pos, std::string const& msg)
+                { error_handler(pos, msg); }
+            )
+        {}
+
+        bool operator()(ast::nil) const { BOOST_ASSERT(0); return false; }
+        bool operator()(unsigned int x) const;
+        bool operator()(ast::variable const& x) const;
+        bool operator()(ast::operation const& x) const;
+        bool operator()(ast::signed_ const& x) const;
+        bool operator()(ast::expression const& x) const;
+        bool operator()(ast::assignment const& x) const;
+        bool operator()(ast::variable_declaration const& x) const;
+        bool operator()(ast::statement_list const& x) const;
+
+        client::code_gen::program& program;
+        error_handler_type error_handler;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/config.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/config.hpp
new file mode 100644
index 00000000..d6664564
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/config.hpp
@@ -0,0 +1,26 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_CONFIG_HPP)
+#define BOOST_SPIRIT_X3_CALC8_CONFIG_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include "error_handler.hpp"
+
+namespace client { namespace parser
+{
+    typedef std::string::const_iterator iterator_type;
+    typedef x3::phrase_parse_context<x3::ascii::space_type>::type phrase_context_type;
+    typedef error_handler<iterator_type> error_handler_type;
+
+    typedef x3::context<
+        error_handler_tag
+      , std::reference_wrapper<error_handler_type>
+      , phrase_context_type>
+    context_type;
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/error_handler.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/error_handler.hpp
new file mode 100644
index 00000000..25cb268c
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/error_handler.hpp
@@ -0,0 +1,44 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_X3_CALC8_ERROR_HANDLER_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/utility/error_reporting.hpp>
+#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
+#include "expression.hpp"
+#include "statement.hpp"
+
+namespace client { namespace parser
+{
+    namespace x3 = boost::spirit::x3;
+    
+    ////////////////////////////////////////////////////////////////////////////
+    //  Our error handler
+    ////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    using error_handler = x3::error_handler<Iterator>;
+
+    // tag used to get our error handler from the context
+    using error_handler_tag = x3::error_handler_tag;
+
+    struct error_handler_base
+    {
+        template <typename Iterator, typename Exception, typename Context>
+        x3::error_handler_result on_error(
+            Iterator& first, Iterator const& last
+          , Exception const& x, Context const& context)
+        {
+            std::string message = "Error! Expecting: " + x.which() + " here:";
+            auto& error_handler = x3::get<error_handler_tag>(context).get();
+            error_handler(x.where(), message);
+            return x3::error_handler_result::fail;
+        }
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/expression.cpp b/src/boost/libs/spirit/example/x3/calc/calc8/expression.cpp
new file mode 100644
index 00000000..e7463cd3
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/expression.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "expression_def.hpp"
+#include "config.hpp"
+
+namespace client { namespace parser
+{
+    BOOST_SPIRIT_INSTANTIATE(expression_type, iterator_type, context_type);
+}}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/expression.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/expression.hpp
new file mode 100644
index 00000000..d619510c
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/expression.hpp
@@ -0,0 +1,26 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_EXPRESSION_HPP)
+#define BOOST_SPIRIT_X3_CALC8_EXPRESSION_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace parser
+    {
+        struct expression_class;
+        typedef x3::rule<expression_class, ast::expression> expression_type;
+        BOOST_SPIRIT_DECLARE(expression_type);
+    }
+    
+    parser::expression_type const& expression();
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/expression_def.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/expression_def.hpp
new file mode 100644
index 00000000..fe9eaee9
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/expression_def.hpp
@@ -0,0 +1,91 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_EXPRESSION_DEF_HPP)
+#define BOOST_SPIRIT_X3_CALC8_EXPRESSION_DEF_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/utility/annotate_on_success.hpp>
+#include "ast.hpp"
+#include "ast_adapted.hpp"
+#include "expression.hpp"
+#include "common.hpp"
+#include "error_handler.hpp"
+
+namespace client { namespace parser
+{
+    using x3::uint_;
+    using x3::char_;
+    using x3::raw;
+    using x3::lexeme;
+    using namespace x3::ascii;
+
+    struct additive_expr_class;
+    struct multiplicative_expr_class;
+    struct unary_expr_class;
+    struct primary_expr_class;
+
+    typedef x3::rule<additive_expr_class, ast::expression> additive_expr_type;
+    typedef x3::rule<multiplicative_expr_class, ast::expression> multiplicative_expr_type;
+    typedef x3::rule<unary_expr_class, ast::operand> unary_expr_type;
+    typedef x3::rule<primary_expr_class, ast::operand> primary_expr_type;
+
+    expression_type const expression = "expression";
+    additive_expr_type const additive_expr = "additive_expr";
+    multiplicative_expr_type const multiplicative_expr = "multiplicative_expr";
+    unary_expr_type unary_expr = "unary_expr";
+    primary_expr_type primary_expr = "primary_expr";
+
+    auto const additive_expr_def =
+        multiplicative_expr
+        >> *(   (char_('+') > multiplicative_expr)
+            |   (char_('-') > multiplicative_expr)
+            )
+        ;
+
+    auto const multiplicative_expr_def =
+        unary_expr
+        >> *(   (char_('*') > unary_expr)
+            |   (char_('/') > unary_expr)
+            )
+        ;
+
+    auto const unary_expr_def =
+            primary_expr
+        |   (char_('-') > primary_expr)
+        |   (char_('+') > primary_expr)
+        ;
+
+    auto const primary_expr_def =
+            uint_
+        |   identifier
+        |   '(' > expression > ')'
+        ;
+
+    auto const expression_def = additive_expr;
+
+    BOOST_SPIRIT_DEFINE(
+        expression
+      , additive_expr
+      , multiplicative_expr
+      , unary_expr
+      , primary_expr
+    );
+
+    struct unary_expr_class : x3::annotate_on_success {};
+    struct primary_expr_class : x3::annotate_on_success {};
+
+}}
+
+namespace client
+{
+    parser::expression_type const& expression()
+    {
+        return parser::expression;
+    }
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/main.cpp b/src/boost/libs/spirit/example/x3/calc/calc8/main.cpp
new file mode 100644
index 00000000..e87ccbb7
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/main.cpp
@@ -0,0 +1,114 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Now we'll introduce variables and assignment. This time, we'll also
+//  be renaming some of the rules -- a strategy for a grander scheme
+//  to come ;-)
+//
+//  This version also shows off grammar modularization. Here you will
+//  see how expressions and statements are built as modular grammars.
+//
+//  [ JDG April 9, 2007 ]       spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG May 17, 2014 ]        Ported from qi calc7 example.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "ast.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+#include "statement.hpp"
+#include "error_handler.hpp"
+#include "config.hpp"
+#include <iostream>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Statement parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type some statements... ";
+    std::cout << "An empty line ends input, compiles, runs and prints results\n\n";
+    std::cout << "Example:\n\n";
+    std::cout << "    var a = 123;\n";
+    std::cout << "    var b = 456;\n";
+    std::cout << "    var c = a + b * 2;\n\n";
+    std::cout << "-------------------------\n";
+
+    std::string str;
+    std::string source;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty())
+            break;
+        source += str + '\n';
+    }
+
+    using client::parser::iterator_type;
+    iterator_type iter(source.begin());
+    iterator_type end(source.end());
+
+    client::vmachine vm;                                    // Our virtual machine
+    client::code_gen::program program;                      // Our VM program
+    client::ast::statement_list ast;                        // Our AST
+
+    using boost::spirit::x3::with;
+    using client::parser::error_handler_type;
+    using client::parser::error_handler_tag;
+    error_handler_type error_handler(iter, end, std::cerr); // Our error handler
+
+    // Our compiler
+    client::code_gen::compiler compile(program, error_handler);
+
+    // Our parser
+    auto const parser =
+        // we pass our error handler to the parser so we can access
+        // it later on in our on_error and on_sucess handlers
+        with<error_handler_tag>(std::ref(error_handler))
+        [
+            client::statement()
+        ];
+
+    using boost::spirit::x3::ascii::space;
+    bool success = phrase_parse(iter, end, parser, space, ast);
+
+    std::cout << "-------------------------\n";
+
+    if (success && iter == end)
+    {
+        if (compile(ast))
+        {
+            std::cout << "Success\n";
+            std::cout << "-------------------------\n";
+            vm.execute(program());
+
+            std::cout << "-------------------------\n";
+            std::cout << "Assembler----------------\n\n";
+            program.print_assembler();
+
+            std::cout << "-------------------------\n";
+            std::cout << "Results------------------\n\n";
+            program.print_variables(vm.get_stack());
+        }
+        else
+        {
+            std::cout << "Compile failure\n";
+        }
+    }
+    else
+    {
+        std::cout << "Parse failure\n";
+    }
+
+    std::cout << "-------------------------\n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/statement.cpp b/src/boost/libs/spirit/example/x3/calc/calc8/statement.cpp
new file mode 100644
index 00000000..ec4bca61
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/statement.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "statement_def.hpp"
+#include "config.hpp"
+
+namespace client { namespace parser
+{
+    BOOST_SPIRIT_INSTANTIATE(statement_type, iterator_type, context_type);
+}}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/statement.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/statement.hpp
new file mode 100644
index 00000000..7b8973d0
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/statement.hpp
@@ -0,0 +1,26 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_STATEMENT_HPP)
+#define BOOST_SPIRIT_X3_CALC8_STATEMENT_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace parser
+    {
+        struct statement_class;
+        typedef x3::rule<statement_class, ast::statement_list> statement_type;
+        BOOST_SPIRIT_DECLARE(statement_type);
+    }
+    
+    parser::statement_type const& statement();
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/statement_def.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/statement_def.hpp
new file mode 100644
index 00000000..8772c76f
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/statement_def.hpp
@@ -0,0 +1,84 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_STATEMENT_DEF_HPP)
+#define BOOST_SPIRIT_X3_CALC8_STATEMENT_DEF_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/utility/annotate_on_success.hpp>
+#include "ast.hpp"
+#include "ast_adapted.hpp"
+#include "statement.hpp"
+#include "expression.hpp"
+#include "common.hpp"
+#include "error_handler.hpp"
+
+namespace client { namespace parser
+{
+    using x3::raw;
+    using x3::lexeme;
+    using namespace x3::ascii;
+
+    struct statement_list_class;
+    struct variable_declaration_class;
+    struct assignment_class;
+    struct variable_class;
+
+    typedef x3::rule<statement_list_class, ast::statement_list> statement_list_type;
+    typedef x3::rule<variable_declaration_class, ast::variable_declaration> variable_declaration_type;
+    typedef x3::rule<assignment_class, ast::assignment> assignment_type;
+    typedef x3::rule<variable_class, ast::variable> variable_type;
+
+    statement_type const statement = "statement";
+    statement_list_type const statement_list = "statement_list";
+    variable_declaration_type const variable_declaration = "variable_declaration";
+    assignment_type const assignment = "assignment";
+    variable_type const variable = "variable";
+
+    // Import the expression rule
+    namespace { auto const& expression = client::expression(); }
+
+    auto const statement_list_def =
+        +(variable_declaration | assignment)
+        ;
+
+    auto const variable_declaration_def =
+            lexeme["var" >> !(alnum | '_')] // make sure we have whole words
+        >   assignment
+        ;
+
+    auto const assignment_def =
+            variable
+        >   '='
+        >   expression
+        >   ';'
+        ;
+
+    auto const variable_def = identifier;
+    auto const statement_def = statement_list;
+
+    BOOST_SPIRIT_DEFINE(
+        statement
+      , statement_list
+      , variable_declaration
+      , assignment
+      , variable
+    );
+
+    struct statement_class : error_handler_base, x3::annotate_on_success {};
+    struct assignment_class : x3::annotate_on_success {};
+    struct variable_class : x3::annotate_on_success {};
+}}
+
+namespace client
+{
+    parser::statement_type const& statement()
+    {
+        return parser::statement;
+    }
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/vm.cpp b/src/boost/libs/spirit/example/x3/calc/calc8/vm.cpp
new file mode 100644
index 00000000..ff6c8400
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/vm.cpp
@@ -0,0 +1,64 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "vm.hpp"
+
+namespace client
+{
+    void vmachine::execute(std::vector<int> const& code)
+    {
+        auto pc = code.begin();
+        auto locals = stack.begin();
+        stack_ptr = stack.begin();
+
+        while (pc != code.end())
+        {
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_load:
+                    *stack_ptr++ = locals[*pc++];
+                    break;
+
+                case op_store:
+                    --stack_ptr;
+                    locals[*pc++] = stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+
+                case op_stk_adj:
+                    stack_ptr = stack.begin() + *pc++;
+                    break;
+            }
+        }
+    }
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc8/vm.hpp b/src/boost/libs/spirit/example/x3/calc/calc8/vm.hpp
new file mode 100644
index 00000000..29072977
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc8/vm.hpp
@@ -0,0 +1,51 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC8_VM_HPP)
+#define BOOST_SPIRIT_X3_CALC8_VM_HPP
+
+#include <vector>
+
+namespace client
+{
+    ////////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ////////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,     //  negate the top stack entry
+        op_add,     //  add top two stack entries
+        op_sub,     //  subtract top two stack entries
+        op_mul,     //  multiply top two stack entries
+        op_div,     //  divide top two stack entries
+
+        op_load,    //  load a variable
+        op_store,   //  store a variable
+        op_int,     //  push constant integer into the stack
+        op_stk_adj  //  adjust the stack for local variables
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+          , stack_ptr(stack.begin())
+        {
+        }
+
+        void execute(std::vector<int> const& code);
+        std::vector<int> const& get_stack() const { return stack; };
+
+    private:
+
+        std::vector<int> stack;
+        std::vector<int>::iterator stack_ptr;
+    };
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/ast.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/ast.hpp
new file mode 100644
index 00000000..b3e82c49
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/ast.hpp
@@ -0,0 +1,139 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_AST_HPP)
+#define BOOST_SPIRIT_X3_CALC9_AST_HPP
+
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <boost/optional.hpp>
+#include <list>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    namespace x3 = boost::spirit::x3;
+
+    struct nil {};
+    struct unary;
+    struct expression;
+
+    struct variable : x3::position_tagged
+    {
+        variable(std::string const& name = "") : name(name) {}
+        std::string name;
+    };
+
+    struct operand :
+        x3::variant<
+            nil
+          , unsigned int
+          , variable
+          , x3::forward_ast<unary>
+          , x3::forward_ast<expression>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+    
+    enum optoken
+    {
+        op_plus,
+        op_minus,
+        op_times,
+        op_divide,
+        op_positive,
+        op_negative,
+        op_not,
+        op_equal,
+        op_not_equal,
+        op_less,
+        op_less_equal,
+        op_greater,
+        op_greater_equal,
+        op_and,
+        op_or
+    };
+
+    struct unary
+    {
+        optoken operator_;
+        operand operand_;
+    };
+
+    struct operation : x3::position_tagged
+    {
+        optoken operator_;
+        operand operand_;
+    };
+
+    struct expression : x3::position_tagged
+    {
+        operand first;
+        std::list<operation> rest;
+    };
+
+    struct assignment : x3::position_tagged
+    {
+        variable lhs;
+        expression rhs;
+    };
+
+    struct variable_declaration
+    {
+        assignment assign;
+    };
+    
+    struct if_statement;
+    struct while_statement;
+    struct statement_list;
+
+    struct statement :
+        x3::variant<
+            variable_declaration
+          , assignment
+          , boost::recursive_wrapper<if_statement>
+          , boost::recursive_wrapper<while_statement>
+          , boost::recursive_wrapper<statement_list>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+    
+    struct statement_list : std::list<statement> {};
+
+    struct if_statement
+    {
+        expression condition;
+        statement then;
+        boost::optional<statement> else_;
+    };
+
+    struct while_statement
+    {
+        expression condition;
+        statement body;
+    };
+
+    // print functions for debugging
+    inline std::ostream& operator<<(std::ostream& out, nil)
+    {
+        out << "nil";
+        return out;
+    }
+
+    inline std::ostream& operator<<(std::ostream& out, variable const& var)
+    {
+        out << var.name; return out;
+    }
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/ast_adapted.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/ast_adapted.hpp
new file mode 100644
index 00000000..3f8d3cb1
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/ast_adapted.hpp
@@ -0,0 +1,41 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_AST_ADAPTED_HPP)
+#define BOOST_SPIRIT_X3_CALC9_AST_ADAPTED_HPP
+
+#include "ast.hpp"
+#include <boost/fusion/include/adapt_struct.hpp>
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::unary,
+    operator_, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::operation,
+    operator_, operand_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::expression,
+    first, rest
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::variable_declaration,
+    assign
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::assignment,
+    lhs, rhs
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::if_statement,
+    condition, then, else_
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::while_statement,
+    condition, body
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/common.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/common.hpp
new file mode 100644
index 00000000..1f1a7011
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/common.hpp
@@ -0,0 +1,28 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_COMMON_HPP)
+#define BOOST_SPIRIT_X3_CALC9_COMMON_HPP
+
+#include <boost/spirit/home/x3.hpp>
+
+namespace client { namespace parser
+{
+    using x3::raw;
+    using x3::lexeme;
+    using x3::alpha;
+    using x3::alnum;
+
+    struct identifier_class;
+    typedef x3::rule<identifier_class, std::string> identifier_type;
+    identifier_type const identifier = "identifier";
+
+    auto const identifier_def = raw[lexeme[(alpha | '_') >> *(alnum | '_')]];
+
+    BOOST_SPIRIT_DEFINE(identifier);
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/compiler.cpp b/src/boost/libs/spirit/example/x3/calc/calc9/compiler.cpp
new file mode 100644
index 00000000..620fa22d
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/compiler.cpp
@@ -0,0 +1,376 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "compiler.hpp"
+#include "vm.hpp"
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/assert.hpp>
+#include <iostream>
+#include <set>
+#include <iostream>
+
+namespace client { namespace code_gen
+{
+    void program::op(int a)
+    {
+        code.push_back(a);
+    }
+
+    void program::op(int a, int b)
+    {
+        code.push_back(a);
+        code.push_back(b);
+    }
+
+    void program::op(int a, int b, int c)
+    {
+        code.push_back(a);
+        code.push_back(b);
+        code.push_back(c);
+    }
+
+    int const* program::find_var(std::string const& name) const
+    {
+        auto i = variables.find(name);
+        if (i == variables.end())
+            return 0;
+        return &i->second;
+    }
+
+    void program::add_var(std::string const& name)
+    {
+        std::size_t n = variables.size();
+        variables[name] = int(n);
+    }
+
+    void program::print_variables(std::vector<int> const& stack) const
+    {
+        for (auto const& p : variables)
+        {
+            std::cout << "    " << p.first << ": " << stack[p.second] << std::endl;
+        }
+    }
+
+    void program::print_assembler() const
+    {
+        auto pc = code.begin();
+
+        std::vector<std::string> locals(variables.size());
+        typedef std::pair<std::string, int> pair;
+        for (pair const& p : variables)
+        {
+            locals[p.second] = p.first;
+            std::cout << "local       "
+                << p.first << ", @" << p.second << std::endl;
+        }
+
+        std::map<std::size_t, std::string> lines;
+        std::set<std::size_t> jumps;
+
+        while (pc != code.end())
+        {
+            std::string line;
+            std::size_t address = pc - code.begin();
+
+            switch (*pc++)
+            {
+                case op_neg:
+                    line += "      op_neg";
+                    break;
+
+                case op_not:
+                    line += "      op_not";
+                    break;
+
+                case op_add:
+                    line += "      op_add";
+                    break;
+
+                case op_sub:
+                    line += "      op_sub";
+                    break;
+
+                case op_mul:
+                    line += "      op_mul";
+                    break;
+
+                case op_div:
+                    line += "      op_div";
+                    break;
+
+                case op_eq:
+                    line += "      op_eq";
+                    break;
+
+                case op_neq:
+                    line += "      op_neq";
+                    break;
+
+                case op_lt:
+                    line += "      op_lt";
+                    break;
+
+                case op_lte:
+                    line += "      op_lte";
+                    break;
+
+                case op_gt:
+                    line += "      op_gt";
+                    break;
+
+                case op_gte:
+                    line += "      op_gte";
+                    break;
+
+                case op_and:
+                    line += "      op_and";
+                    break;
+
+                case op_or:
+                    line += "      op_or";
+                    break;
+
+                case op_load:
+                    line += "      op_load     ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_store:
+                    line += "      op_store    ";
+                    line += locals[*pc++];
+                    break;
+
+                case op_int:
+                    line += "      op_int      ";
+                    line += std::to_string(*pc++);
+                    break;
+
+                case op_true:
+                    line += "      op_true";
+                    break;
+
+                case op_false:
+                    line += "      op_false";
+                    break;
+
+                case op_jump:
+                    {
+                        line += "      op_jump     ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += std::to_string(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_jump_if:
+                    {
+                        line += "      op_jump_if  ";
+                        std::size_t pos = (pc - code.begin()) + *pc++;
+                        if (pos == code.size())
+                            line += "end";
+                        else
+                            line += std::to_string(pos);
+                        jumps.insert(pos);
+                    }
+                    break;
+
+                case op_stk_adj:
+                    line += "      op_stk_adj  ";
+                    line += std::to_string(*pc++);
+                    break;
+            }
+            lines[address] = line;
+        }
+
+        std::cout << "start:" << std::endl;
+        for (auto const& l : lines)
+        {
+            std::size_t pos = l.first;
+            if (jumps.find(pos) != jumps.end())
+                std::cout << pos << ':' << std::endl;
+            std::cout << l.second << std::endl;
+        }
+
+        std::cout << "end:" << std::endl;
+    }
+
+    bool compiler::operator()(unsigned int x) const
+    {
+        program.op(op_int, x);
+        return true;
+    }
+
+    bool compiler::operator()(bool x) const
+    {
+        program.op(x ? op_true : op_false);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable const& x) const
+    {
+        int const* p = program.find_var(x.name);
+        if (p == 0)
+        {
+            error_handler(x, "Undeclared variable: " + x.name);
+            return false;
+        }
+        program.op(op_load, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::operation const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case ast::op_plus: program.op(op_add); break;
+            case ast::op_minus: program.op(op_sub); break;
+            case ast::op_times: program.op(op_mul); break;
+            case ast::op_divide: program.op(op_div); break;
+
+            case ast::op_equal: program.op(op_eq); break;
+            case ast::op_not_equal: program.op(op_neq); break;
+            case ast::op_less: program.op(op_lt); break;
+            case ast::op_less_equal: program.op(op_lte); break;
+            case ast::op_greater: program.op(op_gt); break;
+            case ast::op_greater_equal: program.op(op_gte); break;
+
+            case ast::op_and: program.op(op_and); break;
+            case ast::op_or: program.op(op_or); break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::unary const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.operand_))
+            return false;
+        switch (x.operator_)
+        {
+            case ast::op_negative: program.op(op_neg); break;
+            case ast::op_not: program.op(op_not); break;
+            case ast::op_positive: break;
+            default: BOOST_ASSERT(0); return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::expression const& x) const
+    {
+        if (!boost::apply_visitor(*this, x.first))
+            return false;
+        for (ast::operation const& oper : x.rest)
+        {
+            if (!(*this)(oper))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::assignment const& x) const
+    {
+        if (!(*this)(x.rhs))
+            return false;
+        int const* p = program.find_var(x.lhs.name);
+        if (p == 0)
+        {
+            error_handler(x.lhs, "Undeclared variable: " + x.lhs.name);
+            return false;
+        }
+        program.op(op_store, *p);
+        return true;
+    }
+
+    bool compiler::operator()(ast::variable_declaration const& x) const
+    {
+        int const* p = program.find_var(x.assign.lhs.name);
+        if (p != 0)
+        {
+            error_handler(x.assign.lhs, "Duplicate variable: " + x.assign.lhs.name);
+            return false;
+        }
+        bool r = (*this)(x.assign.rhs);
+        if (r) // don't add the variable if the RHS fails
+        {
+            program.add_var(x.assign.lhs.name);
+            program.op(op_store, *program.find_var(x.assign.lhs.name));
+        }
+        return r;
+    }
+
+    bool compiler::operator()(ast::statement const& x) const
+    {
+        return boost::apply_visitor(*this, x);
+    }
+
+    bool compiler::operator()(ast::statement_list const& x) const
+    {
+        for (auto const& s : x)
+        {
+            if (!(*this)(s))
+                return false;
+        }
+        return true;
+    }
+
+    bool compiler::operator()(ast::if_statement const& x) const
+    {
+        if (!(*this)(x.condition))
+            return false;
+        program.op(op_jump_if, 0);                      // we shall fill this (0) in later
+        std::size_t skip = program.size()-1;            // mark its position
+        if (!(*this)(x.then))
+            return false;
+        program[skip] = int(program.size()-skip);       // now we know where to jump to (after the if branch)
+
+        if (x.else_)                                    // We got an alse
+        {
+            program[skip] += 2;                         // adjust for the "else" jump
+            program.op(op_jump, 0);                     // we shall fill this (0) in later
+            std::size_t exit = program.size()-1;        // mark its position
+            if (!(*this)(*x.else_))
+                return false;
+            program[exit] = int(program.size()-exit);   // now we know where to jump to (after the else branch)
+        }
+
+        return true;
+    }
+
+    bool compiler::operator()(ast::while_statement const& x) const
+    {
+        std::size_t loop = program.size();              // mark our position
+        if (!(*this)(x.condition))
+            return false;
+        program.op(op_jump_if, 0);                      // we shall fill this (0) in later
+        std::size_t exit = program.size()-1;            // mark its position
+        if (!(*this)(x.body))
+            return false;
+        program.op(op_jump,
+            int(loop-1) - int(program.size()));         // loop back
+        program[exit] = int(program.size()-exit);       // now we know where to jump to (to exit the loop)
+        return true;
+    }
+
+    bool compiler::start(ast::statement_list const& x) const
+    {
+        program.clear();
+        // op_stk_adj 0 for now. we'll know how many variables we'll have later
+        program.op(op_stk_adj, 0);
+
+        if (!(*this)(x))
+        {
+            program.clear();
+            return false;
+        }
+        program[1] = int(program.nvars());              // now store the actual number of variables
+        return true;
+    }
+}}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/compiler.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/compiler.hpp
new file mode 100644
index 00000000..96b32a70
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/compiler.hpp
@@ -0,0 +1,87 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_COMPILER_HPP)
+#define BOOST_SPIRIT_X3_CALC9_COMPILER_HPP
+
+#include "ast.hpp"
+#include "error_handler.hpp"
+#include <vector>
+#include <map>
+
+namespace client { namespace code_gen
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Program
+    ///////////////////////////////////////////////////////////////////////////
+    struct program
+    {
+        void op(int a);
+        void op(int a, int b);
+        void op(int a, int b, int c);
+
+        int& operator[](std::size_t i) { return code[i]; }
+        int operator[](std::size_t i) const { return code[i]; }
+        void clear() { code.clear(); variables.clear(); }
+        std::size_t size() const { return code.size(); }
+        std::vector<int> const& operator()() const { return code; }
+
+        std::size_t nvars() const { return variables.size(); }
+        int const* find_var(std::string const& name) const;
+        void add_var(std::string const& name);
+
+        void print_variables(std::vector<int> const& stack) const;
+        void print_assembler() const;
+
+    private:
+
+        std::map<std::string, int> variables;
+        std::vector<int> code;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    //  The Compiler
+    ////////////////////////////////////////////////////////////////////////////
+    struct compiler
+    {
+        typedef bool result_type;
+        typedef std::function<
+            void(x3::position_tagged, std::string const&)>
+        error_handler_type;
+
+        template <typename ErrorHandler>
+        compiler(
+            client::code_gen::program& program
+          , ErrorHandler const& error_handler)
+          : program(program)
+          , error_handler(
+                [&](x3::position_tagged pos, std::string const& msg)
+                { error_handler(pos, msg); }
+            )
+        {}
+
+        bool operator()(ast::nil) const { BOOST_ASSERT(0); return false; }
+        bool operator()(unsigned int x) const;
+        bool operator()(bool x) const;
+        bool operator()(ast::variable const& x) const;
+        bool operator()(ast::operation const& x) const;
+        bool operator()(ast::unary const& x) const;
+        bool operator()(ast::expression const& x) const;
+        bool operator()(ast::assignment const& x) const;
+        bool operator()(ast::variable_declaration const& x) const;
+        bool operator()(ast::statement_list const& x) const;
+        bool operator()(ast::statement const& x) const;
+        bool operator()(ast::if_statement const& x) const;
+        bool operator()(ast::while_statement const& x) const;
+
+        bool start(ast::statement_list const& x) const;
+
+        client::code_gen::program& program;
+        error_handler_type error_handler;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/config.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/config.hpp
new file mode 100644
index 00000000..a250bf72
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/config.hpp
@@ -0,0 +1,26 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_CONFIG_HPP)
+#define BOOST_SPIRIT_X3_CALC9_CONFIG_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include "error_handler.hpp"
+
+namespace client { namespace parser
+{
+    typedef std::string::const_iterator iterator_type;
+    typedef x3::phrase_parse_context<x3::ascii::space_type>::type phrase_context_type;
+    typedef error_handler<iterator_type> error_handler_type;
+
+    typedef x3::context<
+        error_handler_tag
+      , std::reference_wrapper<error_handler_type>
+      , phrase_context_type>
+    context_type;
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/error_handler.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/error_handler.hpp
new file mode 100644
index 00000000..8d4e8a65
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/error_handler.hpp
@@ -0,0 +1,44 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_X3_CALC9_ERROR_HANDLER_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/utility/error_reporting.hpp>
+#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
+#include "expression.hpp"
+#include "statement.hpp"
+
+namespace client { namespace parser
+{
+    namespace x3 = boost::spirit::x3;
+    
+    ////////////////////////////////////////////////////////////////////////////
+    //  Our error handler
+    ////////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    using error_handler = x3::error_handler<Iterator>;
+
+    // tag used to get our error handler from the context
+    using error_handler_tag = x3::error_handler_tag;
+    
+    struct error_handler_base
+    {
+        template <typename Iterator, typename Exception, typename Context>
+        x3::error_handler_result on_error(
+            Iterator& first, Iterator const& last
+          , Exception const& x, Context const& context)
+        {
+            std::string message = "Error! Expecting: " + x.which() + " here:";
+            auto& error_handler = x3::get<error_handler_tag>(context).get();
+            error_handler(x.where(), message);
+            return x3::error_handler_result::fail;
+        }
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/expression.cpp b/src/boost/libs/spirit/example/x3/calc/calc9/expression.cpp
new file mode 100644
index 00000000..e7463cd3
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/expression.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "expression_def.hpp"
+#include "config.hpp"
+
+namespace client { namespace parser
+{
+    BOOST_SPIRIT_INSTANTIATE(expression_type, iterator_type, context_type);
+}}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/expression.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/expression.hpp
new file mode 100644
index 00000000..f9fa1cc3
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/expression.hpp
@@ -0,0 +1,26 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_EXPRESSION_HPP)
+#define BOOST_SPIRIT_X3_CALC9_EXPRESSION_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace parser
+    {
+        struct expression_class;
+        typedef x3::rule<expression_class, ast::expression> expression_type;
+        BOOST_SPIRIT_DECLARE(expression_type);
+    }
+    
+    parser::expression_type const& expression();
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/expression_def.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/expression_def.hpp
new file mode 100644
index 00000000..251fb840
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/expression_def.hpp
@@ -0,0 +1,182 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_EXPRESSION_DEF_HPP)
+#define BOOST_SPIRIT_X3_CALC9_EXPRESSION_DEF_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/utility/annotate_on_success.hpp>
+#include "ast.hpp"
+#include "ast_adapted.hpp"
+#include "expression.hpp"
+#include "common.hpp"
+#include "error_handler.hpp"
+
+namespace client { namespace parser
+{
+    using x3::uint_;
+    using x3::char_;
+    using x3::bool_;
+    using x3::raw;
+    using x3::lexeme;
+    using namespace x3::ascii;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Tokens
+    ////////////////////////////////////////////////////////////////////////////
+
+    x3::symbols<ast::optoken> equality_op;
+    x3::symbols<ast::optoken> relational_op;
+    x3::symbols<ast::optoken> logical_op;
+    x3::symbols<ast::optoken> additive_op;
+    x3::symbols<ast::optoken> multiplicative_op;
+    x3::symbols<ast::optoken> unary_op;
+    x3::symbols<> keywords;
+
+    void add_keywords()
+    {
+        static bool once = false;
+        if (once)
+            return;
+        once = true;
+
+        logical_op.add
+            ("&&", ast::op_and)
+            ("||", ast::op_or)
+            ;
+
+        equality_op.add
+            ("==", ast::op_equal)
+            ("!=", ast::op_not_equal)
+            ;
+
+        relational_op.add
+            ("<", ast::op_less)
+            ("<=", ast::op_less_equal)
+            (">", ast::op_greater)
+            (">=", ast::op_greater_equal)
+            ;
+
+        additive_op.add
+            ("+", ast::op_plus)
+            ("-", ast::op_minus)
+            ;
+
+        multiplicative_op.add
+            ("*", ast::op_times)
+            ("/", ast::op_divide)
+            ;
+
+        unary_op.add
+            ("+", ast::op_positive)
+            ("-", ast::op_negative)
+            ("!", ast::op_not)
+            ;
+
+        keywords.add
+            ("var")
+            ("true")
+            ("false")
+            ("if")
+            ("else")
+            ("while")
+            ;
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Main expression grammar
+    ////////////////////////////////////////////////////////////////////////////
+
+    struct equality_expr_class;
+    struct relational_expr_class;
+    struct logical_expr_class;
+    struct additive_expr_class;
+    struct multiplicative_expr_class;
+    struct unary_expr_class;
+    struct primary_expr_class;
+
+    typedef x3::rule<equality_expr_class, ast::expression> equality_expr_type;
+    typedef x3::rule<relational_expr_class, ast::expression> relational_expr_type;
+    typedef x3::rule<logical_expr_class, ast::expression> logical_expr_type;
+    typedef x3::rule<additive_expr_class, ast::expression> additive_expr_type;
+    typedef x3::rule<multiplicative_expr_class, ast::expression> multiplicative_expr_type;
+    typedef x3::rule<unary_expr_class, ast::operand> unary_expr_type;
+    typedef x3::rule<primary_expr_class, ast::operand> primary_expr_type;
+
+    expression_type const expression = "expression";
+    equality_expr_type const equality_expr = "equality_expr";
+    relational_expr_type const relational_expr = "relational_expr";
+    logical_expr_type const logical_expr = "logical_expr";
+    additive_expr_type const additive_expr = "additive_expr";
+    multiplicative_expr_type const multiplicative_expr = "multiplicative_expr";
+    unary_expr_type const unary_expr = "unary_expr";
+    primary_expr_type const primary_expr = "primary_expr";
+
+    auto const logical_expr_def =
+            equality_expr
+        >> *(logical_op > equality_expr)
+        ;
+
+    auto const equality_expr_def =
+            relational_expr
+        >> *(equality_op > relational_expr)
+        ;
+
+    auto const relational_expr_def =
+            additive_expr
+        >> *(relational_op > additive_expr)
+        ;
+
+    auto const additive_expr_def =
+            multiplicative_expr
+        >> *(additive_op > multiplicative_expr)
+        ;
+
+    auto const multiplicative_expr_def =
+            unary_expr
+        >> *(multiplicative_op > unary_expr)
+        ;
+
+    auto const unary_expr_def =
+            primary_expr
+        |   (unary_op > primary_expr)
+        ;
+
+    auto const primary_expr_def =
+            uint_
+        |   bool_
+        |   (!keywords >> identifier)
+        |   '(' > expression > ')'
+        ;
+
+    auto const expression_def = logical_expr;
+
+    BOOST_SPIRIT_DEFINE(
+        expression
+      , logical_expr
+      , equality_expr
+      , relational_expr
+      , additive_expr
+      , multiplicative_expr
+      , unary_expr
+      , primary_expr
+    );
+
+    struct unary_expr_class : x3::annotate_on_success {};
+    struct primary_expr_class : x3::annotate_on_success {};
+
+}}
+
+namespace client
+{
+    parser::expression_type const& expression()
+    {
+        parser::add_keywords();
+        return parser::expression;
+    }
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/main.cpp b/src/boost/libs/spirit/example/x3/calc/calc9/main.cpp
new file mode 100644
index 00000000..154860a3
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/main.cpp
@@ -0,0 +1,110 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Now we'll introduce boolean expressions and control structures.
+//  Is it obvious now what we are up to? ;-)
+//
+//  [ JDG April 9, 2007 ]       spirit2
+//  [ JDG February 18, 2011 ]   Pure attributes. No semantic actions.
+//  [ JDG June 6, 2014 ]        Ported from qi calc8 example.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "ast.hpp"
+#include "vm.hpp"
+#include "compiler.hpp"
+#include "statement.hpp"
+#include "error_handler.hpp"
+#include "config.hpp"
+#include <iostream>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Statement parser...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type some statements... ";
+    std::cout << "An empty line ends input, compiles, runs and prints results\n\n";
+    std::cout << "Example:\n\n";
+    std::cout << "    var a = 123;\n";
+    std::cout << "    var b = 456;\n";
+    std::cout << "    var c = a + b * 2;\n\n";
+    std::cout << "-------------------------\n";
+
+    std::string str;
+    std::string source;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty())
+            break;
+        source += str + '\n';
+    }
+
+    using client::parser::iterator_type;
+    iterator_type iter(source.begin());
+    iterator_type end(source.end());
+
+
+    client::vmachine vm;                                    // Our virtual machine
+    client::code_gen::program program;                      // Our VM program
+    client::ast::statement_list ast;                        // Our AST
+
+    using boost::spirit::x3::with;
+    using client::parser::error_handler_type;
+    error_handler_type error_handler(iter, end, std::cerr); // Our error handler
+
+    // Our compiler
+    client::code_gen::compiler compile(program, error_handler);
+
+    // Our parser
+    auto const parser =
+        // we pass our error handler to the parser so we can access
+        // it later on in our on_error and on_sucess handlers
+        with<client::parser::error_handler_tag>(std::ref(error_handler))
+        [
+            client::statement()
+        ];
+
+    using boost::spirit::x3::ascii::space;
+    bool success = phrase_parse(iter, end, parser, space, ast);
+
+    std::cout << "-------------------------\n";
+
+    if (success && iter == end)
+    {
+        if (compile.start(ast))
+        {
+            std::cout << "Success\n";
+            std::cout << "-------------------------\n";
+            vm.execute(program());
+
+            std::cout << "-------------------------\n";
+            std::cout << "Assembler----------------\n\n";
+            program.print_assembler();
+
+            std::cout << "-------------------------\n";
+            std::cout << "Results------------------\n\n";
+            program.print_variables(vm.get_stack());
+        }
+        else
+        {
+            std::cout << "Compile failure\n";
+        }
+    }
+    else
+    {
+        std::cout << "Parse failure\n";
+    }
+
+    std::cout << "-------------------------\n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/statement.cpp b/src/boost/libs/spirit/example/x3/calc/calc9/statement.cpp
new file mode 100644
index 00000000..ec4bca61
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/statement.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "statement_def.hpp"
+#include "config.hpp"
+
+namespace client { namespace parser
+{
+    BOOST_SPIRIT_INSTANTIATE(statement_type, iterator_type, context_type);
+}}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/statement.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/statement.hpp
new file mode 100644
index 00000000..d0c3f514
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/statement.hpp
@@ -0,0 +1,27 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_STATEMENT_HPP)
+#define BOOST_SPIRIT_X3_CALC9_STATEMENT_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include "ast.hpp"
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace parser
+    {
+        struct statement_class;
+        typedef x3::rule<statement_class, ast::statement_list> statement_type;
+        typedef statement_type::id statement_id;
+        BOOST_SPIRIT_DECLARE(statement_type);
+    }
+    
+    parser::statement_type const& statement();
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/statement_def.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/statement_def.hpp
new file mode 100644
index 00000000..84355caa
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/statement_def.hpp
@@ -0,0 +1,84 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_STATEMENT_DEF_HPP)
+#define BOOST_SPIRIT_X3_CALC9_STATEMENT_DEF_HPP
+
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/utility/annotate_on_success.hpp>
+#include "ast.hpp"
+#include "ast_adapted.hpp"
+#include "statement.hpp"
+#include "expression.hpp"
+#include "common.hpp"
+#include "error_handler.hpp"
+
+namespace client { namespace parser
+{
+    using x3::raw;
+    using x3::lexeme;
+    using namespace x3::ascii;
+
+    struct statement_list_class;
+    struct variable_declaration_class;
+    struct assignment_class;
+    struct variable_class;
+
+    typedef x3::rule<statement_list_class, ast::statement_list> statement_list_type;
+    typedef x3::rule<variable_declaration_class, ast::variable_declaration> variable_declaration_type;
+    typedef x3::rule<assignment_class, ast::assignment> assignment_type;
+    typedef x3::rule<variable_class, ast::variable> variable_type;
+
+    statement_type const statement("statement");
+    statement_list_type const statement_list("statement_list");
+    variable_declaration_type const variable_declaration("variable_declaration");
+    assignment_type const assignment("assignment");
+    variable_type const variable("variable");
+
+    // Import the expression rule
+    namespace { auto const& expression = client::expression(); }
+
+    auto const statement_list_def =
+        +(variable_declaration | assignment)
+        ;
+
+    auto const variable_declaration_def =
+            lexeme["var" >> !(alnum | '_')] // make sure we have whole words
+        >   assignment
+        ;
+
+    auto const assignment_def =
+            variable
+        >   '='
+        >   expression
+        >   ';'
+        ;
+
+    auto const variable_def = identifier;
+    auto const statement_def = statement_list;
+
+    BOOST_SPIRIT_DEFINE(
+        statement
+      , statement_list
+      , variable_declaration
+      , assignment
+      , variable
+    );
+
+    struct statement_class : error_handler_base, x3::annotate_on_success {};
+    struct assignment_class : x3::annotate_on_success {};
+    struct variable_class : x3::annotate_on_success {};
+}}
+
+namespace client
+{
+    parser::statement_type const& statement()
+    {
+        return parser::statement;
+    }
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/vm.cpp b/src/boost/libs/spirit/example/x3/calc/calc9/vm.cpp
new file mode 100644
index 00000000..d3c16713
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/vm.cpp
@@ -0,0 +1,156 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#include "vm.hpp"
+#include <boost/assert.hpp>
+
+namespace client
+{
+    int vmachine::execute(
+        std::vector<int> const& code
+      , std::vector<int>::const_iterator pc
+      , std::vector<int>::iterator frame_ptr
+    )
+    {
+        std::vector<int>::iterator stack_ptr = frame_ptr;
+
+        while (pc != code.end())
+        {
+            BOOST_ASSERT(pc != code.end());
+
+            switch (*pc++)
+            {
+                case op_neg:
+                    stack_ptr[-1] = -stack_ptr[-1];
+                    break;
+
+                case op_not:
+                    stack_ptr[-1] = !bool(stack_ptr[-1]);
+                    break;
+
+                case op_add:
+                    --stack_ptr;
+                    stack_ptr[-1] += stack_ptr[0];
+                    break;
+
+                case op_sub:
+                    --stack_ptr;
+                    stack_ptr[-1] -= stack_ptr[0];
+                    break;
+
+                case op_mul:
+                    --stack_ptr;
+                    stack_ptr[-1] *= stack_ptr[0];
+                    break;
+
+                case op_div:
+                    --stack_ptr;
+                    stack_ptr[-1] /= stack_ptr[0];
+                    break;
+
+                case op_eq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] == stack_ptr[0]);
+                    break;
+
+                case op_neq:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] != stack_ptr[0]);
+                    break;
+
+                case op_lt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] < stack_ptr[0]);
+                    break;
+
+                case op_lte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] <= stack_ptr[0]);
+                    break;
+
+                case op_gt:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] > stack_ptr[0]);
+                    break;
+
+                case op_gte:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1] >= stack_ptr[0]);
+                    break;
+
+                case op_and:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) && bool(stack_ptr[0]);
+                    break;
+
+                case op_or:
+                    --stack_ptr;
+                    stack_ptr[-1] = bool(stack_ptr[-1]) || bool(stack_ptr[0]);
+                    break;
+
+                case op_load:
+                    *stack_ptr++ = frame_ptr[*pc++];
+                    break;
+
+                case op_store:
+                    --stack_ptr;
+                    frame_ptr[*pc++] = stack_ptr[0];
+                    break;
+
+                case op_int:
+                    *stack_ptr++ = *pc++;
+                    break;
+
+                case op_true:
+                    *stack_ptr++ = true;
+                    break;
+
+                case op_false:
+                    *stack_ptr++ = false;
+                    break;
+
+                case op_jump:
+                    pc += *pc;
+                    break;
+
+                case op_jump_if:
+                    if (!bool(stack_ptr[-1]))
+                        pc += *pc;
+                    else
+                        ++pc;
+                    --stack_ptr;
+                    break;
+
+                case op_stk_adj:
+                    stack_ptr = stack.begin() + *pc++;
+                    break;
+
+                case op_call:
+                    {
+                        int nargs = *pc++;
+                        int jump = *pc++;
+
+                        // a function call is a recursive call to execute
+                        int r = execute(
+                            code
+                          , code.begin() + jump
+                          , stack_ptr - nargs
+                        );
+
+                        // cleanup after return from function
+                        stack_ptr[-nargs] = r;      //  get return value
+                        stack_ptr -= (nargs - 1);   //  the stack will now contain
+                                                    //  the return value
+                    }
+                    break;
+
+                case op_return:
+                    return stack_ptr[-1];
+            }
+        }
+        return -1;
+    }
+}
diff --git a/src/boost/libs/spirit/example/x3/calc/calc9/vm.hpp b/src/boost/libs/spirit/example/x3/calc/calc9/vm.hpp
new file mode 100644
index 00000000..345611cb
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/calc/calc9/vm.hpp
@@ -0,0 +1,81 @@
+/*=============================================================================
+    Copyright (c) 2001-2014 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_CALC9_VM_HPP)
+#define BOOST_SPIRIT_X3_CALC9_VM_HPP
+
+#include <vector>
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The Virtual Machine
+    ///////////////////////////////////////////////////////////////////////////
+    enum byte_code
+    {
+        op_neg,         //  negate the top stack entry
+        op_add,         //  add top two stack entries
+        op_sub,         //  subtract top two stack entries
+        op_mul,         //  multiply top two stack entries
+        op_div,         //  divide top two stack entries
+
+        op_not,         //  boolean negate the top stack entry
+        op_eq,          //  compare the top two stack entries for ==
+        op_neq,         //  compare the top two stack entries for !=
+        op_lt,          //  compare the top two stack entries for <
+        op_lte,         //  compare the top two stack entries for <=
+        op_gt,          //  compare the top two stack entries for >
+        op_gte,         //  compare the top two stack entries for >=
+
+        op_and,         //  logical and top two stack entries
+        op_or,          //  logical or top two stack entries
+
+        op_load,        //  load a variable
+        op_store,       //  store a variable
+
+        op_int,         //  push constant integer into the stack
+        op_true,        //  push constant 0 into the stack
+        op_false,       //  push constant 1 into the stack
+
+        op_jump_if,     //  jump to a relative position in the code if top stack
+                        //  evaluates to false
+        op_jump,        //  jump to a relative position in the code
+
+        op_stk_adj,     // adjust the stack (for args and locals)
+        op_call,        // function call
+        op_return       // return from function
+    };
+
+    class vmachine
+    {
+    public:
+
+        vmachine(unsigned stackSize = 4096)
+          : stack(stackSize)
+        {
+        }
+
+        int execute(
+            std::vector<int> const& code            // the program code
+          , std::vector<int>::const_iterator pc     // program counter
+          , std::vector<int>::iterator frame_ptr    // start of arguments and locals
+        );
+
+        int execute(std::vector<int> const& code)
+        {
+            return execute(code, code.begin(), stack.begin());
+        };
+
+        std::vector<int> const& get_stack() const { return stack; };
+
+    private:
+
+        std::vector<int> stack;
+    };
+}
+
+#endif
+
diff --git a/src/boost/libs/spirit/example/x3/complex_number.cpp b/src/boost/libs/spirit/example/x3/complex_number.cpp
new file mode 100644
index 00000000..3d63ab61
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/complex_number.cpp
@@ -0,0 +1,98 @@
+/*=============================================================================
+    Copyright (c) 2002-2015 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A complex number micro parser.
+//
+//  [ JDG May 10, 2002 ]    spirit1
+//  [ JDG May 9, 2007 ]     spirit2
+//  [ JDG May 12, 2015 ]    spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include <iostream>
+#include <string>
+#include <complex>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our complex number parser/compiler
+///////////////////////////////////////////////////////////////////////////////
+namespace client
+{
+    template <typename Iterator>
+    bool parse_complex(Iterator first, Iterator last, std::complex<double>& c)
+    {
+        using boost::spirit::x3::double_;
+        using boost::spirit::x3::_attr;
+        using boost::spirit::x3::phrase_parse;
+        using boost::spirit::x3::ascii::space;
+
+        double rN = 0.0;
+        double iN = 0.0;
+        auto fr = [&](auto& ctx){ rN = _attr(ctx); };
+        auto fi = [&](auto& ctx){ iN = _attr(ctx); };
+
+        bool r = phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                    '(' >> double_[fr]
+                        >> -(',' >> double_[fi]) >> ')'
+                |   double_[fr]
+            ),
+            //  End grammar
+
+            space);
+
+        if (!r || first != last) // fail if we did not get a full match
+            return false;
+        c = std::complex<double>(rN, iN);
+        return r;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////
+//  Main program
+////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tA complex number micro parser for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a complex number of the form r or (r) or (r,i) \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::complex<double> c;
+        if (client::parse_complex(str.begin(), str.end(), c))
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "got: " << c << 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;
+}
diff --git a/src/boost/libs/spirit/example/x3/employee.cpp b/src/boost/libs/spirit/example/x3/employee.cpp
new file mode 100644
index 00000000..62571027
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/employee.cpp
@@ -0,0 +1,134 @@
+/*=============================================================================
+    Copyright (c) 2002-2015 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A parser for arbitrary tuples. This example presents a parser
+//  for an employee structure.
+//
+//  [ JDG May 9, 2007 ]
+//  [ JDG May 13, 2015 ]    spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our employee struct
+    ///////////////////////////////////////////////////////////////////////////
+    struct employee
+    {
+        int age;
+        std::string forename;
+        std::string surname;
+        double salary;
+    };
+
+    using boost::fusion::operator<<;
+}}
+
+// We need to tell fusion about our employee struct
+// to make it a first-class fusion citizen. This has to
+// be in global scope.
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::employee,
+    age, forename, surname, salary
+)
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our employee parser
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace parser
+    {
+        namespace x3 = boost::spirit::x3;
+        namespace ascii = boost::spirit::x3::ascii;
+
+        using x3::int_;
+        using x3::lit;
+        using x3::double_;
+        using x3::lexeme;
+        using ascii::char_;
+
+        x3::rule<class employee, ast::employee> const employee = "employee";
+
+        auto const quoted_string = lexeme['"' >> +(char_ - '"') >> '"'];
+
+        auto const employee_def =
+            lit("employee")
+            >> '{'
+            >>  int_ >> ','
+            >>  quoted_string >> ','
+            >>  quoted_string >> ','
+            >>  double_
+            >>  '}'
+            ;
+
+        BOOST_SPIRIT_DEFINE(employee);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////
+//  Main program
+////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tAn employee parser for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout
+        << "Give me an employee of the form :"
+        << "employee{age, \"forename\", \"surname\", salary } \n";
+    std::cout << "Type [q or Q] to quit\n\n";
+
+    using boost::spirit::x3::ascii::space;
+    typedef std::string::const_iterator iterator_type;
+    using client::parser::employee;
+
+    std::string str;
+    while (getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        client::ast::employee emp;
+        iterator_type iter = str.begin();
+        iterator_type const end = str.end();
+        bool r = phrase_parse(iter, end, employee, space, emp);
+
+        if (r && iter == end)
+        {
+            std::cout << boost::fusion::tuple_open('[');
+            std::cout << boost::fusion::tuple_close(']');
+            std::cout << boost::fusion::tuple_delimiter(", ");
+
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "got: " << emp << 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;
+}
diff --git a/src/boost/libs/spirit/example/x3/error_handling.cpp b/src/boost/libs/spirit/example/x3/error_handling.cpp
new file mode 100644
index 00000000..3b890a5e
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/error_handling.cpp
@@ -0,0 +1,277 @@
+/*=============================================================================
+    Copyright (c) 2002-2018 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Based on the employee parser (see employee.cpp), this example shows how
+//  to implement error handling. This example also shows how to "inject" client
+//  data, using the "with" directive, that the handlers can access.
+//
+//  [ JDG May 9, 2007 ]
+//  [ JDG May 13, 2015 ]    spirit X3
+//  [ JDG Feb 19, 2018 ]    Error handling for spirit X3
+//
+//    I would like to thank Rainbowverse, llc (https://primeorbial.com/)
+//    for sponsoring this work and donating it to the community.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
+#include <boost/spirit/home/x3/support/utility/error_reporting.hpp>
+#include <boost/spirit/home/x3/support/utility/annotate_on_success.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/io.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our AST (employee and person structs)
+    ///////////////////////////////////////////////////////////////////////////
+    namespace x3 = boost::spirit::x3;
+
+    struct person : x3::position_tagged
+    {
+        person(
+            std::string const& first_name = ""
+          , std::string const& last_name = ""
+        )
+          : first_name(first_name)
+          , last_name(last_name)
+        {}
+
+        std::string first_name, last_name;
+    };
+
+    struct employee : x3::position_tagged
+    {
+        int age;
+        person who;
+        double salary;
+    };
+
+    using boost::fusion::operator<<;
+}}
+
+// We need to tell fusion about our employee struct
+// to make it a first-class fusion citizen. This has to
+// be in global scope.
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::person,
+    first_name, last_name
+)
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::employee,
+    age, who, salary
+)
+
+namespace client
+{
+    namespace parser
+    {
+        namespace x3 = boost::spirit::x3;
+        namespace ascii = boost::spirit::x3::ascii;
+
+        ///////////////////////////////////////////////////////////////////////
+        //  Our error handler
+        ///////////////////////////////////////////////////////////////////////
+        struct error_handler
+        {
+            template <typename Iterator, typename Exception, typename Context>
+            x3::error_handler_result on_error(
+                Iterator& first, Iterator const& last
+              , Exception const& x, Context const& context)
+            {
+                auto& error_handler = x3::get<x3::error_handler_tag>(context).get();
+                std::string message = "Error! Expecting: " + x.which() + " here:";
+                error_handler(x.where(), message);
+                return x3::error_handler_result::fail;
+            }
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        //  Our employee parser
+        ///////////////////////////////////////////////////////////////////////
+
+        using x3::int_;
+        using x3::double_;
+        using x3::lexeme;
+        using ascii::char_;
+
+        struct quoted_string_class;
+        struct person_class;
+        struct employee_class;
+
+        x3::rule<quoted_string_class, std::string> const quoted_string = "quoted_string";
+        x3::rule<person_class, ast::person> const person = "person";
+        x3::rule<employee_class, ast::employee> const employee = "employee";
+
+        auto const quoted_string_def = lexeme['"' >> +(char_ - '"') >> '"'];
+        auto const person_def = quoted_string > ',' > quoted_string;
+
+        auto const employee_def =
+                '{'
+            >   int_ > ','
+            >   person > ','
+            >   double_
+            >   '}'
+            ;
+
+        auto const employees = employee >> *(',' >> employee);
+
+        BOOST_SPIRIT_DEFINE(quoted_string, person, employee);
+
+        struct quoted_string_class {};
+        struct person_class : x3::annotate_on_success {};
+        struct employee_class : error_handler, x3::annotate_on_success {};
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+// Our main parse entry point
+///////////////////////////////////////////////////////////////////////////////
+
+void parse(std::string const& input)
+{
+    using boost::spirit::x3::ascii::space;
+    typedef std::string::const_iterator iterator_type;
+
+    std::vector<client::ast::employee> ast;
+    iterator_type iter = input.begin();
+    iterator_type const end = input.end();
+
+    using boost::spirit::x3::with;
+    using boost::spirit::x3::error_handler_tag;
+    using error_handler_type = boost::spirit::x3::error_handler<iterator_type>;
+
+    // Our error handler
+    error_handler_type error_handler(iter, end, std::cerr);
+
+    // Our parser
+    using client::parser::employees;
+    auto const parser =
+        // we pass our error handler to the parser so we can access
+        // it later in our on_error and on_sucess handlers
+        with<error_handler_tag>(std::ref(error_handler))
+        [
+            employees
+        ];
+
+    bool r = phrase_parse(iter, end, parser, space, ast);
+
+    if (r && iter == end)
+    {
+        std::cout << boost::fusion::tuple_open('[');
+        std::cout << boost::fusion::tuple_close(']');
+        std::cout << boost::fusion::tuple_delimiter(", ");
+
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+
+        for (auto const& emp : ast)
+        {
+            std::cout << "got: " << emp << std::endl;
+        }
+        std::cout << "\n-------------------------\n";
+
+    }
+    else
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "-------------------------\n";
+        ast.clear();
+    }
+}
+
+// Good sample:
+
+std::string good_input = R"(
+{
+    23,
+    "Amanda",
+    "Stefanski",
+    1000.99
+},
+{
+    35,
+    "Angie",
+    "Chilcote",
+    2000.99
+},
+{
+    43,
+    "Dannie",
+    "Dillinger",
+    3000.99
+},
+{
+    22,
+    "Dorene",
+    "Dole",
+    2500.99
+},
+{
+    38,
+    "Rossana",
+    "Rafferty",
+    5000.99
+}
+)";
+
+// Input sample with error:
+
+std::string bad_input = R"(
+{
+    23,
+    "Amanda",
+    "Stefanski",
+    1000.99
+},
+{
+    35,
+    "Angie",
+    "Chilcote",
+    2000.99
+},
+{
+    43,
+    'I am not a person!'    <--- this should be a person
+    3000.99
+},
+{
+    22,
+    "Dorene",
+    "Dole",
+    2500.99
+},
+{
+    38,
+    "Rossana",
+    "Rafferty",
+    5000.99
+}
+)";
+
+int
+main()
+{
+    // Good input
+    parse(good_input);
+
+   // Bad input
+    std::cout << "Now we have some errors" << std::endl;
+    parse(bad_input);
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/minimal/ast.hpp b/src/boost/libs/spirit/example/x3/minimal/ast.hpp
new file mode 100644
index 00000000..b66bb072
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/minimal/ast.hpp
@@ -0,0 +1,31 @@
+/*=============================================================================
+    Copyright (c) 2002-2018 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_MINIMAL_AST_HPP)
+#define BOOST_SPIRIT_X3_MINIMAL_AST_HPP
+
+#include <boost/fusion/include/io.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our employee AST struct
+    ///////////////////////////////////////////////////////////////////////////
+    struct employee
+    {
+        int age;
+        std::string forename;
+        std::string surname;
+        double salary;
+    };
+
+    using boost::fusion::operator<<;
+}}
+
+#endif
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/minimal/ast_adapted.hpp b/src/boost/libs/spirit/example/x3/minimal/ast_adapted.hpp
new file mode 100644
index 00000000..9d6c6fe9
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/minimal/ast_adapted.hpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    Copyright (c) 2002-2018 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_MINIMAL_AST_ADAPTED_HPP)
+#define BOOST_SPIRIT_X3_MINIMAL_AST_ADAPTED_HPP
+
+#include <boost/fusion/include/adapt_struct.hpp>
+#include "ast.hpp"
+
+// We need to tell fusion about our employee struct
+// to make it a first-class fusion citizen. This has to
+// be in global scope.
+
+BOOST_FUSION_ADAPT_STRUCT(client::ast::employee,
+    age, forename, surname, salary
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/minimal/config.hpp b/src/boost/libs/spirit/example/x3/minimal/config.hpp
new file mode 100644
index 00000000..3787346a
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/minimal/config.hpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2001-2018 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_MINIMAL_CONFIG_HPP)
+#define BOOST_SPIRIT_X3_MINIMAL_CONFIG_HPP
+
+#include <boost/spirit/home/x3.hpp>
+
+namespace client { namespace parser
+{
+    namespace x3 = boost::spirit::x3;
+
+    using iterator_type = std::string::const_iterator;
+    using context_type = x3::phrase_parse_context<x3::ascii::space_type>::type;
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/minimal/employee.cpp b/src/boost/libs/spirit/example/x3/minimal/employee.cpp
new file mode 100644
index 00000000..8b2fa6c1
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/minimal/employee.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2001-2018 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)
+=============================================================================*/
+#include "employee_def.hpp"
+#include "config.hpp"
+
+namespace client { namespace parser
+{
+    BOOST_SPIRIT_INSTANTIATE(employee_type, iterator_type, context_type);
+}}
diff --git a/src/boost/libs/spirit/example/x3/minimal/employee.hpp b/src/boost/libs/spirit/example/x3/minimal/employee.hpp
new file mode 100644
index 00000000..a4475ec2
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/minimal/employee.hpp
@@ -0,0 +1,30 @@
+/*=============================================================================
+    Copyright (c) 2002-2018 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_MINIMAL_EMPLOYEE_HPP)
+#define BOOST_SPIRIT_X3_MINIMAL_EMPLOYEE_HPP
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include "ast.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our employee parser declaration
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace parser
+    {
+        namespace x3 = boost::spirit::x3;
+        using employee_type = x3::rule<class employee, ast::employee>;
+        BOOST_SPIRIT_DECLARE(employee_type);
+    }
+
+    parser::employee_type employee();
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/minimal/employee_def.hpp b/src/boost/libs/spirit/example/x3/minimal/employee_def.hpp
new file mode 100644
index 00000000..227b2f7f
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/minimal/employee_def.hpp
@@ -0,0 +1,56 @@
+/*=============================================================================
+    Copyright (c) 2002-2018 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_MINIMAL_EMPLOYEE_DEF_HPP)
+#define BOOST_SPIRIT_X3_MINIMAL_EMPLOYEE_DEF_HPP
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include "ast.hpp"
+#include "ast_adapted.hpp"
+#include "employee.hpp"
+
+namespace client
+{
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Our employee parser definition
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace parser
+    {
+        namespace x3 = boost::spirit::x3;
+        namespace ascii = boost::spirit::x3::ascii;
+
+        using x3::int_;
+        using x3::lit;
+        using x3::double_;
+        using x3::lexeme;
+        using ascii::char_;
+
+        x3::rule<class employee, ast::employee> const employee = "employee";
+
+        auto const quoted_string = lexeme['"' >> +(char_ - '"') >> '"'];
+
+        auto const employee_def =
+            lit("employee")
+            >> '{'
+            >>  int_ >> ','
+            >>  quoted_string >> ','
+            >>  quoted_string >> ','
+            >>  double_
+            >>  '}'
+            ;
+
+        BOOST_SPIRIT_DEFINE(employee);
+    }
+
+    parser::employee_type employee()
+    {
+        return parser::employee;
+    }
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/minimal/main.cpp b/src/boost/libs/spirit/example/x3/minimal/main.cpp
new file mode 100644
index 00000000..aeb3bc51
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/minimal/main.cpp
@@ -0,0 +1,79 @@
+/*=============================================================================
+    Copyright (c) 2002-2018 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 is the same employee parser (see employee.cpp) but structured to
+//  allow separate compilation of the actual parser in its own definition
+//  file (employee_def.hpp) and cpp file (employee.cpp). This main cpp file
+//  sees only the header file (employee.hpp). This is a good example on how
+//  parsers are structured in a C++ application.
+//
+//  [ JDG May 9, 2007 ]
+//  [ JDG May 13, 2015 ]    spirit X3
+//  [ JDG Feb 20, 2018 ]    Minimal "best practice" example
+//
+//    I would like to thank Rainbowverse, llc (https://primeorbial.com/)
+//    for sponsoring this work and donating it to the community.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "ast.hpp"
+#include "ast_adapted.hpp"
+#include "employee.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tAn employee parser for Spirit...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout
+        << "Give me an employee of the form :"
+        << "employee{age, \"forename\", \"surname\", salary } \n";
+    std::cout << "Type [q or Q] to quit\n\n";
+
+    using boost::spirit::x3::ascii::space;
+    using iterator_type = std::string::const_iterator;
+    using client::employee;
+
+    std::string str;
+    while (getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        client::ast::employee emp;
+        iterator_type iter = str.begin();
+        iterator_type const end = str.end();
+        bool r = phrase_parse(iter, end, employee(), space, emp);
+
+        if (r && iter == end)
+        {
+            std::cout << boost::fusion::tuple_open('[');
+            std::cout << boost::fusion::tuple_close(']');
+            std::cout << boost::fusion::tuple_delimiter(", ");
+
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "got: " << emp << 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;
+}
diff --git a/src/boost/libs/spirit/example/x3/num_list/num_list1.cpp b/src/boost/libs/spirit/example/x3/num_list/num_list1.cpp
new file mode 100644
index 00000000..34371e67
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/num_list/num_list1.cpp
@@ -0,0 +1,87 @@
+/*=============================================================================
+    Copyright (c) 2002-2015 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.
+//  No semantic actions.
+//
+//  [ JDG May 10, 2002 ]    spirit1
+//  [ JDG March 24, 2007 ]  spirit2
+//  [ JDG May 12, 2015 ]    spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace ascii = boost::spirit::x3::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list parser
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last)
+    {
+        using x3::double_;
+        using x3::phrase_parse;
+        using ascii::space;
+
+        bool r = phrase_parse(
+            first,                          // Start Iterator
+            last,                           // End Iterator
+            double_ >> *(',' >> double_),   // The Parser
+            space                           // The Skip-Parser
+        );
+        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 << "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;
+
+        if (client::parse_numbers(str.begin(), str.end()))
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << str << " Parses OK: " << std::endl;
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/num_list/num_list2.cpp b/src/boost/libs/spirit/example/x3/num_list/num_list2.cpp
new file mode 100644
index 00000000..67a75053
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/num_list/num_list2.cpp
@@ -0,0 +1,101 @@
+/*=============================================================================
+    Copyright (c) 2002-2015 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.
+//
+//  [ JDG May 10, 2002 ]    spirit1
+//  [ JDG March 24, 2007 ]  spirit2
+//  [ JDG May 12, 2015 ]    spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace ascii = boost::spirit::x3::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list compiler
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
+    {
+        using x3::double_;
+        using x3::phrase_parse;
+        using x3::_attr;
+        using ascii::space;
+
+        auto push_back = [&](auto& ctx){ v.push_back(_attr(ctx)); };
+
+        bool r = phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                double_[push_back] >> *(',' >> double_[push_back])
+            )
+            ,
+            //  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 (client::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;
+}
diff --git a/src/boost/libs/spirit/example/x3/num_list/num_list3.cpp b/src/boost/libs/spirit/example/x3/num_list/num_list3.cpp
new file mode 100644
index 00000000..53a275bb
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/num_list/num_list3.cpp
@@ -0,0 +1,101 @@
+/*=============================================================================
+    Copyright (c) 2002-2015 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.
+//
+//  [ JDG May 10, 2002 ]    spirit1
+//  [ JDG March 24, 2007 ]  spirit2
+//  [ JDG May 12, 2015 ]    spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace ascii = boost::spirit::x3::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list compiler
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
+    {
+        using x3::double_;
+        using x3::phrase_parse;
+        using x3::_attr;
+        using ascii::space;
+
+        auto push_back = [&](auto& ctx){ v.push_back(_attr(ctx)); };
+
+        bool r = phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                double_[push_back] % ','
+            )
+            ,
+            //  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 (client::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;
+}
diff --git a/src/boost/libs/spirit/example/x3/num_list/num_list4.cpp b/src/boost/libs/spirit/example/x3/num_list/num_list4.cpp
new file mode 100644
index 00000000..1c88b284
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/num_list/num_list4.cpp
@@ -0,0 +1,103 @@
+/*=============================================================================
+    Copyright (c) 2002-2015 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.
+//  This time, the numbers are automatically collected into the attribute by
+//  the parser itself using the full power of attribute grammars.
+//
+//  [ JDG May 10, 2002 ]    spirit1
+//  [ JDG March 24, 2007 ]  spirit2
+//  [ JDG May 12, 2015 ]    spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace ascii = boost::spirit::x3::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our number list compiler
+    ///////////////////////////////////////////////////////////////////////////
+    //[tutorial_numlist4
+    template <typename Iterator>
+    bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
+    {
+        using x3::double_;
+        using x3::phrase_parse;
+        using x3::_attr;
+        using ascii::space;
+
+        bool r = phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                double_ % ','
+            )
+            ,
+            //  End grammar
+
+            space, v);
+
+        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 (client::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;
+}
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_examples/a.rexpr b/src/boost/libs/spirit/example/x3/rexpr/rexpr_examples/a.rexpr
new file mode 100644
index 00000000..880f5bac
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_examples/a.rexpr
@@ -0,0 +1,8 @@
+{
+    "color" = "blue"
+    "size" = "29 cm."
+    "position" = {
+        "x" = "123"
+        "y" = "456"
+    }
+}
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/Jamfile b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/Jamfile
new file mode 100644
index 00000000..5723b1ed
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/Jamfile
@@ -0,0 +1,20 @@
+#
+#   Copyright (C) 2015 Michael Caisse, ciere.com
+#
+#   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)
+#
+
+project spirit-x3-example-rexpr
+   : requirements
+      <c++-template-depth>512
+      <use>/boost//headers
+      <define>BOOST_SPIRIT_X3_NO_FILESYSTEM
+      <include>.
+   ;
+
+lib rexpr
+   : [ glob src/*.cpp ]
+   ;
+
+build-project test ;
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/ast.hpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/ast.hpp
new file mode 100644
index 00000000..c7635b12
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/ast.hpp
@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_REPR_AST_HPP)
+#define BOOST_SPIRIT_X3_REPR_AST_HPP
+
+#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+
+#include <map>
+
+namespace rexpr { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  The AST
+    ///////////////////////////////////////////////////////////////////////////
+    namespace x3 = boost::spirit::x3;
+
+    struct rexpr;
+
+    struct rexpr_value : x3::variant<
+            std::string
+          , x3::forward_ast<rexpr>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+
+    typedef std::map<std::string, rexpr_value> rexpr_map;
+    typedef std::pair<std::string, rexpr_value> rexpr_key_value;
+
+    struct rexpr : x3::position_tagged
+    {
+        rexpr_map entries;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/ast_adapted.hpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/ast_adapted.hpp
new file mode 100644
index 00000000..d325cbbd
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/ast_adapted.hpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_REPR_AST_ADAPTED_HPP)
+#define BOOST_SPIRIT_X3_REPR_AST_ADAPTED_HPP
+
+#include "ast.hpp"
+
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+
+// We need to tell fusion about our rexpr and rexpr_key_value
+// to make them a first-class fusion citizens
+
+BOOST_FUSION_ADAPT_STRUCT(rexpr::ast::rexpr,
+    entries
+)
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/config.hpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/config.hpp
new file mode 100644
index 00000000..12a25def
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/config.hpp
@@ -0,0 +1,35 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_REPR_CONFIG_HPP)
+#define BOOST_SPIRIT_X3_REPR_CONFIG_HPP
+
+#include "error_handler.hpp"
+
+#include <boost/spirit/home/x3.hpp>
+
+namespace rexpr { namespace parser
+{
+    // Our Iterator Type
+    typedef std::string::const_iterator iterator_type;
+
+    // The Phrase Parse Context
+    typedef
+        x3::phrase_parse_context<x3::ascii::space_type>::type
+    phrase_context_type;
+
+    // Our Error Handler
+    typedef error_handler<iterator_type> error_handler_type;
+
+    // Combined Error Handler and Phrase Parse Context
+    typedef x3::context<
+        error_handler_tag
+      , std::reference_wrapper<error_handler_type>
+      , phrase_context_type>
+    context_type;
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/error_handler.hpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/error_handler.hpp
new file mode 100644
index 00000000..a173d492
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/error_handler.hpp
@@ -0,0 +1,72 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_REPR_ERROR_HANDLER_HPP)
+#define BOOST_SPIRIT_X3_REPR_ERROR_HANDLER_HPP
+
+#include "rexpr.hpp"
+
+#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
+#include <boost/spirit/home/x3/support/utility/error_reporting.hpp>
+
+#include <map>
+
+namespace rexpr { namespace parser
+{
+    namespace x3 = boost::spirit::x3;
+
+    ////////////////////////////////////////////////////////////////////////////
+    //  Our error handler
+    ////////////////////////////////////////////////////////////////////////////
+    // X3 Error Handler Utility
+    template <typename Iterator>
+    using error_handler = x3::error_handler<Iterator>;
+
+    // tag used to get our error handler from the context
+    using error_handler_tag = x3::error_handler_tag;
+
+    struct error_handler_base
+    {
+        error_handler_base();
+
+        template <typename Iterator, typename Exception, typename Context>
+        x3::error_handler_result on_error(
+            Iterator& first, Iterator const& last
+          , Exception const& x, Context const& context);
+
+        std::map<std::string, std::string> id_map;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Implementation
+    ////////////////////////////////////////////////////////////////////////////
+
+    inline error_handler_base::error_handler_base()
+    {
+        id_map["rexpr"] = "RExpression";
+        id_map["rexpr_value"] = "Value";
+        id_map["rexpr_key_value"] = "Key value pair";
+    }
+
+    template <typename Iterator, typename Exception, typename Context>
+    inline x3::error_handler_result
+    error_handler_base::on_error(
+        Iterator& first, Iterator const& last
+      , Exception const& x, Context const& context)
+    {
+        std::string which = x.which();
+        auto iter = id_map.find(which);
+        if (iter != id_map.end())
+            which = iter->second;
+
+        std::string message = "Error! Expecting: " + which + " here:";
+        auto& error_handler = x3::get<error_handler_tag>(context).get();
+        error_handler(x.where(), message);
+        return x3::error_handler_result::fail;
+    }
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/printer.hpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/printer.hpp
new file mode 100644
index 00000000..a1c307c6
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/printer.hpp
@@ -0,0 +1,57 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_REPR_PRINTER_HPP)
+#define BOOST_SPIRIT_X3_REPR_PRINTER_HPP
+
+#include "ast.hpp"
+
+#include <ostream>
+
+namespace rexpr { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Print out the rexpr tree
+    ///////////////////////////////////////////////////////////////////////////
+    int const tabsize = 4;
+
+    struct rexpr_printer
+    {
+        typedef void result_type;
+
+        rexpr_printer(std::ostream& out, int indent = 0)
+          : out(out), indent(indent) {}
+
+        void operator()(rexpr const& ast) const
+        {
+            out << '{' << std::endl;
+            for (auto const& entry : ast.entries)
+            {
+                tab(indent+tabsize);
+                out << '"' << entry.first << "\" = ";
+                boost::apply_visitor(rexpr_printer(out, indent+tabsize), entry.second);
+            }
+            tab(indent);
+            out << '}' << std::endl;
+        }
+
+        void operator()(std::string const& text) const
+        {
+            out << '"' << text << '"' << std::endl;
+        }
+
+        void tab(int spaces) const
+        {
+            for (int i = 0; i < spaces; ++i)
+                out << ' ';
+        }
+
+        std::ostream& out;
+        int indent;
+    };
+}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/rexpr.hpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/rexpr.hpp
new file mode 100644
index 00000000..f3979f9d
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/rexpr.hpp
@@ -0,0 +1,33 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_REXPR_HPP)
+#define BOOST_SPIRIT_X3_REXPR_HPP
+
+#include "ast.hpp"
+
+#include <boost/spirit/home/x3.hpp>
+
+namespace rexpr
+{
+    namespace x3 = boost::spirit::x3;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // rexpr public interface
+    ///////////////////////////////////////////////////////////////////////////
+    namespace parser
+    {
+        struct rexpr_class;
+        typedef
+            x3::rule<rexpr_class, ast::rexpr>
+        rexpr_type;
+        BOOST_SPIRIT_DECLARE(rexpr_type);
+    }
+
+    parser::rexpr_type const& rexpr();
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/rexpr_def.hpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/rexpr_def.hpp
new file mode 100644
index 00000000..3875031a
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/rexpr/rexpr_def.hpp
@@ -0,0 +1,94 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_REPR_REXPR_DEF_HPP)
+#define BOOST_SPIRIT_X3_REPR_REXPR_DEF_HPP
+
+#include "ast.hpp"
+#include "ast_adapted.hpp"
+#include "error_handler.hpp"
+#include "rexpr.hpp"
+
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/utility/annotate_on_success.hpp>
+
+namespace rexpr { namespace parser
+{
+    namespace x3 = boost::spirit::x3;
+    namespace ascii = boost::spirit::x3::ascii;
+
+    using x3::lit;
+    using x3::lexeme;
+
+    using ascii::char_;
+    using ascii::string;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Rule IDs
+    ///////////////////////////////////////////////////////////////////////////
+
+    struct rexpr_value_class;
+    struct rexpr_key_value_class;
+    struct rexpr_inner_class;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Rules
+    ///////////////////////////////////////////////////////////////////////////
+
+    x3::rule<rexpr_value_class, ast::rexpr_value> const
+        rexpr_value = "rexpr_value";
+
+    x3::rule<rexpr_key_value_class, ast::rexpr_key_value> const
+        rexpr_key_value = "rexpr_key_value";
+
+    x3::rule<rexpr_inner_class, ast::rexpr> const
+        rexpr_inner = "rexpr";
+
+    rexpr_type const rexpr = "rexpr";
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Grammar
+    ///////////////////////////////////////////////////////////////////////////
+
+    auto const quoted_string =
+        lexeme['"' >> *(char_ - '"') >> '"'];
+
+    auto const rexpr_value_def =
+        quoted_string | rexpr_inner;
+
+    auto const rexpr_key_value_def =
+        quoted_string > '=' > rexpr_value;
+
+    auto const rexpr_inner_def =
+        '{' > *rexpr_key_value > '}';
+
+    auto const rexpr_def = rexpr_inner_def;
+
+    BOOST_SPIRIT_DEFINE(rexpr_value, rexpr, rexpr_inner, rexpr_key_value);
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Annotation and Error handling
+    ///////////////////////////////////////////////////////////////////////////
+
+    // We want these to be annotated with the iterator position.
+    struct rexpr_value_class : x3::annotate_on_success {};
+    struct rexpr_key_value_class : x3::annotate_on_success {};
+    struct rexpr_inner_class : x3::annotate_on_success {};
+
+    // We want error-handling only for the start (outermost) rexpr
+    // rexpr is the same as rexpr_inner but without error-handling (see error_handler.hpp)
+    struct rexpr_class : x3::annotate_on_success, error_handler_base {};
+}}
+
+namespace rexpr
+{
+    parser::rexpr_type const& rexpr()
+    {
+        return parser::rexpr;
+    }
+}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/src/rexpr.cpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/src/rexpr.cpp
new file mode 100644
index 00000000..14b84c60
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/src/rexpr.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#include "../rexpr/rexpr_def.hpp"
+#include "../rexpr/config.hpp"
+
+namespace rexpr { namespace parser
+{
+    BOOST_SPIRIT_INSTANTIATE(
+        rexpr_type, iterator_type, context_type);
+}}
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/Jamfile b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/Jamfile
new file mode 100644
index 00000000..4952e281
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/Jamfile
@@ -0,0 +1,23 @@
+#
+#   Copyright (C) 2015 Michael Caisse, ciere.com
+#
+#   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)
+#
+
+import testing ;
+
+project
+   : requirements
+      <source>..//rexpr
+      <source>/boost//regex
+      <source>/boost//filesystem
+      <c++-template-depth>300
+   ;
+
+path-constant TEST_FILES : test_files ;
+
+unit-test parse_rexpr_test
+   : parse_rexpr_test.cpp
+   : <testing.arg>"$(TEST_FILES)"
+   ;
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/parse_rexpr_test.cpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/parse_rexpr_test.cpp
new file mode 100644
index 00000000..bdbacf2d
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/parse_rexpr_test.cpp
@@ -0,0 +1,86 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#include <iostream>
+#include <iterator>
+#include <algorithm>
+#include <sstream>
+
+#include "../rexpr/ast.hpp"
+#include "../rexpr/rexpr.hpp"
+#include "../rexpr/error_handler.hpp"
+#include "../rexpr/config.hpp"
+#include "../rexpr/printer.hpp"
+
+#include "testing.hpp"
+
+namespace fs = boost::filesystem;
+namespace testing = boost::spirit::x3::testing;
+
+auto parse = [](std::string const& source, fs::path input_path)-> std::string
+{
+    std::stringstream out;
+
+    using rexpr::parser::iterator_type;
+    iterator_type iter(source.begin());
+    iterator_type const end(source.end());
+
+    // Our AST
+    rexpr::ast::rexpr ast;
+
+    // Our error handler
+    using boost::spirit::x3::with;
+    using rexpr::parser::error_handler_type;
+    using rexpr::parser::error_handler_tag;
+    error_handler_type error_handler(iter, end, out, input_path.string()); // Our error handler
+
+    // Our parser
+    auto const parser =
+        // we pass our error handler to the parser so we can access
+        // it later on in our on_error and on_sucess handlers
+        with<error_handler_tag>(std::ref(error_handler))
+        [
+            rexpr::rexpr()
+        ];
+
+    // Go forth and parse!
+    using boost::spirit::x3::ascii::space;
+    bool success = phrase_parse(iter, end, parser, space, ast);
+
+    if (success)
+    {
+        if (iter != end)
+            error_handler(iter, "Error! Expecting end of input here: ");
+        else
+            rexpr::ast::rexpr_printer{out}(ast);
+    }
+
+    return out.str();
+};
+
+int num_files_tested = 0;
+auto compare = [](fs::path input_path, fs::path expect_path)
+{
+   testing::compare(input_path, expect_path, parse);
+   ++num_files_tested;
+};
+
+int main(int argc, char* argv[])
+{
+    if (argc < 2)
+    {
+       std::cout << "usage: " << fs::path(argv[0]).filename() << " path/to/test/files" << std::endl;
+       return -1;
+    }
+
+    std::cout << "===================================================================================================" << std::endl;
+    std::cout << "Testing: " << fs::absolute(fs::path(argv[1])) << std::endl;
+    int r = testing::for_each_file(fs::path(argv[1]), compare);
+    if (r == 0)
+        std::cout << num_files_tested << " files tested." << std::endl;
+    std::cout << "===================================================================================================" << std::endl;
+    return r;
+}
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/a.expect b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/a.expect
new file mode 100644
index 00000000..635c145b
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/a.expect
@@ -0,0 +1,8 @@
+{
+    "color" = "blue"
+    "position" = {
+        "x" = "123"
+        "y" = "456"
+    }
+    "size" = "29 cm."
+}
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/a.input b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/a.input
new file mode 100644
index 00000000..880f5bac
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/a.input
@@ -0,0 +1,8 @@
+{
+    "color" = "blue"
+    "size" = "29 cm."
+    "position" = {
+        "x" = "123"
+        "y" = "456"
+    }
+}
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/b.expect b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/b.expect
new file mode 100644
index 00000000..3f485184
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/b.expect
@@ -0,0 +1,4 @@
+In file <%.*?b.input%>, line 4:
+Error! Expecting: Value here:
+    "position" = $
+_________________^_
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/b.input b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/b.input
new file mode 100644
index 00000000..6f0743b1
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/b.input
@@ -0,0 +1,8 @@
+{
+    "color" = "blue"
+    "size" = "29 cm."
+    "position" = $
+        "x" = "123"
+        "y" = "456"
+    }
+}
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/c.expect b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/c.expect
new file mode 100644
index 00000000..bc7efcd0
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/c.expect
@@ -0,0 +1,4 @@
+In file <%.*?c.input%>, line 5:
+Error! Expecting: '}' here:
+        banana
+________^_
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/c.input b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/c.input
new file mode 100644
index 00000000..6eaa1259
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/c.input
@@ -0,0 +1,8 @@
+{
+    "color" = "blue"
+    "size" = "29 cm."
+    "position" = {
+        banana
+        "y" = "456"
+    }
+}
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/d.expect b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/d.expect
new file mode 100644
index 00000000..5b376035
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/d.expect
@@ -0,0 +1,4 @@
+In file <%.*?d.input%>, line 5:
+Error! Expecting: '=' here:
+        "x" : "123"
+____________^_
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/d.input b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/d.input
new file mode 100644
index 00000000..c8be6438
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/d.input
@@ -0,0 +1,8 @@
+{
+    "color" = "blue"
+    "size" = "29 cm."
+    "position" = {
+        "x" : "123"
+        "y" = "456"
+    }
+}
\ No newline at end of file
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/e.expect b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/e.expect
new file mode 100644
index 00000000..4fed2140
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/e.expect
@@ -0,0 +1,5 @@
+In file <%.*?e.input%>, line 8:
+Error! Expecting end of input here: 
+};
+_^_
+
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/e.input b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/e.input
new file mode 100644
index 00000000..1bd447f1
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/test_files/e.input
@@ -0,0 +1,8 @@
+{
+    "color" = "blue"
+    "size" = "29 cm."
+    "position" = {
+        "x" = "123"
+        "y" = "456"
+    }
+};
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/testing.hpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/testing.hpp
new file mode 100644
index 00000000..eb99f692
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_full/test/testing.hpp
@@ -0,0 +1,269 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_X3_TEST_UTILITIES)
+#define BOOST_SPIRIT_X3_TEST_UTILITIES
+
+#include <boost/regex.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
+namespace boost { namespace spirit { namespace x3 { namespace testing
+{
+    namespace fs = boost::filesystem;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // compare
+    //
+    //      Compares the contents of in with the template tem. The template
+    //      may include embedded regular expressions marked up within re_prefix
+    //      and re_suffix tags. For example, given the default RE markup, this
+    //      template <%[0-9]+%> will match any integer in in. The function
+    //      will return the first non-matching position. The flag full_match
+    //      indicates a full match. It is possible for returned pos to be
+    //      at the end of in (in.end()) while still returning full_match ==
+    //      false. In that case, we have a partial match.
+    ////////////////////////////////////////////////////////////////////////////
+
+    template <typename Iterator>
+    struct compare_result
+    {
+        compare_result(
+            Iterator pos
+          , bool full_match
+        ) : pos(pos), full_match(full_match) {}
+
+        Iterator pos;
+        bool full_match;
+    };
+
+    template <typename Range>
+    compare_result<typename Range::const_iterator>
+    compare(
+        Range const& in
+      , Range const& tem
+      , char const* re_prefix = "<%"
+      , char const* re_suffix = "%>"
+    );
+
+    ////////////////////////////////////////////////////////////////////////////
+    // compare
+    //
+    //      1) Call f, given the contents of input_path loaded in a string.
+    //         The result of calling f is the output string.
+    //      2) Compare the result of calling f with expected template
+    //         file (expect_path) using the low-level compare utility
+    //         abive
+    ////////////////////////////////////////////////////////////////////////////
+    template <typename F>
+    bool compare(
+        fs::path input_path, fs::path expect_path
+      , F f
+      , char const* re_prefix = "<%"
+      , char const* re_suffix = "%>"
+    );
+
+    ////////////////////////////////////////////////////////////////////////////
+    // for_each_file
+    //
+    //      For each *.input and *.expect file in a given directory,
+    //      call the function f, passing in the *.input and *.expect paths.
+    ////////////////////////////////////////////////////////////////////////////
+    template <typename F>
+    int for_each_file(fs::path p, F f);
+
+    ////////////////////////////////////////////////////////////////////////////
+    // load_file
+    //
+    //      Load file into a string.
+    ////////////////////////////////////////////////////////////////////////////
+    std::string load(fs::path p);
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Implementation
+    ////////////////////////////////////////////////////////////////////////////
+
+    template <typename Iterator>
+    inline bool is_regex(
+        Iterator& first
+      , Iterator last
+      , std::string& re
+      , char const* re_prefix
+      , char const* re_suffix
+   )
+   {
+       boost::regex e(re_prefix + std::string("(.*?)") + re_suffix);
+       boost::match_results<Iterator> what;
+       if (boost::regex_search(
+            first, last, what, e
+          , boost::match_default | boost::match_continuous))
+        {
+            re = what[1].str();
+            first = what[0].second;
+            return true;
+        }
+        return false;
+    }
+
+    template <typename Range>
+    inline compare_result<typename Range::const_iterator>
+    compare(
+        Range const& in
+      , Range const& tem
+      , char const* re_prefix
+      , char const* re_suffix
+    )
+    {
+       typedef typename Range::const_iterator iter_t;
+       typedef compare_result<iter_t> compare_result_t;
+
+       iter_t in_first = in.begin();
+       iter_t in_last = in.end();
+       iter_t tem_first = tem.begin();
+       iter_t tem_last = tem.end();
+       std::string re;
+
+       while (in_first != in_last && tem_first != tem_last)
+       {
+            if (is_regex(tem_first, tem_last, re, re_prefix, re_suffix))
+            {
+                boost::match_results<iter_t> what;
+                boost::regex e(re);
+                if (!boost::regex_search(
+                    in_first, in_last, what, e
+                  , boost::match_default | boost::match_continuous))
+                {
+                    // RE mismatch: exit now.
+                    return compare_result_t(in_first, false);
+                }
+                else
+                {
+                    // RE match: gobble the matching string.
+                    in_first = what[0].second;
+                }
+            }
+            else
+            {
+                // Char by char comparison. Exit if we have a mismatch.
+                if (*in_first++ != *tem_first++)
+                    return compare_result_t(in_first, false);
+            }
+        }
+
+        // Ignore trailing spaces in template
+        bool has_trailing_nonspaces = false;
+        while (tem_first != tem_last)
+        {
+            if (!std::isspace(*tem_first++))
+            {
+                has_trailing_nonspaces = true;
+                break;
+            }
+        }
+        while (in_first != in_last)
+        {
+            if (!std::isspace(*in_first++))
+            {
+                has_trailing_nonspaces = true;
+                break;
+            }
+        }
+        // return a full match only if the template is fully matched and if there
+        // are no more characters to match in the source
+        return compare_result_t(in_first, !has_trailing_nonspaces);
+   }
+
+    template <typename F>
+    inline int for_each_file(fs::path p, F f)
+    {
+        try
+        {
+            if (fs::exists(p) && fs::is_directory(p))
+            {
+                for (auto i = fs::directory_iterator(p); i != fs::directory_iterator(); ++i)
+                {
+                   auto ext = fs::extension(i->path());
+                   if (ext == ".input")
+                   {
+                      auto input_path = i->path();
+                      auto expect_path = input_path;
+                      expect_path.replace_extension(".expect");
+                      f(input_path, expect_path);
+                   }
+                }
+            }
+            else
+            {
+                std::cerr << "Directory: " << fs::absolute(p) << " does not exist." << std::endl;
+                return 1;
+            }
+        }
+
+        catch (const fs::filesystem_error& ex)
+        {
+            std::cerr << ex.what() << '\n';
+            return 1;
+        }
+        return 0;
+    }
+
+    inline std::string load(fs::path p)
+    {
+        boost::filesystem::ifstream file(p);
+        if (!file)
+            return "";
+        std::string contents((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+        return contents;
+    }
+
+    template <typename F>
+    inline bool compare(
+        fs::path input_path, fs::path expect_path
+      , F f
+      , char const* re_prefix
+      , char const* re_suffix
+    )
+    {
+        std::string output = f(load(input_path), input_path);
+        std::string expected = load(expect_path);
+
+        auto result = compare(output, expected, re_prefix, re_suffix);
+        if (!result.full_match)
+        {
+            std::cout << "=============================================" << std::endl;
+            std::cout << "==== Mismatch Found:" << std::endl;
+            int line = 1;
+            int col = 1;
+            for (auto i = output.begin(); i != result.pos; ++i)
+            {
+                if (*i == '\n')
+                {
+                    line++;
+                    col = 0;
+                }
+                ++col;
+            }
+
+            std::cerr
+                << "==== File: " << expect_path
+                << ", Line: " << line
+                << ", Column: " << col
+                << std::endl;
+            std::cerr << "=============================================" << std::endl;
+
+            // Print output
+            std::cerr << output;
+            std::cerr << "=============================================" << std::endl;
+            std::cerr << "==== End" << std::endl;
+            std::cerr << "=============================================" << std::endl;
+            return false;
+        }
+        return true;
+    }
+
+}}}}
+
+#endif
diff --git a/src/boost/libs/spirit/example/x3/rexpr/rexpr_min/rexpr.cpp b/src/boost/libs/spirit/example/x3/rexpr/rexpr_min/rexpr.cpp
new file mode 100644
index 00000000..f3a3556d
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/rexpr/rexpr_min/rexpr.cpp
@@ -0,0 +1,215 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A simple parser for X3 intended as a minimal starting point.
+//  'rexpr' is a parser for a language resembling a minimal subset
+//  of json, but limited to a dictionary (composed of key=value pairs)
+//  where the value can itself be a string or a recursive dictionary.
+//
+//  Example:
+//
+//  {
+//      "color" = "blue"
+//      "size" = "29 cm."
+//      "position" = {
+//          "x" = "123"
+//          "y" = "456"
+//      }
+//  }
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/spirit/home/x3/support/ast/variant.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/include/std_pair.hpp>
+#include <boost/fusion/include/io.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <map>
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our AST
+///////////////////////////////////////////////////////////////////////////////
+namespace client { namespace ast
+{
+    namespace fusion = boost::fusion;
+    namespace x3 = boost::spirit::x3;
+
+    struct rexpr;
+
+    struct rexpr_value : x3::variant<
+            std::string
+          , x3::forward_ast<rexpr>
+        >
+    {
+        using base_type::base_type;
+        using base_type::operator=;
+    };
+
+    typedef std::map<std::string, rexpr_value> rexpr_map;
+    typedef std::pair<std::string, rexpr_value> rexpr_key_value;
+
+    struct rexpr
+    {
+        rexpr_map entries;
+    };
+}}
+
+// We need to tell fusion about our rexpr struct
+// to make it a first-class fusion citizen
+BOOST_FUSION_ADAPT_STRUCT(client::ast::rexpr,
+    entries
+)
+
+///////////////////////////////////////////////////////////////////////////////
+//  AST processing
+///////////////////////////////////////////////////////////////////////////////
+namespace client { namespace ast
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  Print out the rexpr tree
+    ///////////////////////////////////////////////////////////////////////////
+    int const tabsize = 4;
+
+    struct rexpr_printer
+    {
+        typedef void result_type;
+
+        rexpr_printer(int indent = 0)
+          : indent(indent) {}
+
+        void operator()(rexpr const& ast) const
+        {
+            std::cout << '{' << std::endl;
+            for (auto const& entry : ast.entries)
+            {
+                tab(indent+tabsize);
+                std::cout << '"' << entry.first << "\" = ";
+                boost::apply_visitor(rexpr_printer(indent+tabsize), entry.second);
+            }
+            tab(indent);
+            std::cout << '}' << std::endl;
+        }
+
+        void operator()(std::string const& text) const
+        {
+            std::cout << '"' << text << '"' << std::endl;
+        }
+
+        void tab(int spaces) const
+        {
+            for (int i = 0; i < spaces; ++i)
+                std::cout << ' ';
+        }
+
+        int indent;
+    };
+}}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Our rexpr grammar
+///////////////////////////////////////////////////////////////////////////////
+namespace client { namespace parser
+{
+    namespace x3 = boost::spirit::x3;
+    namespace ascii = boost::spirit::x3::ascii;
+
+    using x3::lit;
+    using x3::lexeme;
+
+    using ascii::char_;
+    using ascii::string;
+
+    x3::rule<class rexpr_value, ast::rexpr_value>
+        rexpr_value = "rexpr_value";
+
+    x3::rule<class rexpr, ast::rexpr>
+        rexpr = "rexpr";
+
+    x3::rule<class rexpr_key_value, ast::rexpr_key_value>
+        rexpr_key_value = "rexpr_key_value";
+
+    auto const quoted_string =
+        lexeme['"' >> *(char_ - '"') >> '"'];
+
+    auto const rexpr_value_def =
+        quoted_string | rexpr;
+
+    auto const rexpr_key_value_def =
+        quoted_string >> '=' >> rexpr_value;
+
+    auto const rexpr_def =
+        '{' >> *rexpr_key_value >> '}';
+
+    BOOST_SPIRIT_DEFINE(rexpr_value, rexpr, rexpr_key_value);
+}}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv)
+{
+    char const* filename;
+    if (argc > 1)
+    {
+        filename = argv[1];
+    }
+    else
+    {
+        std::cerr << "Error: No input file provided." << std::endl;
+        return 1;
+    }
+
+    std::ifstream in(filename, std::ios_base::in);
+
+    if (!in)
+    {
+        std::cerr << "Error: Could not open input file: "
+            << filename << std::endl;
+        return 1;
+    }
+
+    std::string storage; // We will read the contents here.
+    in.unsetf(std::ios::skipws); // No white space skipping!
+    std::copy(
+        std::istream_iterator<char>(in),
+        std::istream_iterator<char>(),
+        std::back_inserter(storage));
+
+    using client::parser::rexpr; // Our grammar
+    client::ast::rexpr ast; // Our tree
+
+    using boost::spirit::x3::ascii::space;
+    std::string::const_iterator iter = storage.begin();
+    std::string::const_iterator end = storage.end();
+    bool r = phrase_parse(iter, end, rexpr, space, ast);
+
+    if (r && iter == end)
+    {
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing succeeded\n";
+        std::cout << "-------------------------\n";
+        client::ast::rexpr_printer printer;
+        printer(ast);
+        return 0;
+    }
+    else
+    {
+        std::string::const_iterator some = iter+30;
+        std::string context(iter, (some>end)?end:some);
+        std::cout << "-------------------------\n";
+        std::cout << "Parsing failed\n";
+        std::cout << "stopped at: \": " << context << "...\"\n";
+        std::cout << "-------------------------\n";
+        return 1;
+    }
+}
diff --git a/src/boost/libs/spirit/example/x3/roman.cpp b/src/boost/libs/spirit/example/x3/roman.cpp
new file mode 100644
index 00000000..7423c19c
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/roman.cpp
@@ -0,0 +1,179 @@
+/*=============================================================================
+    Copyright (c) 2001-2015 Joel de Guzman
+    Copyright (c) 2015 Ahmed Charles
+
+    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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A Roman Numerals Parser (demonstrating the symbol table). This is
+//  discussed in the "Symbols" chapter in the Spirit User's Guide.
+//
+//  [ JDG August 22, 2002 ] spirit1
+//  [ JDG March 13, 2007 ]  spirit2
+//  [ JDG May 13, 2015 ]    spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace ascii = boost::spirit::x3::ascii;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Parse roman hundreds (100..900) numerals using the symbol table.
+    //  Notice that the data associated with each slot is the parser's attribute
+    //  (which is passed to attached semantic actions).
+    ///////////////////////////////////////////////////////////////////////////////
+    struct hundreds_ : x3::symbols<unsigned>
+    {
+        hundreds_()
+        {
+            add
+                ("C"    , 100)
+                ("CC"   , 200)
+                ("CCC"  , 300)
+                ("CD"   , 400)
+                ("D"    , 500)
+                ("DC"   , 600)
+                ("DCC"  , 700)
+                ("DCCC" , 800)
+                ("CM"   , 900)
+            ;
+        }
+
+    } hundreds;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Parse roman tens (10..90) numerals using the symbol table.
+    ///////////////////////////////////////////////////////////////////////////////
+    struct tens_ : x3::symbols<unsigned>
+    {
+        tens_()
+        {
+            add
+                ("X"    , 10)
+                ("XX"   , 20)
+                ("XXX"  , 30)
+                ("XL"   , 40)
+                ("L"    , 50)
+                ("LX"   , 60)
+                ("LXX"  , 70)
+                ("LXXX" , 80)
+                ("XC"   , 90)
+            ;
+        }
+
+    } tens;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  Parse roman ones (1..9) numerals using the symbol table.
+    ///////////////////////////////////////////////////////////////////////////////
+    struct ones_ : x3::symbols<unsigned>
+    {
+        ones_()
+        {
+            add
+                ("I"    , 1)
+                ("II"   , 2)
+                ("III"  , 3)
+                ("IV"   , 4)
+                ("V"    , 5)
+                ("VI"   , 6)
+                ("VII"  , 7)
+                ("VIII" , 8)
+                ("IX"   , 9)
+            ;
+        }
+
+    } ones;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    //  roman (numerals) grammar
+    //
+    //      Note the use of the || operator. The expression
+    //      a || b reads match a or b and in sequence. Try
+    //      defining the roman numerals grammar in YACC or
+    //      PCCTS. Spirit rules! :-)
+    ///////////////////////////////////////////////////////////////////////////////
+    namespace parser
+    {
+        using x3::eps;
+        using x3::lit;
+        using x3::_val;
+        using x3::_attr;
+        using ascii::char_;
+
+        auto set_zero = [](auto& ctx){ _val(ctx) = 0; };
+        auto add1000 = [](auto& ctx){ _val(ctx) += 1000; };
+        auto add = [](auto& ctx){ _val(ctx) += _attr(ctx); };
+
+        x3::rule<class roman, unsigned> const roman = "roman";
+
+        auto const roman_def =
+            eps                 [set_zero]
+            >>
+            (
+                -(+lit('M')     [add1000])
+                >>  -hundreds   [add]
+                >>  -tens       [add]
+                >>  -ones       [add]
+            )
+        ;
+
+        BOOST_SPIRIT_DEFINE(roman);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Main program
+///////////////////////////////////////////////////////////////////////////////
+int
+main()
+{
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "\t\tRoman Numerals Parser\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+    std::cout << "Type a Roman Numeral ...or [q or Q] to quit\n\n";
+
+    typedef std::string::const_iterator iterator_type;
+    using client::parser::roman; // Our parser
+
+    std::string str;
+    unsigned result;
+    while (std::getline(std::cin, str))
+    {
+        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
+            break;
+
+        iterator_type iter = str.begin();
+        iterator_type const end = str.end();
+        bool r = parse(iter, end, roman, result);
+
+        if (r && iter == end)
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << "result = " << result << std::endl;
+            std::cout << "-------------------------\n";
+        }
+        else
+        {
+            std::string rest(iter, end);
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "stopped at: \": " << rest << "\"\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}
diff --git a/src/boost/libs/spirit/example/x3/sum.cpp b/src/boost/libs/spirit/example/x3/sum.cpp
new file mode 100644
index 00000000..81315fb2
--- /dev/null
+++ b/src/boost/libs/spirit/example/x3/sum.cpp
@@ -0,0 +1,98 @@
+/*=============================================================================
+    Copyright (c) 2002-2015 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)
+=============================================================================*/
+///////////////////////////////////////////////////////////////////////////////
+//
+//  A parser for summing a comma-separated list of numbers using phoenix.
+//
+//  [ JDG June 28, 2002 ]   spirit1
+//  [ JDG March 24, 2007 ]  spirit2
+//  [ JDG May 12, 2015 ]    spirit X3
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <iostream>
+#include <string>
+
+namespace client
+{
+    namespace x3 = boost::spirit::x3;
+    namespace ascii = boost::spirit::x3::ascii;
+
+    using x3::double_;
+    using ascii::space;
+    using x3::_attr;
+
+    ///////////////////////////////////////////////////////////////////////////
+    //  Our adder
+    ///////////////////////////////////////////////////////////////////////////
+
+    template <typename Iterator>
+    bool adder(Iterator first, Iterator last, double& n)
+    {
+        auto assign = [&](auto& ctx){ n = _attr(ctx); };
+        auto add = [&](auto& ctx){ n += _attr(ctx); };
+
+        bool r = x3::phrase_parse(first, last,
+
+            //  Begin grammar
+            (
+                double_[assign] >> *(',' >> double_[add])
+            )
+            ,
+            //  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 parser for summing a list of numbers...\n\n";
+    std::cout << "/////////////////////////////////////////////////////////\n\n";
+
+    std::cout << "Give me a comma separated list of numbers.\n";
+    std::cout << "The numbers are added using Phoenix.\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;
+
+        double n;
+        if (client::adder(str.begin(), str.end(), n))
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing succeeded\n";
+            std::cout << str << " Parses OK: " << std::endl;
+
+            std::cout << "sum = " << n;
+            std::cout << "\n-------------------------\n";
+        }
+        else
+        {
+            std::cout << "-------------------------\n";
+            std::cout << "Parsing failed\n";
+            std::cout << "-------------------------\n";
+        }
+    }
+
+    std::cout << "Bye... :-) \n\n";
+    return 0;
+}