Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r83367 - trunk/boost/spirit/home/classic/utility
From: joel_at_[hidden]
Date: 2013-03-08 23:41:34


Author: djowel
Date: 2013-03-08 23:41:33 EST (Fri, 08 Mar 2013)
New Revision: 83367
URL: http://svn.boost.org/trac/boost/changeset/83367

Log:
Fixes #8186
Text files modified:
   trunk/boost/spirit/home/classic/utility/rule_parser.hpp | 304 ++++++++++++++++++++--------------------
   1 files changed, 152 insertions(+), 152 deletions(-)

Modified: trunk/boost/spirit/home/classic/utility/rule_parser.hpp
==============================================================================
--- trunk/boost/spirit/home/classic/utility/rule_parser.hpp (original)
+++ trunk/boost/spirit/home/classic/utility/rule_parser.hpp 2013-03-08 23:41:33 EST (Fri, 08 Mar 2013)
@@ -16,7 +16,7 @@
 //
 // Using a typeof operator or Boost.Typeof to automatically set the type of
 // variables (as done in the Spirit example demonstrating typeof) is by far not
-// all we can do to tighten up our grammars as there are some significant
+// all we can do to tighten up our grammars as there are some significant
 // drawbacks of this approach:
 // - the types complexity scales with the complexity of the grammar (sooner or
 // later hitting the limits of the compiler),
@@ -32,242 +32,242 @@
 // In practice manually applying this technique leads to rather lengthy code and
 // overthis requires the user to have a solid understanding of Spirit details.
 //
-// Here is a generalized, macro-based approach to easily create typeof-based
+// Here is a generalized, macro-based approach to easily create typeof-based
 // grammars that can be recursive and arbitrarily complex.
 //
 //
 // Quick manual:
 // ============
-//
+//
 // 1. Setup
-//
-// Before the rule parser macro (the protagonist of the facility) can be used
+//
+// Before the rule parser macro (the protagonist of the facility) can be used
 // the the user must define the macro BOOST_SPIRIT__NAMESPACE (note the double
 // underscore characeter) and setup a registration group for Boost.Typeof.
-//
+//
 // Examples:
-//
+//
 // // should come after regular #includeS
 // #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-//
+//
 // // [...]
-//
+//
 // #define BOOST_SPIRIT__NAMESPACE (2,(my_project, my_module))
 // // | | +- outer +- inner
 // // ! space ! -+ | namespace namespace
 // // |
 // // +--- number of nested namespaces
-//
+//
 // namespace my_project { namespace my_module {
-//
+//
 // // [...]
-//
+//
 // ---
-//
+//
 // // should come after regular #includeS
 // #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-//
+//
 // // [...]
-//
+//
 // #define BOOST_SPIRIT__NAMESPACE (2,(my_project, (anonymous) ))
-//
+//
 // namespace my_project { namespace {
-//
+//
 // // [...]
-//
+//
 // ---
-//
+//
 // // should come after regular #includeS
 // #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-//
+//
 // // [...]
-//
-//
+//
+//
 // #define BOOST_SPIRIT__NAMESPACE -
 // // we're working at root namespace
-//
-//
+//
+//
 // Why do I have to do this?
-//
+//
 // Boost.Typeof needs to assign a unique ID for each registration. This ID is
-// created composed of the line number and the registration group. The
+// created composed of the line number and the registration group. The
 // facility performs Typeof registration and thus requires the source file to
 // have its own registration group. Further Boost.Typeof requires registration
 // to happen at root namespace so we have to close and reopen the namespace
 // we're in.
 //
-//
+//
 // 2. The rule parser macro
-//
+//
 // A simple rule parser definition looks like that:
-//
+//
 // // we're at namespace scope here
-//
+//
 // // Skip parser for C/C++ comments and whitespace
-// BOOST_SPIRIT_RULE_PARSER(skipper,
-// -,-,-,
-//
-// +( confix_p("//",*anychar_p,eol_p)
+// BOOST_SPIRIT_RULE_PARSER(skipper,
+// -,-,-,
+//
+// +( confix_p("//",*anychar_p,eol_p)
 // | confix_p("/*",*anychar_p,"*/")
-// | space_p
+// | space_p
 // )
 // )
-//
+//
 // Now we can use 'skipper' in other Spirit expressions.
-//
-// The code above creates a parser (template) class 'skpper_t' and (in this
-// case, because there are no parameters) a static const instance 'skipper' of
+//
+// The code above creates a parser (template) class 'skpper_t' and (in this
+// case, because there are no parameters) a static const instance 'skipper' of
 // that class. The class is automatically registered with Boost.Typeof. The type
 // name our parser is skipper_t here.
-//
-//
+//
+//
 // 2.1. Parametrized rule parsers
-//
+//
 // Rule parser definitions can have parameters.
-//
+//
 // Parameters are passed to the BOOST_SPIRIT_RULE_PARSER macro as its second
-// argument (just pass '-' if there are no parameters) with the following
+// argument (just pass '-' if there are no parameters) with the following
 // format:
-//
+//
 // (N,( param1,param2, / ... / paramN ))
 // +-- number of parameters
-//
+//
 // Example of a whole rule parser:
-//
+//
 // BOOST_SPIRIT_RULE_PARSER(new_name,
 // (1,( symbol_table )),-,-,
-//
+//
 // lexeme_d[ (alpha_p >> *alnum_p)[ symbol_table.add ] ]
 // )
-//
+//
 // The expression 'new_name(my_symbols)' parses a string literal and adds it to
 // the symbol table 'my_symbols'.
-//
+//
 // The rule parser macro creates a function template as called 'new_name' that
 // takes one parameter of deduced reference type and returns a specialization of
 // 'new_name_t' in this case.
-//
-// Since parsers that require to be fast and lightweight often also require to
-// be reentrant, it's quite common to pass in some semantic controller (the
+//
+// Since parsers that require to be fast and lightweight often also require to
+// be reentrant, it's quite common to pass in some semantic controller (the
 // symbol table in the example above).
-// However, parameters are templated so they can be anything (including parsers
+// However, parameters are templated so they can be anything (including parsers
 // of course) so refactoring tasks can be abstracted with rule parsers as well.
-//
+//
 // BOOST_SPIRIT_RULE_PARSER(enumeration_parser,
 // (2,( element_parser, delimiter_parser )),-,-,
-//
+//
 // element_parser >> *(delimiter_parser >> element_parser)
-// )
-//
-// The expression 'enumeration_parser(int_p[ some_action ], ',')' creates a
+// )
+//
+// The expression 'enumeration_parser(int_p[ some_action ], ',')' creates a
 // parser for a comma-separated list of integers.
-//
-//
+//
+//
 // 2.2. Rule parsrs and semantic actions
-//
+//
 // While semantic actions can be globally attached to a rule parser or passed
-// to a parametrized rule parser as (part of) an argument, even more control is
+// to a parametrized rule parser as (part of) an argument, even more control is
 // possible by using action placeholders. E.g:
-//
+//
 // BOOST_SPIRIT_ACTION_PLACEHOLDER(int_action)
-//
+//
 // BOOST_SPIRIT_RULE_PARSER(int_list,
 // -,(1,( int_action )),-,
-//
+//
 // int_p[ int_action ] >> *(',' >> int_p[ int_action ])
 // )
-//
-// The expression 'int_list[ my_action ]' parses a comma separated list of
+//
+// The expression 'int_list[ my_action ]' parses a comma separated list of
 // integers and calls 'my_action' for every integer parsed therein.
-//
-// Of course multiple actions can be attached to one placeholder as usual (in
+//
+// Of course multiple actions can be attached to one placeholder as usual (in
 // this case 'int_list[ my_action1 ][ my_action2 ] would call two actions).
-//
+//
 // Further there can be multiple action placeholders for a single rule parser:
-//
+//
 // BOOST_SPIRIT_ACTION_PLACEHOLDER(feed_int)
 // BOOST_SPIRIT_ACTION_PLACEHOLDER(next_int)
-//
+//
 // BOOST_SPIRIT_RULE_PARSER(int_list,
 // -,(2,( feed_int, next_int )),-,
-//
+//
 // int_p[ feed_int ] >> *(',' >> int_p[ next_int ][ feed_int ])
 // )
-//
+//
 // The expression 'int_list[ (feed_int = my_action1), (next_int = my_action2) ]'
-// creates a parser for a comma separated list of integers with the actions
+// creates a parser for a comma separated list of integers with the actions
 // attached appropriately.
-//
+//
 // int_list[ feed_int = my_action1,my_action2, next_int = my_action3 ]
-//
-// works too (in this case the action placeholder 'feed_int' has two actions
+//
+// works too (in this case the action placeholder 'feed_int' has two actions
 // attached to it).
-//
-// You can both override and append actions associated with an action
+//
+// You can both override and append actions associated with an action
 // placeholder:
-//
+//
 // var = int_list[ feed_int = my_action1, next_int = my_action2 ]
-//
+//
 // // [...]
-//
-// ... var[ feed_int = another_action ]
+//
+// ... var[ feed_int = another_action ]
 // // 'another_action' overrides the actions previously attached to 'feed_int'
-//
+//
 // ... var[ next_int += another_action ]
-// // 'another_action' is appended to the list of actions attached to
+// // 'another_action' is appended to the list of actions attached to
 // // 'next_int'
-//
+//
 // Action placeholders are not entirely for free -- they add to the size and the
-// initialization time of the rule parser. However, the impact on an already
+// initialization time of the rule parser. However, the impact on an already
 // initialized rule parser instance should be quite small.
-//
-//
+//
+//
 // 2.3. Member variables
-//
-// You can add member variables to the rule parser class using the third
+//
+// You can add member variables to the rule parser class using the third
 // parameter of the rule parser macro:
-//
+//
 // BOOST_SPIRIT_RULE_PARSER( calc,
 // -,
 // -,
 // (3,( ((subrule<0>),expression,()),
 // ((subrule<1>),term,()),
 // ((subrule<2>),factor,() )) ),
-//
+//
 // // [...]
-//
+//
 // adds three subrules to the rule parser.
 // Each parameter must have the following type to allow commas to be handled
 // safely from within the preprocessing code:
-//
+//
 // ((type)),name,(constructor argument(s)))
-//
+//
 //
 // 2.4. The opaque rule parser
 //
-// Rule parsers usually are templates. Building large grammars pushes the
-// compiler really hard (and eventually to its limits) because of the
+// Rule parsers usually are templates. Building large grammars pushes the
+// compiler really hard (and eventually to its limits) because of the
 // metafunction complexity involved.
-// If a rule parser without parameters and action placeholders is defined, a
+// If a rule parser without parameters and action placeholders is defined, a
 // non-template class is created. Non-templated rule parsers can also be created
-// explicitly by using BOOST_SPIRIT_OPAQUE_RULE_PARSER.
+// explicitly by using BOOST_SPIRIT_OPAQUE_RULE_PARSER.
 // Opaque rule parsers can have parameters and member variables (note: no action
-// placeholders are possible). The parameters of an opaque rule parsers are
+// placeholders are possible). The parameters of an opaque rule parsers are
 // strictly typed, e.g:
 //
 // BOOST_SPIRIT_OPAQUE_RULE_PARSER(new_identifier,
 // (1,( ((my_symbol_table_t &),symbol_table) ))
 // ,-,
 // (alpha_p >> *alnum_p) [ symbol_table.add ]
-// )
+// )
 //
-// Note it's also possible to have opaque rule parsers accept parameters of
+// Note it's also possible to have opaque rule parsers accept parameters of
 // non-const reference types which is not possible with regular rule parsers.
 //
 //
 // 3. Utilities for by-reference embedding
-//
-// When using parsers mutiple times or recursively it can be helpful to embed
+//
+// When using parsers mutiple times or recursively it can be helpful to embed
 // them by-reference into the final parser expression.
 // For this purpose the library provides a wrapper template 'parser_reference'.
 // There is also a function template to create a wrapped parser which can deduce
@@ -349,22 +349,22 @@
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // RP_REGISTER_TEMPLATE
 //
-// Boost.Typeof registration from within BOOST_SPIRIT__NAMESPACE
+// Boost.Typeof registration from within BOOST_SPIRIT__NAMESPACE
 # define BOOST_SPIRIT_RP_REGISTER_TEMPLATE(name,params) \
       BOOST_SPIRIT_RP_EMIT(NS_CLOSE,BOOST_SPIRIT__NAMESPACE,-) \
     BOOST_TYPEOF_REGISTER_TEMPLATE( \
         BOOST_SPIRIT_RP_EMIT(NS_QUALIFY,BOOST_SPIRIT__NAMESPACE,-) name, \
         params) \
- BOOST_SPIRIT_RP_EMIT(NS_OPEN,BOOST_SPIRIT__NAMESPACE,-)
+ BOOST_SPIRIT_RP_EMIT(NS_OPEN,BOOST_SPIRIT__NAMESPACE,-)
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // RP_REGISTER_TYPE
 //
-// Boost.Typeof registration from within BOOST_SPIRIT__NAMESPACE
+// Boost.Typeof registration from within BOOST_SPIRIT__NAMESPACE
 # define BOOST_SPIRIT_RP_REGISTER_TYPE(name) \
       BOOST_SPIRIT_RP_EMIT(NS_CLOSE,BOOST_SPIRIT__NAMESPACE,-) \
     BOOST_TYPEOF_REGISTER_TYPE( \
         BOOST_SPIRIT_RP_EMIT(NS_QUALIFY,BOOST_SPIRIT__NAMESPACE,-) name ) \
- BOOST_SPIRIT_RP_EMIT(NS_OPEN,BOOST_SPIRIT__NAMESPACE,-)
+ BOOST_SPIRIT_RP_EMIT(NS_OPEN,BOOST_SPIRIT__NAMESPACE,-)
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // RP_AP_IMPL
 //
@@ -385,7 +385,7 @@
           { return ns :: action_chain< name, ns :: append, Action> (__a); } \
         }; \
       } \
- __action_placeholder:: name const name = __action_placeholder:: name ();
+ __action_placeholder:: name const name = __action_placeholder:: name ();
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // RP_IMPL_I
 //
@@ -409,7 +409,7 @@
                                                                                \
       template< BOOST_SPIRIT_RP_TPL_PARAMS(pars,acts,typename __,1) > \
       class name_t \
- : public ::BOOST_SPIRIT_CLASSIC_NS::parser< name_t \
+ : public ::BOOST_SPIRIT_CLASSIC_NS::parser< name_t \
                        < BOOST_SPIRIT_RP_TPL_PARAMS(pars,acts,__,0) > > \
       { \
         class __rule \
@@ -419,7 +419,7 @@
           BOOST_SPIRIT_RP_EMIT(MV_STATIC,mbrs,BOOST_PP_IDENTITY(typename)) \
         public: \
           BOOST_TYPEOF_NESTED_TYPEDEF_TPL(__expr, \
- ::BOOST_SPIRIT_CLASSIC_NS::type_of::depend_on_type<__Dummy>(x) ) \
+ ::BOOST_SPIRIT_CLASSIC_NS::type_of::depend_on_type<__Dummy>(x) ) \
         }; \
                                                                                \
       public: \
@@ -471,7 +471,7 @@
       BOOST_PP_IF(np,BOOST_SPIRIT_RP_GEN_FUNC,BOOST_SPIRIT_RP_GLOB_VAR) \
                                                            (name,name_t,np,na) \
       BOOST_SPIRIT_RP_REGISTER_TEMPLATE \
- (name_t,BOOST_PP_INC(BOOST_PP_ADD(np,na)))
+ (name_t,BOOST_PP_INC(BOOST_PP_ADD(np,na)))
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // RP_OPAQUE_IMPL_I
 //
@@ -536,7 +536,7 @@
       BOOST_PP_IF(np,BOOST_SPIRIT_RP_GEN_OPAQUE,BOOST_SPIRIT_RP_GLOB_OPAQUE) \
                                                          (name,name_t,np,pars)
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-// RP_AP_HANDLER
+// RP_AP_HANDLER
 //
 // Part of the rule parser definition for handling action placeholders
 # define BOOST_SPIRIT_RP_AP_HANDLER(name_t,np,acts,na,ns) \
@@ -590,7 +590,7 @@
 # define BOOST_SPIRIT_RP_AP_EXTRA_MBRS(np,na) \
       private: \
         BOOST_PP_REPEAT(np,BOOST_SPIRIT_RP_PM_MBRS,-) \
- BOOST_PP_REPEAT(na,BOOST_SPIRIT_RP_AP_MBRS,-)
+ BOOST_PP_REPEAT(na,BOOST_SPIRIT_RP_AP_MBRS,-)
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // RP_PM_MBRS
 //
@@ -617,7 +617,7 @@
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // RP_TPL_PARAMS
 //
-// Expands to the template parameters or arguments of the rule parser template
+// Expands to the template parameters or arguments of the rule parser template
 # define BOOST_SPIRIT_RP_TPL_PARAMS(pars,acts,prefix,defaults) \
       prefix ## Dummy \
       BOOST_SPIRIT_RP_EMIT(PM_TEMPLATE_PARAMS,pars,prefix ## T) \
@@ -679,7 +679,7 @@
 // PM_CTOR_PARAMS
 # define BOOST_SPIRIT_RP__PM_CTOR_PARAMS(r,data,i,elem) \
       BOOST_PP_COMMA_IF(i) \
- typename ::boost::call_traits< data ## i >::param_type elem
+ typename ::boost::call_traits< data ## i >::param_type elem
 
 // PM_CTOR_ARGS
 # define BOOST_SPIRIT_RP__PM_CTOR_ARGS(r,data,i,elem) \
@@ -777,7 +777,7 @@
 // AP_REBOUND_TPL_ARGS
 # define BOOST_SPIRIT_RP__AP_REBOUND_TPL_ARGS(r,data,i,elem) \
       , typename ::BOOST_SPIRIT_CLASSIC_NS::type_of::placeholdee< \
- __action_placeholder:: elem , __A ## i, data >::type
+ __action_placeholder:: elem , __A ## i, data >::type
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // PP_EMIT
@@ -787,7 +787,7 @@
 # define BOOST_SPIRIT_RP_EMIT(op, array, data) \
       BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I(BOOST_SPIRIT_RP__ ## op,data,array)
 // --- --- - - --- - - --- - - - - --- - - - - - - - - - - - - - - - - - - - - -
-// RP_ARRAY_FOR_EACH_I
+// RP_ARRAY_FOR_EACH_I
 //
 // Iterates an optional array. That is you can pass e.g.'-' or 'none' to denote
 // emptiness.
@@ -796,13 +796,13 @@
                    BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I_IMPL, \
                    BOOST_PP_TUPLE_EAT(3))(macro,data,optional_array)
 
-// RP_ARRAY_FOR_EACH_I_IMPL
+// RP_ARRAY_FOR_EACH_I_IMPL
 # define BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I_IMPL(macro,data,array) \
       BOOST_SPIRIT_RP_IF(BOOST_PP_ARRAY_SIZE(array),PP_SEQ_FOR_EACH_I,3) \
         (macro,data, BOOST_SPIRIT_RP_IF(BOOST_PP_ARRAY_SIZE(array), \
                                         PP_TUPLE_TO_SEQ,2) array)
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-// RP_ARRAY_SIZE
+// RP_ARRAY_SIZE
 //
 // Expands to the size of an "optional array".
 //
@@ -818,7 +818,7 @@
                    BOOST_PP_ARRAY_SIZE, 0 BOOST_PP_TUPLE_EAT(1))(optional_array)
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // RP_OPTIONAL
-//
+//
 // Expands to nothing if the argument is parenthesized.
 //
 // Examples:
@@ -827,7 +827,7 @@
 // BOOST_SPIRIT_RP_OPTIONAL( (none) ) // evaluates to nothing
 //
 # define BOOST_SPIRIT_RP_OPTIONAL(elem) \
- BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_PP_IS_UNARY(elem)),elem)
+ BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_PP_IS_UNARY(elem)),elem)
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 // RP_COMMA_IF_OR
 //
@@ -851,13 +851,13 @@
 // Wrapper and gernator function to embed a parser by reference
 //------------------------------------------------------------------------------
 
-namespace boost { namespace spirit {
+namespace boost { namespace spirit {
 
 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 
   // Wrapper to embed a parser by reference
 
- template<class P> class parser_reference
+ template<class P> class parser_reference
     : public parser< parser_reference<P> >
   {
     P const & ref_that;
@@ -868,19 +868,19 @@
     { }
 
     typedef parser_reference<P> self_t;
- typedef self_t const & embed_t;
+ typedef self_t const & embed_t;
     typedef typename P::parser_category_t parser_category_t;
 
- template<typename ScannerT> struct result
+ template<typename ScannerT> struct result
     { typedef typename P::BOOST_NESTED_TEMPLATE result<ScannerT>::type type; };
 
- template<typename ScannerT>
+ template<typename ScannerT>
     typename result<ScannerT>::type
     parse(ScannerT const & scan) const
     { return this->ref_that.parse(scan); }
   };
 
- template<class P> parser_reference<P>
+ template<class P> parser_reference<P>
   embed_by_reference(::BOOST_SPIRIT_CLASSIC_NS::parser<P> & p)
   { return p; }
 
@@ -894,18 +894,18 @@
 // Expression templates for action placeholders.
 //------------------------------------------------------------------------------
 
-namespace boost { namespace spirit {
+namespace boost { namespace spirit {
 
 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 
-namespace type_of {
+namespace type_of {
 
   // No-operation functor
 
- struct nop_functor
+ struct nop_functor
   {
     template<typename T>
- bool operator()(T const &) const
+ bool operator()(T const &) const
     { return false; }
     template<typename T, typename U>
     bool operator()(T const &, U const &) const
@@ -949,26 +949,26 @@
   {
     typedef Action type;
 
- static type concatenate(nop_functor const &, Action const & a)
+ static type concatenate(nop_functor const &, Action const & a)
     { return a; }
   };
   template<typename Action> struct action_concatenator<Action, nop_functor>
   {
     typedef Action type;
 
- static type concatenate(Action const & a, nop_functor const &)
+ static type concatenate(Action const & a, nop_functor const &)
     { return a; }
   };
   template<> struct action_concatenator<nop_functor, nop_functor>
   {
     typedef nop_functor type;
 
- static type concatenate(nop_functor const &, nop_functor const &)
+ static type concatenate(nop_functor const &, nop_functor const &)
     { return nop_functor(); }
   };
 
   template<typename Action1, typename Action2>
- typename action_concatenator<Action1,Action2>::type
+ typename action_concatenator<Action1,Action2>::type
   concatenate_actions(Action1 const & a1, Action2 const & a2)
   {
     return action_concatenator<Action1,Action2>::concatenate(a1,a2);
@@ -1017,17 +1017,17 @@
 
     head_type const & head() const { return obj_head; }
     tail_type const & tail() const { return obj_tail; }
- };
+ };
 
   // Action chain concatenation
   template<class Head, class Tail>
   action_chains<Head,Tail> make_chain(Head const & h, Tail const & t)
   { return action_chains<Head,Tail>(h,t); }
 
- template<class PH1, action_chain_mode M1, typename A1,
+ template<class PH1, action_chain_mode M1, typename A1,
            class PH2, action_chain_mode M2, typename A2>
   action_chains< action_chain<PH1,M1,A1>, action_chain<PH2,M2,A2> >
- operator, (action_chain<PH1,M1,A1> const & h,
+ operator, (action_chain<PH1,M1,A1> const & h,
              action_chain<PH2,M2,A2> const & t)
   { return make_chain(h,t); }
 
@@ -1037,12 +1037,12 @@
   { return make_chain(h,t); }
 
 
- // Extract the (maybe composite) action associated with an action
+ // Extract the (maybe composite) action associated with an action
   // placeholders from the chains with a fold algorithm.
   template<class Placeholder, typename StartAction, class NewChainOrChains>
   struct placeholdee
   {
- typedef StartAction type;
+ typedef StartAction type;
 
     static type get(StartAction const & a, NewChainOrChains const &)
     { return a; }
@@ -1054,7 +1054,7 @@
   get_placeholdee(StartAction const & a, NewChainOrChains const & c)
   { return placeholdee<Placeholder,StartAction,NewChainOrChains>::get(a,c); }
 
- template<class Placeholder, typename StartAction, class Head, class Tail>
+ template<class Placeholder, typename StartAction, class Head, class Tail>
   struct placeholdee
             < Placeholder, StartAction, action_chains<Head,Tail> >
   {
@@ -1075,7 +1075,7 @@
   {
     typedef A type;
 
- static type get(StartAction const &,
+ static type get(StartAction const &,
                     action_chain<Placeholder,replace,A> const & c)
     { return c.action(); }
   };
@@ -1086,12 +1086,12 @@
   {
     typedef typename action_concatenator<StartAction,A>::type type;
 
- static type get(StartAction const & a,
+ static type get(StartAction const & a,
                     action_chain<Placeholder,append,A> const & c)
     { return concatenate_actions(a,c.action()); }
   };
 
-}
+}
 
 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
 
@@ -1104,7 +1104,7 @@
 // Misc.utilities
 //------------------------------------------------------------------------------
 
-namespace boost { namespace spirit {
+namespace boost { namespace spirit {
 
 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 
@@ -1113,7 +1113,7 @@
   // Utility function to create a dependency to a template argument.
 
   template<typename T, typename X>
- X const & depend_on_type(X const & x)
+ X const & depend_on_type(X const & x)
   { return x; }
 
   // Utility to allow use parenthesized type expressions with commas inside
@@ -1130,13 +1130,13 @@
   template<typename T> struct remove_special_fptr< special_result & (*)(T) >
   { typedef T type; };
 
-}
+}
 
 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
 
 } } // namespace ::BOOST_SPIRIT_CLASSIC_NS::type_of
 
 //------------------------------------------------------------------------------
-#endif
+#endif
 //------------------------------------------------------------------------------
 


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